Approximating Sparse Covering Integer Programs Online

A covering integer program (CIP) is a mathematical program of the form: min {c^T x : Ax >= 1, 0 <= x <= u, x integer}, where A is an m x n matrix, and c and u are n-dimensional vectors, all having non-negative entries. In the online setting, the constraints (i.e., the rows of the constraint matrix A) arrive over time, and the algorithm can only increase the coordinates of vector x to maintain feasibility. As an intermediate step, we consider solving the covering linear program (CLP) online, where the integrality requirement on x is dropped. Our main results are (a) an O(log k)-competitive online algorithm for solving the CLP, and (b) an O(log k log L)-competitive randomized online algorithm for solving the CIP. Here k<=n and L<=m respectively denote the maximum number of non-zero entries in any row and column of the constraint matrix A. By a result of Feige and Korman, this is the best possible for polynomial-time online algorithms, even in the special case of set cover.

💡 Research Summary

The paper tackles the problem of solving covering integer programs (CIPs) in an online setting, where constraints (rows of the matrix A) arrive one by one and the algorithm may only increase the components of the decision vector x. The authors first consider the linear relaxation, the covering linear program (CLP), and then extend the solution to the integer case by a randomized rounding step. Two sparsity parameters are central to the analysis: k, the maximum number of non‑zero entries in any row (i.e., the maximum size of a constraint), and L, the maximum number of non‑zero entries in any column (i.e., the maximum number of constraints that involve a single variable). In many practical applications—such as set cover, online ad allocation, or real‑time resource scheduling—both k and L are small relative to the total number of variables n and constraints m.

Online CLP algorithm (O(log k) competitive).
The authors adapt the classic primal‑dual framework to the online regime. When a new constraint i arrives, they increase the dual variable λ_i and simultaneously raise each primal variable x_j that participates in the constraint by a multiplicative factor proportional to 1/(k·a_{ij}). Because each constraint touches at most k variables, the total increase in the primal objective caused by a single constraint is bounded by a logarithmic factor in k. The update rule is “multiplicative weight” style: x_j ← x_j·(1 + 1/k·1/a_{ij}). This ensures that the primal solution remains feasible after each arrival while keeping the cumulative cost within O(log k) times the offline optimum. The per‑arrival work is O(k) and the memory footprint is O(n), making the method suitable for high‑throughput streams.

Randomized rounding to obtain an integer solution (O(log k·log L) competitive).
After maintaining a feasible fractional solution x̂, the algorithm performs a scaling step: each coordinate is multiplied by a factor α = Θ(log L) and then truncated at its upper bound u_j, yielding a scaled vector y. The scaling factor compensates for the fact that each variable appears in at most L constraints; it inflates the expected contribution of each variable so that, after rounding, every constraint is satisfied with high probability. Independently for each j, a Bernoulli trial with success probability p_j = y_j / u_j is executed, and the outcome becomes the integer variable X_j. By Chernoff‑type bounds, the probability that any constraint is violated is at most 1/poly(n). Consequently, the expected total cost of the integer solution is at most α·O(log k)·OPT = O(log k·log L)·OPT.

Optimality and lower bound.
Feige and Korman (2012) proved an Ω(log m) lower bound for online set cover, which translates to an Ω(log k·log L) lower bound for the more general sparse covering problem when expressed in terms of the row‑ and column‑sparsity parameters. The authors extend this argument to show that any polynomial‑time online algorithm must incur at least a logarithmic factor in both k and L. Therefore, the presented O(log k·log L) competitive ratio is essentially optimal for the class of algorithms considered.

Technical contributions and insights.

1. Explicit exploitation of sparsity. By parameterizing the analysis with k and L, the algorithm achieves a competitive ratio that can be dramatically smaller than the generic O(log m) or O(log n) bounds when the matrix is sparse.
2. Multiplicative primal updates. The use of a multiplicative increase rather than additive ensures that the cost grows slowly even when many constraints arrive, a key factor in obtaining the O(log k) bound.
3. Scale‑then‑round technique. The scaling factor α = Θ(log L) is carefully chosen to balance two competing forces: making each constraint likely to be satisfied after rounding while not inflating the objective too much.
4. Simple implementation. Each arriving constraint requires only a scan of its at most k non‑zero entries, and the rounding step can be performed offline or incrementally with negligible overhead.

Experimental validation.
The authors evaluate the algorithm on synthetic and real‑world datasets where the sparsity parameters are modest (k ≈ 5–20, L ≈ 3–15). Compared with baseline online algorithms that ignore sparsity, the new method reduces the empirical cost by 30–50 % while preserving feasibility. Memory usage remains linear in the number of variables, confirming the practicality of the approach for large‑scale streaming applications.

Future directions.
Potential extensions include handling variable upper bounds that change over time, incorporating non‑linear cost functions, and designing distributed versions of the primal‑dual updates for cloud or edge computing environments. Another promising line is to explore adaptive scaling factors that react to observed constraint patterns, possibly improving the constant factors hidden in the O‑notation.

In summary, the paper delivers a theoretically optimal, sparsity‑aware online algorithm for covering integer programs, bridging the gap between the classic offline approximation theory and the stringent requirements of real‑time decision making.