Near-Linear Time Algorithm for n-fold ILPs via Color Coding

Jansen, Klaus; Lassota, Alexandra; Rohwedder, Lars

doi:10.48550/arxiv.1811.00950

Cited by 3 publications

(10 citation statements)

References 9 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…Subsequent work. Jansen, Lassota, and Rohwedder [36] showed a near-linear time algorithm for n-fold IP, which has a slightly better parameter dependence but slightly worse dependence on n when compared with our algorithms, and only applies to the case of (ILP) while our algorithm also solves (IP) and generalizes to tree-fold IP. Knop, Pilipczuk, and Wrochna [44] gave lower bounds for (ILP) with few rows and also (ILP) parameterized by td D (A); our lower bound of Theorem 114 generalizes their latter bound.…”

Section: Type Of Instancementioning

confidence: 79%

“…Previous best run time Our result n-fold a O(r st +st 2 ) n 3 L [28] a O(r 2 s+r s 2 ) (nt) 2 log 3 (nt) + R(A, L) Cor 91 a O(r 2 s+r s 2 ) (nt) log(nt)L Cor 91 n f1(a,r,s,t ) [11] t O(r ) (ar ) [42] (ars) O(r 2 s+s 2 ) (nt) log 6 (nt)L [36] 2-stage stochastic f 2 (a, r , s)n 3 L [49] f 3 (a, r , s)n 2 log 5 n + R(A, L) Cor 93 f 3 (a, r , s)n log 3 nL Cor 93 f 3 (a, r , s)n 2 log nL [40] Tree-fold f 4 (a, r 1 , . .…”

Section: Type Of Instancementioning

confidence: 99%

“…Second, when it comes to optimization, the situation differs significantly in the case of linear and separable convex functions. For the linear case, Jansen et al [36] use an elegant argument to show that unboundedness can be detected and convergence is fast. We present their proof for completeness.…”

Section: Feasibility Oraclesmentioning

confidence: 99%

See 2 more Smart Citations

An Algorithmic Theory of Integer Programming

Eisenbrand¹,

Hunkenschröder²,

Klein³

et al. 2019

Preprint

View full text Add to dashboard Cite

We study the general integer programming problem where the number of variables n is a variable part of the input. We consider two natural parameters of the constraint matrix A: its numeric measure a and its sparsity measure d. We show that integer programming can be solved in time д(a, d)poly(n, L), where д is some computable function of the parameters a and d, and L is the binary encoding length of the input. In particular, integer programming is fixed-parameter tractable parameterized by a and d, and is solvable in polynomial time for every fixed a and d. Our results also extend to nonlinear separable convex objective functions. Moreover, for linear objectives, we derive a strongly-polynomial algorithm, that is, with running time д(a, d)poly(n), independent of the rest of the input data.We obtain these results by developing an algorithmic framework based on the idea of iterative augmentation: starting from an initial feasible solution, we show how to quickly find augmenting steps which rapidly converge to an optimum. A central notion in this framework is the Graver basis of the matrix A, which constitutes a set of fundamental augmenting steps. The iterative augmentation idea is then enhanced via the use of other techniques such as new and improved bounds on the Graver basis, rapid solution of integer programs with bounded variables, proximity theorems and a new proximity-scaling algorithm, the notion of a reduced objective function, and others.As a consequence of our work, we advance the state of the art of solving block-structured integer programs. In particular, we develop near-linear time algorithms for n-fold, tree-fold, and 2-stage stochastic integer programs. We also discuss some of the many applications of these classes.

show abstract

Section: Type Of Instancementioning

confidence: 79%

Section: Type Of Instancementioning

confidence: 99%

See 1 more Smart Citation

An Algorithmic Theory of Integer Programming

Eisenbrand¹,

Hunkenschröder²,

Klein³

et al. 2019

Preprint

View full text Add to dashboard Cite

show abstract

“…Eisenbrand et al [10] independently (and using slightly different techniques) arrive at the same complexity of N -fold IP as our Theorem 2. Jansen et al [20] have shown a near-linear time algorithm for N -fold IP with linear objectives. Their approach is relevant to implementations of an FPT algorithm for N -fold IP, however due to our approach of using existing ILP solvers as a subroutine we do not exploit it.…”

Section: Related Workmentioning

confidence: 99%

“…For each generated instance we run the iterative algorithm for various choices of the augmentation strategy Γ ∈ {Γ any , Γ best , Γ 2-apx , Γ 5-apx , Γ 10-apx } and the tuning parameter g 1 . The main parameters are thus gc_values A list of integers, by default [4,8,12,20,30,40,50,75,100], corresponding to choices of g 1 .…”

Section: Common Parametersmentioning

confidence: 99%

Evaluating and Tuning n -fold Integer Programming

Altmanová

Knop

Koutecký

2019

ACM J. Exp. Algorithmics

View full text Add to dashboard Cite

In recent years, algorithmic breakthroughs in stringology, computational social choice, scheduling, etc., were achieved by applying the theory of so-called n-fold integer programming. An n-fold integer program (IP) has a highly uniform block structured constraint matrix. Hemmecke, Onn, and Romanchuk [Math. Programming, 2013] showed an algorithm with runtime ∆ O(rst+r 2 s) n 3 , where ∆ is the largest coefficient, r, s, and t are dimensions of blocks of the constraint matrix and n is the total dimension of the IP; thus, an algorithm efficient if the blocks are of small size and with small coefficients. The algorithm works by iteratively improving a feasible solution with augmenting steps, and n-fold IPs have the special property that augmenting steps are guaranteed to exist in a not-too-large neighborhood. However, this algorithm has never been implemented and evaluated.We have implemented the algorithm and learned the following along the way. The original algorithm is practically unusable, but we discover a series of improvements which make its evaluation possible. Crucially, we observe that a certain constant in the algorithm can be treated as a tuning parameter, which yields an efficient heuristic (essentially searching in a smaller-than-guaranteed neighborhood). Furthermore, the algorithm uses an overly expensive strategy to find a "best" step, while finding only an "approximately best" step is much cheaper, yet sufficient for quick convergence. Using this insight, we improve the asymptotic dependence on n from n 3 to n 2 log n.Finally, we tested the behavior of the algorithm with various values of the tuning parameter and different strategies of finding improving steps. First, we show that decreasing the tuning parameter initially leads to an increased number of iterations needed for convergence and eventually to getting stuck in local optima, as expected. However, surprisingly small values of the parameter already exhibit good behavior while significantly lowering the time the algorithm spends per single iteration. Second, our new strategy for finding "approximately best" steps wildly outperforms the original construction. ACM Subject ClassificationTheory of computation → Parameterized complexity and exact algorithms; Mathematics of computing → Solvers; Theory of computation → Discrete optimization Keywords and phrases n-fold integer programming, integer programming, analysis of algorithms, primal heuristic, local search Supplement Material https://github.com/katealtmanova/nfoldexperiment

show abstract

About the Complexity of Two-Stage Stochastic IPs

Klein

2020

Integer Programming and Combinatorial Optimization

View full text Add to dashboard Cite

We consider so called 2-stage stochastic integer programs (IPs) and their generalized form of multi-stage stochastic IPs. A 2-stage stochastic IP is an integer program of the form max{c T x | Ax = b, l ≤ x ≤ u, x ∈ Z nt+s } where the constraint matrix A ∈ Z r×s consists roughly of n repetition of a block matrix A on the vertical line and n repetitions of a matrix B ∈ Z r×t on the diagonal.In this paper we improve upon an algorithmic result by Hemmecke and Schultz form 2003 [17] to solve 2-stage stochastic IPs. The algorithm is based on the Graver augmentation framework where our main contribution is to give an explicit doubly exponential bound on the size of the augmenting steps. The previous bound for the size of the augmenting steps relied on non-constructive finiteness arguments from commutative algebra and therefore only an implicit bound was known that depends on parameters r, s, t and ∆, where ∆ is the largest entry of the constraint matrix. Our new improved bound however is obtained by a novel theorem which argues about the intersection of paths in a vector space.As a result of our new bound we obtain an algorithm to solve 2-stage stochastic IPs in time poly(n, t) · f (r, s, ∆), where f is a doubly exponential function.To complement our result, we also prove a doubly exponential lower bound for the size of the augmenting steps. * This work was mostly done during the authors time at EPFL. The project was supported by the Swiss National Science Foundation (SNSF) within the project Convexity, geometry of numbers, and the complexity of integer programming (Nr.163071)

show abstract

Near-Linear Time Algorithm for n-fold ILPs via Color Coding

Cited by 3 publications

References 9 publications

An Algorithmic Theory of Integer Programming

An Algorithmic Theory of Integer Programming

Evaluating and Tuning n -fold Integer Programming

About the Complexity of Two-Stage Stochastic IPs

Contact Info

Product

Resources

About