Skip to main content

Linear Programming Using Limited-Precision Oracles

  • Conference paper
  • First Online:
Integer Programming and Combinatorial Optimization (IPCO 2019)

Abstract

Linear programming is a foundational tool for many aspects of integer and combinatorial optimization. This work studies the complexity of solving linear programs exactly over the rational numbers through use of an oracle capable of returning limited-precision LP solutions. Under mild assumptions, it is shown that a polynomial number of calls to such an oracle and a polynomial number of bit operations, is sufficient to compute an exact solution to an LP. Previous work has often considered oracles that provide solutions of an arbitrary specified precision. While this leads to polynomial-time algorithms, the level of precision required is often unrealistic for practical computation. In contrast, our work provides a foundation for understanding and analyzing the behavior of the methods that are currently most effective in practice for solving LPs exactly.

The first author was supported by the Research Campus MODAL funded by the German Ministry of Education and Research under grant number 05M14ZAM.

This is a preview of subscription content, log in via an institution to check access.

Access this chapter

Chapter
USD 29.95
Price excludes VAT (USA)
  • Available as PDF
  • Read on any device
  • Instant download
  • Own it forever
eBook
USD 59.99
Price excludes VAT (USA)
  • Available as EPUB and PDF
  • Read on any device
  • Instant download
  • Own it forever
Softcover Book
USD 79.99
Price excludes VAT (USA)
  • Compact, lightweight edition
  • Dispatched in 3 to 5 business days
  • Free shipping worldwide - see info

Tax calculation will be finalised at checkout

Purchases are for personal use only

Institutional subscriptions

