Classification of Local Optimization Problems in Directed Cycles

We present a complete classification of the distributed computational complexity of local optimization problems in directed cycles for both the deterministic and the randomized LOCAL model. We show that for any local optimization problem $Π$ (that can be of the form min-sum, max-sum, min-max, or max-min, for any local cost or utility function over some finite alphabet), and for any constant approximation ratio $α$, the task of finding an $α$-approximation of $Π$ in directed cycles has one of the following complexities: 1. $O(1)$ rounds in deterministic LOCAL, $O(1)$ rounds in randomized LOCAL, 2. $Θ(\log^* n)$ rounds in deterministic LOCAL, $O(1)$ rounds in randomized LOCAL, 3. $Θ(\log^* n)$ rounds in deterministic LOCAL, $Θ(\log^* n)$ rounds in randomized LOCAL, 4. $Θ(n)$ rounds in deterministic LOCAL, $Θ(n)$ rounds in randomized LOCAL. Moreover, for any given $Π$ and $α$, we can determine the complexity class automatically, with an efficient (centralized, sequential) meta-algorithm, and we can also efficiently synthesize an asymptotically optimal distributed algorithm. Before this work, similar results were only known for local search problems (e.g., locally checkable labeling problems). The family of local optimization problems is a strict generalization of local search problems, and it contains numerous commonly studied distributed tasks, such as the problems of finding approximations of the maximum independent set, minimum vertex cover, minimum dominating set, and minimum vertex coloring.

💡 Research Summary

This paper delivers a complete classification of the distributed computational complexity of all local optimization problems (LOPs) on directed cycles, covering both deterministic and randomized LOCAL models. A local optimization problem is defined by a finite output alphabet Γ, a locality radius r, and a cost/utility function c that assigns a numeric value to each (r + 1)-tuple of output labels. The global objective can be one of four forms—max‑min, max‑sum, min‑max, or min‑sum—and the goal is to compute an α‑approximation for a constant α ≥ 1.

The authors prove that, regardless of the specific LOP or the chosen α, the round complexity of finding an α‑approximation on a directed n‑node cycle falls into exactly one of four classes:

1. O(1) rounds in both deterministic and randomized LOCAL.
2. Θ(log⁎ n) rounds deterministically, O(1) rounds randomly.
3. Θ(log⁎ n) rounds in both models.
4. Θ(n) rounds in both models.

To achieve this, they introduce a systematic reduction of any LOP to a de Bruijn‑type directed graph G whose vertices correspond to all possible local configurations (the (r + 1)-tuples) and whose edges represent the shift along the cycle. A feasible global solution corresponds to a closed walk in G, and the total cost/utility equals the sum of edge‑weights along that walk.

Four subgraphs of G are defined:

• G_opt (the whole graph),
• G_flex (the “flexible” strongly‑connected components that admit closed walks of every sufficiently large length),
• G_gap (flexible components that also contain a self‑loop),
• G_const (the subgraph consisting solely of self‑loops).

From these subgraphs the authors extract seven purely graph‑theoretic parameters: β_opt, β_flex, δ_flex, β_coprime, β_gap, δ_gap, and β_const. Roughly, each β measures the average cost per node of the cheapest closed walk in the corresponding subgraph, while each δ captures the minimal length needed to realize that walk. β_coprime captures the cheapest pair of closed walks whose lengths are coprime, a notion needed for max‑min and min‑max problems.

The key insight is that the relative magnitudes of these parameters completely determine which of the four complexity classes a given (Π, α) pair belongs to. For example, if β_opt is constant and a self‑loop exists, the problem is solvable in O(1) rounds. If β_flex is constant but β_const is large, deterministic algorithms need Θ(log⁎ n) (e.g., Cole‑Vishkin coloring) while randomization can break symmetry in constant time using a random ruling set. If only β_gap is constant, both models need Θ(log⁎ n). When none of the cheap cycles exist and α forces a solution close to the optimum, any algorithm must essentially explore the whole cycle, yielding Θ(n) rounds.

The paper provides a three‑step algorithmic framework:

1. Parameter Extraction – Construct G (polynomial in the description size of Π), identify the four subgraphs, and compute the seven parameters using standard graph algorithms (strongly‑connected components, shortest cycles, and coprime length detection).
2. Complexity Determination – Compare the parameters against α to decide the appropriate class. This decision procedure runs in polynomial time and is fully automated.
3. Algorithm Synthesis – Based on the class, automatically generate an asymptotically optimal distributed algorithm:
   • For O(1) class: direct local rule evaluation.
   • For Θ(log⁎ n) deterministic: Cole‑Vishkin or similar symmetry‑breaking.
   • For Θ(log⁎ n) randomized: constant‑time random ruling set or random color assignment.
   • For Θ(n): a simple brute‑force scan of the whole cycle.

The authors illustrate the theory with several canonical problems (maximum independent set, minimum dominating set, minimum vertex coloring, domatic partition) and a crafted “sloppy coloring” example that exhibits all four regimes as α varies. In the sloppy coloring case, they show precise α‑thresholds where the complexity jumps from Θ(n) to Θ(log⁎ n) to O(1), confirming the tightness of their classification.

Beyond the technical contributions, the work has broader implications. It demonstrates that for directed cycles, increasing the runtime from Θ(log⁎ n) to any intermediate bound (e.g., Θ(log n) or Θ(√n)) never yields a better constant‑factor approximation; only a jump to Θ(n) can improve the approximation ratio beyond certain limits. Moreover, the meta‑algorithm provides a practical tool: given a new local optimization problem, a researcher can input its local cost table and instantly obtain both the theoretical round‑complexity classification and a ready‑to‑run distributed algorithm.

In summary, the paper establishes a clean, four‑tiered complexity landscape for all constant‑approximation local optimization problems on directed cycles, supplies a polynomial‑time decision procedure, and automates the synthesis of optimal distributed algorithms. This advances the state of the art from the well‑understood LCL setting to the richer realm of optimization, opening avenues for similar classifications on other graph families such as trees or grids.