Expander Compiler Collection (ECC)

• Expander Compiler Collection (ECC) is a systematic framework for nearly-linear-time graph algorithms that unifies classical and length-constrained expander decompositions.
• It provides scalable modules for efficient network partitioning, routing, and sparse flow computation with provable approximation and tunable trade-offs.
• ECC extends traditional expander techniques by incorporating general edge lengths and capacities, facilitating advanced applications like multi-commodity flow and dynamic distance oracles.

The Expander Compiler Collection (ECC) is a systematic and extensible framework for constructing nearly-linear time algorithms for a broad class of graph algorithmic problems. At its core, ECC abstracts and unifies the use of expander decompositions and related structural graph techniques, offering algorithmic primitives (modules) for network decomposition, routing, and partitioning that are efficient, flexible, and amenable to formal analysis. ECC's scope has broadened to encompass advanced constructs such as length-constrained expander decompositions, enabling sophisticated algorithmic trade-offs in both theory and practical implementation.

1. Foundations and Motivation

Expander decompositions have historically underpinned close-to-linear-time algorithms for classical graph problems such as global min-cut, multi-commodity flow, and network design. Traditional expander decompositions focus on partitioning $n$-vertex, $m$-edge graphs into a small collection of vertex-induced subgraphs, each with strong expansion, while controlling the number of inter-part edges. Application of such decompositions—particularly in routing and sparsification—facilitates oblivious routing schemes, cut approximations, and sampling-based reductions.

However, classic expander decompositions do not address requirements involving edge lengths, costs, or path length constraints, which are critical in settings such as distance-sensitive routing and cost-sensitive flows. The ECC framework is motivated by the need to generalize these techniques—covering general edge capacities, lengths, and distance guarantees—while guaranteeing algorithmic efficiency, provable approximation, and feasible trade-off regimes.

2. Core Concepts: Expander Decomposition and Length-Constrained Generalizations

Expander Decomposition

An expander decomposition partitions a graph into subgraphs (expanders) such that each part exhibits strong edge expansion with respect to its size (conductance at least $\phi$), and the sum of the "boundary" (cut) sizes is tightly bounded relative to the size of the graph. This decomposition allows for balanced, low-congestion flow routing: any demand can be efficiently routed by "switching" only at a modest number of cross-part cut edges.

Length-Constrained $(h, s)$ $\phi$-Expander Decomposition

A principal innovation integrated in modern ECC is the length-constrained expander decomposition (Haeupler et al., 20 Apr 2024). It extends classical decompositions by enforcing the following: for each node subset with a bounded diameter (in terms of original lengths), there exists a collection of length increases (i.e., cut modifications) that transform the graph such that all $h$-length, unit demands can be routed in the augmented graph using paths of length at most $hs$, incurring congestion $O(1/\phi)$.

Formally, an $(h, s)$-length $\phi$-expander decomposition for node-weighting $A$ consists of a collection of length increases of total cost at most $K|A|$, after which $A$ is $(h, s)$-length $\phi$-expanding.

3. ECC Algorithmic Modules: Structures, Theorems, and Algorithms

Structural Theorems: Union of Sparse Cuts

A central theoretical pillar is the "union-of-sparse-cuts" theorem. In classical settings, the union of $O(\log n)$ sparse cuts remains sparse up to a polylogarithmic factor, guaranteeing robustness under sequential cut operations. The length-constrained version (Theorem 1.2 (Haeupler et al., 20 Apr 2024)) asserts that for a sequence of $(h, s)$-length $\phi$-sparse cuts on residual graphs, their union yields an $(2h, s-2)$-length $\phi'$-sparse cut, where $\phi'$ is controlled by a function of $s$, $\log n$, and the relative sparsities.

$$\phi' = \Theta(s^3 \log^3 n \cdot n^{O(1/s)} \cdot {\sum_i |C_i|}/{\sum_i |C_i|/\phi_i})$$

This property is crucial for ensuring that iterative or recursive decomposition procedures do not accumulate excessive slack or lose expansion guarantees.

Algorithmic Primitives

ECC provides efficient, scalable modules for:

• Sparse Length-Constrained Flows: Algorithms for computing $h$-length flows and corresponding cuts with support $\widetilde{O}(|E| + b)$ and work $m \cdot \widetilde{O}(b \cdot \mathrm{poly}(h))$ (Theorem 1.3).
• Witnessed and Linked Decompositions: Outputs furnish not just the decomposition but explicit routing tables (certificates) attesting to expansion and routing properties for each part, ensuring robustness under local modifications.
• Spiral Recursion Framework: Through equivalence theorems (e.g., Theorem 11.1), ECC leverages the equivalence (up to controllable slack) between maximal sparse cut size, expander complementation, and minimum decomposition size to drive recursive partitioning and decomposition, alternating between cut separation and expansion certification.

Complexity and Trade-offs

For any $\epsilon > 0$ (not too small), ECC computes a length-constrained expander decomposition of size $m \cdot \phi \cdot n^\epsilon$ in close-to-linear time with path length slack $s = \exp(\mathrm{poly}(1/\epsilon))$. By tuning $\epsilon$, practitioners can balance between decomposition size (cut overhead) and the permitted path length increase.

4. Practical Applications and Implementations

ECC's design enables:

• $O(1)$-Approximate Multi-Commodity Flow Algorithms: By leveraging coarse decompositions, flows can be efficiently routed with both congestion and path length guarantees close to optimal, extending to capacitated, length-sensitive settings.
• Distributed and Oblivious Routing: The decomposition and routing tables output by ECC algorithms are sufficiently local and robust to be deployed in distributed settings, supporting demand-independent oblivious routing with constant-factor competitiveness in both length and congestion.
• Dynamic Distance Oracles: Length-constrained decompositions support oracles with sublinear update and query times and explicit control over the distance stretch.

ECC modules are constructed to accept graphs with general positive edge capacities and lengths. The underlying algorithms avoid dependence on the diameter, using structural arguments (e.g., arboricity bounds, spanner constructions) to ensure scalability.

5. Innovations Beyond Prior Expander-Based Frameworks

The ECC framework, as augmented by (Haeupler et al., 20 Apr 2024), subsumes previous approaches (e.g., [HRG22]) by:

• Supporting general edge lengths and capacities in both theoretical guarantees and algorithmic implementation.
• Providing tunable trade-offs between length slack and decomposition (cut) size.
• Enabling proportional routing guarantees: for each demand pair, the routed path length is commensurate with the original shortest-path distance.
• Introducing new structural theorems controlling the sparsity of arbitrary unions of length-constrained sparse cuts.
• Utilizing sparse flow rounding techniques to decouple support size from path length, improving both the theoretical and empirical resource requirements.
• Presenting a simpler algorithmic infrastructure—eschewing intricate "expander gluing" for inductive, union-based construction.

6. Summary Table: Key Features of ECC (capabilities as per (Haeupler et al., 20 Apr 2024))

Feature	Prior State (HRG22)	Expander Compiler Collection (Augmented)
Edge lengths/capacities	Unit only	General
Cut/Length Slack	Fixed	Tunable $(K \leftrightarrow s)$
Running time	$m^{1+o(1)}$	$m^{1+\epsilon}\mathrm{poly}(h)$
Routing guarantee	$(h, s)$, weak	$(\leq h, s)$, strong (proportional)
Flow support size	$b \cdot \mathrm{poly}(h)m$	$|E| + b$ (no $h$ dependence)
Union-of-cuts property	Limited	Robust via spanner/arboricity arguments
Applications	Limited scope	Multi-commodity flow, distance oracles, distributed routing

7. Significance and Ongoing Directions

ECC systematizes algorithmic expander constructions, partitioning, and routing into a composable compiler-like toolchain for large-scale and complex graphs. Its recent generalizations empower it to address a wide array of modern algorithmic challenges: supporting dynamic, weighted, and distance-sensitive network models, and integrating new notions of structural sparsity and routing optimality.

This suggests that further extensions—such as probabilistic decompositions, local certification mechanisms, or new trade-off regimes between failure tolerance and routing efficiency—may be naturally accommodated within the ECC philosophy. A plausible implication is that, as network requirements diversify (e.g., in distributed ledgers, quantum networks, or adversarial communication models), ECC's abstraction and modularity will serve as a template for rapid adaptation of combinatorial and algorithmic innovations.