References

  1. Abbott, J., Mulders, T.: How tight is Hadamard’s bound? Exp. Math. 10(3), 331–336 (2001). http://projecteuclid.org/euclid.em/1069786341

    Article  MathSciNet  Google Scholar 

  2. Applegate, D.L., Cook, W., Dash, S., Espinoza, D.G.: Qsopt\(\_\)ex. http://www.dii.uchile.cl/~daespino/ESolver_doc/

  3. Applegate, D.L., Cook, W., Dash, S., Espinoza, D.G.: Exact solutions to linear programming problems. Oper. Res. Lett. 35(6), 693–699 (2007). https://doi.org/10.1016/j.orl.2006.12.010

    Article  MathSciNet  MATH  Google Scholar 

  4. Azulay, D.-O., Pique, J.-F.Ç.: Optimized Q-pivot for exact linear solvers. In: Maher, M., Puget, J.-F. (eds.) CP 1998. LNCS, vol. 1520, pp. 55–71. Springer, Heidelberg (1998). https://doi.org/10.1007/3-540-49481-2_6

    Chapter  Google Scholar 

  5. Chen, Z., Storjohann, A.: A BLAS based C library for exact linear algebra on integer matrices. In: Proceedings of the 2005 International Symposium on Symbolic and Algebraic Computation, ISSAC 2005, pp. 92–99 (2005). https://doi.org/10.1145/1073884.1073899

  6. Cheung, D., Cucker, F.: Solving linear programs with finite precision: II. Algorithms. J. Complex. 22(3), 305–335 (2006). https://doi.org/10.1016/j.jco.2005.10.001

    Article  MathSciNet  MATH  Google Scholar 

  7. Cook, W., Steffy, D.E.: Solving very sparse rational systems of equations. ACM Trans. Math. Softw. 37(4), 39:1–39:21 (2011). https://doi.org/10.1145/1916461.1916463

    Article  MathSciNet  MATH  Google Scholar 

  8. Dhiflaoui, M., et al.: Certifying and repairing solutions to large LPs: how good are LP-solvers? In: Proceedings of the 14th Annual ACM-SIAM Symposium on Discrete Algorithms, SODA 2003, pp. 255–256. SIAM (2003)

    Google Scholar 

  9. Edmonds, J.: Systems of distinct representatives and linear algebra. J. Res. Natl. Bur. Stan. 71B(4), 241–245 (1967)

    Article  MathSciNet  Google Scholar 

  10. Edmonds, J., Maurras, J.F.: Note sur les \(Q\)-matrices d’Edmonds. RAIRO. Recherche Opérationnelle 31(2), 203–209 (1997). http://www.numdam.org/item?id=RO_1997__31_2_203_0

  11. Escobedo, A.R., Moreno-Centeno, E.: Roundoff-error-free algorithms for solving linear systems via Cholesky and LU factorizations. INFORMS J. Comput. 27(4), 677–689 (2015). https://doi.org/10.1287/ijoc.2015.0653

    Article  MathSciNet  MATH  Google Scholar 

  12. Escobedo, A.R., Moreno-Centeno, E.: Roundoff-error-free basis updates of LU factorizations for the efficient validation of optimality certificates. SIAM J. Matrix Anal. Appl. 38(3), 829–853 (2017). https://doi.org/10.1137/16M1089630

    Article  MathSciNet  MATH  Google Scholar 

  13. Gärtner, B.: Exact arithmetic at low cost - a case study in linear programming. Comput. Geom. 13(2), 121–139 (1999). https://doi.org/10.1016/S0925-7721(99)00012-7

    Article  MathSciNet  MATH  Google Scholar 

  14. Gleixner, A.M., Steffy, D.E., Wolter, K.: Iterative refinement for linear programming. INFORMS J. Comput. 28(3), 449–464 (2016). https://doi.org/10.1287/ijoc.2016.0692

    Article  MathSciNet  MATH  Google Scholar 

  15. Grötschel, M., Lovász, L., Schrijver, A.: Geometric Algorithms and Combinatorial Optimization. Algorithms and Combinatorics, vol. 2. Springer, Heidelberg (1988). https://doi.org/10.1007/978-3-642-78240-4

    Book  MATH  Google Scholar 

  16. Karmarkar, N.: A new polynomial-time algorithm for linear programming. Combinatorica 4(4), 373–395 (1984). https://doi.org/10.1007/BF02579150

    Article  MathSciNet  MATH  Google Scholar 

  17. Khachiyan, L.G.: Polynomial algorithms in linear programming (in Russian). Zhurnal Vychislitel’noi Matematiki i Matematicheskoi Fiziki 20(1), 51–68 (1980). https://doi.org/10.1016/0041-5553(80)90061-0. English translation: USSR Computational Mathematics and Mathematical Physics, 20(1):53-72, 1980

    Article  MathSciNet  Google Scholar 

  18. Koch, T.: The final NETLIB-LP results. Oper. Res. Lett. 32(2), 138–142 (2004). https://doi.org/10.1016/S0167-6377(03)00094-4

    Article  MathSciNet  MATH  Google Scholar 

  19. Kwappik, C.: Exact linear programming. Master’s thesis, Universität des Saarlandes, May 1998

    Google Scholar 

  20. Lenstra, A.K., Lenstra, H.W., Lovász, L.: Factoring polynomials with rational coefficients. Mathematische Annalen 261(4), 515–534 (1982). https://doi.org/10.1007/BF01457454

    Article  MathSciNet  MATH  Google Scholar 

  21. Renegar, J.: A polynomial-time algorithm based on Newton’s method, for linear programming. Math. Program. 40(1–3), 59–93 (1988). https://doi.org/10.1007/BF01580724

    Article  MathSciNet  MATH  Google Scholar 

  22. Schrijver, A.: Theory of Linear and Integer Programming. Wiley, New York (1986)

    MATH  Google Scholar 

  23. Steffy, D.E.: Exact solutions to linear systems of equations using output sensitive lifting. ACM Commun. Comput. Algebra 44(3/4), 160–182 (2011). https://doi.org/10.1145/1940475.1940513

    Article  MATH  Google Scholar 

  24. Wang, X., Pan, V.Y.: Acceleration of Euclidean algorithm and rational number reconstruction. SIAM J. Comput. 2(32), 548–556 (2003)

    Article  MathSciNet  Google Scholar 

  25. Zuse Institute Berlin: SoPlex. Sequential object-oriented simPlex. http://soplex.zib.de/

Download references

Author information

Authors and Affiliations

Authors

Corresponding author

