Deterministic O(m polylog m) maximum flow, or an m^(1+o(1)) implementation that beats push-relabel
Difficulty is low-to-mid because the theory is largely in place and the gap is constant factors and engineering, though removing the m^{o(1)} factor deterministically is a real theory problem. Application value is moderate: flow underlies many pipelines but push-relabel already scales well in practice. Leverage is narrow: algorithm engineering and a few theory results depend on it.
The problem
An almost-linear-time method for pushing the most stuff through a network exists on paper, but is too complicated to use.
- 1Max flow: most stuff through a network
- 22022: near-linear time method found
- 3Too complex and heavy to run
- 4Goal: simple deterministic and fast
- 5Open: beat practical codes on huge graphs
The problem. Given a directed graph with edges and integer capacities in with , find a maximum – flow. Almost-linear-time algorithms with running time exist, including deterministic ones, but the factor is a large subpolynomial overhead, and they rely on dynamic data structures for low-stretch decompositions and expander hierarchies. The task: find a deterministic algorithm running in time, or at least an implementation of an algorithm whose measured running time on standard benchmark families (DIMACS, SNAP) beats push-relabel and Dinic implementations on graphs with .
Path to understanding
foundations → problemThe research entries this problem rests on, in the order to read them. Each links to its explainer.
- Start with
- Step 2
- Step 3
- Fast matrix multiplicationAlgorithm
- Step 4
- Linear programmingAlgorithm · host
- Then
- Deterministic O(m polylog m) maximum flow, or an m^(1+o(1)) implementation that beats push-relabelThe problem
State of the art
Almost-linear time. Chen, Kyng, Liu, Peng, Probst Gutenberg and Sachdeva (arXiv March 2022; FOCS 2022) solve exact max flow and min-cost flow on directed graphs with polynomially bounded integer data in time. The method is an interior-point method whose steps are approximate undirected minimum-ratio cycles, found with a dynamic data structure with amortised update time. Van den Brand, Chen, Kyng, Liu, Peng, Probst Gutenberg, Sachdeva and Sidford (arXiv September 2023; FOCS 2023) made it deterministic. The framework extends to convex edge-separable objectives, including entropy-regularised optimal transport and matrix scaling. The factor hides a large subpolynomial overhead, and no implementation competitive with push-relabel or Dinic codes is reported in the sources reviewed.
Realistic applications
A practical near-linear max-flow would speed up everything reducible to flows: bipartite matching, image segmentation, scheduling, network reliability and transportation, as well as min-cost flow and optimal-transport solvers. Today the asymptotically fastest algorithms are not used in practice, so the benefit would come from an implementable variant, not from the theoretical bound alone.
What counts as solved
(a) A proof of a deterministic max-flow algorithm, or (b) an open-source implementation of a worst-case algorithm whose wall-clock time on the standard benchmark suites at is at least competitive with the best push-relabel code, with a reproducible report. (a) is theoretical resolution; (b) is the practical target.
How it gets verified
ReproductionA training run, experiment or computation rerun by someone else.
Part (b) is checkable by running: an open-source implementation of a worst-case m^(1+o(1)) algorithm must be at least competitive in wall-clock time with the best push-relabel code on the standard benchmark suites at m >= 10^8. The report must name the machine, compiler flags, instance suites, a correctness check of the flow value against a reference solver, and the number of repeats. Part (a), a deterministic O(m polylog m) proof, goes to expert review.
Claims under verification
+ add a claimNo claimed results on the Verification board for this problem yet.
Where the work is
Half of the work is simplifying the theory (replacing expander hierarchies with something implementable) and half is a serious implementation with benchmarking.
Bottlenecks
ranked by votes- #1TheorySubpolynomial overhead and heavy data structures
The m^{o(1)} factors come from recursive expander decompositions and dynamic low-stretch trees whose constants are enormous; simpler routes are only starting to appear.
Community grades
Sign in to add your own grade.
Connected problems
No connections yet.
Progress
- Aug 1, 2026Preprint: m^(1+o(1)) without the outer interior-point methodsource
Li and Wice report an approximate pseudo-circulation route to max flow; not yet refereed.
- Jun 5, 2024Combinatorial algorithm for dense graphssource
Bernstein, Blikstad, Saranurak and Tu gave an augmenting-path algorithm in n^(2+o(1)) log U time (FOCS 2024).
- Sep 28, 2023Deterministic almost-linear timesource
Van den Brand et al. derandomised the algorithm (FOCS 2023).
- Mar 1, 2022Almost-linear-time max flowsource
Chen et al. gave an m^(1+o(1)) max-flow and min-cost flow algorithm (FOCS 2022).