Strongly Polynomial Work-Depth Tradeoffs

• The paper introduces strongly polynomial tradeoffs that decouple algorithm complexity from numerical magnitudes via batch discovery and heavy-light preprocessing in directed SSSP.
• It defines work as total computational effort and depth as parallel time, providing tunable tradeoffs for both dense and sparse graph scenarios.
• The techniques promise practical improvements for optimization problems such as min-cost flow and dynamic cycle detection, potentially reshaping parallel algorithm design.

Strongly Polynomial Work-Depth Tradeoffs refer to complexity-theoretic phenomena and algorithmic regimes in which one can achieve both sublinear parallel time ("depth") and subquadratic total computation ("work") for key combinatorial problems using algorithms whose cost parameters depend only on the combinatorial size of the input—independent of numerical magnitudes or bit complexities. The quintessential example, presented in "Strongly Polynomial Parallel Work-Depth Tradeoffs for Directed SSSP" (Karczmarz et al., 22 Oct 2025), demonstrates such tradeoffs for the directed Single-Source Shortest Paths (SSSP) problem in non-negatively weighted digraphs.

1. Formal Definition and Historical Context

A work-depth tradeoff quantifies the relationship between:

• Work ($W$): The total computational effort, often measured as the total number of operations or the cumulative size of the parallel computation.
• Depth ($D$): The length of the longest chain of dependent operations—equivalently, the parallel time to solve the problem on an ideal PRAM.

A strongly polynomial tradeoff is one in which both work and depth are polynomially bounded in the input size (e.g., $n$ vertices, $m$ edges of a graph) and critically, do not depend on parameters such as edge weights, bit lengths, or input magnitudes.

Historically, depth and work have been in tension. For example, parallelization of Dijkstra's algorithm for SSSP attains optimal work $\tilde{O}(m)$ but incurs depth $\tilde{O}(n)$; matrix squaring strategies (min-plus algebra) achieve constant depth but with cubic work $\tilde{O}(n^3)$. Classical “weakly polynomial” algorithms (e.g., Bellman-Ford, or Spencer's methods) depend on the largest edge weight, and thus fail strong polynomiality.

2. Fundamental Theorems: Directed SSSP

The core results are two explicit tradeoff theorems (dense and sparse graph cases):

• Dense SSSP Tradeoff:

For any $G = (V,E)$, $|V| = n$, $|E| = m$, fix batch size $t \in [1, n^{1/17}]$,

$$\text{Work}:~ \tilde{O}(m + n^{9/5} t^{17/5}), \qquad \text{Depth}:~ \tilde{O}(n/t)$$

By choosing $t = n^{\epsilon}$ ($\epsilon > 0$), one obtains:

$$\text{Work}:~ \tilde{O}(m + n^{2-\epsilon}), \qquad \text{Depth}:~ \tilde{O}(n^{1-\epsilon})$$

• Sparse SSSP Tradeoff:

For weighted $G$, batch size $t \in [1, m^{1/2}]$,

$$\text{Work}:~ \tilde{O}(m^{5/3}t^{2}+m^{3/2}t^{7/2}), \qquad \text{Depth}:~ \tilde{O}(m/t)$$

For any $\epsilon > 0$, these are strictly below the trivial $\tilde{O}(n^2)/\tilde{O}(n)$ thresholds for depth and work on dense graphs, and require only polynomial dependence on the core input parameters, not on edge weight magnitudes.

3. Algorithmic Machinery and Technical Principles

The advances hinge on multi-pronged algorithmic strategies:

• Grouped Exploration (Batch Discovery): Extends Dijkstra's method by exploring $t$ vertices in parallel ("batching"), using min-plus matrix operations for repeated squaring to simulate many Dijkstra advances in few parallel steps.
• Heavy-Light Preprocessing:

Constructs “near-lists” $NL(u)$ for each vertex $u$, precomputing the $t$ nearest neighbors robust to adversarial vertex removals. Vertices appearing too frequently (“heavy”) are handled specially to avoid congestion.

• Auxiliary Subgraph Construction:

An adaptive subgraph $H$ is formed at each stage containing heavy vertices, their neighborhoods, and other relevant nodes. This dramatically shrinks the instance size in each batch discovery step and allows careful control of both work and parallel overhead.

• Edge Filtering (Dense Graphs):

Enforces degree bounds by selective marking of “permanently heavy” vertices and retaining only the most relevant edges (“alive” edges).