Correspondence to Daniel E. Steffy .

Editor information

Editors and Affiliations

Appendix

Appendix

This appendix collects proofs for the main results used in the paper.

Proof of Theorem 2

Proof

Line 10 ensures that at iteration k, \(\varDelta _k \leqslant 2^{\lceil \log \alpha \rceil (k-1)}\) and thus \(\langle \varDelta _k\rangle \leqslant \lceil \log \alpha \rceil k\). From line 15, the entries in the refined solution vectors \(x_k,y_k\) have the form \( \sum _{j = 1}^k {\varDelta _j}^{-1} \frac{n_j}{2^p} \) with \(n_j \in \mathbb {Z}\), \(|n_j| \leqslant 2^{2p}\), for \(j = 1,\ldots ,k\). With \(D_j := \log (\varDelta _j)\) and \(a:= \lceil \log (\alpha )\rceil \) this can be rewritten as

$$\begin{aligned} \sum _{j = 1}^k 2^{-D_j} \frac{n_j}{2^p} = \big ( \sum _{j = 1}^k n_j 2^{a(k-1) - D_j} \big ) / 2^{p+ a(k-1)}. \end{aligned}$$
(6)

The latter is a fraction with integer numerator and denominator. The numerator is bounded by \(2^{2p+ ak} - 1\). Hence, \(\langle x_k\rangle + \langle y_k\rangle \leqslant (n+m) (2 ak + 3p+ 2)\). The numbers stored in \(\hat{ b}, \hat{l}, \hat{ c}\) and \(\delta _k\) satisfy the same asymptotic bound. By Lemma 1, the maximum number of iterations is \(O(\log (1/\tau )) = O(\langle \tau \rangle )\). All in all, the size of the numbers encountered during the algorithm is \(O(\langle A,b,\ell ,c\rangle + (n+m)\langle \tau \rangle )\).

Finally, the total number of elementary operations is polynomially bounded as follows. The initial rounding of the constraint matrix costs \(O(nnz)\) elementary operations, where nnz is the number of nonzero entries in A. For each of the \(O(\langle \tau \rangle )\) refinements, computing residual errors, maximum violation, and checking termination involves \(O(nnz+n+m)\) operations; the computation of the scaling factors takes constant effort, and the update of the transformed problem and the correction of the primal–dual solution vectors costs \(O(n+m)\) operations.    \(\square \)

Proof of Theorem 4

Proof

Let \(\varepsilon := \max \{\eta , 1/\alpha \}\), where \(\eta \) is the feasibility tolerance of the LP oracle and \(\alpha \) is the scaling limit used in Algorithm 1. Conditions (3a3c) of Theorem 3 follow directly from Lemma 1. We prove conditions (4a) and (4b) by induction. For \(k=1\), they follow from (2a) and (2b). Suppose they hold for \(k \geqslant 1\). Let \(\hat{ x},\hat{ y}, \hat{\mathcal {B}}\) be the last approximate solution returned by the oracle. Then for all \(i\not \in \mathcal {B}_{k+1}\)

proving (4a). The induction step for (4b) is analogous. Thus, the sequence of basic solutions \(x_k,y_k,\mathcal {B}_k\) satisfies the conditions of Theorem 3 and \(\mathcal {B}_k\) is optimal after a polynomial number of refinements. According to Theorem 2, this runs in oracle-polynomial time. The linear systems used to compute the basic solutions exactly over the rational numbers can be solved in polynomial time [9].    \(\square \)

Proof of Lemma 3

Proof

