Incremental Approximate Maximum Flow via Residual Graph Sparsification

Goranci, Gramoz; Henzinger, Monika; Räcke, Harald; Sricharan, A. R.

doi:10.4230/LIPIcs.ICALP.2025.91

Incremental Approximate Maximum Flow via Residual Graph Sparsification

Gramoz Goranci

Faculty of Computer Science, University of Vienna, Austria Monika Henzinger

Institute of Science and Technology Austria (ISTA), Klosterneuburg, Austria Harald Räcke

Technical University Munich, Germany A. R. Sricharan

Faculty of Computer Science, UniVie Doctoral School Computer Science DoCS, University of Vienna, Austria

Abstract

We give an algorithm that, with high probability, maintains a $(1-\epsilon)$ -approximate $s$ - $t$ maximum flow in undirected, uncapacitated $n$ -vertex graphs undergoing $m$ edge insertions in $\tilde{O}(m+nF^{*}/\epsilon)$ total update time, where $F^{*}$ is the maximum flow on the final graph. This is the first algorithm to achieve polylogarithmic amortized update time for dense graphs ( $m=\Omega(n^{2})$ ), and more generally, for graphs where $F^{*}=\tilde{O}(m/n)$ .

At the heart of our incremental algorithm is the residual graph sparsification technique of Karger and Levine [SICOMP ’15], originally designed for computing exact maximum flows in the static setting. Our main contributions are (i) showing how to maintain such sparsifiers for approximate maximum flows in the incremental setting and (ii) generalizing the cut sparsification framework of Fung et al. [SICOMP ’19] from undirected graphs to balanced directed graphs.

Keywords and phrases:

incremental flow, sparsification, approximate flow

Category:

Track A: Algorithms, Complexity and Games

Funding:

Harald Räcke: This project has received funding from the Deutsche Forschungsgemeinschaft (DFG, German Research Foundation) – 498605858 and 470029389.

Copyright and License:

2012 ACM Subject Classification:

Theory of computation

\rightarrow

Dynamic graph algorithms

Related Version:

Full Version: https://arxiv.org/abs/2502.09105

Funding:

Monika Henzinger and A. R. Sricharan: This project has received funding from the European Research Council (ERC) under the European Union’s Horizon 2020 research and innovation programme (MoDynStruct, No. 101019564) ^†^†margin:

and the Austrian Science Fund (FWF) grant DOI 10.55776/Z422, grant DOI 10.55776/I5982, and grant DOI 10.55776/P33775 with additional funding from the netidee SCIENCE Stiftung, 2020–2024.

DOI:

10.4230/LIPIcs.ICALP.2025.91

Event:

52nd International Colloquium on Automata, Languages, and Programming (ICALP 2025)

Editors:

Keren Censor-Hillel, Fabrizio Grandoni, Joël Ouaknine, and Gabriele Puppis

Series and Publisher:

Leibniz International Proceedings in Informatics, Schloss Dagstuhl – Leibniz-Zentrum für Informatik

1 Introduction

The maximum $s$ - $t$ flow problem has been at the forefront of research in theoretical computer science and combinatorial optimization. Algorithms developed for maximum $s$ - $t$ flow and its dual problem, minimum $s$ - $t$ cut, have been highly influential due to their wide applicability [1] and their use as subroutines in other algorithms [2, 25]. A long line of work has improved our understanding of how efficiently maximum flow can be solved in the static setting. Two landmark combinatorial results are the deterministic algorithm by Goldberg and Rao [14], which achieves a running time of $O(\min\{n^{2/3},m^{1/2}\}\cdot m)$ , and the randomized algorithm by Karger and Levine [21] which has a running time of $\widetilde{O}(m+nF^{*})$ ,¹¹1In this paper, we use $\widetilde{O}(X)$ to denote $O(X\operatorname{polylog}(X))$ and $\widehat{O}(X)$ to denote $O(X^{1+o(1)})$ . where $F^{*}$ is the value of the maximum flow. More recently, efforts building upon a novel blend of continuous optimization techniques, the Laplacian paradigm [30] and graph-based data structures have led to even faster algorithms; notably, a randomized $\widetilde{O}(m/\epsilon)$ time approximate maximum flow algorithm on undirected graphs [26, 22, 24, 27], and a deterministic $\widehat{O}(m)$ time exact algorithm for min-cost flow (and thus maximum flow) even on directed graphs [7, 6], which constitutes a major algorithmic breakthrough.

Recently, there has been growing interest in solving the maximum $s$ - $t$ flow problem in the challenging dynamic setting, where the goal is to maintain a flow (or its value) under edge insertions and deletions and answer queries about the maintained flow efficiently. For directed graphs, there are strong conditional hardness results [8, 18] showing a lower bound of $\Omega(n)$ and $\Omega(\sqrt{m})$ amortized update time for maintaining exact maximum flow, assuming the OMv conjecture. These strong polynomial lower bounds have motivated a shift in focus toward maintaining approximate maximum flows.

Research on maintaining approximate maximum flows in the dynamic setting can be categorized into the following three lines of works. The first line of work [5, 16, 31] deals with the fully dynamic setting, supporting both edge insertions and deletions and is based on dynamically maintaining tree-based cut approximations. However, these algorithms require at least a logarithmic loss in the quality of the maintained flow. The second line of work [19, 17, 15] is purely combinatorial and works by repeatedly finding augmenting paths in an incremental residual graph together with a lazy rebuilding technique. While these algorithms achieve sub-linear update time, it is not clear how to use them to go beyond the $\sqrt{n}$ barrier on the update time. To address this challenge, the third line of work [33, 32, 6, 31] leverages continuous optimization techniques to maintain a $(1-\epsilon)$ -approximate max flow in the incremental (only edge insertions) and decremental (only edge deletions) settings in $m^{o(1)}$ update time. Table 1 offers a detailed summary of the state-of-the-art results on dynamic maximum flow algorithms.

Focusing on the $(1-\epsilon)$ -approximation regime, the recent partially dynamic maximum flow algorithms suffer from the following two main drawbacks: (i) they depend on the powerful yet intricate machinery of continuous optimization methods, such as interior point methods, monotone multiplicative weight updates, and dynamic min-ratio cycle/cut problems, (ii) all existing algorithms incur an $m^{o(1)}$ factor in the update time, a limitation that arises in many modern dynamic graph-based data structures and appears difficult to overcome. This leads to the following fundamental question:

Is there an incremental maximum flow algorithm that achieves $(1-\epsilon)$ approximation with polylogarithmic update time?

We answer this question in the affirmative for dense graphs that are undirected and uncapacitated, as summarized in the theorem below.

Theorem 1.

Given any $\epsilon\in(0,1)$ , there is an incremental randomized algorithm that maintains a $(1-\epsilon)$ -approximate maximum $s$ - $t$ flow $f$ under edge insertions on an undirected uncapacitated $n$ -vertex graph $G$ with high probability in total time $O(m\log(n)\alpha(n)+nF^{*}\log^{3}(n)/\epsilon)$ , where $m$ is the number of edge insertions, $F^{*}$ is the value of the max flow after $m$ insertions, and $\alpha(n)$ is the inverse Ackermann function.

Note that in addition to dense graphs ( $m=\Omega(n^{2})$ ), our algorithm achieves polylogarithmic amortized update time even for graphs with small flow value $F^{*}=\widetilde{O}(m/n)$ , regardless of their density. An important feature of our algorithm is that it builds upon arguably simple and classic combinatorial techniques, such as residual graph sparsification and cut sparsification.

Table 1: Results on dynamic max flow. The “Flow/Value” column indicates whether the algorithm maintains an actual flow or just the value of a flow. The update time stated is the amortized time over all updates.

Setting	Apx. Factor	Flow/Value	Directed	Weighted	Update Time	Reference
Incremental	1	Flow	Yes	Yes	$O(F^{*})$	[19, 17]
	1	Flow	No	No	$\widetilde{O}(n^{2.5}m^{-1})$	[15]
	$1+\epsilon$	Flow	Yes	No	$\widehat{O}(m^{0.5}\epsilon^{-0.5})$	[15]
	$1+\epsilon$	Flow	Yes	Yes	$\widehat{O}(n^{0.5}\epsilon^{-1})$	[33]
	$1+\epsilon$	Flow	No	Yes	$O(m^{o(1)}\epsilon^{-3})$	[32]
	$1+\epsilon$	Flow	Yes	Yes	$O(m^{o(1)}\epsilon^{-1})$	[6]
	$1+\epsilon$	Flow	No	No	$\widetilde{O}(nF^{*}m^{-1}\epsilon^{-1})$	Theorem 1
Decremental	$1+\epsilon$	Value	Yes	Yes	$O(m^{o(1)}\epsilon^{-1})$	[31]
Fully dynamic	$\widetilde{O}(\log n)$	Value	No	Yes	$\widehat{O}(n^{0.667})$	[5]
	$m^{o(1)}$	Value	No	No	$m^{o(1)}$	[16]
	$m^{o(1)}$	Value	No	Yes	$m^{o(1)}$	[31]

1.1 Technical Overview

The main idea underlying our result is to dynamize the static algorithm by Karger and Levine [21] (abbrv. KL algorithm) that computes an exact max flow in $\widetilde{O}(m+nF^{*})$ time. We start by reviewing their static construction and then identify the challenges in the dynamic setting, along with our approach to overcome them. We present the algorithm and its analysis in full in Section 3.

The KL algorithm proceeds by repeatedly sampling $\rho=O(n\log n)$ edges from the residual graph, searching for an augmenting path in this sample, and then augmenting along this path before resampling again. When the search fails to find an augmenting path, the number of sampled edges is doubled to $2\rho$ and this process is repeated until the sampled graph becomes as large as the original graph. Denoting the value of the maximum flow by $F^{*}$ , they show that at least $F^{*}/2$ of the augmentations are performed on the sparsest graph with $\rho$ edges, at least $F^{*}/4$ of the augmentations are performed on the graph with $2\rho$ edges and so on. After spending $\widetilde{O}(m)$ on pre-processing to compute the sampling probabilities, the total running time thus adds up to $\approx\sum_{i}(F^{*}/2^{i})\cdot 2^{i-1}\rho$ , which gives the required $\widetilde{O}(m+nF^{*})$ bound. Crucially, the last augmentation from $F^{*}-1$ to $F^{*}$ is performed on a graph of size $\Omega(m)$ .

This final augmentation, which requires a sample of size $\Omega(m)$ , effectively invalidates any attempts to use the KL approach for obtaining an incremental exact max flow algorithm. To understand why, observe that after every edge insertion, the algorithm needs to check if this edge insertion creates a new $s\to t$ augmenting path in the sampled graph. As we discuss below, this can be done in two ways, but both lead to algorithmic dead ends.

We could try to use an incremental single source reachability data structure (e.g., the one by Italiano [20]) to detect augmenting paths in the sampled graph, but since the actual augmentation reverses the direction of edges, we would need to reinitialize the incremental data structure on the sample after each augmentation. Since $F^{*}$ augmentations are performed on samples of size $\Omega(m)$ , this leads to a time bound of $\Omega(mF^{*})$ . As a concrete example, consider an initially empty bipartite graph $G=(S\cup T,\emptyset)$ , with $s\in S$ and $t\in T$ . In the first phase, insert all edges between $S\times T\setminus\{t\}$ , then in the second phase, insert all the remaining edges of the type $\{(v,t)\}_{v\in S}$ . Each edge insertion in the second phase increases the max flow by $1$ , and any algorithm based on a KL-type approach with an incremental reachability data structure needs to check an $\Omega(m)$ -edge graph to perform each augmentation.

