Length-Constrained Directed Expander Decomposition and Length-Constrained Vertex-Capacitated Flow Shortcuts
Abstract
We show the existence of length-constrained expander decomposition in directed graphs and undirected vertex-capacitated graphs. Previously, its existence was shown only in undirected edge-capacitated graphs [24, 21]. Along the way, we prove the multi-commodity maxflow-mincut theorems for length-constrained expansion in both directed and undirected vertex-capacitated graphs. Based on our decomposition, we build a length-constrained flow shortcut for undirected vertex-capacitated graphs, which roughly speaking is a set of edges and vertices added to the graph so that every multi-commodity flow demand can be routed with approximately the same vertex-congestion and length, but all flow paths only contain few edges. This generalizes the shortcut for undirected edge-capacitated graphs from [20]. Length-constrained expander decomposition and flow shortcuts have been crucial in the recent algorithms in undirected edge-capacitated graphs [20, 23]. Our work thus serves as a foundation to generalize these concepts to directed and vertex-capacitated graphs.
Keywords and phrases:
Length-Constrained Expander, Expander Decomposition, ShortcutFunding:
Bernhard Haeupler: Supported by the European Research Council (ERC) under the European Union’s Horizon 2020 research and innovation program (ERC grant agreement 949272).Copyright and License:
2012 ACM Subject Classification:
Theory of computation Graph algorithms analysisFunding:
Part of this work was done while at INSAIT, Sofia University “St. Kliment Ohridski”, Bulgaria. This work was partially funded from the Ministry of Education and Science of Bulgaria (support for INSAIT, part of the Bulgarian National Roadmap for Research Infrastructure).Editors:
Anne Benoit, Haim Kaplan, Sebastian Wild, and Grzegorz HermanSeries and Publisher:
Leibniz International Proceedings in Informatics, Schloss Dagstuhl – Leibniz-Zentrum für Informatik
1 Introduction
Expander decomposition found its early applications in property testing [17], clustering [32], and approximation algorithms [10] and, for the last two decades, has been the crucial ingredient in important developments of fast graph algorithms. This includes the first almost-linear time algorithms for spectral sparsifiers and Laplacian solvers [46], approximate max flow [33, 45, 42], deterministic global min cut [35], exact max flow [12], as well as many almost-optimal dynamic algorithms for minimum spanning trees [41], shortest paths [14, 4], sparsifiers [5], -edge-connectivity [30], minimum cuts [31, 16], and more [18]. Significant effort [43, 8, 13, 7, 37, 36, 27, 1, 19, 11] has focused on constructing expander decomposition itself. Below, we discuss two successful orthogonal generalizations of expander decomposition.
Vertex and Directed Expander Decomposition.
In 2005, Chekuri, Khanna, and Shepherd [10] showed that the construction of expander decomposition in undirected edge-capacitated graphs naturally extends to work in undirected vertex-capacitated graphs and applies them for approximating all-or-nothing vertex-capacitated flow problems. Later, this was extended to directed graphs, an even more general setting [9].111In fact, expander decomposition was only implicit in [10, 9] as their definitions were specific to their applications. The purely graph-theoretic definition was later formalized in [3].
Since 2020, almost-linear time expander decomposition algorithms in these generalized settings have been developed [3, 39, 27, 47] and found impressive applications. For the vertex-capacitated ones, they were crucial for the fastest deterministic vertex connectivity algorithms [44, 40] and data structures for connectivity queries under vertex failures [39, 38, 29]. For the directed ones, they were used for dynamic algorithms in directed graphs [3] and the new combinatorial approaches for exact max flow [15, 2].
Length-Constrained Expander Decomposition and Flow Shortcuts.
More recently, Haeupler, Räcke, and Ghaffari [24] introduced length-constrained expanders (LC-expanders). At a very high level, these are graphs such that any “reasonable” demand can be routed with low congestion and length. In contrast, normal expanders only guarantee low congestion. [24] constructed LC-expander decomposition and applied it to show universally optimal distributed algorithms. In general, LC-expander decomposition is much more effective for problems that simultaneously concern length and congestion.
Based on the new decomposition, [20] introduced the notion of LC-flow shortcut222It was called a low-step flow emulator in [20]., a new kind of graph augmentation. Roughly speaking, an LC-flow shortcut is a set of edges and vertices added to the graph so that every multi-commodity flow demand can be routed with approximately the same congestion and length, but all flow paths only have a few edges. We use steps, which count the number of edges, to distinguish between edge lengths. This is formalized as follows (see Section 2 for background).
Definition 1 (Length-Constrained Flow Shortcut).
Given a graph , we say an edge set (possibly with endpoints outside ) is a -step flow shortcut of with length slack and congestion slack if
-
(Forward Mapping) for every demand routable in with congestion and length , is routable in with congestion 1, length , and maximum step , and
-
(Backward Mapping) for every demand on routable in with congestion 1 and length , is routable in with congestion and length .
In any undirected edge-capacitated graph, [20] showed, for any , the existence of a -step LC-flow shortcut of size with length slack and congestion slack .333The shortcut in [20] actually has length slack and maximum step, but this is only because they tried to ensure that all endpoints of are in . Allowing endpoints outside , one can replace their router with a star and improve the quality to be as we stated. Combined with newly developed close-to-linear time LC-expander decomposition [21, 22], they also obtained a close-to-linear time construction for LC-flow shortcuts albeit with worse quality.
LC-flow shortcuts have led to significant further progress. This includes the first close-to-linear time constant-approximation algorithm for minimum cost multi-commodity flow [20]. The dynamic but weaker version of flow shortcuts was also the key object in the first deterministic dynamic constant-approximate distance oracle with update time [23].
However, all applications of LC-expander decomposition until now are limited to undirected edge-capacitated graphs.
1.1 Our Results
To extend the reach of the expander decomposition paradigm further, the history above suggests the following research question:
Can we construct length-constrained expander decomposition and flow shortcuts
beyond undirected edge-capacitated graphs?
Indeed, we answer this question affirmatively. In this paper, we focus on the existential results, but the arguments naturally give polynomial-time algorithms. For future work, we are working towards almost-linear-time constructions, which would lead to further applications for minimum cost (multi-commodity) flow in vertex-capacitated and directed graphs. Below, we discuss our contribution in more detail.
Length-Constrained Directed and Vertex Expander Decompositions.
We formalize the notions of length-constrained expanders in directed graphs and in undirected vertex-capacitated graphs. Then, we show the existence of length-constrained expander decomposition in directed graphs (Theorem 10) and in undirected vertex-capacitated graphs (Theorem 11). Along the way, we also show that the definition of length-constrained expanders based on cuts is almost equivalent to the characterization based on multi-commodity flow (Theorems 9 and 12). This can be viewed as a version of the approximate multicommodity maxflow mincut theorem [34] but for length-constrained expansion in directed and vertex-capacitated graphs. While this part does not require technical novelty, it is an important foundation for our paper and, we believe, for future work using this concept.
Length-Constrained Vertex-Capacitated Flow Shortcuts.
Our main technical contribution (Theorem 14) is to show that, for any undirected vertex-capacitated graph and any , there exists a -step flow shortcut of size with length slack and congestion slack . This generalizes the flow shortcut of [20] in undirected edge-capacitated graphs.
Our trade-off between size, length slack, and congestion slack matches the one of [20]. However, our step-bound is instead of . This is due to technical barriers unique to vertex-capacitated graphs, which also requires us to use very different analysis. We leave as a very interesting open problem if it is possible to obtain steps.
We note that obtaining similar LC-flow shortcuts on directed graphs is currently out of reach because it would give the breakthrough on reachability shortcuts. Given a graph , an edge set is a -step reachability shortcut of if, for every pair of vertices , can reach in if and only if can reach in using at most steps. Observe that an LC-flow shortcut in a directed graph is strictly stronger than a reachability shortcut. It is a major open problem whether there exists a -step reachability shortcut of size .444When endpoints of must be in , [26, 28, 6] already showed that there is no -step reachability shortcut of size . The lower bounds extend to the shortcut of size with a worse step bound.
2 Preliminaries
We give some brief background on length-constrained expansion. A demand assigns value to pair of vertices and is -length is it assigns non-zero values only to vertex pairs of distance in . A demand is routable with congestion and length if there exists a multi-commodity flow routing with congestion and length . respects a node-weighting if for each vertex , . Let . For any , is -length -expanding in if every -length -respecting demand is routable with length and congestion .555Our definition in the paper (Definition 7) is actually cut-based. This almost-equivalent flow-based definition follows from Theorem 12 and is more convenient in this overview. A length-constrained cut assigns to each edge an integral length increase, and is the graph applied with the length increase from cut . We informally say that is a length-constrained expander (LC-expander) if a node-weighting whose support is the whole vertex set is expanding in . An -length -expander decomposition for is a length-constrained cut such that is -length -expanding in .
We use standard graph terminology, deferring details to the full version for further (standard) preliminaries for directed graphs and vertex-capacitated graphs.
2.1 Our Techniques
Next, we give a technical overview of our LC-flow shortcut on vertex-capacitated graphs. We will explain how the strategy used in [20] fails in our setting and how we overcome the obstacle. For simplicity, here we only consider graphs with unit capacity. Also, we only construct a slightly weaker notion of LC-flow shortcut in the sense that, it receives an additional length parameter and the forward mapping only guarantees that every demand routable in with length and congestion is routable in with length , congestion and step .
Warm-up: Shortcutting LC-expanders.
Before explaining the obstacle, we first show how to shortcut an LC-vertex expander as a warm-up. Suppose that a node-weighting is -length -vertex expanding in . Say, (i.e., for all ).
Suppose further that has diameter at most . In this case, our shortcut is simply a star connecting each original vertex to a Steiner vertex with an -length -capacity edge. We can shortcut any feasible flow in with steps. An illustrative example is shown in Figure 1. The length slack is since an -length original feasible flow is mapped forward to a -length feasible flow in the star. The congestion slack is because any feasible flow in the star induces an -length -respecting demand. Since is -length -expanding in , we route such demand in with congestion and without length increasing.
In general, the diameter can be large. Thus, we can construct a sparse neighborhood cover to decompose the graph into clusters with diameter , such that (1) for each vertex , there is a cluster containing all vertices within distance from , and (2) each vertex is inside clusters. Then, we can construct a shortcut by adding an -edge-length star on each cluster. By a similar argument, we obtain a flow shortcut graph for -length original flows with length slack , congestion slack and step .
So far, when we build an LC-flow shortcut for an LC-expander, the vertex-capacitated setting presents no difficulties compared to the edge-capacitated setting, because the above simple approach works in both settings. However, the differences between the two settings arise when generalizing this approach to general graphs via expander hierarchies.
Previous Approach: Shortcutting General Graphs via Boundary-Linkedness.
The key idea of [20] is to exploit a hierarchy of boundary-linked LC-expander decomposition, defined as follows. Let be an edge-unit-capacity graph. Initialize the node-weight . For each level , compute a cut of size such that is -length -expanding in where counts the number of -edges incident to .666In the actual construction, assigns fractional values to edges and is called a moving cut, defined in Section 3. Here, we assume is a classic edge cut for simplicity. The cut is called the boundary-linked LC-expander decomposition for because it gives a stronger expansion guarantee of instead of just . Then, we set and continue to the next level . By setting , we have that and .
From the above construction, we conclude that, for each , is -length -expanding in . Therefore, as we have seen in the warm-up, we can add stars on the support of so that any flows routing -length -respecting demands in can be shortcut.
Now consider a feasible -length flow in . The boundary-linkedness suggests a natural bottom-up shortcut scheme. For each flow path , we can think of routing ’s head packet and tail packet (initially at ’s left and right endpoints, denoted by and ) to the same place via shortcuts. Take the head packet as an example. Start with . At each level , let be the left endpoint of the first -edge behind . By definition, and ’s subpath between and is disjoint from , so we can use star graphs at level to route the head packet from to within steps. In sum, each of the head and tail packets is routed from the bottom up until they reach , and the top-level star graphs can route them together. The total number of steps is 777We note that the step bound in [20] is because they used powers of expander graphs instead of star graphs to avoid creating vertices outside , which brought another factor..
The Obstacle from Vertex Cuts.
The overall strategy of the above approach is to shortcut flow paths from a vertex of to an endpoint of edges in . This was possible since the boundary-linked expander decomposition guarantees that is expanding.
In the vertex-capacitated graph, however, the cut is now a vertex set. To follow the same strategy, we have two natural options. We shortcut flow from a vertex of to either (1) a vertex in , or (2) a neighbor of .
In the first case, the strategy requires that is expanding in . This is trivially impossible because is not even in the graph . In the second case, let denote the neighbors of that are not in . The strategy requires is expanding in . However, possibly is very big and has size . It is unlikely that expander decomposition exists to guarantee the expansion of such a large node-weighting. Even if it exists, we would set and, hence, we cannot guarantee . So the number of levels of the hierarchy is unbounded.
In either option, this overall strategy fails in the vertex-capacitated graphs. At a very high level, this is because edges have two endpoints while vertices may have an unbounded number of neighbors.
Our Approach: Top-Down Analysis without Boundary-linkedness.
We construct a similar hierarchy of LC-vertex expander decomposition without boundary-linkedness as follows. Let be a vertex-unit-capacity graph. Initialize node-weighting . At each level , computes a cut such that is -length -vertex-expanding in , and set . In particular, the top level has . The LC-vertex-expander decomposition guarantees , so the number of levels is by choosing proper .
Next, we construct the shortcut as follows. For each , by the expansion of , we can add stars on the support of into our shortcut so that any flows routing -length -respecting demands in can be shortcut. To analyze the shortcut quality, we will no longer try to route from to as in the edge-capacitated setting, because we no longer have boundary-linkedness guarantee.
Our analysis is instead top-down. At each level , we shortcut the current flow path as much as possible, and then the prefix and suffix that have not yet been shortcut will be deferred to lower levels as subproblems. To be more concrete, say our initial goal is to shortcut a flow path in a feasible -length original flow. At each level , assume we will receive a subpath of with length at most in (note that is a valid input to the top level because is empty). We will shortcut using star graphs at levels up to as follows (see Figure 2 for an illustration when ).
Step 1.
Let and be the first and last -vertices in respectively. We can easily shortcut the subpath (i.e. the subpath from to ) within steps using the star graphs at level .
Step 2.
Let be the -vertex right before and let be the -vertex right after . We regard shortcutting the prefix and the suffix as two subproblems at level , where are endpoints of . Note that both and has length at most in because they are disjoint from by definition.
Step 3.
After the recursion, we obtain shortcuts for both and . The shortcut for is given by concatenating shortcuts for and using two original edges and .
It is not hard to see the final step bound is since the recursion has levels and each level has two branches. We note that the actual argument is more complicated because the cuts are actually moving cuts which have fractional cut values, and there is no clear partition of into parts.
3 Length-Constrained Directed Expansion
In this section, we follow the theory of length-constrained expansion and extend it to the setting of directed graphs. We start with the generalization of notations from length-constrained expanders, which serves as the foundation for subsequent results. Next, we characterize length-constrained expansion in directed graphs with routing, and show the existence of length-constrained directed expander decomposition.
Basic Concepts of Length-Constrained Directed Expansion.
The following definition of moving cuts and separation was introduced by Haeupler, Wajc and Zuzic in [25].
Definition 2 (Length-Constrained Cut).
An -length moving cut assigns to each edge a fractional cut value between zero and one which is a multiple of . The size of is defined as . The length increase associated with the -length moving cut is denoted with and defined as assigning an edge the length increase . Any moving cut which only assigns cut values equal to either or is called a pure moving cut. We define the degree of a moving cut over vertex to be .
Definition 3 (-Length Separated Demand).
For any demand and any -length moving cut , we define the amount of -length separated demand as the sum of demands between vertices that are -length separated by . We denote this quantity with , i.e.,
Definition 4 (-Length Sparsity of a Cut for Demand ).
For any demand and any -length moving cut with , the -length sparsity of with respect to is the ratio of ’s size to how much demand it -length separates i.e.,
Above we generalize the definition of length-constrained moving cut w.r.t arbitrary directed -length demand. However, for the definition of a directed length-constrained expander, we restrict to symmetric -length demands.
Definition 5 (-Length Sparsity of a Cut w.r.t. a Node-Weighting).
The -length sparsity of any -length moving cut with respect to a node-weighting is defined as:
Intuitively, -length sparsity of a cut measures how much it -length separates -length demand w.r.t its own size. Furthermore, for a given node-weighting, we associate the sparsest cut w.r.t the node-weighting with its conductance.
Definition 6 (-Length Conductance of a Node-Weighting).
The -length conductance of a node-weighting in a graph is defined as the -length sparsity of the sparsest -length moving cut with respect to , i.e.,
Definition 7 (-Length -Expanding Node-Weightings).
We say a node-weighting is -length -expanding if the -length conductance of in is at least .
To see the connection, in the full version, we explain how our notion of length-constrained directed expansion generalizes the non-length-constrained version. Lastly, we give the formal definition of length-constrained directed expander decompositions as follows:
Definition 8 (Length-Constrained Directed Expander Decomposition).
Given a graph , a directed -length -expander decomposition for a node-weighting with length slack and cut slack is an -length cut of size at most such that is -length -expanding in .
Routing Characterization of Length-Constrained Directed Expansion.
The definition of -expanding characterizes the sparsity of moving cuts in directed graphs. With the routing characterization, we further show that sparsity is closely related to demand routing.
Theorem 9 (Routing Characterization of Length-Constrained Directed Expanders).
Given a directed graph and node-weighting , for any , and we have:
-
If is -length -expanding in , then every -respecting -length symmetric demand can be routed in with congestion at most and length at most .
-
If is not -length -expanding in , then some -respecting -length symmetric demand cannot be routed with congestion at most and length at most .
Existence of Length-Constrained Directed Expander Decompositions.
Now, we prove the existence of length-constrained directed expander decompositions. The following theorem formally states the result:
Theorem 10.
For any , a node-weighting , , , and a length slack parameter , there is a directed -length -expander decomposition for with cut slack .
The proof of Theorem 10 closely follows the undirected-case proof in [24], and we append it in the full version for completeness. The basic idea is that, unless the graph is already an -length -expander for node-weighting , we can repeatedly identify and apply cuts with -sparsity less than . The union of these cuts ultimately renders the graph as an -length -expander. To bound for the total size of all cuts, we sum individual cut sizes. However, since each cut size depends on the sparsity associated with different demands, analysis becomes complex. Thus, we first introduce a special base demand, called exponential demand to relate all other demands in terms of sparsity. Using this, we apply a potential argument to prove the above main theorem.
In the full version, we further discuss boundary-linked LC-directed expander decomposition (also called linked LC-directed expander decomposition). Expander decompositions with boundary-linkedness have been shown to be very useful in the length-constrained undirected setting and the classic (i.e. non-length-constrained) setting.
4 Length-Constrained Vertex Expansion
In this section we extend the theory of length-constrained expander decomposition to vertex-capacitated graphs. The basic concepts of length-constrained vertex expansion are analogous to those of length-constrained directed expansion in Section 3. The major difference is that now a moving cut can assign cut values to both vertices and edges. See the full version for preliminaries and formal description of the basic concepts of vertex-capacitated graphs.
The main results of this section is the existence of length-constrained expander decomposition for vertex-capacitated graphs (Theorem 11) and the routing characterization of length-constrained vertex expanders (Theorem 12).
Theorem 11 (Existential -length Expander Decomposition for Vetex-Capacitated Graphs).
For any vertex-capacitated graph , node-weighting , , and a length slack parameter , there is an -length -expander decomposition for with cut slack .
Theorem 12 (Routing Characterization of Length-Constrained Vertex Expanders).
Given a vertex-capacitated graph and node-weighting , for any , and we have:
-
If is -length -expanding in , then every -length -respecting demand can be routed in wth congestion at most and dilation at most .
-
If is not -length -expanding in , then some -length -respecting demand cannot be routed with congestion at most and dilation at most .
The proofs of above are in the full version. We introduce a reduction that transforms vertex-capacitated graphs into directed edge-capacitated graphs to show the equivalence, which is crucial for the proofs of Theorem 11 and Theorem 12.
5 Length-Constrained Vertex-Capacitated Flow Shortcuts
In this section, we show the existence of LC-flow shortcuts in vertex-capacitated graphs. The Definition 13 below generalizes Definition 1 of LC-flow shortcuts in the sense that an additional length parameter is given and the forward mapping only holds for demands routable in with congestion and length at most .
Definition 13 (Length-Constrained Flow Shortcut).
Given a graph , we say an edge set (possibly with endpoints outside ) is an -step -LC-flow shortcut of with length slack and congestion slack if
-
(Forward Mapping) for every demand routable in with congestion and length , is routable in with congestion 1, length , and maximum step , and
-
(Backward Mapping) for every demand on routable in with congestion 1 and length , is routable in with congestion and length .
We note that in [20] there is an analogous but weaker definition of -LC-flow shortcut, in which the forward mapping only guarantee that is routable in with length instead of (and the same congestion and step). That is, the length slack in Definition 13 is competitive in the sense that it upper bounds the ratio between the lengths of the shortcut flow and the original flow. Hence, by choosing a sufficiently large , the total length of vertices and edges in , an -LC-flow shortcut is automatically an LC-flow shortcut.
Theorem 14.
Given a vertex-capacitated graph with parameters , there exists a -step LC-flow shortcut with length slack , congestion slack , and size .
Theorem 14 is the main theorem of this section. In what follows, actually we will focus on constructing -LC-flow shortcut. Setting gives the LC-flow shortcut in Theorem 14.
5.1 The Construction
The construction of the flow shortcut graph is given by Algorithm 1. The star graphs in Line 9 are formally defined in Definition 15.
Definition 15 (Star Graphs).
Given a graph with a node-weighting and a length parameter , the -length -capacitated star graph on some , denoted by , has
where the vertex is a Steiner vertex serving as the center and are original vertices. The length and capacity of each original vertex is unchanged, while has length and capacity . Each edge has length and capacity .
In short, Algorithm 1 mainly constructs a length-constrained expander hierarchy
where is the largest such that . We point out that is a zero cut for all . Then the shortcut graph is obtained by adding star graphs on neighborhoods of each LC-expander .
We remark that we do LC-expander decompositions with different length parameters at one level because we aim at a shortcut graph with length slack significantly smaller than its step bound. Intuitively, if we only use LC-expanders with length parameter around to shortcut an original -length flow path , then inevitably each step will have length around , which means the length slack cannot go far below the number of steps. Now, providing LC-expanders with different length parameters, when we want to shortcut a subpath of with length far smaller than , we can choose the appropriate LC-expander to obtain a shortcut with length around instead of . Another benefit is that this automatically gives a competitive length slack (this is why in Definition 13 we define the length slack of -LC-flow shortcut to be competitive).
We first argue the size bound of . Observe that, in Line 7, we have by Theorem 11. In Line 8, the width of each neighborhood cover is by Theorem 2.1 in the full version. Furthermore, because in Line 11 we have , we can upper bound by . Finally, by the algorithm, we have
Next we show the quality of the shortcut. Before that, we introduce a helper lemma Lemma 16, which shows the demands that each can route within small steps. We defer its proof to the full version.
Lemma 16.
For each , any demand that is -length in , -respecting and -respecting can be routed in with length , congestion and step .
Now we show that the shortcut constructed by Algorithm 1 has length slack , congestion slack and step . To do this, it suffices to show the quality of the forward mapping and backward mapping, i.e. Lemma 17 and Lemma 18, whose proofs are given in Section 5.2 and the full version. Let be the shortcut graph.
Lemma 17 (Forward Mapping).
For any feasible -length flow in , there is a feasible flow routing in with and .
Lemma 18 (Backward Mapping).
For any feasible flow in such that , there is a flow routing in with and .
5.2 Forward Mapping: Proof of Lemma 17
We will employ a top-down argument. Start from the top level . At the beginning of processing a level , we are given a feasible flow with the following invariant: each flow path has , where is the minimum index s.t. (which means ). Initially at the top level , we set . Note that satisfies the invariant above because is a zero cut for any .
First, at the bottom level , we can easily shortcut every flow path in . For each star graph , we assign it a demand which sums over for each flow path such that is the minimum index with . Observe that each is an -length in and -respecting, so it can be routed in with length , congestion and step by Lemma 16.
From now on we consider levels . When processing a level , for each flow path , we may shortcut some subpaths of using shortcut edges in . The subpaths of that have not been shortcut will be added to , meaning that they are deferred to lower levels to get shortcut. At the end, the final should ensure the invariants above, and we proceed to the lower level .
Now we will explain the shortcut at a level in detail. Fix a flow path . Let be the minimum index such that . We consider two cases.
Case 1: Defer.
When , we simply add to . We have
where the inequality is by , and . Therefore, in this case, the flow path added to satisfies the invariant.
Case 2: Shortcut.
Now suppose . Let and be ’s endpoints. We say is the left side and the right side. For each , we refer to as the -vertex with steps away from . In particular, and .
We now define two functions denoting the budgets of -vertices from the left and the right respectively: for each vertex ,
In particular,
Let be the minimum index such that , and symmetrically let be the maximum index such that . To avoid clutter, we let and . The following Claim 19 says that and have at most one common vertex.
Claim 19.
.
Proof.
By the definition of and , we have
However, . This means there exists a vertex with , which implies
We assign each vertex a load , satisfying that and . We consider the following three-phase strategy to route flow units from to . Phase 1: the vertex sends flow units and each receives units. Phase 2: Each vertex sends units and each vertex receives units. Phase 3: Each vertex sends exactly units, and the vertex receives units.
The First and Third Phases.
Roughly speaking, for the first and third phases, we will add their corresponding original flows into , meaning that they will be deferred to lower levels to get shortcut.
Regarding the first phase, recall that for each , we want to route units from to . To do this, we add into a flow path with value . That is, we require the lower levels to give a shortcut that routes from to (the -vertex one step closer to than ). Then, we route units from to using the original edge .
The third phase is handled in a similar way. For each , we route flow units from to using the original edge , and then we add into a flow path with value .
To proceed to the lower level , it remains to show that the flow paths added into satisfy the invariant. Consider a flow path added from the first phase (where , i.e. ). We want to show that , where is the minimum index such that . By the definition of the budget function , we have , where the second inequality is by and (from the definition of ). In particular, . Because is an -length moving cut, we have
as desired, where the first inequality uses . By a similar argument, we can show that each flow path added from the third phase also satisfies the invariant, so we will not explain it in detail.
The Second Phase.
The second phase is where the shortcut happens. We define an arbitrary (multi-commodity) demand capturing this single-commodity demand. Namely, satisfies that (1) ; (2) for each , ; and (3) for each , . We will assign to , meaning that we route using shortcut edges in .
By the above assignment, for each at level , its total assigned demand, denoted by , sums over of all s.t. is the minimum index with . The following Lemma 20 showing that can be routed with low steps, small length and congestion , and we defer the proof to the full version.
Lemma 20.
For each at level , its total assigned demand can be routed in with length , congestion and step .
Quality of the Forward Mapping.
It remains to show that can be routed in with length , congestion and step . The proof for this can be found in the full version.
References
- [1] Daniel Agassy, Dani Dorfman, and Haim Kaplan. Expander decomposition with fewer inter-cluster edges using a spectral cut player. In Proceedings of the International Colloquium on Automata, Languages, and Programming (ICALP), pages 9:1–9:20, 2023. doi:10.4230/LIPICS.ICALP.2023.9.
- [2] Aaron Bernstein, Joakim Blikstad, Thatchaphol Saranurak, and Ta-Wei Tu. Maximum flow by augmenting paths in time, 2024. doi:10.48550/arXiv.2406.03648.
- [3] Aaron Bernstein, Maximilian Probst Gutenberg, and Thatchaphol Saranurak. Deterministic decremental reachability, scc, and shortest paths via directed expanders and congestion balancing. In Proceedings of the Symposium on Foundations of Computer Science (FOCS), pages 1123–1134, 2020. doi:10.1109/FOCS46700.2020.00108.
- [4] Aaron Bernstein, Maximilian Probst Gutenberg, and Thatchaphol Saranurak. Deterministic decremental sssp and approximate min-cost flow in almost-linear time. In Proceedings of the Symposium on Foundations of Computer Science (FOCS), pages 1000–1008, 2022. doi:10.1109/FOCS52979.2021.00100.
- [5] Aaron Bernstein, Jan van den Brand, Maximilian Probst Gutenberg, Danupon Nanongkai, Thatchaphol Saranurak, Aaron Sidford, and He Sun. Fully-dynamic graph sparsifiers against an adaptive adversary. In Mikolaj Bojanczyk, Emanuela Merelli, and David P. Woodruff, editors, 49th International Colloquium on Automata, Languages, and Programming, ICALP 2022, July 4-8, 2022, Paris, France, volume 229 of LIPIcs, pages 20:1–20:20. Schloss Dagstuhl – Leibniz-Zentrum für Informatik, 2022. doi:10.4230/LIPIcs.ICALP.2022.20.
- [6] Greg Bodwin and Gary Hoppenworth. Folklore sampling is optimal for exact hopsets: Confirming the n barrier. In 64th IEEE Annual Symposium on Foundations of Computer Science, FOCS 2023, Santa Cruz, CA, USA, November 6-9, 2023, pages 701–720. IEEE, 2023. doi:10.1109/FOCS57990.2023.00046.
- [7] Y. Chang and T. Saranurak. Deterministic distributed expander decomposition and routing with applications in distributed derandomization. In Proceedings of the Symposium on Foundations of Computer Science (FOCS), pages 377–388, 2020. doi:10.1109/FOCS46700.2020.00043.
- [8] Yi-Jun Chang and Thatchaphol Saranurak. Improved distributed expander decomposition and nearly optimal triangle enumeration. In Proceedings of the International Symposium on Principles of Distributed Computing (PODC), pages 66–73, 2019. doi:10.1145/3293611.3331618.
- [9] Chandra Chekuri and Alina Ene. The all-or-nothing flow problem in directed graphs with symmetric demand pairs. Mathematical Programming, 154:249–272, 2015. doi:10.1007/S10107-014-0856-Z.
- [10] Chandra Chekuri, Sanjeev Khanna, and F Bruce Shepherd. Multicommodity flow, well-linked terminals, and routing problems. In Proceedings of the Symposium on Theory of Computing (STOC), pages 183–192, 2005. doi:10.1145/1060590.1060618.
- [11] Daoyuan Chen, Simon Meierhans, Maximilian Probst Gutenberg, and Thatchaphol Saranurak. Parallel and distributed expander decomposition: Simple, fast, and near-optimal. In Proceedings of ACM-SIAM Symposium on Discrete Algorithms (SODA), pages 1705–1719, 2025. doi:10.1137/1.9781611978322.53.
- [12] Li Chen, Rasmus Kyng, Yang P. Liu, Richard Peng, Maximilian Probst Gutenberg, and Sushant Sachdeva. Maximum flow and minimum-cost flow in almost-linear time. In Proceedings of the Symposium on Foundations of Computer Science (FOCS), pages 612–623, 2022. doi:10.1109/FOCS54457.2022.00064.
- [13] Julia Chuzhoy, Yu Gao, Jason Li, Danupon Nanongkai, Richard Peng, and Thatchaphol Saranurak. A deterministic algorithm for balanced cut with applications to dynamic connectivity, flows, and beyond. In Proceedings of the Symposium on Foundations of Computer Science (FOCS), pages 1158–1167, 2020. doi:10.1109/FOCS46700.2020.00111.
- [14] Julia Chuzhoy and Sanjeev Khanna. A new algorithm for decremental single-source shortest paths with applications to vertex-capacitated flow and cut problems. In Proceedings of the Symposium on Theory of Computing (STOC), pages 389–400, 2019. doi:10.1145/3313276.3316320.
- [15] Julia Chuzhoy and Sanjeev Khanna. Maximum bipartite matching in time via a combinatorial algorithm. In Proceedings of the Symposium on Theory of Computing (STOC), pages 83–94, 2024. doi:10.1145/3618260.3649725.
- [16] Antoine El-Hayek, Monika Henzinger, and Jason Li. Fully dynamic approximate minimum cut in subpolynomial time per operation. In Proceedings of ACM-SIAM Symposium on Discrete Algorithms (SODA), pages 750–784, 2025. doi:10.1137/1.9781611978322.22.
- [17] Oded Goldreich and Dana Ron. A sublinear bipartiteness tester for bounded degree graphs. In Proceedings of the Symposium on Theory of Computing (STOC), pages 289–298, 1998. doi:10.1145/276698.276767.
- [18] Gramoz Goranci, Harald Räcke, Thatchaphol Saranurak, and Zihan Tan. The expander hierarchy and its applications to dynamic graph algorithms. In Proceedings of ACM-SIAM Symposium on Discrete Algorithms (SODA), pages 2212–2228, 2021. doi:10.1137/1.9781611976465.132.
- [19] Lars Gottesbüren, Nikos Parotsidis, and Maximilian Probst Gutenberg. Practical expander decomposition. In Proceedings of the European Symposium on Algorithms (ESA), pages 61:1–61:17, 2024. doi:10.4230/LIPICS.ESA.2024.61.
- [20] Bernhard Haeupler, D. Ellis Hershkowitz, Jason Li, Antti Roeyskoe, and Thatchaphol Saranurak. Low-step multi-commodity flow emulators. In Bojan Mohar, Igor Shinkar, and Ryan O’Donnell, editors, Proceedings of the 56th Annual ACM Symposium on Theory of Computing, STOC 2024, Vancouver, BC, Canada, June 24-28, 2024, pages 71–82. ACM, 2024. doi:10.1145/3618260.3649689.
- [21] Bernhard Haeupler, D Ellis Hershkowitz, and Zihan Tan. New structures and algorithms for length-constrained expander decompositions. In Proceedings of the Symposium on Foundations of Computer Science (FOCS), pages 1634–1645, 2024. doi:10.1109/FOCS61266.2024.00102.
- [22] Bernhard Haeupler, Jonas Huebotter, and Mohsen Ghaffari. A cut-matching game for constant-hop expanders. In Proceedings of ACM-SIAM Symposium on Discrete Algorithms (SODA), pages 1651–1678, 2025. doi:10.1137/1.9781611978322.51.
- [23] Bernhard Haeupler, Yaowei Long, and Thatchaphol Saranurak. Dynamic deterministic constant-approximate distance oracles with worst-case update time. In Proceedings of the Symposium on Foundations of Computer Science (FOCS), pages 2033–2044, 2024. doi:10.1109/FOCS61266.2024.00121.
- [24] Bernhard Haeupler, Harald Räcke, and Mohsen Ghaffari. Hop-constrained expander decompositions, oblivious routing, and distributed universal optimality. In Stefano Leonardi and Anupam Gupta, editors, STOC ’22: 54th Annual ACM SIGACT Symposium on Theory of Computing, Rome, Italy, June 20 - 24, 2022, pages 1325–1338. ACM, 2022. doi:10.1145/3519935.3520026.
- [25] Bernhard Haeupler, David Wajc, and Goran Zuzic. Network coding gaps for completion times of multiple unicasts. In Proceedings of the Symposium on Foundations of Computer Science (FOCS), pages 494–505, 2020. doi:10.1109/FOCS46700.2020.00053.
- [26] William Hesse. Directed graphs requiring large numbers of shortcuts. In Proceedings of ACM-SIAM Symposium on Discrete Algorithms (SODA), pages 665–669, 2003. URL: http://dl.acm.org/citation.cfm?id=644108.644216.
- [27] Yiding Hua, Rasmus Kyng, Maximilian Probst Gutenberg, and Zihang Wu. Maintaining expander decompositions via sparse cuts. In Proceedings of ACM-SIAM Symposium on Discrete Algorithms (SODA), pages 48–69, 2023. doi:10.1137/1.9781611977554.CH2.
- [28] Shang-En Huang and Seth Pettie. Lower bounds on sparse spanners, emulators, and diameter-reducing shortcuts. SIAM J. Discret. Math., 35(3):2129–2144, 2021. doi:10.1137/19M1306154.
- [29] Yonggang Jiang, Merav Parter, and Asaf Petruschka. New oracles and labeling schemes for vertex cut queries, 2025. doi:10.48550/arXiv.2501.13596.
- [30] Wenyu Jin and Xiaorui Sun. Fully dynamic s-t edge connectivity in subpolynomial time (extended abstract). In 62nd IEEE Annual Symposium on Foundations of Computer Science, FOCS 2021, Denver, CO, USA, February 7-10, 2022, pages 861–872. IEEE, 2021. doi:10.1109/FOCS52979.2021.00088.
- [31] Wenyu Jin, Xiaorui Sun, and Mikkel Thorup. Fully dynamic min-cut of superconstant size in subpolynomial time. In Proceedings of ACM-SIAM Symposium on Discrete Algorithms (SODA), pages 2999–3026, 2024. doi:10.1137/1.9781611977912.107.
- [32] Ravi Kannan, Santosh Vempala, and Adrian Vetta. On clusterings: Good, bad and spectral. Journal of the ACM (JACM), 51(3):497–515, 2004. doi:10.1145/990308.990313.
- [33] Jonathan A Kelner, Yin Tat Lee, Lorenzo Orecchia, and Aaron Sidford. An almost-linear-time algorithm for approximate max flow in undirected graphs, and its multicommodity generalizations. In Proceedings of ACM-SIAM Symposium on Discrete Algorithms (SODA), pages 217–226, 2014. doi:10.1137/1.9781611973402.16.
- [34] Tom Leighton and Satish Rao. Multicommodity max-flow min-cut theorems and their use in designing approximation algorithms. Journal of the ACM (JACM), 46(6):787–832, 1999. doi:10.1145/331524.331526.
- [35] Jason Li. Deterministic mincut in almost-linear time. In Proceedings of the Symposium on Theory of Computing (STOC), pages 384–395, 2021. doi:10.1145/3406325.3451114.
- [36] Jason Li, Danupon Nanongkai, Debmalya Panigrahi, and Thatchaphol Saranurak. Near-linear time approximations for cut problems via fair cuts. In Proceedings of ACM-SIAM Symposium on Discrete Algorithms (SODA), pages 240–275, 2023. doi:10.1137/1.9781611977554.CH10.
- [37] Jason Li and Thatchaphol Saranurak. Deterministic weighted expander decomposition in almost-linear time, 2021. doi:10.48550/arXiv.2106.01567.
- [38] Yaowei Long, Seth Pettie, and Thatchaphol Saranurak. Connectivity labeling schemes for edge and vertex faults via expander hierarchies. In Proceedings of ACM-SIAM Symposium on Discrete Algorithms (SODA), pages 1–47, 2025. doi:10.1137/1.9781611978322.1.
- [39] Yaowei Long and Thatchaphol Saranurak. Near-optimal deterministic vertex-failure connectivity oracles. In Proceedings of the Symposium on Foundations of Computer Science (FOCS), pages 1002–1010, 2022. doi:10.1109/FOCS54457.2022.00098.
- [40] Chaitanya Nalam, Thatchaphol Saranurak, and Sorrachai Yingchareonthawornchai. Deterministic -vertex connectivity in max-flows, 2023. doi:10.48550/arXiv.2308.04695.
- [41] Danupon Nanongkai, Thatchaphol Saranurak, and Christian Wulff-Nilsen. Dynamic minimum spanning forest with subpolynomial worst-case update time. In Proceedings of the Symposium on Foundations of Computer Science (FOCS), pages 950–961, October 2017. doi:10.1109/FOCS.2017.92.
- [42] Harald Räcke, Chintan Shah, and Hanjo Täubig. Computing cut-based hierarchical decompositions in almost linear time. In Proceedings of ACM-SIAM Symposium on Discrete Algorithms (SODA), pages 227–238, 2014. doi:10.1137/1.9781611973402.17.
- [43] Thatchaphol Saranurak and Di Wang. Expander decomposition and pruning: Faster, stronger, and simpler. In Proceedings of ACM-SIAM Symposium on Discrete Algorithms (SODA), pages 2616–2635, 2019. doi:10.1137/1.9781611975482.162.
- [44] Thatchaphol Saranurak and Sorrachai Yingchareonthawornchai. Deterministic small vertex connectivity in almost linear time. In Proceedings of the Symposium on Foundations of Computer Science (FOCS), pages 789–800, 2022. doi:10.1109/FOCS54457.2022.00080.
- [45] Jonah Sherman. Nearly maximum flows in nearly linear time. In Proceedings of the Symposium on Foundations of Computer Science (FOCS), pages 263–269, 2013. doi:10.1109/FOCS.2013.36.
- [46] Daniel A Spielman and Shang-Hua Teng. Nearly-linear time algorithms for graph partitioning, graph sparsification, and solving linear systems. In Proceedings of the Symposium on Theory of Computing (STOC), pages 81–90, 2004. doi:10.1145/1007352.1007372.
- [47] Aurelio L. Sulser and Maximilian Probst Gutenberg. A simple and near-optimal algorithm for directed expander decompositions. CoRR, abs/2403.04542, 2024. doi:10.48550/arXiv.2403.04542.