This result inherently relies on the boundedness of the corrector solutions returned by the oracle. Since their entries are in \(\mathbb {F}(p)\), \(||(\hat{x}_k,\hat{y}_k)||_\infty \leqslant 2^p\). Then \((x_k,y_k) = \sum _{i = 1}^k \frac{1}{\varDelta _{i}} (\hat{x}_i,\hat{y}_i)\) constitutes a Cauchy sequence: for any \(k,k' \geqslant K\), \(||(x_k,y_k) - (x_{k'},y_{k'})||_\infty \leqslant 2^p\sum _{i = K+1}^\infty \varepsilon ^i = 2^p\varepsilon ^{K+1} / (1 - \varepsilon )\), where \(\varepsilon \) is the rate of convergence from Lemma 1. Thus, a unique limit point \((\tilde{x},\tilde{y})\) exists. Using proof techniques as for Theorem 3 one can show that \((\tilde{x},\tilde{y})\) is basic, hence rational.    \(\square \)

Proof of Theorem 5

Proof

Note that \(\varDelta _{k} / \varDelta _{k+1} \leqslant \varepsilon \) for all k implies \(\varDelta _{i} \geqslant \varDelta _{j} \varepsilon ^{j-i}\) for all \(j \leqslant i\). Then \(M_k = \sqrt{\varDelta _{k+1} / (2 \beta ^k)} \geqslant \tilde{q}\) holds if \(\sqrt{1/(2 \beta ^k \varepsilon ^k)} \geqslant \tilde{q}\). This holds for all

$$\begin{aligned} k \geqslant K_1 := (2\log \tilde{q} + 1) / \log ( 1/(\beta \varepsilon ) ) \in O(\langle \tilde{q}\rangle ). \end{aligned}$$
(7)

Furthermore, \(C\sum _{i=k+1}^{\infty } \varDelta _i^{-1} \leqslant C\sum _{i=k+1}^{\infty } \varepsilon ^{i-k-1} \varDelta _{k+1}^{-1} = C / ((1-\varepsilon ) \varDelta _{k+1})\), which is less than \(1 / (2M_k^2) = \beta ^k / \varDelta _{k+1}\) for all

$$\begin{aligned} k > K_2 := (\log C - \log (1-\varepsilon )) / \log \beta \in O(\langle C\rangle ). \end{aligned}$$
(8)

Hence (5) holds for all \(k > K := \max \{ K_1, K_2 \}\).    \(\square \)

Proof of Lemma 4

Proof

From the proof of Theorem 2 we know that at the k-th iteration of the algorithm, the encoding length of the components of \(x_k,y_k\) are each bounded by \((2\alpha k +3 p + 2)\), which is O(k) as \(\alpha ,p\) are constants. Together with the fact that rational reconstruction can be performed in quadratic time, as discussed above, the first result is established.

To show the second claim we assume that \(f>1\) and let K be the final index at which rational reconstruction is attempted. Then if we consider the sequence of indices at which rational reconstruction was applied, that sequence is term-wise bounded above by the following sequence (given in decreasing order): \(S = (K, \lfloor K /f\rfloor , \lfloor K /f^2\rfloor ,\ldots , \lfloor K /f^a\rfloor )\) where \(a=\lceil \log _f{K}\rceil \). Thus, the cost to perform rational reconstruction at iterations indexed by the sequence S gives an upper bound on the total cost. Again, using the quadratic bound on the cost for rational reconstruction, we arrive at the following cumulative bound, involving a geometric series:

$$\begin{aligned} O\left( (n+m)\sum _{i=0}^a\lfloor K/f^i\rfloor ^2\right)&= O\left( (n+m)K^2 \sum _{i=0}^a f^{-2i}\right) =O((n+m)K^2). \end{aligned}$$

This establishes the result.    \(\square \)

Rights and permissions

Reprints and permissions

Copyright information

© 2019 Springer Nature Switzerland AG

About this paper

Check for updates. Verify currency and authenticity via CrossMark

Cite this paper

Gleixner, A., Steffy, D.E. (2019). Linear Programming Using Limited-Precision Oracles . In: Lodi, A., Nagarajan, V. (eds) Integer Programming and Combinatorial Optimization. IPCO 2019. Lecture Notes in Computer Science(), vol 11480. Springer, Cham. https://doi.org/10.1007/978-3-030-17953-3_30

Download citation

  • DOI: https://doi.org/10.1007/978-3-030-17953-3_30

  • Published:

  • Publisher Name: Springer, Cham

  • Print ISBN: 978-3-030-17952-6

  • Online ISBN: 978-3-030-17953-3

  • eBook Packages: Computer ScienceComputer Science (R0)

Publish with us

Policies and ethics