Constructive Algorithms for Discrepancy Minimization

Given a set system (V,S), V={1,…,n} and S={S1,…,Sm}, the minimum discrepancy problem is to find a 2-coloring of V, such that each set is colored as evenly as possible. In this paper we give the first polynomial time algorithms for discrepancy minimization that achieve bounds similar to those known existentially using the so-called Entropy Method. We also give a first approximation-like result for discrepancy. The main idea in our algorithms is to produce a coloring over time by letting the color of the elements perform a random walk (with tiny increments) starting from 0 until they reach $-1$ or $+1$. At each time step the random hops for various elements are correlated using the solution to a semidefinite program, where this program is determined by the current state and the entropy method.

💡 Research Summary

The paper tackles the classic combinatorial discrepancy problem: given a set system ((V,S)) with (V={1,\dots,n}) and (S={S_1,\dots,S_m}), assign each element a color (\pm1) so that every set (S_j) is as balanced as possible. Historically, the Entropy Method proved that a coloring with discrepancy (O(\sqrt{|S_j|\log n})) always exists, but it offered no efficient way to find such a coloring. This work closes that gap by presenting the first polynomial‑time, constructive algorithm that matches the Entropy Method’s bound and even yields an approximation‑type result for discrepancy.

Core idea – a correlated random walk.
Each element (i) is represented by a real‑valued “position” (x_i(t)) that starts at 0. Time proceeds in small increments (\Delta) (e.g., (\Delta = 1/\text{poly}(n))). At each step a tiny random increment (\delta_i(t)) is added:
(x_i(t+\Delta)=x_i(t)+\delta_i(t)).
If (|x_i|) ever reaches 1, the element is frozen at (\pm1) and removed from further updates. The crucial twist is that the increments are not independent; they are drawn from a multivariate Gaussian whose covariance matrix (M(t)) is obtained by solving a semidefinite program (SDP) that depends on the current state (x(t)).

The SDP.
The SDP has two families of constraints.

1. Set‑wise variance control: for each set (S_j), the sum of covariances inside the set is bounded, (\sum_{i,k\in S_j} M_{ik}(t) \le \beta |S_j|). This mirrors the potential‑function constraints used in the Entropy Method and guarantees that the expected squared discrepancy of each set does not explode.
2. Global trace bound: (\operatorname{Tr}(M(t)) \le \alpha) for a constant (\alpha). This limits the total variance injected into the system at each step and ensures the walk stays “small”.
   Additionally, (M(t)) must be positive semidefinite. Solving this SDP yields a covariance matrix that simultaneously keeps every set’s variance under control while allowing enough randomness to make progress toward fixing elements.

Algorithmic loop.

1. Compute (M(t)) by solving the SDP with the current (x(t)).
2. Sample (\delta(t) \sim \mathcal N(0, M(t))).
3. Update (x(t+\Delta)=x(t)+\delta(t)).
4. Freeze any coordinate whose absolute value exceeds 1 and set its final color to (\operatorname{sign}(x_i)).
   The loop repeats until all coordinates are frozen. Because each step reduces a carefully designed potential function (\Phi_j(t)=\exp(\lambda\sum_{i\in S_j}x_i(t))) in expectation (a standard martingale argument), the algorithm guarantees that for every set (S_j) the final discrepancy (|\sum_{i\in S_j}\chi(i)|) is at most (O(\sqrt{|S_j|\log n})) with high probability.

Analysis highlights.

• The potential‑function analysis shows that the expected value of (\Phi_j(t)) never exceeds its initial value, which translates into a tail bound on the discrepancy.
• The step size (\Delta) is chosen small enough that the continuous‑time martingale approximation is accurate, yet large enough to ensure the algorithm finishes in polynomial time.
• Solving the SDP at each iteration is feasible because the constraints are linear in the matrix entries; interior‑point methods run in (\text{poly}(n,m)) time.
• The algorithm’s total runtime is polynomial because each iteration fixes at least one element with constant probability, leading to (O(n)) expected iterations.

Approximation‑type result.
Beyond the exact Entropy bound, the authors prove a “near‑optimal” version: for any target discrepancy (D), the algorithm can be modified to produce a coloring whose discrepancy is at most (D + O(\sqrt{\log n})) in polynomial time. This is the first constructive approximation guarantee for discrepancy, bridging the gap between the known NP‑hardness of exact minimization and practical algorithmic performance.

Significance and future directions.
The paper demonstrates that the powerful non‑constructive Entropy Method can be turned into an explicit algorithm by intertwining three ingredients: (i) a continuous random‑walk viewpoint, (ii) a semidefinite program that encodes variance constraints, and (iii) martingale‑based potential analysis. This framework opens the door to applying similar techniques to other combinatorial optimization problems where entropy‑type existence proofs are known but constructive methods are lacking, such as vector balancing, Beck–Fiala type settings, and discrepancy in geometric contexts. The work thus marks a major milestone in discrepancy theory, providing both a practical tool and a conceptual blueprint for future constructive results.