The parameters $(t,p,\ell)$—controlling batch size, heavy threshold, and number of steps per phase—are tuned to balance exploration granularity and subgraph complexity.

4. Comparison to Classical and Previous Results

Algorithm/Reference	Work	Depth	Notes
Parallel Dijkstra	$\tilde{O}(m)$	$\tilde{O}(n)$	Strongly poly
Min-plus cubing	$\tilde{O}(n^3)$	$O(1)$	Strongly poly
Spencer '97 (weakly poly)	$(m+nt^2)\log L$	$(n/t)\log L$	Dependent on $L$
This work	$\tilde{O}(m + n^{9/5} t^{17/5})$	$\tilde{O}(n/t)$	Strongly poly, sublinear depth

Previous strongly polynomial parallel algorithms required either high work or failed for dense directed graphs. Weakly polynomial algorithms depended essentially on $L$ (largest edge weight); see (Karczmarz et al., 22 Oct 2025).

5. Implications for Classic and Dynamic Optimization Problems

The new tradeoffs impact several central problems:

• Min-Cost Flow and Assignment:

Orlin's strongly polynomial min-cost flow algorithm reduces to $\tilde{O}(m)$ SSSP computations. Plugging in the new tradeoff (dense case) yields:

$$\tilde{O}(m^2 + m n^{9/5} t^{17/5})\ \text{work,}\quad \tilde{O}(mn/t)\ \text{depth}$$

This improves substantially over historic $O(m^2)$ work for dense graphs with lower parallel time.

• Dynamic Minimum Mean Cycle/Min-Ratio Cycle:

Via Megiddo's parametric search, achieves the first non-trivial strongly polynomial dynamic algorithm (update time $\tilde{O}(mn^{1-1/22})$) for maintaining the min mean cycle under edge insertions.

• Lexicographic and Exponential Weights SSSP:

Extends the machinery to path measures valued in exponential or lexicographic domains (Theorems 7.1/7.2), while retaining near-optimal complexity.

6. Implementation Details and High-Level Pseudocode

The main loop (dense case) is as follows:

Input: G=(V, E), t ∈ [1, n^{1/17}] Preprocessing: - Compute heavy vertex set Z and near-lists NL(u) for all u Repeat until all V discovered: 1. Let S be current discovered set (initially {s}) 2. Contract S into source s' (update neighbor adjacency lists) 3. Build auxiliary graph H = induced subgraph on relevant vertices 4. Using parallel repeat-squaring, find t nearest vertices to s' in H 5. Mark these t as discovered and repeat

Efficient parallel data structures (batch-parallel BST/map-reduce) ensure work per iteration is bounded. Parameters $t$ and $p$ are critical for performance tuning.

7. Broader Impact, Open Problems, and Future Directions

This set of techniques breaks a longstanding barrier in parallel graph algorithms, especially for directed graphs and dense instances. Prior to this work, all parallel SSSP algorithms either incurred suboptimal work or were not strongly polynomial in input size. The tradeoff regime established here allows practical algorithm design with tunable parallel time and total work, with direct extensions to network flow and assignment algorithms beyond historic cost barriers.

A plausible implication is that further reductions in depth for directed SSSP—without increasing work above quadratic—may require entirely new algorithmic paradigms or deeper structural insights. Extending analogous tradeoffs to undirected graphs with negative weights, or to all-pairs shortest paths, remains an important open problem. The batch exploration/near-list approach may inform progress in dynamic graph algorithms and parallel computation for more general path-property optimization problems.

---

Summary Table: Work-Depth Tradeoffs for Directed SSSP

Setting	Work	Depth	Valid for
Dense (this work)	$\tilde{O}(m + n^{2-\epsilon})$	$\tilde{O}(n^{1-\epsilon})$	non-neg, real
Sparse (this work)	$\tilde{O}(m^{5/3} t^2 + m^{3/2} t^{7/2})$	$\tilde{O}(m/t)$	non-neg, real
Previous (weak poly)	$(m + nt^2)\log L$	$(n/t)\log L$	integer weights
Previous (Dijkstra)	$\tilde{O}(m)$	$\tilde{O}(n)$	non-neg, real

---

Strongly polynomial work-depth tradeoffs characterize a regime where both sublinear parallel time and subquadratic work are attainable for core directed graph problems, without dependence on numerical edge weights, using batch discovery, heavy-light partitioning, and optimized auxiliary graphs. This advances the landscape for parallel combinatorial optimization significantly.