The second approach would be to use a fully dynamic directed $s\to t$ reachability data structure. This would solve the above problem, as an augmentation in the residual graph can be simulated using $O(n)$ directed edge deletions and insertions. However, fully dynamic $s\to t$ reachability is known to admit strong conditional lower bounds – for any $\eta>0$ , no algorithm can achieve $O(n^{1-\eta})$ worst-case update time and $O(n^{2-\eta})$ worst-case query time, assuming the OMv conjecture [18].

Interestingly, we show that the first approach can be extended to the incremental setting if we relax our algorithm to maintain a $(1-\epsilon)$ -approximate $s$ - $t$ max flow instead of an exact one. The high-level reason why is as follows: To show that at least $F^{*}/2^{i}$ of the augmentations are found in the sampled graph of size $2^{i-1}\rho$ , Karger and Levine prove that when at least $F^{*}/2^{i}$ of the max flow still remains to be augmented, a sampled graph of size $2^{i-1}\rho$ suffices to preserve the existence of an augmenting path whp. For our setting, if we want to maintain a $(1-\epsilon)$ -approximate max flow, the above claim with $i=\log(1/\epsilon)$ tells us that it suffices to maintain a sparsifier with just $O(n\log(n)/\epsilon)$ edges incrementally. This then removes the need to augment on an $\Omega(m)$ -edge graph which lets us circumvent the above barrier. While incrementally maintaining the sparsifier used by Karger and Levine would be highly non-trivial, we show that we can both efficiently maintain a different sparsifier incrementally, and that the new sparsifier is powerful enough to recover the guarantees required for the KL approach to work (at the cost of a $\log n$ factor in the sparsifier size).

The challenge of incrementally maintaining the KL sparsifier is due to its fragility under edge insertions. The KL sampling depends on a parameter called the strong connectivity of an edge [3], and in the incremental setting, a single edge insertion could modify the strong connectivities (and thus the sampling probabilities) of all other edges of the graph. As a result, no existing algorithm can even just maintain the sampling probabilities, let alone maintain an actual sample from the corresponding distribution. The same issue arises for other well-known connectivity measures used for sampling such as edge-connectivity [12] and effective resistances [28], and even maintaining approximations to them is quite involved [9, 10, 5, 13]. Instead, our key observation is to use Nagamochi-Ibaraki (NI) indices [23] for our sampling because of their resilience to incremental updates.

While the other connectivity parameters mentioned are unique for an edge, the NI index is determined by the forest packing constructed, and different packings gives rise to different indices. This flexibility in choosing the index allows us to maintain the same value even under edge updates, which we crucially use to maintain the sampling probabilities. The resilience property we use is as follows: when inserting an edge, the NI index of all other edges remains the same, and our task is to only determine the NI index of the newly inserted edge efficiently (which then doesn’t change in the future). Efficient maintenance of NI indices is discussed in Section 4.

While we now maintain a set of sampling probabilities using NI indices, it is unclear how they can be used to replace strong connectivity in the KL algorithm. We extend the general result of Fung et al. [12] on using a wide variety of connectivity parameters for cut sparsification on undirected graphs to showing that the same parameters also lead to cut sparsification on balanced directed graphs, which cover residual graphs that arise in our algorithm as a special case. Their results sample each edge independently, which in our setting leads to a prohibitive $\Omega(m)$ time for sampling. We adapt this to repeated sampling from a probability distribution, where we only spend $O(\log n)$ time per edge for a total $O(n\log^{2}(n)/\epsilon)$ edges sampled. We present this result in full detail in Section 5.

Finally, we simplify our algorithm by not maintaining an exact sample from the distribution at each time step, but an oversample. Specifically, we obtain a sample of the correct size ( $O(n\log^{2}(n)/\epsilon)$ ) right after an augmentation, but between two augmentations, we add edges directly to the sample instead of trying to maintain the distribution. This could blow up the number of edges in the sample to $\Omega(m)$ at some time steps, but since each edge is added this way to at most one sample throughout the algorithm, the total time bound of $\widetilde{O}(m+nF^{*}/\epsilon)$ still holds.

2 Preliminaries

2.1 Graphs and Flows

Flows.

Our algorithmic results are on undirected uncapacitated graphs $G=(V,E)$ . We denote $n=|V|$ and $m=|E|$ . For two vertices $s,t\in V$ , an $s$ - $t$ flow $f\in\mathbb{R}^{m}$ assigns a value $f_{e}$ to each edge such that $\sum_{e\sim v}f_{e}=0$ for all $v\neq s,t$ with $|f_{e}|\leq 1$ $\forall e$ . The value of a flow $f$ is $F(f)=\sum_{e\sim s}f_{e}$ , and the maximum flow $f^{*}=\operatorname*{argmax}_{\text{$s$-$t$ flows $f$}}F(f)$ , with value $F^{*}=F(f^{*})$ . We use $F$ without the argument $f$ when the flow is clear from context. For any $\alpha\leq 1$ , an $s$ - $t$ flow $f$ is an $\alpha$ -approximate flow if $F\geq\alpha\cdot F^{*}$ . If $\alpha>1$ , then the statement holds with $\alpha^{\prime}=1/\alpha$ .

Model.

In the incremental model, we start with an empty graph with no edges, and the graph is revealed as a sequence of edge insertions $e_{1},e_{2},\ldots$ , leading to graphs $G_{1},G_{2},\ldots$ . Our goal is to maintain, after each edge insertion $e_{i}$ , an $s$ - $t$ flow $f$ that is a $(1-\epsilon)$ approximation to the max $s$ - $t$ flow $f^{*}_{i}$ in the current graph $G_{i}$ . We use $F_{i}^{*}$ to denote the value of the flow $f_{i}^{*}$ , and we use $F^{*}$ to denote the final max $s$ - $t$ flow value after all edge insertions.

Directed graphs.

