Solving Linear Programs with Differential Privacy
Abstract
We study the problem of solving linear programs of the form , with differential privacy. For homogeneous LPs , we give an efficient -differentially private algorithm which with probability at least finds in polynomial time a solution that satisfies all but constraints, for problems with margin . This improves the bound of by [Kaplan-Mansour-Moran-Stemmer-Tur, STOC ’25]. For general LPs , with potentially zero margin, we give an efficient -differentially private algorithm that w.h.p drops constraints, where is an upper bound for the entries of and in absolute value. This improves the result by Kaplan et al. by at least a factor of . Our techniques build upon privatizing a rescaling perceptron algorithm by [Hoberg-Rothvoss, IPCO ’17] and a more refined iterative procedure for identifying equality constraints by Kaplan et al.
Keywords and phrases:
Differential Privacy, Linear ProgrammingCategory:
RANDOMFunding:
Alina Ene: AE was supported in part by an Alfred P. Sloan Research Fellowship.Copyright and License:
2012 ACM Subject Classification:
Theory of computation Design and analysis of algorithms ; Security and privacyEditors:
Alina Ene and Eshan ChattopadhyaySeries and Publisher:
Leibniz International Proceedings in Informatics, Schloss Dagstuhl – Leibniz-Zentrum für Informatik
1 Introduction
Linear programming is a fundamental tool for modeling and solving problems in computer science. Consider the standard feasibility problem of finding subject to , where the constraints are input from users. The input can contain sensitive information such as the users’ private health data or private transactions, which the users may wish to be protected. For the algorithm designer, this is where differential privacy proves its usefulness. Differential privacy protects sensitive information by requiring that the algorithm must have approximately the same output upon receiving similar input.
The study of solving linear programs with differential privacy was initiated by [9] and has subsequently been studied under different contexts along with other related problems. Notably, privately solving linear programs is closely related to private learning of subspaces and halfspaces, which are fundamental problems in learning theory. In particular, a line of work by [3, 1, 11, 7, 2] showed reductions from learning halfspaces to the problem of finding a point in a convex hull, which in turn can be solved via linear programing. This means that the existence of an efficient private solver for linear programs implies an upper bound for the sample complexity of efficient private learners for halfspaces, and any improvement for the former problem implies an improvement for the latter.
Imposing differential privacy when solving a linear program comes with the impossibility to ensure all constraints are satisfied. Indeed, in the extreme case, the addition of one more constraint can change the problem from feasible to infeasible. Therefore, to guarantee differential privacy, it is required that a number of constraints must be dropped. It was known (by folklore) that for a linear program whose feasible region is of positive volume, privatizing the algorithm by [4] results in a solution that violates constraints, where is the dimension of the problem. The recent work by [10] formalized this claim and generalized it to all linear programs. Their algorithm, however, suffered from a high degree polynomial dependence on (at least dependence), whereas the lower bound (from learning theory) is linear in . Closing this gap remains a challenging open question.
In our work, we make progress in this direction, and propose new algorithms for solving linear programs with differential privacy. Our algorithms are efficient and they achieve significantly improved guarantees on the number of violated constraints.
1.1 Our contribution
Our first contribution is a new algorithm for privately solving linear programs with positive margin with guarantee stated in Theorem 1. Here the margin of the problem is the radius of the largest ball that fits in the intersection of the feasible region and the unit ball, which we define in Section 2.
Theorem 1.
Let be given an input. There exists an efficient -differentially private algorithm for finding a feasible solution to the linear program , such that whenever the margin of the system is at least , with probability at least , the algorithm outputs a solution that satisfies all but constraints.
In terms of the dependence on the dimension , our algorithm significantly improves over the prior work by [10], which drops constraints.
For general linear programs with potentially zero margin, we give an iterative private algorithm with the following guarantee.
Theorem 2.
Let be given an input. There exists an efficient -differentially private algorithm for finding a feasible solution to the linear program ; with integer entries such that with probability at least , the algorithm outputs a solution that satisfies all but constraints, where is an upper bound on the absolute values of the entries in and .
The algorithm by [10] requires to drop constraints to guarantee privacy. To improve this, one can use the algorithm from Theorem 1 as a subroutine in the algorithm by [10] to reduce to the number of dropped constraints to . Our algorithm with a more refined analysis goes one step further to remove another factor and achieves dependence. Our bound is a significant improvement towards the lower bound .
1.2 Our techniques
Our technique for showing Theorem 1 is based on privatizing a rescaling perceptron algorithm for solving linear programs of the form with positive margin. Instead of using the algorithm by [4] as in [10], we develop an algorithm based on the work of [8].
A rescaling perceptron algorithm consists of two phases: the Perceptron Phase to find a new solution and the Rescaling Phase to find a direction to rescale the input. To privatize the Perceptron Phase, the algorithm of [10] uses the mechanism by [13] to construct a noisy average of the constraints that are violated by the current solution, and then updates the solution in the same direction. In the Rescaling Phase, the non-private algorithm by [4] and the privatized version by [10] use another perceptron-style procedure to find a rescaling direction. This approach requires updates and each call to the Rescaling Phase requires to drop constraints.
The main difference between our work and [10] lies in the rescaling phase. We use the following technique by [14] and [8]. During the perceptron phase, the algorithm maintains a weight vector for tracking which constraints are violated by the solution in each iteration. Using a random Gaussian vector, the algorithm produces a rescaling direction by a convex combination weighted by of the rows satisfied by the random vector. [14] and [8] show that with a constant probability, rescaling the input matrix along that direction increases the volume of the feasible region inside the unit ball by a constant factor.
The benefit of using the weight vector to rescale is that, since we only need ) steps to boost the success probability, the amount of noise needed to make this phase private is much smaller. Further, we can keep all constraints around until we find a good solution and only discard constraints once at the end of the algorithm. We discard only constraints in total.
For general linear programs with potentially zero margin, we use the standard technique of adding a small perturbation to the constraints that does not change the feasibility of the problem. This perturbation increases the problem margin and allows the application of the private perceptron algorithm. Similar to [10], our algorithm iteratively identifies tight (equality) constraints in the LP, privatizes these equality constraints and uses them to eliminate variables. The approach by [10] needs to account for the blow-up of the input entries after performing the variable elimination steps, which can quickly diminish the margin. The cost of this shows up as an extra factor in the number of dropped constraints. By contrast, our algorithm always returns to the initial LP after identifying tight constraints. We show that in this way the margin reduces at a slower rate, saving the factor .
1.3 Related work
Rescaling Perceptron algorithms.
To find a solution that satisfies , one can use the classic perceptron algorithm which convergences after at most iterations on problems with positive margin , where the margin is the radius of the largest ball that fits in the intersection of the feasible region and the unit ball. [4] show a modification of the classic algorithm with an additional rescaling procedure that runs in time , for problems with . The rescaling procedure by [4] is another variant of the perceptron algorithm which finds a rescaling direction by moving a random unit vector along the direction of a violated constraint. Subsequent works by [14, 8] explore different rescaling operations. In particular, our work relies on the technique by [8] in which the rescaling direction is found by a convex combination of rows whose corresponding constraints are satisfied by a random Gaussian vector.
Solving linear programs with privacy.
Solving linear programs with differential privacy has been the focus of several prior works. Under various notions of neighboring inputs (such as input differing by a row or a column), [9] give algorithms that approximately satisfy most constraints. [12] show an algorithm that satisfy most constraints exactly, but only considering neighboring inputs to be differing on the right hand side scalars. [11] provide an algorithm to solve the general feasibility problem , but requires a running time that is exponential in the dimension. Most relevant for our work is the work of [10], which studies the same setting. We provide a detailed comparison of the results and techniques in sections 1.1 and 1.2.
Beyond solving linear programs.
Solving linear programs is closely related to private learning subspaces and halfspaces [3]. [1] show a reduction from learning halfspaces to the problem of finding a point in the convex hull, where an efficient algorithm for the latter problem implies an upper bound for the sample complexity of efficient algorithms for the former. Subsequent works by [11, 7, 2] have targeted this question. [10] build techniques for solving this problem via privately solving LPs and achieve the first algorithm that has polynomial dependence on the dimension and polylogarithmic dependence on the domain size. Our algorithm can be used as a subroutine to improve the runtime of the algorithm by [10].
2 Preliminaries
Notation.
We let be the -norm and be the -norm. When it is clear from context, also denotes the norm. For a matrix , we denote by the -th row of . For a vector , we let be the normalized vector . We also use to denote the matrix with normalized rows. We denote by the Laplace distribution with density ; the Gaussian distribution with mean zero and variance and the multivariate Gaussian distribution with mean zero and covariance . The dimension will be clear from context.
Linear programs.
We consider the problem of finding a feasible solution to a linear program in general standard form , where has dimension , is a vector of dimension and the entries of and are integers. Following [4], we refer to the problem of finding a solution satisfying , as a homogeneous LP. A homogeneous LP is characterized by a quantity , namely, the margin (or roundness) parameter, given as
Geometrically, is the radius of a ball that fits into the intersection between the feasible region and the unit ball. The classic perceptron algorithm for LPs with converges with iterations. Rescaling algorithms such as [4, 14, 8] have total runtime .
Homogenization.
[4] give a simple reduction (called homogenization) from a general LP to a homogeneous LP , by setting and . We refer to the homogeneous LP constructed via this reduction as the homogenized LP.
Differential privacy.
We use the notation as shorthand for the LP . We say that two LPs and are neighbors is they differ by only one constraint (one LP has an extra constraint). A randomized algorithm is said to be -differentially private (DP) if for all neighboring LPs and and every subset of possible outcomes ,
In the case , we say the algorithm is -DP. Two commonly used mechanisms for achieving differential privacy are the Laplace mechanism and the Gaussian mechanism. Let be a function whose output has dimension . We say has sensitivity if on any two neighboring inputs and , , and has sensitivity if on any two neighboring inputs and , .
Theorem 3 (Laplace mechanism [6]).
Let be a function of sensitivity . The mechanism that on an input adds independently generated noise with the Laplace distribution to each of the coordinates of is -DP.
Theorem 4 (Gaussian mechanism [5]).
Let be a function of sensitivity . The mechanism that on an input adds noise generated with the Gaussian distribution where to each of the coordinates of is -DP.
3 Private Perceptron Algorithm for Positive Margin LPs
3.1 Algorithm
We describe our Private Perceptron algorithm in Algorithm 1. Given a matrix , margin parameter , privacy parameters , and failure probability , the algorithm runs at most and makes calls to procedure given in Algorithm 2. Algorithm 2 has three possible outcomes. If it outputs a solution, Algorithm 1 terminates and returns this solution with a suitable rescaling. If it outputs a rescaling direction, Algorithm 1 rescales the input matrix and repeats. Otherwise, Algorithm 1 terminates and returns .
Our main novel contribution lies in Algorithm 2. This algorithm consists of two phases: the Perceptron Phase in which the algorithm attempts to find a solution to the LP and the Rescaling Phase in which the algorithm finds a good direction to rescale the input if the solution from the Perceptron Phase is not satisfactory. In each phase, we add maintain the privacy by adding appropriate noise. During the Perceptron Phase, the algorithm maintains a solution and updates it along the direction of a noisy average of the violated constraints. The algorithm also maintains a weight vector which picks up the constraints violated by the current solution. We keep private, and use the average value to determine the rescaling direction. To determine the rescaling direction, during the Rescaling Phase, the algorithm takes a random gaussian vector and computes a noisy sum of all rows satisfied by this vector weighted by . We will show that with a constant probability, this noisy sum provides a good rescaling direction, and the algorithm repeats the process a number of iterations to boost the success probability.
In the next subsections, we show the privacy and utility guarantees of our algorithm.
3.2 Privacy analysis
Throughout, we let and be two neighboring LPs. The corresponding computed terms in Algorithm 2 for are denoted with the extra prime symbol (for example, and ).
Proposition 5.
Algorithm 1 is -DP for and .
To show this Proposition, we show the following lemmas.
Lemma 6.
Each iteration of the Perceptron Phase is -DP.
The following claim follows similarly to the proof of the algorithm by [13]. We include the proof in the appendix.
Claim 7.
For all , has sensitivity , and has sensitivity .
Proof of Lemma 6.
For the purpose of analysis, in each iteration of the Perceptron Phase, we define the output of the algorithm to be either the solution or the new update vector . Let be the outputs of the iteration on and respectively, and let be an arbitrary subset of . First, due the the privacy of the Laplace mechanism,
Next, consider the case where the output is an update vector . If :
If , then , and due to the privacy of the Gaussian mechanism,
Lemma 8.
Each iteration of the Rescaling Phase is -DP.
To show this lemma, first, we show the sensitivity of in the following claim, whose proof is deferred to the appendix.
Claim 9.
Let . The sensitivity of is .
Proof of Lemma 8.
If , the Rescaling Phase only happens when for all , . Hence, for any set of outcomes , by union bound
Next, consider the case . Since by the privacy guarantee of the Gaussian mechanism
Proof of Proposition 5.
The algorithm is -DP, following directly from advanced composition.
3.3 Utility analysis
To analyze the runtime and utility of Algorithm 1 we let be the unit ball and be the feasible region defined by . We will show the following proposition about the guarantee on the output of Algorithm 1.
Proposition 10.
With probability at least , Algorithm 1 outputs a solution that satisfies all but constraints.
We outline the proof of Proposition 10. First, if in an iteration, Algorithm 1 finds a solution outputted by Algorithm 2, we show that this solution must be correct with probability .
Lemma 11.
If Algorithm 2 terminates in the Perceptron Phase and outputs a solution , then with probability at least , satisfies all but constraints.
If Algorithm 1 finds a rescaling vector by the output of Algorithm 2, we show that the volume of the feasible region inside the unit ball is increased by a constant factor with high probability. To start with, assuming the initial margin parameter is at least , [14] give a lower bound on the volume of the initial feasible region inside the unit ball:
Lemma 12 (Lemma 3 [14]).
Suppose then .
Note that the rescaling operation is equivalent to a linear map such that, and for all . [8] show the following lemma.
Lemma 13 (Lemma 4 [14]).
Suppose that satisfies , then .
Next, we show that the rescaling vector outputted by Algorithm 2 satisfies the condition of Lemma 13 with high probability.
Lemma 14.
If Algorithm 2 does not return a solution, then with probability at least , it outputs a rescaling vector that satisfies .
Proof of Proposition 10.
The algorithm fails if either it outputs a solution that does not satisfy more than constraints, or it fails to output a rescaling vector that satisfies the condition of Lemma 13. This happens with probability at most .
Proof of Lemma 11.
If Algorithm 2 terminates in iteration of the Perceptron Phase, we have where . That is
Here, is the number of constraints not satisfied by the solution, and we have
To show Lemma 14 we start with the following claim:
Claim 15.
.
To show Claim 15, we use the following facts about Gaussian random variables.
Fact 16.
If then for , . If then for , follows and follows -squared distribution with degrees of freedom. Furthermore, for , .
Proof of Claim 15.
We give an outline of this proof. First, notice that, by the update of , we have with high probability (proof will follow):
Then, the main task is to bound . However, is not a bounded variable, so we cannot directly apply concentration inequalities. Instead, we will define a bounded sequence that behaves like and proceed to bound . Finally, we will show that with high probability behaves like and from there we can bound .
For each iteration of Algorithm 2, consider the following event, called that both of the following happen: 1), and 2). Since is the average of unit length vectors, . Then because , follows a with (Fact 16). Additionally, follows a -squared distribution with degrees of freedom (Fact 16). Therefore, by Fact 16,
We define the following random variable:
Due to the symmetry of , . If happens and we have
Then forms a bounded martingale difference sequence. By Azuma’s inequality,for all
Thus by union bound we have with probability , happens and , for all , simultaneously. When this happens we show by induction that . This is true for . Suppose that we have for all . We have
where in the last inequality, conditioned on , we have and . Since , and , we have and . Continuing expanding this recursion, we have
Due to the induction hypothesis for all , and happens for all we have then for all . It follows that . Therefore
Claim 17.
With probability at least , , where for convenience we define and is the diagonal matrix obtained from .
Proof.
First, with probability at least we have . By Claim 15 and union bound, we have, with probability at least , and . We have that
Hence. Thus The claim follows due to .
Claim 18.
Conditioned on , with probability at least , we have , in which case .
Lemma 19 (Lemma 6 [8]).
Let and be such that and . Take a random gaussian vector and let . With probability at least , .
Proof.
For simplicity, we drop the superscript . The proof follows similarly to [8]; however, we need to take into account the noise component . Since with , follows a -squared distribution of degrees of freedom (Fact 16). By Fact 16, for sufficiently large constant in , . Further, by Lemma 19, with probability we have .
The two events: and are independent. With probability at least , both events happen. Then,
To complete the proof, we now show that, conditioned on the two events and happening, we have . Since and , we have and . This gives us
The third inequality is due to and since . Besides, since for , we also have
The last inequality holds for large enough .
Proof of Lemma 14.
3.4 Putting it all together
Proof of Theorem 1.
4 When the LP is Not Fully Dimensional
Algorithm 1 can only guarantee the number of dropped constraints is when the LP has a strictly positive margin. In case the LP has zero margin, i.e, tight (equality) constraints, we can use a standard perturbation technique to create a margin without changing the feasibility of the problem. However, the challenge is to output a solution that satisfies the original constraints. The main idea to handle this case, due to [10], is to iteratively identify tight constraints based on the following observation. An LP with integer entries bounded by in the absolute value has the same feasibility as that of a relaxed LP with slackness added to each constraint and, if a solution to the relaxed LP violates a constraint in the initial LP, that constraint must be tight. This suggests that we can solve the relaxed LP which has a positive margin, then identify tight constraints and recurse at most times (we can stop after identifying linearly independent tight constraints).
Our improvement over the algorithm of [10] is two-fold. First, we use Algorithm 1 as the solver in each iteration, which improves the number of dropped constraints from to . Second, we avoid the fast decrease of the margin during the course of the algorithm, which saves another factor .
4.1 Synthetic systems of linear equations
During its course, the algorithm needs to identify the set of tight constraints and privatize them for the subsequent use. To this end, we will use the algorithm from [10] for privately generating (or sanitizing) synthetic systems of linear equations, stated in the following result.
Theorem 20 (Theorem C [10]).
There exists an -DP algorithm such that for any system of linear equations , with probability at least , the algorithm outputs a system of linear equations which satisfies
-
1.
Any solution to is a solution to , and
-
2.
Each solution to satisfies all but equations in
Note that for the analysis we also use the fact that this algorithm first privately selects a set of tight constraints in the original LP, then outputs a canonical basis for the subspace defined by these tight constraints.
4.2 Algorithm
The algorithm is as follows. The algorithm runs at most iterations. In each iteration, the algorithm solves the LP with a set of sanitized equality constraints that were identified in previous iterations. First, the algorithm selects independent columns in to eliminate variables then solves the LP without equality constraints using the Algorithm 1 (after homogenizing the LP via the reduction from Section 2). The algorithm terminates if it has found tight constraints or if the number of constraints violated by the solution is small. Otherwise, the algorithm sanitizes the set of constraints violated by the solution and adds them to then recurses. Our algorithm is described in Algorithm 3.
4.3 Analysis
For the privacy guarantee, we have the following lemma.
Proposition 21.
The algorithm is -DP for .
Proof.
This comes directly from advanced composition over iterations, each of which uses three private mechanisms.
Next, for the utility guarantee, we first show that during the iterations, the entries of the LP (after variable elimination) does not blow up by a factor more than and thereby, we can lower bound the margin of the relaxed LP.
Lemma 22.
For each step of Algorithm 3, consider the LP , with the entries of bounded by in the absolute value and let be the set of equality constraints where has rank . We can use independent columns in and Gaussian elimination to eliminate variables to obtain an LP , with integer entries and variables such that the entries of are bounded by . Furthermore, if the LP is feasible then the LP resulting from the same elimination from has margin parameter .
Proof.
See Appendix. Equipped with Lemma 22, we can show the bound for the number of dropped constraints.
Proposition 23.
With probability at least , Algorithm 3 outputs a solution that satisfies all but constraints.
Proof.
See Appendix.
4.4 Proof of Theorem 2
Proof.
References
- [1] Amos Beimel, Shay Moran, Kobbi Nissim, and Uri Stemmer. Private center points and learning of halfspaces. In COLT, volume 99 of Proceedings of Machine Learning Research, pages 269–282. PMLR, 2019. URL: http://proceedings.mlr.press/v99/beimel19a.html.
- [2] Omri Ben-Eliezer, Dan Mikulincer, and Ilias Zadik. Archimedes meets privacy: On privately estimating quantiles in high dimensions under minimal assumptions. In NeurIPS, 2022.
- [3] Mark Bun, Kobbi Nissim, Uri Stemmer, and Salil P. Vadhan. Differentially private release and learning of threshold functions. In FOCS, pages 634–649. IEEE Computer Society, 2015. doi:10.1109/FOCS.2015.45.
- [4] John Dunagan and Santosh S. Vempala. A simple polynomial-time rescaling algorithm for solving linear programs. Math. Program., 114(1):101–114, 2008. doi:10.1007/S10107-007-0095-7.
- [5] Cynthia Dwork, Krishnaram Kenthapadi, Frank McSherry, Ilya Mironov, and Moni Naor. Our data, ourselves: Privacy via distributed noise generation. In EUROCRYPT, volume 4004 of Lecture Notes in Computer Science, pages 486–503. Springer, 2006. doi:10.1007/11761679_29.
- [6] Cynthia Dwork, Frank McSherry, Kobbi Nissim, and Adam D. Smith. Calibrating noise to sensitivity in private data analysis. J. Priv. Confidentiality, 7(3):17–51, 2016. doi:10.29012/JPC.V7I3.405.
- [7] Yue Gao and Or Sheffet. Differentially private approximations of a convex hull in low dimensions. In ITC, volume 199 of LIPIcs, pages 18:1–18:16. Schloss Dagstuhl – Leibniz-Zentrum für Informatik, 2021. doi:10.4230/LIPIcs.ITC.2021.18.
- [8] Rebecca Hoberg and Thomas Rothvoss. An improved deterministic rescaling for linear programming algorithms. In IPCO, volume 10328 of Lecture Notes in Computer Science, pages 267–278. Springer, 2017. doi:10.1007/978-3-319-59250-3_22.
- [9] Justin Hsu, Aaron Roth, Tim Roughgarden, and Jonathan R. Ullman. Privately solving linear programs. In ICALP (1), volume 8572 of Lecture Notes in Computer Science, pages 612–624. Springer, 2014. doi:10.1007/978-3-662-43948-7_51.
- [10] Haim Kaplan, Yishay Mansour, Shay Moran, Uri Stemmer, and Nitzan Tur. On differentially private linear algebra. CoRR, abs/2411.03087, 2024. doi:10.48550/arXiv.2411.03087.
- [11] Haim Kaplan, Yishay Mansour, Uri Stemmer, and Eliad Tsfadia. Private learning of halfspaces: Simplifying the construction and reducing the sample complexity. In NeurIPS, 2020.
- [12] Andrés Muñoz Medina, Umar Syed, Sergei Vassilvitskii, and Ellen Vitercik. Private optimization without constraint violations. In AISTATS, volume 130 of Proceedings of Machine Learning Research, pages 2557–2565. PMLR, 2021. URL: http://proceedings.mlr.press/v130/munoz21a.html.
- [13] Kobbi Nissim, Uri Stemmer, and Salil P. Vadhan. Locating a small cluster privately. In PODS, pages 413–427. ACM, 2016. doi:10.1145/2902251.2902296.
- [14] Javier Peña and Negar Soheili. A deterministic rescaled perceptron algorithm. Math. Program., 155(1-2):497–510, 2016. doi:10.1007/S10107-015-0860-Y.
Appendix A Missing Proofs from Section 3
A.1 From Section 3.2
As a reminder, we let and be the neighboring LPs. The corresponding computed terms in Algorithm 2 for are denoted with the extra prime symbol (for example, and ).
Proof of Claim 7.
Fix two neighboring LPs and . Suppose has one extra constraint. can have at most one more constraint so it is immediate that has sensitivity . We consider the case has one extra constraint ,
Then by triangle inequality
When has one less constraint, we proceed similarly.
Then by triangle inequality
Claim 9.
For simplicity, we drop the superscript for iteration . Consider the case where and have one extra constraint . For all , for we have
Hence . Besides, we also have . For coordinate ,
Then, to compute the sensitivity of , we take .
Similarly, consider the case where and have one extra constraint compared with the neighbor . For all , for we have
Hence . Besides, we also have . For coordinate
Then
Appendix B Missing Proofs from Section 4
Proof of Lemma 22.
Recall that the equality constraint is obtained from sanitizing a set of equality constraints with the entries bounded by in the absolute value. In particular, there is a set of tight constraints in the original LP with entries bounded by in the absolute value that spans the same subspace as – that is, there is an invertible matrix such that .
Let be independent columns of , where we let be the set of indices of the columns we selected; the set corresponds to the set of variables that we will eliminate. Eliminating the variables in in using means switching to the new linear constraints . Eliminating the same variables using would get the result . Notice that and so the two results are identical.
Therefore, we can think of using for variable elimination instead of using . Note that the entries of are bounded by and the entries of are fractions with denominator , so to maintain the integrality during the elimination, we can multiply each row of with . Therefore, the resulting LP has entries bounded by .
We now show the second claim. First, let us show that the LP has a solution such that for all . Let be any vertex solution. By Cramer’s rule, is the ratio of two determinants with integer entries . We can bound the numerator of this ratio by and lower bound the denominator by .
Next, consider the LP with added slack . After performing the variable elimination as described above, we obtain an LP . Finally, we bound the margin of the vertex solution (restricted to the variables that were not eliminated) for the homogenized version of the latter LP . Since have entries bounded by and has entries bounded by , the margin of the homogenized LP is at least
To show Lemma 23, we restate the following lemma from [10] shows that tightness in the relaxed system implies tightness in the original system.
Lemma 24 (Lemma 36 [10]).
For matrices with dimension , and being vectors of length , . The entries are integers with upper bound in the absolute value. For being a vector of length such that the entries of are bounded by . Then if the system
is feasible then the system
is feasible.
Proof of Lemma 23.
In each iteration, the algorithm solves the LP with a set of equality constraints , where is a subset of the constraints of the original LP . Note that, by construction, is equivalent to a set of tight constraints in the original LP. Solving this LP gives us a solution that satisfies
for a vector , where and are constraints in the original LP. Since all entries of the above LP are bounded by and , Lemma 24 implies that the LP
is feasible. The algorithm succeeds with probability and the sanitization step succeeds with probability . Therefore, after each iteration, with probability at least the set of tight (equality) constraints is increased by at least . Hence, with probability at least the algorithm must terminate after at most iterations.
By Lemma 22, in the homogenized LP after variable elimination, the margin is at least . Therefore, with probability , the number of dropped constraints when using in Line 5 is at most
If in iteration , the algorithm returns at Line 7, the number of dropped constraints in is at most with probability at least
If the algorithm returns at Line 10, again, the number of dropped constraints is at most with probability . By Theorem 20, the number of dropped constraints by sanitization in each iteration is at most with probability .
Combining these, over all iterations, with probability at least , the number of dropped constraints is at most
