Polylogarithmic Iteration Complexity

• Polylogarithmic iteration complexity is defined by an O((log n)^c) bound on iterations, offering significant parallel scalability in large optimization problems.
• It achieves efficient solutions by partitioning constraints into core-sequences that reduce parallel depth in distributed and MWU frameworks.
• Applications in packing/covering LPs, Metric-TSP, and kECSS demonstrate exponential improvements over traditional linear or polynomial iteration bounds.

Polylogarithmic iteration complexity describes an algorithmic regime where the number of computational steps or iterations necessary to solve a problem asymptotically scales as a polylogarithmic function of certain problem parameters, such as the input size, the number of constraints, or accuracy parameters. Formally, a function $f(n)$ is polylogarithmic in $n$ if $f(n) = O((\log n)^c)$ for some constant $c > 0$. Polylogarithmic iteration complexity is highly prized in parallel and distributed computation settings, as it enables sublinear depth (parallel time) and dramatic scalability even for algorithms on very large or implicitly defined problems.

1. Formal Definition and Motivation

Polylogarithmic iteration complexity refers to situations in algorithm design where the requisite number of iterations to reach a target solution (feasibility, optimality, accuracy) is $O((\log n)^c)$, typically with $n$ representing the problem size, number of variables, or constraints. This regime stands in contrast to linear, polynomial, or exponential iteration bounds, offering significant parallelizability and depth reduction in large-scale settings.

Such complexity is particularly consequential in the design of parallel solvers for packing/covering LPs with implicit constraint structures and combinatorial optimization problems. In classic settings, depth (or parallel time) is often proportional to the number of sequential iterations, so polylogarithmic depth implies near-optimal parallel speedups (Koh et al., 2024).

2. Core-Sequences and Polylogarithmic Depth in Parallel MWU Frameworks

Recent advances for packing/covering LPs and combinatorial algorithms have leveraged the core-sequence abstraction to transition iteration complexity from $poly(\log N)$—where $N$ is the total number of constraints, often prohibitively large—to polylogarithmic in structural parameters that are much smaller. In the Luby–Nisan/Young parallel MWU framework, a core-sequence is defined for each epoch as a short sequence of small batches of active constraints such that clearing each batch in order suffices to eliminate all violations below the threshold (Koh et al., 2024).

For a constraint matrix $A \in \mathbb{R}_{\geq 0}^{m \times N}$ and an epoch-oriented threshold $\lambda > 0$, the set of active constraints

$$B := \{ j \in [N] \mid (A^\top w)_j < (1+\varepsilon)\lambda \}$$

is partitioned into a sequence of batches $$\tilde{\mathcal{B}} = (\tilde B_1, \ldots, \tilde B_\ell)$$, each $\tilde B_k \subseteq B$. Crucially, the sum

$$\sum_{k=1}^\ell \frac{\log(|\tilde B_k|\log m/\varepsilon)}{\varepsilon^2}$$

governs the depth complexity per epoch, leading to overall work and depth bounds that are polylogarithmic in the sizes $|\tilde B_k|$ of the batches, not $N$ (Koh et al., 2024).

3. Applications: Metric-TSP and $k$-Edge-Connected Spanning Subgraph (kECSS)

In implicitly defined LPs such as the Metric-TSP cut-covering LP or the kECSS (Knapsack-Cover LP), core-sequence construction is enabled by the submodularity and posimodularity of the underlying combinatorial structure and Karger’s tree-packing theorem. For the Metric-TSP, every epoch admits a core-sequence of length $\ell = \widetilde{O}(1/\varepsilon^2)$, with each batch having cardinality $|\tilde B_k| = \widetilde{O}(n)$, and clearing is achieved in $\widetilde{O}(m)$ work and $\widetilde{O}(1)$ depth per batch. This yields total parallel depth

$\widetilde{O}(1/\varepsilon^4)$

on the full LP, a regime confirmed for both Metric-TSP and kECSS (Koh et al., 2024). Notably, this is the first parallel MWU-based solver for these LPs simultaneously achieving nearly-linear work and polylogarithmic depth.

4. Structural Techniques for Achieving Polylogarithmic Iteration Complexity

The construction of short and small core-sequences is typically underpinned by properties such as:

• Submodularity/Posimodularity: The structure of graph-cut functions constrains the number of active cuts, allowing batch sizes scaling with $n$.
• Tree-Packing: Sampling $O(\log n)$ spanning trees guarantees that every relevant min-cut is respected, so the depth reductions follow from path-doubling decompositions of these trees.
• Forbidden-$Z$ Argument: Extremal-matrix theory, applied to the posimodular structure, ensures that the number of small cuts or constraint violations per batch is bounded by $O(|P|)$ for each path $P$.

A plausible implication is that similar structural decompositions may extend polylogarithmic iteration complexity to other classes of implicitly defined combinatorial LPs or semidefinite programs, provided the requisite submodular structure is present.

5. Impact on the State of Parallel Optimization

The transition from $poly(\log N)$ depth—where $N$ may be exponential in input size—to polylogarithmic in the size of core-sequence batches (each $\widetilde{O}(n)$) constitutes an exponential improvement in iteration complexity for certain classes of LPs (Koh et al., 2024). This enables practical parallel solvers for problems such as approximating the Held-Karp bound for Metric-TSP or fractional kECSS, where previous parallel algorithms either incurred nearly-linear work or polynomial depth, but not both. The use of core-sequences is generic and has established new upper bounds for parallel MWU frameworks.

6. Limitations, Caveats, and Related Complexity Classes

Polylogarithmic iteration complexity is context-sensitive: the relevant parameters may depend on incidence structures, batch sizes, depth, or accuracy requirements. While core-sequences yield exponential depth improvement for certain LP classes, they rely on problem-specific combinatorial and algebraic properties such as cut submodularity and treepack respectness. For nonconvex optimization (e.g., restarted AGD, HB methods (Li et al., 2022)), attaining tight complexity bounds sometimes requires avoiding hidden polylogarithmic factors that can arise in sophisticated restart mechanisms or negative curvature procedures. Not all settings where polylogarithmic complexity is desirable are amenable to such reductions.

A plausible implication is that further reductions in polylogarithmic factors may be possible through additional restart or decomposition strategies, but only in settings where the problem structure supports hierarchical or local batch-clearing.

7. Connections to Polylogarithmic Step Complexity in Other Domains

Polylogarithmic complexity is not unique to optimization; similar concepts arise in distributed computing, such as the wait-free queue with $O(\log p)$ steps per enqueue and $O(\log^2 p+\log q)$ per dequeue, where $p$ is the process count and $q$ the queue size (Naderibeni et al., 2023). In such settings, the reduction of step complexity from linear (in $p$) to polylogarithmic fundamentally alters concurrent scalability. This illustrates that polylogarithmic iteration or step bounds derive their impact from parallelization and compositional decomposition, a unifying principle across computational domains.