We denote by $\vec{\mkern 0.0muG}=(V,\vec{\mkern 0.0muE})$ a directed (multi-)graph without edge capacities. An edge of integer capacity $x\in\mathbb{Z}^{+}$ is represented using $x$ parallel edges. For any subset of vertices $S\subseteq V$ , $\bar{S}=V\setminus S$ is the complement of $S$ , and $\partial_{\vec{\mkern 0.0muG}}(S)$ denotes the set of edges leaving $S$ , which is also denoted by $\vec{\mkern 0.0muC}(S)=\partial_{\vec{\mkern 0.0muG}}(S)$ . Similarly, we use ${\mathchoice{\vbox{\offinterlineskip\halign{#\cr\reflectbox{$\displaystyle\vec% {\mkern 0.0mu}\mkern 4.0mu$}\cr\kern-4.30554pt\cr$\displaystyle C$\cr}}}{\vbox% {\offinterlineskip\halign{#\cr\reflectbox{$\textstyle\vec{\mkern 0.0mu}\mkern 4% .0mu$}\cr\kern-4.30554pt\cr$\textstyle C$\cr}}}{\vbox{\offinterlineskip\halign% {#\cr\reflectbox{$\scriptstyle\vec{\mkern 0.0mu}\mkern 4.0mu$}\cr\kern-3.01389% pt\cr$\scriptstyle C$\cr}}}{\vbox{\offinterlineskip\halign{#\cr\reflectbox{$% \scriptscriptstyle\vec{\mkern 0.0mu}\mkern 4.0mu$}\cr\kern-2.15277pt\cr$% \scriptscriptstyle C$\cr}}}}(S)=\partial_{\vec{\mkern 0.0muG}}(\bar{S})$ to denote the set of edges entering $S$ . We use $\vec{\mkern 0.0muC}$ and $\textstyle\vec{\mkern 0.0mu}\mkern 4.0mu$ $\textstyle C$ without the argument $S$ when the subset is clear from context. The capacity $u(\vec{\mkern 0.0muC})=|\vec{\mkern 0.0muC}|$ of the cut $\vec{\mkern 0.0muC}$ is the number of edges in $\vec{\mkern 0.0muC}$ .

Underlying undirected graph.

For any directed (multi-)graph $\vec{\mkern 0.0muG}$ , we denote by $G$ the underlying undirected (multi-)graph obtained from $\vec{\mkern 0.0muG}$ by forgetting edge orientations, and $\partial_{G}(S)$ is the set of edges leaving $S$ , which is also denoted by $C(S)=\partial_{G}(S)$ . For a directed cut $\vec{\mkern 0.0muC}=\partial_{\vec{\mkern 0.0muG}}(S)$ , we use $C=\partial_{G}(S)$ to denote the underlying undirected cut in $G$ .

Residual graph.

For any undirected, uncapacitated graph $G$ , the corresponding residual graph for the zero flow $f=0^{m}$ is given by $G_{0^{m}}$ where each edge $(u,v)$ in $G$ is replaced by two directed edges $\vec{\mkern 0.0muuv}$ and $\vec{\mkern 0.0muvu}$ . For any $G$ and a non-zero flow $f$ , the residual graph $G_{f}$ is constructed the following way: start with the graph $G_{0^{m}}$ as above, and for every edge $e$ that carries flow in the direction $u\to v$ , replace the edge $\vec{\mkern 0.0muuv}$ in $G_{0^{m}}$ with the edge $\vec{\mkern 0.0muvu}$ . In that case there are two edges $\vec{\mkern 0.0muvu}$ in $G_{f}$ . A flow $f^{*}$ is a maximum flow if and only if $G_{f^{*}}$ contains no $s\to t$ paths.

2.2 Sampling Parameters

We define our importance parameter for sampling edges next. Since the residual graph has multiple edges between the same vertex pairs, we consider multi-graphs (which allow parallel edges) for the following definition.

Definition 2 (NI index [23]).

Given an undirected, unweighted (multi-)graph $G$ , an ordered sequence of edge-disjoint spanning forests $T_{1},T_{2},\ldots$ of $G$ is said to be an NI forest packing of $G$ if each $T_{i}$ is a maximal spanning forest on $G\setminus\cup_{1\leq j<i}\{T_{j}\}$ , and $\cup_{i}\{T_{i}\}$ is a partition of all the edges of $G$ . The NI index $\ell_{e}$ of an edge $e$ is the index $i$ of the forest $T_{i}$ that $e$ belongs to.

While the NI indices are the connectivity parameters that we will use for our sampling scheme due to their resilience to incremental graph updates, the following connectivity parameter is required for our directed sparsification proofs and cut-counting.

Definition 3 (Edge-connectivity).

Given an undirected unweighted (multi-)graph $G$ and two vertices $u$ and $v$ , the edge connectivity between $u$ and $v$ is defined to be the value of the minimum cut (and thus also the maximum flow) between $u$ and $v$ in $G$ . For an edge $e=(u,v)$ , we define the edge-connectivity of $e$ to be the edge connectivity between $u$ and $v$ .

As we perform non-uniform sampling of the edges, we maintain connectivity parameters $\lambda_{e}$ that influence the sampling probabilities. The NI index of an edge and the edge-connectivity of an edge are examples of such connectivity parameters. We will show concentration bounds for classes of edges whose $\lambda_{e}$ s are close to each other, which motivates the following definition.

Definition 4 (Connectivity class).

Given an undirected graph $G$ and connectivity parameters $\lambda_{e}$ for each edge, taking $\Lambda=\max_{e}\left\lceil\log\lambda_{e}\right\rceil+1$ , the connectivity classes $\mathcal{F}=\{F_{i}:1\leq i\leq\Lambda\}$ are given by

F_{i}=\{e:2^{i-1}\leq\lambda_{e}\leq 2^{i}-1\}.

For any connectivity class $F_{i}$ , the graph $(V,F_{i})$ does not have the same edge-connectivity properties that $G=(V,E)$ did. An edge $e\in F_{i}$ could have edge-connectivity $\Omega(n)$ in $G$ and $1$ in $(V,F_{i})$ , e.g., a graph with a single $(s,t)$ edge and $\Omega(n)$ parallel paths from $s$ to $t$ of length two. The following definitions from [12] are used to construct a subgraph of $G$ that is slightly larger than $F_{i}$ that certify connectivity properties of edges in $F_{i}$ .

Definition 5 ( $\Pi$ -connected decomposition [12]).

Given an undirected graph $G$ and connectivity parameters $\lambda_{e}$ , a decomposition $\mathcal{G}=\left(G_{i}=(V,E_{i})\right)_{1\leq i\leq\Lambda}$ is a sequence of subgraphs of $G$ that satisfy $F_{i}\subseteq E_{i}$ for all $i$ with $\Lambda=\max_{e}\left\lceil\log\lambda_{e}\right\rceil+1$ . Further, for a sequence of parameters $\Pi=\left(\pi_{i}\right)_{1\leq i\leq\Lambda}$ , the decomposition satisfies $\Pi$ -connectivity if all edges $e\in F_{i}$ have edge-connectivity at least $\pi_{i}$ in $G_{i}$ for all $i$ .

Note that the same edge is allowed to appear in multiple sets $E_{i}$ .

Definition 6 ( $\gamma$ -overlap [12]).

For any $\gamma\geq 1$ , an undirected graph $G$ and its $\Pi$ -connected decomposition $\mathcal{G}$ satisfies $\gamma$ -overlap if for all $i$ and for all cuts $C=\partial_{G}(S)$ ,

\sum_{i=0}^{\Lambda}u(C\cap E_{i})\cdot\frac{2^{i-1}}{\pi_{i}}\leq\gamma\cdot u% (C)

2.3 Balance and Cut Counting

Imbalance of directed graphs.

Preserving various graph properties by subsampling is difficult on general directed graphs. However, sampling algorithms can be successfully applied when the directed graph exhibits some nice structure, for example, they have a similar number of edges crossing a cut in both directions. Eulerian graphs have exactly the same number of edges crossing any cut in both directions, and more pertinently, the residual graph of a flow that is not a $(1-\epsilon)$ approximate max flow has at least an $O(\epsilon)$ fraction of edges crossing any cut in one direction over the other.

Definition 7 (balance [11]).

Given a directed (multi-)graph $\vec{\mkern 0.0muG}=(V,\vec{\mkern 0.0muE})$ , the (im)balance of a cut $\vec{\mkern 0.0muC}=\partial_{\vec{\mkern 0.0muG}}(S)$ is defined as

\beta(\vec{\mkern 0.0muC})=\frac{u(\vec{\mkern 0.0muC})}{u({\mathchoice{\vbox{% \offinterlineskip\halign{#\cr\reflectbox{$\displaystyle\vec{\mkern 0.0mu}% \mkern 4.0mu$}\cr\kern-4.30554pt\cr$\displaystyle C$\cr}}}{\vbox{% \offinterlineskip\halign{#\cr\reflectbox{$\textstyle\vec{\mkern 0.0mu}\mkern 4% .0mu$}\cr\kern-4.30554pt\cr$\textstyle C$\cr}}}{\vbox{\offinterlineskip\halign% {#\cr\reflectbox{$\scriptstyle\vec{\mkern 0.0mu}\mkern 4.0mu$}\cr\kern-3.01389% pt\cr$\scriptstyle C$\cr}}}{\vbox{\offinterlineskip\halign{#\cr\reflectbox{$% \scriptscriptstyle\vec{\mkern 0.0mu}\mkern 4.0mu$}\cr\kern-2.15277pt\cr$% \scriptscriptstyle C$\cr}}}})}

where ${\mathchoice{\vbox{\offinterlineskip\halign{#\cr\reflectbox{$\displaystyle\vec% {\mkern 0.0mu}\mkern 4.0mu$}\cr\kern-4.30554pt\cr$\displaystyle C$\cr}}}{\vbox% {\offinterlineskip\halign{#\cr\reflectbox{$\textstyle\vec{\mkern 0.0mu}\mkern 4% .0mu$}\cr\kern-4.30554pt\cr$\textstyle C$\cr}}}{\vbox{\offinterlineskip\halign% {#\cr\reflectbox{$\scriptstyle\vec{\mkern 0.0mu}\mkern 4.0mu$}\cr\kern-3.01389% pt\cr$\scriptstyle C$\cr}}}{\vbox{\offinterlineskip\halign{#\cr\reflectbox{$% \scriptscriptstyle\vec{\mkern 0.0mu}\mkern 4.0mu$}\cr\kern-2.15277pt\cr$% \scriptscriptstyle C$\cr}}}}=\partial_{\vec{\mkern 0.0muG}}(\bar{S})$ is the set of edges in the other direction of the cut.

Counting cut projections.

Karger shows that there are at most $n^{2\alpha}$ distinct cuts whose size is $\leq\alpha\lambda$ , where $\lambda$ is the global mincut. We, like Fung et al. [12], look at larger cuts in the graph and require a tighter bound than the one given by Karger, which requires the following definition.

Definition 8 (directed $k$ -projection).

Let $\vec{\mkern 0.0muG}=(V,\vec{\mkern 0.0muE})$ be a directed (multi-)graph and let $G$ be the corresponding undirected graph. The $k$ -projection of any cut $\vec{\mkern 0.0muC}=\partial(S)$ in $\vec{\mkern 0.0muG}$ is $\vec{\mkern 0.0muC}\cap H_{k}$ where

H_{k}=\left\{\vec{\mkern 0.0mue}\in\vec{\mkern 0.0muE}:\text{the \hyperref@@ii% [def:edgeconnectivity]{{\color[rgb]{0,0,0}\definecolor[named]{pgfstrokecolor}{% rgb}{0,0,0}\pgfsys@color@gray@stroke{0}\pgfsys@color@gray@fill{0}edge-% connectivity}} of e in $G$ is at least $k$}\right\}

2.4 Data Structures

We also need three classic data structures for our results, which we produce here.

Fact 1 (UnionFind [29]).

There is a data structure that supports the following operations

$\blacksquare$

$\textup{{Add}}(u)$ : Adds $\{u\}$ to the set of sets in $O(1)$ time.
$\blacksquare$

$\textup{{Find}}(u)$ : Finds the representative of the set that $u$ belongs to in amortized $O(\alpha(n))$ time.
$\blacksquare$

$\textup{{Union}}(u,v)$ : Replaces the sets that $u$ and $v$ belong to with their union in $O(1)$ time.

where $n$ is the number of elements present at that time, and $\alpha(n)$ is the inverse Ackermann function.

Fact 2 (SingleSourceReachability [20]).

There is a data structure that supports the following operations on a graph $\vec{\mkern 0.0muG}$ with $n$ vertices

$\blacksquare$

$\textup{{Initialize}}(\vec{\mkern 0.0muG},s)$ : Initializes a data structure on $\vec{\mkern 0.0muG}$ with special vertex $s$ in $O(m+n)$ time.
$\blacksquare$

$\textup{{Insert}}(e=\vec{\mkern 0.0muuv})$ : Inserts the directed edge $\{e=\vec{\mkern 0.0muuv}\}$ into $\vec{\mkern 0.0muG}$ in amortized $O(1)$ time.
$\blacksquare$

$\textup{{Reachable}}(t)$ : Returns “True” if $t$ is reachable from $s$ in $\vec{\mkern 0.0muG}$ in amortized $O(1)$ time.
$\blacksquare$

$\textup{{GetPath}}(t)$ : Returns a directed $s\to t$ path in $\vec{\mkern 0.0muG}$ in time proportional to the length of the path.

Fact 3 (BinarySearchTree).

There is a data structure that supports the following operations

$\blacksquare$

Initialize: Initializes the binary search tree data structure.
$\blacksquare$

$\textup{{Insert}}(e,x)$ : Inserts the key $e$ with value $x$ in amortized $O(\log n)$ time.
$\blacksquare$

$\textup{{Search}}(x)$ : Returns the largest key $e$ with value $\leq x$ in amortized $O(\log n)$ time.

where $n$ is the number of items inserted into the data structure at time of operation.

High probability bounds.

Finally, we say that an algorithm satisfies a guarantee with high probability if the guarantee holds with probability at least $1-4/n$ .

3 Incremental Maximum Flow

Our main result in this section is the following:

See 1

Algorithm 1 Algorithm for incremental approximate maximum flow on undirected, uncapacitated graphs.

We present the algorithm achieving the guarantees in Algorithm 1. The algorithm works in phases. At the start of a new phase, we sample $O(n\log^{2}(n)/\epsilon)$ edges from the residual graph using a specific probability distribution which we will discuss later, and add them to the sampled graph $H$ . On top of $H$ , we run an incremental directed single-source reachability algorithm, called $D$ , starting from $s$ . At the beginning, and after each edge insertion, we query $D$ if there exists an $s\to t$ path in the sample. As long as $D$ does not return “Yes”, for each edge insertion $e=(u,v)$ , we add edges $\vec{\mkern 0.0muuv}$ and $\vec{\mkern 0.0muvu}$ to $D$ . When $D$ returns “Yes”, this corresponds to an $s\to t$ path in the residual graph, and we retrieve this path from $D$ , augment along this path in $G_{f}$ , and start a new phase.

We need to argue about the time bounds and the correctness. For correctness, we show that whenever an edge insertion increases the max flow to a value larger than a $(1-\epsilon)^{-1}$ factor over the current flow maintained by the algorithm, the existence of an $s\to t$ path in the sampled graph $H$ is guaranteed with high probability. Since $H$ is a subsample of the residual graph $G_{f}$ , this provides us an augmenting path in $G_{f}$ along which we augment the flow. With a union bound over the at most $n$ times when this can happen (since the max flow value is at most $n$ and each augmentation increases the flow by $1$ ), this will imply that at the end of every time step, the algorithm maintains a valid $(1-\epsilon)$ -approximate $s$ - $t$ flow with high probability. To show this claim, we first show that an extension of Fung et al.’s high probability result [12] on independent sampling for cut sparsification on undirected graphs also extends to repeated sampling for cut sparsification on balanced directed graphs. When combined with the fact that the residual graph of a flow that is not a $(1-\epsilon)$ -approximate max flow is $\Omega(\epsilon)$ -balanced, this shows that sampling approximately $n\log^{2}(n)/\epsilon$ edges based on the probability distribution discussed below will preserve directed cuts, and thus also the existence of an augmenting path in residual graphs of non- $(1-\epsilon)$ -approximate flows. Our initial sample at the beginning of a phase already satisfies the size requirement above, and since we add further edges directly to the maintained sample, we always oversample the rate required for the augmenting path preservation guarantee.

For the time bounds, assuming that the sampling can be done in time approximately $O(\log n)$ per sample and that the reachability data structure runs in total time proportional to the number of edges in $D$ , we will show that the algorithm runs in $\widetilde{O}(m+nF^{*}/\epsilon)$ time. If we had maintained the size of the sampled graph at $\widetilde{O}(n/\epsilon)$ throughout a phase, then the claimed time bound would follow since $D$ runs on a graph of size $\widetilde{O}(n/\epsilon)$ in each phase, at the end of which the value of the flow increases by $1$ , and the max flow is bounded by $F^{*}$ which bounds the number of phases by $F^{*}$ as well. However, the size of the sampled graph could increase to $\Omega(m)$ if no paths are found by $D$ over all edge insertions, so this argument does not immediately work. The bound follows from a slight modification to the above argument: in each phase, denote an edge to be “old” when it is inserted into $H$ due to sampling, and “new” when it is inserted into $H$ directly on insertion in $G$ . Then the claimed time bound follows since each edge appears as “new” in at most one phase throughout the algorithm, and the previous argument still holds for the “old” edges of each phase since there are at most $\widetilde{O}(n/\epsilon)$ of them per phase.

Finally, we maintain NI indices incrementally for the probability distribution, which we discuss in Section 4. We use the following definition in our proofs.

Definition 9 (Phase).

Let $t_{0}=0$ , and let $t_{i}$ be the time step when the $i^{\mathrm{th}}$ augmenting path is found. Let $m_{k}$ be the number of edges inserted in time steps $(t_{k-1},t_{k}]$ . Phase $k$ refers to the computations performed after the $(k-1)^{th}$ augmentation finishes until the $k^{th}$ augmentation ends.

We also use the following two statements directly, whose proofs can be found in Section 4 and Section 5 respectively.

Lemma 10.

There is an incremental data structure that maintains an NI forest packing (and thus the NI index $\ell_{e}$ of each edge) of an undirected graph under edge insertions in total time $O(m\cdot\log m\cdot\alpha(n))$ where $\alpha(n)$ is the inverse Ackermann function and $m$ is the number of edges in the final graph. At any point of time, it also allows querying for an edge sampled from the probability distribution $\left\{\ell_{e}^{-1}/L\right\}_{e\in E}$ where $L=\sum_{e}\ell_{e}^{-1}$ in amortized time $O(\log n)$ for each sample.

Algorithm 2 Algorithm for directed balanced sparsification.

Theorem 11.

Let $\vec{\mkern 0.0muG}=(V,\vec{\mkern 0.0muE})$ be any directed (multi-)graph, and $G$ be the underlying undirected graph. Let $\{\lambda_{e}\}_{e\in E}$ be some connectivity parameters in $G$ , and $\beta,\gamma\geq 1$ and $\epsilon<1$ be input parameters. Let $\vec{\mkern 0.0muH}=(V,\vec{\mkern 0.0muF},w)$ be the random graph with $O\!\left(\gamma\beta\ln(n)\cdot\sum_{e\in E}\lambda_{e}^{-1}/\epsilon^{2}\right)$ edges generated as in Algorithm 2.

If there exists a $\Pi$ -connected decomposition $\mathcal{G}=\{G_{i}=(V,E_{i}):1\leq i\leq\Lambda\}$ of $G$ that satisfies $\gamma$ -overlap, then for all cuts $\vec{\mkern 0.0muC}=\partial_{\vec{\mkern 0.0muG}}(S)$ of balance at least $\beta^{-1}$ in $\vec{\mkern 0.0muG}$ , it holds simultaneously with probability $\geq 1-4/n^{2}$ that

(1-\epsilon)\cdot u(\vec{\mkern 0.0muC})\leq w(\vec{\mkern 0.0muC})\leq(1+% \epsilon)\cdot u(\vec{\mkern 0.0muC}).

3.1 Running Time

Lemma 12.

Phase $k$ takes total time $O(m_{k}\log(n)\alpha(n)+n\log^{3}(n)/\epsilon)$ , where $m_{k}$ is the number of edges inserted in Phase $k$ and $\alpha(n)$ is the inverse Ackermann function.

Proof.

Phase $k$ starts with sampling $O(n\log^{2}(n)/\epsilon)$ edges from the sampler, where each sample takes time $O(\log n)$ by Lemma 10. $D$ has a total of $m_{k}+O(n\log^{2}(n)/\epsilon)$ many edges added to it in its entire lifetime, which gives a total update time of $O(m_{k}+n\log^{2}(n)/\epsilon)$ . Inserting each edge into the sampler takes amortized time $O(\log m\cdot\alpha(n))$ by Lemma 10. Augmenting along a path takes time proportional to the length of the path, which is $\leq n$ . $\hfill\blacktriangleleft$

Lemma 13.

The algorithm takes total time $O(m\log(n)\alpha(n)+n\log^{3}(n)F^{*}/\epsilon)$ where $F^{*}$ is the value of the final max flow after all edge insertions.

Proof.

Let $K$ be the total number of phases in the algorithm. Then $K\leq F^{*}$ since each phase increases the value of the flow by $1$ . Since the set of edges inserted in each phase are disjoint, $\sum_{k}m_{k}=m$ . By Lemma 12, phase $k$ takes time $O(m_{k}\log(n)\alpha(n)+n\log^{3}(n)/\epsilon)$ . Together, all phases take time

\sum_{k=1}^{K}O(m_{k}\log(n)\alpha(n)+n\log^{3}(n)/\epsilon)=O\left(m\log(n)% \alpha(n)+n\log^{3}(n)F^{*}/\epsilon\right)\

$\hfill\blacktriangleleft$

3.2 Correctness

We first collect a few general statements that will be useful in the final proof.

Lemma 14.

Let $f$ be any $s$ - $t$ flow in an undirected graph $G$ of value $F$ , and let $G_{f}$ be its corresponding residual graph. Suppose $F\leq(1-\epsilon)F^{*}$ , where $F^{*}$ is the value of the maximum flow. Then every cut in $G_{f}$ is at least $\epsilon/2$ -balanced.

Proof.

For any cut $\vec{\mkern 0.0muC}=\partial(S)$ that is not an $s$ - $t$ cut (or a $t$ - $s$ cut), the net flow out of $S$ in $G_{f}$ is zero, and thus $\vec{\mkern 0.0muC}$ is $1$ -balanced. All $t$ - $s$ cuts are $\geq 1$ -balanced since the residual graph has more flow in the $s\to t$ direction and thus more capacity in the $t\to s$ direction. Consider an $s$ - $t$ cut $\vec{\mkern 0.0muC}$ . Let $c$ be the capacity of the underlying undirected cut $C$ . Since $F$ units of flow cross $C$ in the forward direction $s\to t$ , the forward capacity across $C$ in $G_{f}$ is $c-F$ , and the backward capacity is thus $c+F$ since the total capacity is $2c$ . Using (in order) $c\geq F$ , $c\geq F^{*}$ , and $F\leq(1-\epsilon)F^{*}$ , we get

\beta(\vec{\mkern 0.0muC})=\frac{u(\vec{\mkern 0.0muC})}{u({\mathchoice{\vbox{% \offinterlineskip\halign{#\cr\reflectbox{$\displaystyle\vec{\mkern 0.0mu}% \mkern 4.0mu$}\cr\kern-4.30554pt\cr$\displaystyle C$\cr}}}{\vbox{% \offinterlineskip\halign{#\cr\reflectbox{$\textstyle\vec{\mkern 0.0mu}\mkern 4% .0mu$}\cr\kern-4.30554pt\cr$\textstyle C$\cr}}}{\vbox{\offinterlineskip\halign% {#\cr\reflectbox{$\scriptstyle\vec{\mkern 0.0mu}\mkern 4.0mu$}\cr\kern-3.01389% pt\cr$\scriptstyle C$\cr}}}{\vbox{\offinterlineskip\halign{#\cr\reflectbox{$% \scriptscriptstyle\vec{\mkern 0.0mu}\mkern 4.0mu$}\cr\kern-2.15277pt\cr$% \scriptscriptstyle C$\cr}}}})}=\frac{c-F}{c+F}\geq\frac{c-F}{2c}=\frac{1}{2}% \cdot\left(1-\frac{F}{c}\right)\geq\frac{1}{2}\cdot\left(1-\frac{F}{F^{*}}% \right)\geq\frac{\epsilon}{2}\

$\hfill\blacktriangleleft$

Lemma 15.

Let $\left\{\ell_{e}\right\}_{e\in E}$ be a set of NI indices for an undirected (multi-)graph $G$ with $m$ edges. Then $\sum_{e}\ell_{e}^{-1}\leq 2n\log m$ .

Proof.

Consider the NI forest packing $T_{1},T_{2},\ldots$ corresponding to the NI indices $\ell_{e}$ . Since each forest contains at least one edge, the total number of forests is at most $m$ . As each edge $e$ in $T_{i}$ has $\ell_{e}=i$ , the sum of NI indices of all edges in forest $i$ contributes at most $\frac{n-1}{i}$ to the total sum. Thus,

\sum_{e\in E}\ell_{e}^{-1}=\sum_{1\leq i\leq m}\sum_{e\in T_{i}}\ell_{e}^{-1}% \leq\sum_{1\leq i\leq m}\frac{n-1}{i}\leq(n-1)\cdot(2\log m)\leq 2n\log m

where $1+\frac{1}{2}+\frac{1}{3}+\dots+\frac{1}{m}$ is the $m$ -th harmonic number, which is upper bounded by $2\log m$ . $\hfill\blacktriangleleft$

Since we work with the residual graph which has two copies of each edge of $G$ , we prove the following lemma to show that an NI forest packing of $G$ can be easily transformed into an NI forest packing of the undirected residual graph.

Lemma 16.

Let $\{\ell_{e}\}_{e\in E}$ be a set of NI indices for an undirected, simple graph $G=(V,E)$ . Let $E^{\prime}$ be a copy of the edges in $E$ . Then, for the multigraph $H=(V,E\cup E^{\prime})$ which doubles the edges in $E$ , assigning $h_{e}=2\ell_{e}-1$ and $h_{e^{\prime}}=2\ell_{e}$ is a set of NI indices for $H$ .

Proof.

If $T_{1},T_{2},\ldots$ forms an NI forest packing of $G$ , then $T_{1},T_{1},T_{2},T_{2},\ldots$ forms an NI forest packing of $H$ . Letting $e$ be the edge in the first copy of $T_{i}$ and $e^{\prime}$ be the edge in the second copy gives the lemma. $\hfill\blacktriangleleft$

Lemma 17 ([12]).

Let $T_{1},T_{2},\ldots$ be an NI forest packing of an undirected graph $G$ leading to NI indices $\ell_{e}$ , and let $\mathcal{F}=\{F_{i}\}$ be the corresponding connectivity classes. Then $E_{1}=F_{1}$ and $E_{i}=F_{i-1}\cup F_{i}$ for $i\geq 2$ is a decomposition that satisfies $\Pi$ -connectivity and $\gamma$ -overlap for $\pi_{i}=2^{i-1}$ and $\gamma=2$ , i.e., for all $i$ and for all cuts $C=\partial_{G}(S)$ ,

\sum_{i=0}^{\Lambda}u(C\cap E_{i})\leq 2\cdot u(C).

Using these, we will first show that sampling $\Omega(n\log^{2}(n)/\epsilon)$ edges from the residual graph of a non- $(1-\epsilon)$ -approximate flow preserves an augmenting path with high probability.

Lemma 18.

Consider an undirected, uncapacitated graph $G$ with some $s$ - $t$ flow $f$ of value $F$ and a max $s$ - $t$ flow of value $F^{*}$ such that $F\leq(1-\epsilon)F^{*}$ . Let $\ell_{e}$ be a NI index of edge $e$ . If a sample of $5390\cdot n\log^{2}(n)/\epsilon$ edges is chosen i.i.d. with probability $\left\{\ell_{e}^{-1}/\sum_{e}\ell_{e}^{-1}\right\}_{e\in G_{f}}$ from the residual graph $G_{f}$ , then there exists an augmenting path in the sample with probability $1-4/n^{2}$ .

Proof.

We will first argue that sampling the mentioned number of edges and reweighting them as in Algorithm 2 gives a (weighted) cut sparsifier $\vec{\mkern 0.0muH}=(V,\vec{\mkern 0.0muF},w)$ of $G_{f}$ . We show that this implies the presence of an augmenting path in $\vec{\mkern 0.0muH}$ . Then, we note that the property of presence of an augmenting path holds regardless of the presence of weights. Since the sample chosen in the lemma is an unweighted version of $\vec{\mkern 0.0muH}$ , the lemma follows.

Since there are at most ${\binom{n}{2}}$ edges in a simple graph $G$ (and thus at most $n^{2}$ edges in a residual graph), Lemma 15 gives that that $\sum_{e\in E}\ell_{e}^{-1}\leq 4n\log n$ . By Lemma 17, there is a decomposition for NI indices that satisfies $\Pi$ -connectivity and $\gamma$ -overlap for $\pi_{i}=2^{i-1}$ and $\gamma=2$ . Thus, if one runs Algorithm 2 with $\rho=5390\cdot n\log^{2}(n)/\epsilon$ edges, then by Theorem 11 one obtains a weighted $(1+\epsilon^{\prime})$ -sparsifier $\vec{\mkern 0.0muH}=(V,\vec{\mkern 0.0muF},w)$ of the residual graph $G_{f}$ where the parameters are set as $\epsilon^{\prime}=1/2$ , $\gamma=2$ , $\beta=2/\epsilon$ , and $\sum_{e}\ell_{e}^{-1}\leq 4n\log n$ . Since every cut in the residual graph of a flow with $F\leq(1-\epsilon)F^{*}$ has balance at least $\epsilon/2$ (Lemma 14), we have that the weighted sparsifier $\vec{\mkern 0.0muH}=(V,\vec{\mkern 0.0muF},w)$ from Theorem 11 satisfies

w(\vec{\mkern 0.0muC})\geq\frac{u(\vec{\mkern 0.0muC})}{2}>0

for all directed cut $\vec{\mkern 0.0muC}=\partial(S)$ simultaneously with probability $1-4/n^{2}$ . In particular, this also means that at least one edge from $S$ to $\bar{S}$ is sampled in $\vec{\mkern 0.0muH}$ for every directed $s$ - $t$ cut $(S,\bar{S})$ . This implies that an $s$ - $t$ augmenting path exists in $\vec{\mkern 0.0muH}$ with probability $1-4/n^{2}$ .

Defining $H^{\prime}=(V,\vec{\mkern 0.0muF})$ to be the unweighted graph obtained from $\vec{\mkern 0.0muH}$ by dropping the edge weights, the existence of an augmenting path holds in $H^{\prime}$ as well with probability $1-4/n^{2}$ . Since the sampled graph stated in the lemma is generated exactly as in $H^{\prime}$ , the lemma follows. $\hfill\blacktriangleleft$

We will now show that at any fixed time step, the augmenting path guarantee holds with high probability.

Lemma 19.

At the beginning of any phase $k$ , if $F\leq(1-\epsilon)F^{*}_{t_{k-1}}$ , then there exists an augmenting path in $H$ with probability $1-4/n^{2}$ . Here, $F^{*}_{i}$ is the max flow at time $i$ , and $t_{k-1}$ is the time step when the $(k-1)$ -th augmentation ends.

Proof.

At the beginning of the phase, the sample has just been performed and no new edges have been inserted. Since we sample an undirected edge and put in both directions into the sample, this is an oversample of the rate required by Lemma 18. The lemma follows by guarantees of Lemma 18. $\hfill\blacktriangleleft$

Lemma 20.

At each time step $i$ , whenever $F<(1-\epsilon)F^{*}_{i}$ , there exists an augmenting path in $H$ with probability $1-4/n^{2}$ . Here, $F^{*}_{i}$ is the value of the max flow at time $i$ .

Proof.

At the beginning of a phase, this follows from Lemma 19. Else, there has been at least one edge insertion into $H$ . On edge insertions, the total sampling weight of the graph, which is $\sum_{e}\ell_{e}^{-1}$ , strictly increases. The NI index of every existing edge, on the other hand, stays the same. Thus adding the new edge directly to $H$ is an oversample of the rate required by Lemma 18 to guarantee the existence of an augmenting path, both for the already existing edges and for the new edge. Using the guarantees of Lemma 18 gives the lemma. $\hfill\blacktriangleleft$

Finally, we take a simple union bound to extend the guarantee to all time steps.

Lemma 21.

Algorithm 1 maintains a $(1-\epsilon)$ -approximate $s$ - $t$ max flow at all times with probability $1-4/n$ .

Proof.

Whenever $F<(1-\epsilon)F_{i}^{*}$ , we use Lemma 20 to argue the existence of an augmenting path in the sample with probability $\geq 1-4/n^{2}$ . Each time an augmenting path is found, $F$ increases by $1$ . Thus, we need to invoke Lemma 20 at most $F^{*}\leq n$ times. Taking a union bound over all times that $F$ increases, we get that the approximation guarantee holds throughout the entire insertion sequence with probability $1-4/n$ as required. $\hfill\blacktriangleleft$

4 Incremental Nagamochi-Ibaraki Indices

In this section, we show how to incrementally maintain (and sample from) Nagamochi-Ibaraki indices $\ell_{e}$ for each edge $e$ . The main result of this section is the following: See 10

We maintain Nagamochi-Ibaraki indices instead of other sampling parameters because of their stability under incremental updates. When an edge $e=(u,v)$ is inserted into a graph $G$ , it could change other connectivity parameters (such as edge-connectivity, strong-connectivity, or the effective resistance) of every existing edge in the graph. However, the NI index of every other edge remains the same on edge insertion, which is a very desirable property for dynamic algorithms. This happens because while other graph properties are unique for an edge in a given graph, the NI index depends heavily on the particular forest packing used. It could vary wildly for the same edge, and could range from $1$ up to $n$ depending on the packing.

The incremental algorithm involves maintaining a collection of forests, where each forest is a union-find data structure on the vertices currently in that forest. On an edge insertion, we binary search across the forests to find the first one where its endpoints are disconnected, and insert the edge into that forest (and also adding the endpoints to the forest or initializing a new forest if necessary).

Due to the subtleties of implementing this, we present the data structure in full detail below. In particular, if we naively “initialized” a new forest by inserting all the vertices into the forest, then this would lead to a running time of $\Omega(n)$ per forest, which could be prohibitive. For the extreme case where $n$ parallel edges are inserted between the same two vertices $u$ and $v$ , this necessitates initializing $\Omega(n)$ forests, which leads to $\Omega(n^{2})$ total time for the naive implementation, as opposed to adding a vertex to a forest only when necessary (as done below with the $last\_tree$ variable).

Algorithm 3 Maintaining Incremental Nagamochi-Ibaraki Indices (IncNIIndex).

Algorithm 4 Incremental Nagamochi-Ibaraki sampling (IncNISample).

Lemma 22.

Algorithm 3 maintains the NI forest packing at all times, and runs in total time $O(m\cdot\log m\cdot\alpha(n))$

Proof.

We first argue about correctness by induction. It is clearly true before any edge insertions. Suppose it was true until $k$ insertions. Let $e=(u,v)$ be the $(k+1)$ -th inserted edge. If $i$ is the index of the tree returned by FindTree, then it satisfies the property that for all $j<i$ , vertices $u$ and $v$ are connected in forest $tree[j]$ , and that they are not connected in forest $tree[i]$ . Thus connecting $u$ and $v$ in forest $tree[i]$ and setting the index of the edge to $i$ maintains correctness after the $(k+1)$ -th edge as well.

Next, we argue about the time taken by the algorithm. If there are $m$ edges in the graph currently, then the algorithm maintains $\leq m$ forests. Thus the binary search takes $O(\log m)$ iterations. In each iteration, it queries a union-find data structure if two vertices are connected, which takes $O(\alpha(n))$ amortized time. Union of two elements in, insertion of new elements into, and initialization of a union-find data structure takes constant time. Thus the algorithm runs in total time $O(m\cdot\log m\cdot\alpha(n))$ . $\hfill\blacktriangleleft$

We quickly recall an example of a binary search tree insertion sequence before we prove the next lemma. In a binary search tree, if there are three consecutive insertions of (key, value) pairs $(a,0),(b,1/3),$ and $(c,1/2)$ , then searching for any $z\in[0,1/3)$ returns $a$ , searching for $z\in[1/3,1/2)$ returns $b$ , and searching for $z\in[1/2,\infty)$ returns $c$ .

Lemma 23.

Algorithm 4 maintains a sample from the correct distribution at all times, each insertion takes time $O(\log(m)\alpha(n))$ and each sample takes time $O(\log n)$ .

Proof.

Let $e_{1},\ldots,e_{m}$ be the sequence of edge insertions performed, and let $\ell_{e_{i}}$ be their corresponding NI indices obtain from Algorithm 3. The $\ell_{e}$ values obtained from Algorithm 3 are correct by the guarantees of Lemma 22. Define $s_{1}=0$ and $s_{i}=\sum_{1\leq j<i}\ell_{e_{j}}^{-1}$ be the sum of inverse NI indices of all edges inserted until $e_{i-1}$ . We will show that at any time $k$ , for all $i\in\{1,\ldots,k\}$ , searching for any $z\in[s_{i},s_{i+1}]\subseteq[0,s_{k+1}]$ returns key $e_{i}$ in the binary search tree. This then gives correctness of the algorithm since, after the $k$ -th insertion, the edge $e_{i}$ is sampled with probability $(s_{i+1}-s_{i})/L=\ell_{e_{i}}^{-1}/s_{k+1}$ since $L=s_{k+1}$ after $k$ edge insertions.

The statement is clearly true after the first edge insertion. Suppose it was true until $k-1$ insertions. Since the key $e_{k-1}$ had value $s_{k-1}$ , searching for any $z\in[s_{k-1},\infty)$ would have given key $e_{k-1}$ . Let $e_{k}$ be the $k$ -th inserted edge, which is inserted with value $s_{k}$ . Thus, for all $z\in[s_{k},\infty)$ , the search returns key $e_{k}$ , and for $z\in[s_{k-1},s_{k})$ , the search returns key $e_{k-1}$ . As $s_{k}-s_{k-1}=\ell_{e_{k-1}}^{-1}$ , $s_{k+1}-s_{k}=\ell_{e_{k}}^{-1}$ , and the other edges $e_{j}$ for $j<k-1$ are not affected by this insertion, the claim follows.

For time bounds, note that each edge insertion into Algorithm 3 takes time $O(\log(m)\alpha(n))$ , each insertion into the binary search tree with length $\ell_{e}^{-1}$ takes time $O(\log n)$ , and each sample takes time $O(\log n)$ as well, given that the random number is generated in time $O(\log n)$ . $\hfill\blacktriangleleft$

Lemma 10 now follows from Lemma 22 and Lemma 23.

5 Balanced Sparsification

We remark that while Cen et al. [4] obtain a cut sparsification result for balanced directed graphs, their result only works with strong connectivity and cannot be used with NI indices, which we need for our algorithm. In this section, we show the following result.

See 11

This is an extension of the result of [12] to balanced directed graphs, with the sampling scheme changed from sampling each edge independently with probability $\approx\operatorname{polylog}(n)/(\lambda_{e}\epsilon^{2})$ to sampling $\approx O(n\operatorname{polylog}(n)/\epsilon^{2})$ edges with probability distribution proportional to $\lambda_{e}^{-1}$ . The proof proceeds by reducing the problem to showing concentration for each connectivity class where the connectivity parameters are close to each other. Inside each connectivity class $F_{i}$ , the cuts are then collected by the size of the underlying undirected cut in $G_{i}$ and concentration is shown for each collection separately. This involves combining the concentration for each cut in the collection, along with a cut-counting argument similar to the one on [12] (which is an extension of Karger’s cut-counting). Finally, the concentration of each cut is shown using a standard Chernoff bound.

Concretely, we will show later that the following concentration holds for every connectivity class.

Lemma 24.

It holds for all $i\in[\Lambda]$ and for all cuts $\vec{\mkern 0.0muC}=\partial_{\vec{\mkern 0.0muG}}(S)$ simultaneously with probability at least $1-4/n^{2}$ that

\left|w(\vec{\mkern 0.0muC}\cap F_{i})-u(\vec{\mkern 0.0muC}\cap F_{i})\right|% \leq\frac{\epsilon}{2}\cdot\left(\frac{u(C\cap E_{i})\cdot 2^{i-1}}{\pi_{i}% \cdot\gamma\cdot(\beta+1)}+u(\vec{\mkern 0.0muC}\cap F_{i})\right)

where $C=\partial_{G}(S)$ is the underlying undirected cut of $\vec{\mkern 0.0muC}$ in $G$ .

We first use it to prove Theorem 11.

Proof of Theorem 11.

We group the edges by the probability it is picked, and show concentration for each such connectivity class separately. With probability $\geq 1-4/n^{2}$ , we have for all cuts $\vec{\mkern 0.0muC}=\partial_{\vec{\mkern 0.0muG}}(S)$ of balance $\beta^{-1}$ ,

$\displaystyle\left\|w(\vec{\mkern 0.0muC})-u(\vec{\mkern 0.0muC})\right\|$	$\displaystyle=\left\|\sum_{i=0}^{\Lambda}w(\vec{\mkern 0.0muC}\cap F_{i})-\sum_% {i=0}^{\Lambda}u(\vec{\mkern 0.0muC}\cap F_{i})\right\|$
	$\displaystyle\leq\sum_{i=0}^{\Lambda}\left\|w(\vec{\mkern 0.0muC}\cap F_{i})-u(% \vec{\mkern 0.0muC}\cap F_{i})\right\|$
	$\displaystyle\leq\frac{\epsilon}{2}\cdot\left(\sum_{i=0}^{\Lambda}\frac{u(C% \cap E_{i})\cdot 2^{i-1}}{\pi_{i}\cdot\gamma\cdot(\beta+1)}+\sum_{i=0}^{% \Lambda}u(\vec{\mkern 0.0muC}\cap F_{i})\right)$	(by Lemma 24)
	$\displaystyle\leq\frac{\epsilon}{2}\cdot\left(\frac{u(C)}{\beta+1}+u(\vec{% \mkern 0.0muC})\right)$
	$\displaystyle=\frac{\epsilon}{2}\cdot\left(\frac{u(\vec{\mkern 0.0muC})+u({% \mathchoice{\vbox{\offinterlineskip\halign{#\cr\reflectbox{$\displaystyle\vec{% \mkern 0.0mu}\mkern 4.0mu$}\cr\kern-4.30554pt\cr$\displaystyle C$\cr}}}{\vbox{% \offinterlineskip\halign{#\cr\reflectbox{$\textstyle\vec{\mkern 0.0mu}\mkern 4% .0mu$}\cr\kern-4.30554pt\cr$\textstyle C$\cr}}}{\vbox{\offinterlineskip\halign% {#\cr\reflectbox{$\scriptstyle\vec{\mkern 0.0mu}\mkern 4.0mu$}\cr\kern-3.01389% pt\cr$\scriptstyle C$\cr}}}{\vbox{\offinterlineskip\halign{#\cr\reflectbox{$% \scriptscriptstyle\vec{\mkern 0.0mu}\mkern 4.0mu$}\cr\kern-2.15277pt\cr$% \scriptscriptstyle C$\cr}}}})}{\beta+1}+u(\vec{\mkern 0.0muC})\right)$
	$\displaystyle\leq\epsilon\cdot u(\vec{\mkern 0.0muC})$

where the penultimate inequality follows since

\sum_{i=0}^{\Lambda}\frac{u(C\cap E_{i})\cdot 2^{i-1}}{\pi_{i}\cdot\gamma}\leq u% (C)

by $\gamma$ -overlap and

\sum_{i=0}^{\Lambda}u(\vec{\mkern 0.0muC}\cap F_{i})=u(\vec{\mkern 0.0muC})

since $\mathcal{F}=\{F_{i}\}$ is a partition of $E$ . $\hfill\blacktriangleleft$

To show Lemma 24, we partition the cuts in a connectivity class based on the size of the underlying undirected cut, and show concentration in each of them separately. Formally, we will show later that

Lemma 25.

Let $\mathcal{C}_{ij}$ be the collection of all cuts $\vec{\mkern 0.0muC}=\partial_{\vec{\mkern 0.0muG}}(S)$ such that for the corresponding undirected cut $C=\partial_{G}(S)$ in $G$ ,

\pi_{i}\cdot 2^{j}\leq u(C\cap E_{i})\leq\pi_{i}\cdot 2^{j+1}-1

Then for all cuts $\vec{\mkern 0.0muC}$ in $\mathcal{C}_{ij}$ simultaneously, it holds with probability $1-2/n^{4\cdot 2^{j}}$ that

\left|w(\vec{\mkern 0.0muC}\cap F_{i})-u(\vec{\mkern 0.0muC}\cap F_{i})\right|% \leq\frac{\epsilon}{2}\cdot\left(\frac{u(C\cap E_{i})\cdot 2^{i-1}}{\pi_{i}% \cdot\gamma\cdot(\beta+1)}+u(\vec{\mkern 0.0muC}\cap F_{i})\right)

We first use this to prove Lemma 24.

See 24

Proof.

We will show that the statement holds for any fixed $i$ with probability at least $1-4/n^{4}$ . Since $\mathcal{F}=\{F_{i}\}$ is a partition of the edges, and since there are at most $n^{2}$ edges in the graph, a union bound over all $i$ with non-empty $F_{i}$ gives the lemma.

Fix any $i\in[\Lambda]$ . For all cuts $\vec{\mkern 0.0muC}$ with no edge in class $F_{i}$ , the claim holds with probability $1$ . In what follows, we only consider cuts that have at least one edge in class $F_{i}$ .

We concentrate on the graph $G_{i}$ , and only consider cuts that contain at least $\pi_{i}$ edges since every edge in $F_{i}$ has connectivity at least $\pi_{i}$ in $G_{i}$ by $\Pi$ -connectivity. Let $\mathcal{C}_{ij}$ be the collection of all cuts $\vec{\mkern 0.0muC}=\partial_{\vec{\mkern 0.0muG}}(S)$ such that for the corresponding undirected cut $C=\partial_{G}(S)$ in $G$ ,

\pi_{i}\cdot 2^{j}\leq u(C\cap E_{i})\leq\pi_{i}\cdot 2^{j+1}-1

Then by Lemma 25, for all $\vec{\mkern 0.0muC}\in\mathcal{C}_{ij}$ , it holds with probability at least $1-2/n^{4\cdot 2^{j}}$ that

\left|w(\vec{\mkern 0.0muC}\cap F_{i})-u(\vec{\mkern 0.0muC}\cap F_{i})\right|% \leq\frac{\epsilon}{2}\cdot\left(\frac{u(C\cap E_{i})\cdot 2^{i-1}}{\pi_{i}% \cdot\gamma\cdot(\beta+1)}+u(\vec{\mkern 0.0muC}\cap F_{i})\right)

Thus the probability that there exists a $j$ for which there exists a cut $\vec{\mkern 0.0muC}\in\mathcal{C}_{ij}$ where the bound does not hold is at most

\frac{2}{n^{4}}\cdot\left(\frac{1}{n^{2^{0}}}+\frac{1}{n^{2^{1}}}+\ldots\right% )\leq\frac{4}{n^{4}}

as required. $\hfill\blacktriangleleft$

To show Lemma 25, we need the bound for a single cut as in Lemma 26 and use this with a directed cut counting argument as in Lemma 27. We defer the proofs of both of these lemmas to the full version.

Lemma 26.

For any single cut $\vec{\mkern 0.0muC}$ in $\mathcal{C}_{ij}$ , it holds with probability $1-2/n^{8\cdot 2^{j}}$ that

\left|w(\vec{\mkern 0.0muC}\cap F_{i})-u(\vec{\mkern 0.0muC}\cap F_{i})\right|% \leq\frac{\epsilon}{2}\cdot\left(\frac{u(C\cap E_{i})\cdot 2^{i-1}}{\pi_{i}% \cdot\gamma\cdot(\beta+1)}+u(\vec{\mkern 0.0muC}\cap F_{i})\right)

Lemma 27.

Let $\vec{\mkern 0.0muG}=(V,\vec{\mkern 0.0muE})$ be a directed (multi-)graph, and $G$ be the underlying undirected graph. Let $k\geq\lambda$ be any real number, where $\lambda$ is the value of the global minimum cut in $G$ . Consider all the cuts $\vec{\mkern 0.0muC}=\partial_{\vec{\mkern 0.0muG}}(S)$ in $\vec{\mkern 0.0muG}$ such that $u(C)\leq\alpha k$ for the corresponding undirected cut $C=\partial_{G}(S)$ , and let $\mathcal{C}^{\downarrow k}_{\alpha}$ be the set of all directed $k$ -projections of these cuts. Then $|\mathcal{C}^{\downarrow k}_{\alpha}|\leq 2\cdot n^{2\alpha}$ .

We use them to show Lemma 25.

See 25

Proof.

For any single cut $\vec{\mkern 0.0muC}$ in $\mathcal{C}_{ij}$ , Lemma 26 shows that with probability at least $1-2/n^{8\cdot 2^{j}}$ ,

\left|w(\vec{\mkern 0.0muC}\cap F_{i})-u(\vec{\mkern 0.0muC}\cap F_{i})\right|% \leq\frac{\epsilon}{2}\cdot\left(\frac{u(C\cap E_{i})\cdot 2^{i-1}}{\pi_{i}% \cdot\gamma\cdot(\beta+1)}+u(\vec{\mkern 0.0muC}\cap F_{i})\right)

At this point, we would like to take a union bound over all the cuts in $\mathcal{C}_{ij}$ . Ideally, we would like the number of cuts in this set to grow as $n^{c\cdot 2^{j}}$ . However, the number of directed cuts $\vec{\mkern 0.0muC}$ that arise might be much larger than that. However, note that the inequality only depends on $\vec{\mkern 0.0muC}\cap F_{i}$ , and not $\vec{\mkern 0.0muC}$ . We thus focus on working with the distinct subsets $\vec{\mkern 0.0muC}\cap F_{i}$ that arise, and use these to prove our claim.

We first show that the number of distinct directed cuts $\vec{\mkern 0.0muC}\cap F_{i}$ that are encountered is still $O(n^{c\cdot 2^{j}})$ using Lemma 27. In particular, we apply Lemma 27 on the graph $G_{i}=(V,E_{i})$ , setting $k=\pi_{i}$ and $\alpha k=\pi_{i}\cdot 2^{j+1}-1$ . The total number of distinct subsets $\vec{\mkern 0.0muC}\cap H_{k}$ that arise from cuts in $\mathcal{C}_{ij}$ is at most

2n^{2\alpha}<2n^{4\cdot 2^{j}}

where $H_{k}$ is the subgraph of $G_{i}$ of all edges with edge-connectivity at least $\pi_{i}$ . Since each edge in $F_{i}$ has edge-connectivity at least $\pi_{i}$ by $\Pi$ -connectivity, we have that $F_{i}\subseteq H_{k}$ . Every non-empty subset of the form $\vec{\mkern 0.0muC}\cap F_{i}$ has a corresponding subset of the form $\vec{\mkern 0.0muC}\cap H_{k}$ that is counted above, and for every $\vec{\mkern 0.0muC}\cap H_{k}$ counted above, there is at most one non-empty subset of the form $\vec{\mkern 0.0muC}\cap F_{i}$ , which proves the claim.

To simplify notation, we use the following definition for the next claim. Call a subset of directed edges $\vec{\mkern 0.0muR}\subseteq\vec{\mkern 0.0muE}$ to be bad for a directed cut $\vec{\mkern 0.0muC}\subseteq\vec{\mkern 0.0muE}$ if $\vec{\mkern 0.0muC}\cap F_{i}=\vec{\mkern 0.0muR}$ and

\left|w(\vec{\mkern 0.0muR})-u(\vec{\mkern 0.0muR})\right|>\frac{\epsilon}{2}% \cdot\left(\frac{u(C\cap E_{i})\cdot 2^{i-1}}{\pi_{i}\cdot\gamma\cdot(\beta+1)% }+u(\vec{\mkern 0.0muR})\right)

Note that if $\vec{\mkern 0.0muR}$ is bad for any particular directed cut $\vec{\mkern 0.0muC}$ , then it is also bad for

\vec{\mkern 0.0muD}=\operatorname*{argmin}_{\vec{\mkern 0.0muC^{\prime}}:(\vec% {\mkern 0.0muC^{\prime}}\cap F_{i}=\vec{\mkern 0.0muR})\land(\vec{\mkern 0.0% muC^{\prime}}\in\mathcal{C}_{ij})}u(C^{\prime}\cap E_{i})

since

\left|w(\vec{\mkern 0.0muR})-u(\vec{\mkern 0.0muR})\right|>\frac{\epsilon}{2}% \cdot\left(\frac{u(C\cap E_{i})\cdot 2^{i-1}}{\pi_{i}\cdot\gamma\cdot(\beta+1)% }+u(\vec{\mkern 0.0muR})\right)\geq\frac{\epsilon}{2}\cdot\left(\frac{u(D\cap E% _{i})\cdot 2^{i-1}}{\pi_{i}\cdot\gamma\cdot(\beta+1)}+u(\vec{\mkern 0.0muR})\right)

where the first inequality is because $\vec{\mkern 0.0muR}$ is bad for $\vec{\mkern 0.0muC}$ , and the second inequality is by choice of $\vec{\mkern 0.0muD}$ .

Thus, the probability we need to bound is

	$\displaystyle\ \ \ \ \,\Pr[\text{$\exists$ a cut $\vec{\mkern 0.0muC}\in% \mathcal{C}_{ij}$ such that $\vec{\mkern 0.0muC}\cap F_{i}$ is bad for $\vec{% \mkern 0.0muC}$}]$
	$\displaystyle=\Pr[\text{$\exists$ an $\vec{\mkern 0.0muR}\subseteq\vec{\mkern 0% .0muE}$ and a cut $\vec{\mkern 0.0muC}\in\mathcal{C}_{ij}$ such that $\vec{% \mkern 0.0muR}$ is bad for $\vec{\mkern 0.0muC}$}]$
	$\displaystyle\leq\sum_{\vec{\mkern 0.0muR}\subseteq\vec{\mkern 0.0muE}}\Pr[% \text{$\exists$ a cut $\vec{\mkern 0.0muC}\in\mathcal{C}_{ij}$ such that $\vec% {\mkern 0.0muR}$ is bad for $\vec{\mkern 0.0muC}$}]$
	$\displaystyle=\sum_{\vec{\mkern 0.0muR}\subseteq\vec{\mkern 0.0muE}}\Pr[\text{% $\vec{\mkern 0.0muR}$ is bad for $\vec{\mkern 0.0muD}=\operatorname*{argmin}_{% \vec{\mkern 0.0muC^{\prime}}:(\vec{\mkern 0.0muC^{\prime}}\cap F_{i}=\vec{% \mkern 0.0muR})\land(\vec{\mkern 0.0muC^{\prime}}\in\mathcal{C}_{ij})}u(C\cap E% _{i})$}]$
	$\displaystyle\leq 2n^{4\cdot 2^{j}}\cdot\frac{2}{n^{8\cdot 2^{j}}}\leq\frac{4}% {n^{4\cdot 2^{j}}}$

where the penultimate inequality holds because the number of distinct $\vec{\mkern 0.0muR}$ s that can be of the form $\vec{\mkern 0.0muC}\cap F_{i}$ is at most $2n^{4\cdot 2^{j}}$ , and for each $\vec{\mkern 0.0muR}$ , the probability that $\vec{\mkern 0.0muR}$ is bad for $\vec{\mkern 0.0muD}$ is at most $2/n^{8\cdot 2^{j}}$ by Lemma 26. $\hfill\blacktriangleleft$

References

[1] Ravindra K Ahuja, Thomas L Magnanti, James B Orlin, and MR Reddy. Applications of network optimization. Handbooks in Operations Research and Management Science, 7:1–83, 1995. URL: https://www.sciencedirect.com/science/article/abs/pii/S0927050705801185.
[2] Sanjeev Arora, Elad Hazan, and Satyen Kale. The multiplicative weights update method: a meta-algorithm and applications. Theory Comput., 8(1):121–164, 2012. doi:10.4086/TOC.2012.V008A006.
[3] András A. Benczúr and David R. Karger. Randomized approximation schemes for cuts and flows in capacitated graphs. SIAM J. Comput., 44(2):290–319, 2015. doi:10.1137/070705970.
[4] Ruoxu Cen, Yu Cheng, Debmalya Panigrahi, and Kevin Sun. Sparsification of directed graphs via cut balance. In International Colloqium on Automata, Languages, and Programming (ICALP), pages 45:1–45:21. Schloss Dagstuhl – Leibniz-Zentrum für Informatik, 2021. doi:10.4230/LIPICS.ICALP.2021.45.
[5] Li Chen, Gramoz Goranci, Monika Henzinger, Richard Peng, and Thatchaphol Saranurak. Fast dynamic cuts, distances and effective resistances via vertex sparsifiers. In Foundations of Computer Science (FOCS), pages 1135–1146. IEEE, 2020. doi:10.1109/FOCS46700.2020.00109.
[6] Li Chen, Rasmus Kyng, Yang P. Liu, Simon Meierhans, and Maximilian Probst Gutenberg. Almost-linear time algorithms for incremental graphs: Cycle detection, sccs, s-t shortest path, and minimum-cost flow. In Symposium on Theory of Computing (STOC), pages 1165–1173. ACM, 2024. doi:10.1145/3618260.3649745.
[7] 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 Foundations of Computer Science (FOCS), pages 612–623. IEEE, 2022. doi:10.1109/FOCS54457.2022.00064.
[8] Søren Dahlgaard. On the hardness of partially dynamic graph problems and connections to diameter. In International Colloqium on Automata, Languages, and Programming (ICALP), pages 48:1–48:14. Schloss Dagstuhl – Leibniz-Zentrum für Informatik, 2016. doi:10.4230/LIPICS.ICALP.2016.48.
[9] David Durfee, Yu Gao, Gramoz Goranci, and Richard Peng. Fully dynamic effective resistances. CoRR, abs/1804.04038, 2018. arXiv:1804.04038.
[10] David Durfee, Yu Gao, Gramoz Goranci, and Richard Peng. Fully dynamic spectral vertex sparsifiers and applications. In Symposium on Theory of Computing (STOC), pages 914–925, 2019. doi:10.1145/3313276.3316379.
[11] Alina Ene, Gary L. Miller, Jakub Pachocki, and Aaron Sidford. Routing under balance. In Symposium on Theory of Computing (STOC), pages 598–611, 2016. doi:10.1145/2897518.2897654.
[12] Wai Shing Fung, Ramesh Hariharan, Nicholas J. A. Harvey, and Debmalya Panigrahi. A general framework for graph sparsification. SIAM J. Comput., 48(4):1196–1223, 2019. doi:10.1137/16M1091666.
[13] Yu Gao, Yang P. Liu, and Richard Peng. Fully dynamic electrical flows: Sparse maxflow faster than goldberg-rao. In Foundations of Computer Science, (FOCS), pages 516–527, 2021. doi:10.1109/FOCS52979.2021.00058.
[14] Andrew V. Goldberg and Satish Rao. Beyond the flow decomposition barrier. J. ACM, 45(5):783–797, 1998. doi:10.1145/290179.290181.
[15] Gramoz Goranci and Monika Henzinger. Efficient data structures for incremental exact and approximate maximum flow. In International Colloqium on Automata, Languages, and Programming (ICALP), pages 69:1–69:14. Schloss Dagstuhl – Leibniz-Zentrum für Informatik, 2023. doi:10.4230/LIPICS.ICALP.2023.69.
[16] Gramoz Goranci, Harald Räcke, Thatchaphol Saranurak, and Zihan Tan. The expander hierarchy and its applications to dynamic graph algorithms. In Symposium on Discrete Algorithms (SODA), pages 2212–2228. SIAM, 2021. doi:10.1137/1.9781611976465.132.
[17] Manoj Gupta and Shahbaz Khan. Simple dynamic algorithms for maximal independent set, maximum flow and maximum matching. In Symposium on Simplicity in Algorithms (SOSA), pages 86–91. SIAM, 2021. doi:10.1137/1.9781611976496.10.
[18] Monika Henzinger, Sebastian Krinninger, Danupon Nanongkai, and Thatchaphol Saranurak. Unifying and strengthening hardness for dynamic problems via the online matrix-vector multiplication conjecture. In Symposium on Theory of Computing (STOC), pages 21–30. ACM, 2015. doi:10.1145/2746539.2746609.
[19] Monika Rauch Henzinger. A static 2-approximation algorithm for vertex connectivity and incremental approximation algorithms for edge and vertex connectivity. J. Algorithms, 24(1):194–220, 1997. doi:10.1006/JAGM.1997.0855.
[20] Giuseppe F. Italiano. Amortized efficiency of a path retrieval data structure. Theor. Comput. Sci., 48(3):273–281, 1986. doi:10.1016/0304-3975(86)90098-8.
[21] David R. Karger and Matthew S. Levine. Fast augmenting paths by random sampling from residual graphs. SIAM J. Comput., 44(2):320–339, 2015. doi:10.1137/070705994.
[22] 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 Symposium on Discrete Algorithms (SODA), pages 217–226. SIAM, 2014. doi:10.1137/1.9781611973402.16.
[23] Hiroshi Nagamochi and Toshihide Ibaraki. A linear-time algorithm for finding a sparse k-connected spanning subgraph of a k-connected graph. Algorithmica, 7(5&6):583–596, 1992. doi:10.1007/BF01758778.
[24] Richard Peng. Approximate undirected maximum flows in O(mpolylog(n)) time. In Symposium on Discrete Algorithms (SODA), pages 1862–1867. SIAM, 2016. doi:10.1137/1.9781611974331.CH130.
[25] Jonah Sherman. Breaking the multicommodity flow barrier for o(vlog n)-approximations to sparsest cut. In Foundations of Computer Science (FOCS), pages 363–372. IEEE Computer Society, 2009. doi:10.1109/FOCS.2009.66.
[26] Jonah Sherman. Nearly maximum flows in nearly linear time. In Foundations of Computer Science (FOCS), pages 263–269. IEEE Computer Society, 2013. doi:10.1109/FOCS.2013.36.
[27] Jonah Sherman. Area-convexity, l ${}_{\mbox{{$\infty$}}}$ regularization, and undirected multicommodity flow. In Symposium on Theory of Computing (STOC), pages 452–460, 2017. doi:10.1145/3055399.3055501.
[28] Daniel A. Spielman and Nikhil Srivastava. Graph sparsification by effective resistances. SIAM J. Comput., 40(6):1913–1926, 2011. doi:10.1137/080734029.
[29] Robert Endre Tarjan and Jan van Leeuwen. Worst-case analysis of set union algorithms. J. ACM, 31(2):245–281, 1984. doi:10.1145/62.2160.
[30] Shang-Hua Teng. The laplacian paradigm: Emerging algorithms for massive graphs. In Theory and Applications of Models of Computation (TAMC), pages 2–14, 2010. doi:10.1007/978-3-642-13562-0_2.
[31] Jan van den Brand, Li Chen, Rasmus Kyng, Yang P. Liu, Simon Meierhans, Maximilian Probst Gutenberg, and Sushant Sachdeva. Almost-linear time algorithms for decremental graphs: Min-cost flow and more via duality. In Foundations of Computer Science (FOCS), pages 2010–2032. IEEE, 2024. doi:10.1109/FOCS61266.2024.00120.
[32] Jan van den Brand, Li Chen, Rasmus Kyng, Yang P. Liu, Richard Peng, Maximilian Probst Gutenberg, Sushant Sachdeva, and Aaron Sidford. Incremental approximate maximum flow on undirected graphs in subpolynomial update time. In Symposium on Discrete Algorithms (SODA), pages 2980–2998. SIAM, 2024. doi:10.1137/1.9781611977912.106.
[33] Jan van den Brand, Yang P. Liu, and Aaron Sidford. Dynamic maxflow via dynamic interior point methods. In Symposium on Theory of Computing (STOC), pages 1215–1228. ACM, 2023. doi:10.1145/3564246.3585135.

[bib.bib1] [1] Ravindra K Ahuja, Thomas L Magnanti, James B Orlin, and MR Reddy. Applications of network optimization. Handbooks in Operations Research and Management Science, 7:1–83, 1995. URL: https://www.sciencedirect.com/science/article/abs/pii/S0927050705801185.

[bib.bib2] [2] Sanjeev Arora, Elad Hazan, and Satyen Kale. The multiplicative weights update method: a meta-algorithm and applications. Theory Comput., 8(1):121–164, 2012. doi:10.4086/TOC.2012.V008A006.

[bib.bib3] [3] András A. Benczúr and David R. Karger. Randomized approximation schemes for cuts and flows in capacitated graphs. SIAM J. Comput., 44(2):290–319, 2015. doi:10.1137/070705970.

[bib.bib4] [4] Ruoxu Cen, Yu Cheng, Debmalya Panigrahi, and Kevin Sun. Sparsification of directed graphs via cut balance. In International Colloqium on Automata, Languages, and Programming (ICALP), pages 45:1–45:21. Schloss Dagstuhl – Leibniz-Zentrum für Informatik, 2021. doi:10.4230/LIPICS.ICALP.2021.45.

[bib.bib5] [5] Li Chen, Gramoz Goranci, Monika Henzinger, Richard Peng, and Thatchaphol Saranurak. Fast dynamic cuts, distances and effective resistances via vertex sparsifiers. In Foundations of Computer Science (FOCS), pages 1135–1146. IEEE, 2020. doi:10.1109/FOCS46700.2020.00109.

[bib.bib6] [6] Li Chen, Rasmus Kyng, Yang P. Liu, Simon Meierhans, and Maximilian Probst Gutenberg. Almost-linear time algorithms for incremental graphs: Cycle detection, sccs, s-t shortest path, and minimum-cost flow. In Symposium on Theory of Computing (STOC), pages 1165–1173. ACM, 2024. doi:10.1145/3618260.3649745.

[bib.bib7] [7] 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 Foundations of Computer Science (FOCS), pages 612–623. IEEE, 2022. doi:10.1109/FOCS54457.2022.00064.

[bib.bib8] [8] Søren Dahlgaard. On the hardness of partially dynamic graph problems and connections to diameter. In International Colloqium on Automata, Languages, and Programming (ICALP), pages 48:1–48:14. Schloss Dagstuhl – Leibniz-Zentrum für Informatik, 2016. doi:10.4230/LIPICS.ICALP.2016.48.

[bib.bib9] [9] David Durfee, Yu Gao, Gramoz Goranci, and Richard Peng. Fully dynamic effective resistances. CoRR, abs/1804.04038, 2018. arXiv:1804.04038.

[bib.bib10] [10] David Durfee, Yu Gao, Gramoz Goranci, and Richard Peng. Fully dynamic spectral vertex sparsifiers and applications. In Symposium on Theory of Computing (STOC), pages 914–925, 2019. doi:10.1145/3313276.3316379.

[bib.bib11] [11] Alina Ene, Gary L. Miller, Jakub Pachocki, and Aaron Sidford. Routing under balance. In Symposium on Theory of Computing (STOC), pages 598–611, 2016. doi:10.1145/2897518.2897654.

[bib.bib12] [12] Wai Shing Fung, Ramesh Hariharan, Nicholas J. A. Harvey, and Debmalya Panigrahi. A general framework for graph sparsification. SIAM J. Comput., 48(4):1196–1223, 2019. doi:10.1137/16M1091666.

[bib.bib13] [13] Yu Gao, Yang P. Liu, and Richard Peng. Fully dynamic electrical flows: Sparse maxflow faster than goldberg-rao. In Foundations of Computer Science, (FOCS), pages 516–527, 2021. doi:10.1109/FOCS52979.2021.00058.

[bib.bib14] [14] Andrew V. Goldberg and Satish Rao. Beyond the flow decomposition barrier. J. ACM, 45(5):783–797, 1998. doi:10.1145/290179.290181.

[bib.bib15] [15] Gramoz Goranci and Monika Henzinger. Efficient data structures for incremental exact and approximate maximum flow. In International Colloqium on Automata, Languages, and Programming (ICALP), pages 69:1–69:14. Schloss Dagstuhl – Leibniz-Zentrum für Informatik, 2023. doi:10.4230/LIPICS.ICALP.2023.69.

[bib.bib16] [16] Gramoz Goranci, Harald Räcke, Thatchaphol Saranurak, and Zihan Tan. The expander hierarchy and its applications to dynamic graph algorithms. In Symposium on Discrete Algorithms (SODA), pages 2212–2228. SIAM, 2021. doi:10.1137/1.9781611976465.132.

[bib.bib17] [17] Manoj Gupta and Shahbaz Khan. Simple dynamic algorithms for maximal independent set, maximum flow and maximum matching. In Symposium on Simplicity in Algorithms (SOSA), pages 86–91. SIAM, 2021. doi:10.1137/1.9781611976496.10.

[bib.bib18] [18] Monika Henzinger, Sebastian Krinninger, Danupon Nanongkai, and Thatchaphol Saranurak. Unifying and strengthening hardness for dynamic problems via the online matrix-vector multiplication conjecture. In Symposium on Theory of Computing (STOC), pages 21–30. ACM, 2015. doi:10.1145/2746539.2746609.

[bib.bib19] [19] Monika Rauch Henzinger. A static 2-approximation algorithm for vertex connectivity and incremental approximation algorithms for edge and vertex connectivity. J. Algorithms, 24(1):194–220, 1997. doi:10.1006/JAGM.1997.0855.

[bib.bib20] [20] Giuseppe F. Italiano. Amortized efficiency of a path retrieval data structure. Theor. Comput. Sci., 48(3):273–281, 1986. doi:10.1016/0304-3975(86)90098-8.

[bib.bib21] [21] David R. Karger and Matthew S. Levine. Fast augmenting paths by random sampling from residual graphs. SIAM J. Comput., 44(2):320–339, 2015. doi:10.1137/070705994.

[bib.bib22] [22] 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 Symposium on Discrete Algorithms (SODA), pages 217–226. SIAM, 2014. doi:10.1137/1.9781611973402.16.

[bib.bib23] [23] Hiroshi Nagamochi and Toshihide Ibaraki. A linear-time algorithm for finding a sparse k-connected spanning subgraph of a k-connected graph. Algorithmica, 7(5&6):583–596, 1992. doi:10.1007/BF01758778.

[bib.bib24] [24] Richard Peng. Approximate undirected maximum flows in O(mpolylog(n)) time. In Symposium on Discrete Algorithms (SODA), pages 1862–1867. SIAM, 2016. doi:10.1137/1.9781611974331.CH130.

[bib.bib25] [25] Jonah Sherman. Breaking the multicommodity flow barrier for o(vlog n)-approximations to sparsest cut. In Foundations of Computer Science (FOCS), pages 363–372. IEEE Computer Society, 2009. doi:10.1109/FOCS.2009.66.

[bib.bib26] [26] Jonah Sherman. Nearly maximum flows in nearly linear time. In Foundations of Computer Science (FOCS), pages 263–269. IEEE Computer Society, 2013. doi:10.1109/FOCS.2013.36.

[bib.bib27] [27] Jonah Sherman. Area-convexity, l ${}_{\mbox{{$\infty$}}}$ regularization, and undirected multicommodity flow. In Symposium on Theory of Computing (STOC), pages 452–460, 2017. doi:10.1145/3055399.3055501.

[bib.bib28] [28] Daniel A. Spielman and Nikhil Srivastava. Graph sparsification by effective resistances. SIAM J. Comput., 40(6):1913–1926, 2011. doi:10.1137/080734029.

[bib.bib29] [29] Robert Endre Tarjan and Jan van Leeuwen. Worst-case analysis of set union algorithms. J. ACM, 31(2):245–281, 1984. doi:10.1145/62.2160.

[bib.bib30] [30] Shang-Hua Teng. The laplacian paradigm: Emerging algorithms for massive graphs. In Theory and Applications of Models of Computation (TAMC), pages 2–14, 2010. doi:10.1007/978-3-642-13562-0_2.

[bib.bib31] [31] Jan van den Brand, Li Chen, Rasmus Kyng, Yang P. Liu, Simon Meierhans, Maximilian Probst Gutenberg, and Sushant Sachdeva. Almost-linear time algorithms for decremental graphs: Min-cost flow and more via duality. In Foundations of Computer Science (FOCS), pages 2010–2032. IEEE, 2024. doi:10.1109/FOCS61266.2024.00120.

[bib.bib32] [32] Jan van den Brand, Li Chen, Rasmus Kyng, Yang P. Liu, Richard Peng, Maximilian Probst Gutenberg, Sushant Sachdeva, and Aaron Sidford. Incremental approximate maximum flow on undirected graphs in subpolynomial update time. In Symposium on Discrete Algorithms (SODA), pages 2980–2998. SIAM, 2024. doi:10.1137/1.9781611977912.106.

[bib.bib33] [33] Jan van den Brand, Yang P. Liu, and Aaron Sidford. Dynamic maxflow via dynamic interior point methods. In Symposium on Theory of Computing (STOC), pages 1215–1228. ACM, 2023. doi:10.1145/3564246.3585135.

Incremental Approximate Maximum Flow via Residual Graph Sparsification

Abstract

Keywords and phrases:

Category:

Funding:

Copyright and License:

2012 ACM Subject Classification:

Related Version:

Funding:

DOI:

Event:

Editors:

Series and Publisher:

1 Introduction

Theorem 1.

1.1 Technical Overview

2 Preliminaries

2.1 Graphs and Flows

Flows.

Model.

Directed graphs.

Underlying undirected graph.

Residual graph.

2.2 Sampling Parameters

Definition 2 (NI index [23]).

Definition 3 (Edge-connectivity).

Definition 4 (Connectivity class).

Definition 5 (Π-connected decomposition [12]).

Definition 6 (γ-overlap [12]).

2.3 Balance and Cut Counting

Imbalance of directed graphs.

Definition 7 (balance [11]).

Counting cut projections.

Definition 8 (directed k-projection).

2.4 Data Structures

Fact 1 (UnionFind [29]).

Fact 2 (SingleSourceReachability [20]).

Fact 3 (BinarySearchTree).

High probability bounds.

3 Incremental Maximum Flow

Definition 9 (Phase).

Lemma 10.

Theorem 11.

3.1 Running Time

Lemma 12.

Proof.

Lemma 13.

Proof.

3.2 Correctness

Lemma 14.

Proof.

Lemma 15.

Proof.

Lemma 16.

Proof.

Lemma 17 ([12]).

Lemma 18.

Proof.

Lemma 19.

Proof.

Lemma 20.

Proof.

Lemma 21.

Proof.

4 Incremental Nagamochi-Ibaraki Indices

Lemma 22.

Proof.

Lemma 23.

Proof.

5 Balanced Sparsification

Lemma 24.

Proof of Theorem 11.

Lemma 25.

Proof.

Lemma 26.

Lemma 27.

Proof.

References

Definition 5 ( $\Pi$ -connected decomposition [12]).

Definition 6 ( $\gamma$ -overlap [12]).

Definition 8 (directed $k$ -projection).