Electrical Flows, Laplacian Systems, and Faster Approximation of Maximum Flow in Undirected Graphs

Introduction

The maximum $s$-$t$ flow problem and its dual, the minimum $s$-$t$ cut problem, are two of the most fundamental and extensively studied problems in Operations Research and Optimization . They have many applications (see ) and are often used as subroutines in other algorithms (see ). Many advances have been made in the development of algorithms for this problem (see Goldberg and Rao for an overview). However, for the basic problem of computing or $(1-\epsilon)$-approximating the maximum flow in undirected, unit-capacity graphs with $m=O(n)$ edges, the asymptotically fastest known algorithm is the one developed in 1975 by Even and Tarjan , which takes time $O(n^{3/2})$. Despite 35 years of extensive work on the problem, this bound has not been improved.

In this paper, we introduce a new approach to computing approximately maximum $s$-$t$ flows and minimum $s$-$t$ cuts in undirected, capacitated graphs. Using it, we present the first algorithms that break the $O(n^{3/2})$ complexity barrier described above. In addition to being the fastest known algorithms for this problem, they are simple to describe and introduce techniques that may be applicable to other problems. In them, we reduce the problem of computing maximum flows subject to capacity constraints to the problem of computing electrical flows in resistor networks. An approximate solution to each electrical flow problem can be found in time $\widetilde{O}\left(m\right)$ using recently developed algorithms for solving systems of linear equations in Laplacian matrices .

There is a simple physical intuition that underlies our approach, which we describe here in the case of a graph with unit edge capacities. We begin by thinking of each edge of the input graph as a resistor with resistance one, and we compute the electrical flow that results when we send current from the source $s$ to the sink $t$. These currents obey the flow conservation constraints, but they may not respect the capacities of the edges. To remedy this, we increase the resistance of each edge in proportion to the amount of current flowing through it—thereby penalizing edges that violate their capacities—and compute the electrical flow with these new resistances.

We remark that the results in this paper immediately improve the running time of algorithms that use the computation of an approximately maximum $s$-$t$ flow on an undirected, capacitated graph as a subroutine. For example, combining our work with that of Sherman allows us to achieve the best currently known approximation ratio of $O(\sqrt{\log{n}})$ for the sparsest cut problem in time $\widetilde{O}\left(m+n^{4/3}\right)$.

We are hopeful that our approach can be extended to directed graphs and can also eventually lead to an algorithm that approximately solves the maximum flow problem in nearly-linear time.

The best previously known algorithms for the problems studied here are due to Goldberg and Rao. In a breakthrough paper, Goldberg and Rao developed an algorithm for computing exact maximum $s$-$t$ flows in directed or undirected capacitated graphs in time $O(m\min(n^{2/3},m^{1/2})\log(n^{2}/m)\log U),$ assuming that the edge capacities are integers between $1$ and $U$. When we are interested in finding $(1-\epsilon)$-approximately maximum $s$-$t$ flow, the dependence on $\log U$ can be removed and, by employing the smoothing technique of Karger , one can obtain a running time of

By applying their algorithm to a sparsifier, as constructed by Benczúr and Karger , Goldberg and Rao show how to compute a $(1+\epsilon)$-approximately minimum $s$-$t$ cut in an undirected graph in time

Their work was the culmination of a long line of papers on the problem; we refer the reader to their paper for an extensive survey of earlier developments in algorithms for computing maximum $s$-$t$ flows. In more recent work, Daitch and Spielman showed that fast solvers for Laplacian linear systems could be used to make interior-point algorithms for the maximum flow and minimum-cost flow problems run in time $\widetilde{O}\left(m^{3/2}\log U\right)$, and Mądry showed that one can approximate a wide range of cut problems, including the minimum $s$-$t$ cut problem, within a polylogarithmic factor in almost linear time.

2 Outline

We begin the technical part of this paper in Section 2 with a review of maximum flows and electrical flows, along with several theorems about them that we will need in the sequel. In Section 3 we give a simplified version of our approximate maximum-flow algorithm that has running time $\widetilde{O}\left(m^{3/2}\epsilon^{-5/2}\right)$. In Section 4, we will show how to improve the running time of our algorithm to $\widetilde{O}\left(m^{4/3}\epsilon^{-3}\right)$; we will then describe how to combine this with existing graph smoothing and sparsification techniques to compute approximately maximum $s$-$t$ flows in time $\widetilde{O}\left(mn^{1/3}\epsilon^{-11/3}\right)$ and to approximate the value of such flows in time $\widetilde{O}\left(m+n^{4/3}\epsilon^{-8/3}\right)$. In Section 5, we present a variant of our algorithm that computes approximately minimum $s$-$t$ cuts in time $\widetilde{O}\left(m+n^{4/3}\epsilon^{-8/3}\right)$.

Maximum Flows, Electrical Flows, and Laplacian Systems

We arbitrarily orient each edge in $E$; this divides the edges incident to a vertex $v\in V$ into the set $E^{+}(v)$ of edges oriented towards $v$ and the set $E^{-}(v)$ of edges oriented away from $v$. These orientations are merely for notational convenience. We use them to interpret the meaning of a positive flow on an edge. If an edge has positive flow and is in $E^{+}(v)$, then the flow is towards $v$. Conversely, if it has negative flow then the flow is away from $v$. One should keep in mind that our graphs are undirected and that the flow on an edge can go in either direction, regardless of this edge‘s orientation.

We now define our primary objects of study, $s$-$t$ cuts and $s$-$t$ flows.

An $s$-$t$ cut is a partition $(S,V\setminus S)$ of the vertices into two disjoint sets such that $s\in S$ and $t\in V\setminus S$. The capacity $u(S)$ of the cut is defined to be the sum $u(S):=\sum_{e\in E(S)}u_{e},$ where $E(S)\subseteq E$ is the set of edges with one endpoint in $S$ and one endpoint in $V\setminus S$.

An $s$-$t$ flow is a function $f:E\rightarrow{\rm I\kern-2.0ptR}$ that obeys the flow-conservation constraints

The value $|f|$ of the flow is defined to be the net flow out of the source vertex, $|f|:=\sum_{e\in E^{-}(s)}f(e)-\sum_{e\in E^{+}(s)}f(e).$

It follows easily from the flow conservation constraints that the net flow out of $s$ is equal to the net flow into $t$, so $|f|$ may be interpreted as the amount of flow that is sent from $s$ to $t$.

2 Maximum Flows and Minimum Cuts

We say that an $s$-$t$ flow $f$ is feasible if $|f(e)|\leq u_{e}$ for each edge $e$, i.e., if the amount of flow routed through any edge does not exceed its capacity. The maximum $s$-$t$ flow problem is that of finding a feasible $s$-$t$ flow in $G$ of maximum value. We denote a maximum flow in $G$ (with the given capacities) by $f^{*}$, and we denote its value by $F^{*}:=|f^{*}|$. We say that $f$ is a $(1-\epsilon)$-approximately maximum flow if it is a feasible $s$-$t$ flow of value at least $(1-\epsilon)F^{*}$.

To simplify the exposition, we will take $\epsilon$ to be a constant independent of $m$ throughout the paper, and $m$ will be assumed to be larger than some fixed constant. However, our analysis will go through unchanged as long as $\epsilon>\widetilde{\Omega}{(m^{-1/3}})$. In particular, our analysis will apply to all $\epsilon$ for which our given bounds are faster than the $O(m^{3/2})$ time required by existing exact algorithms.

One can easily reduce the problem of finding a $(1-\epsilon)$-approximation to the maximum flow in an arbitrary undirected graph to that of finding a $(1-\epsilon/2)$-approximation in a graph in which the ratio of the largest to smallest capacities is polynomially bounded. To do this, one should first compute a crude approximation of the maximum flow in the original graph. For example, one can compute the $s$-$t$ path of maximum bottleneck in time $O(m+n\log n)$ [16, Section 8.6e], where we recall that the bottleneck of a path is the minimum capacity of an edge on that path. If this maximum bottleneck of an $s$-$t$ path is $B$, then the maximum flow lies between $B$ and $mB$. This means that there is a maximum flow in which each edge flows at most $mB$, so all capacities can be decreased to be at most $mB$. On the other hand, if one removes all the edges with capacities less $\epsilon B/2m$, the maximum flow can decrease by at most $\epsilon B/2$. So, we can assume that the minimum capacity is at least $\epsilon B/2m$ and the maximum is at most $Bm$, for a ratio of $2m^{2}/\epsilon$. Thus, by a simple scaling, we can assume that all edge capacities are integers between $1$ and $2m^{2}/\epsilon$.

The minimum $s$-$t$ cut problem is that of finding the $s$-$t$ cut of minimum capacity. The Max Flow-Min Cut Theorem () states that the capacity of the minimum $s$-$t$ cut is equal to $F^{*}$, the value of the maximum $s$-$t$ flow.

In particular, the Max Flow-Min Cut Theorem implies that one can use the capacity of any $s$-$t$ cut as an upper bound on the value of any feasible $s$-$t$ flow, and that the task of finding the value of the maximum flow is equivalent to the task of finding the capacity of a minimal $s$-$t$ cut.

One should note, however, that the above equivalence applies only to the values of the flow and the capacity and that although one can easily obtain a minimum $s$-$t$ cut of a graph given its maximum flow, there is no known procedure that obtains a maximum flow from minimum $s$-$t$ cut more efficiently than by just computing the maximum flow from a scratch.

3 Electrical Flows and the Nearly Linear Time Laplacian Solver

In this section, we review some basic facts about electrical flows in networks of resistors and present a theorem that allows us to quickly approximate these flows. For an in-depth treatment of the background material, we refer the reader to .

We begin by assigning a resistance $r_{e}>0$ to each edge $e\in E$, and we collect these resistances into a vector $\boldsymbol{\mathit{r}}\in{\rm I\kern-2.0ptR}^{m}$. For a given $s$-$t$ flow $f$, we define its energy (with respect to $\boldsymbol{\mathit{r}}$) as

The electrical flow of value $F$ (with respect to $\boldsymbol{\mathit{r}}$, from $s$ to $t$) is the flow that minimizes $\mathcal{E}_{\boldsymbol{\mathit{r}}}(f)$ among all $s$-$t$ flows $f$ of value $F$. This flow is easily shown to be unique, and we note that it need not respect the capacity constraints.

From a physical point of view, the electrical flow of value one corresponds to the current that is induced in $G$ if we view it as an electrical circuit in which each edge $e$ has resistance of $r_{e}$, and we send one unit of current from $s$ to $t$, say by attaching $s$ to a current source and $t$ to ground.

While finding the maximum $s$-$t$ flow corresponds to solving a linear program, we can compute the electrical flow by solving a system of linear equations. To do so, we introduce the edge-vertex incidence matrix $\boldsymbol{\mathit{B}}$, which is an $n\times m$ matrix with rows indexed by vertices and columns indexed by edges, such that

If we treat our flow $f$ as a vector $\boldsymbol{\mathit{f}}\in{\rm I\kern-2.0ptR}^{m}$, where we use the orientations of the edges to determine the signs of the coordinates, the $v^{\text{th}}$ entry of the vector $\boldsymbol{\mathit{B}}^{T}\boldsymbol{\mathit{f}}$ will be the difference between the flow out of and the flow into vertex $v$. As such, the constraints that one unit of flow is sent from $s$ to $t$ and that flow is conserved at all other vertices can be written as

where $\boldsymbol{\mathit{\chi_{s,t}}}$ is the vector with a $1$ in the coordinate corresponding to $s$, a $-1$ in the coordinate corresponding to $t$, and all other coordinates equal to 0.

We define the (weighted) Laplacian $\boldsymbol{\mathit{L}}$ of $G$ (with respect to the resistances $\boldsymbol{\mathit{r}}$) to be the $n\times n$ matrix

where $\boldsymbol{\mathit{C}}$ is the $m\times m$ diagonal matrix with $\boldsymbol{\mathit{C}}_{e,e}=c_{e}=1/r_{e}$. One can easily check that its entries are given by

Let $\boldsymbol{\mathit{R}}=\boldsymbol{\mathit{C}}^{-1}$ be the diagonal matrix with $\boldsymbol{\mathit{R}}_{e,e}=r_{e}$. The energy of a flow $\boldsymbol{\mathit{f}}$ is given by

The electrical flow of value 1 thus corresponds to the vector $\boldsymbol{\mathit{f}}$ that minimizes $\left\|\boldsymbol{\mathit{R}}^{1/2}\boldsymbol{\mathit{f}}\right\|^{2}$ subject to $\boldsymbol{\mathit{B}}\boldsymbol{\mathit{f}}=\boldsymbol{\mathit{\chi_{s,t}}}.$ If $f$ is an electrical flow, it is well known that it is a potential flow, which means that there is a vector $\boldsymbol{\mathit{\phi}}\in{\rm I\kern-2.0ptR}^{V}$ such that

Applying $\boldsymbol{\mathit{B}}\boldsymbol{\mathit{f}}=\boldsymbol{\mathit{\chi_{s,t}}}$, we have $\boldsymbol{\mathit{B}}\boldsymbol{\mathit{f}}=\boldsymbol{\mathit{B}}\boldsymbol{\mathit{C}}\boldsymbol{\mathit{B}}^{T}\boldsymbol{\mathit{\phi}}=\boldsymbol{\mathit{\chi_{s,t}}}$, and hence the vertex potentials are given by

where ${\boldsymbol{\mathit{L}}}^{\dagger}$ denotes the Moore-Penrose pseudo-inverse of $\boldsymbol{\mathit{L}}$. Thus, the electrical flow $\boldsymbol{\mathit{f}}$ is given by the expression

This lets us rewrite the energy of the electrical flow of value 1 as

3.2 Effective ss-tt Resistance and Effective ss-tt Conductance

Our analysis will make repeated use of two basic quantities from the theory of electrical networks, the effective $s$-$t$ resistance and effective $s$-$t$ conductance.

Let $f$ be the electrical $s$-$t$ flow of value 1, and let $\boldsymbol{\mathit{\phi}}$ be its vector of vertex potentials. The effective $s$-$t$ resistance of $G$ with respect to the resistances $\boldsymbol{\mathit{r}}$ is given by

Using our linear algebraic description of the electrical flow and Equation (1), we have

This gives us an alternative description of the effective $s$-$t$ resistance as the energy of the electrical flow of value 1.

It will sometimes be convenient to use the related notion of the effective $s$-$t$ conductance of $G$ with respect to the resistances $\boldsymbol{\mathit{r}}$, which we define by

We note that this is equal to the value of the electrical flow in which $\phi(s)-\phi(t)=1$.

3.3 Approximately Computing Electrical Flows

From the algorithmic point of view, the crucial property of the Laplacian $\boldsymbol{\mathit{L}}$ is that it is symmetric and diagonally dominant, i.e., for any $u$, $\sum_{v^{\prime}\neq u}|\boldsymbol{\mathit{L}}_{u,v}|\leq\boldsymbol{\mathit{L}}_{u,v}$. This allows us to use the result of Koutis, Miller, and Peng , which builds on the work of Spielman and Teng , to approximately solve our linear system in nearly-linear time. By rounding the approximate solution to a flow, we can prove the following theorem (see Appendix A for a proof).

$\mathcal{E}_{\boldsymbol{\mathit{r}}}(\widetilde{f})\leq(1+\delta)\mathcal{E}_{\boldsymbol{\mathit{r}}}(f)$, where $f$ is the electrical $s$-$t$ flow of value $F$, and

We will refer to a flow meeting the above conditions as a $\delta$-approximate electrical flow.

4 How the Resistance of an Edge Influences the Effective Resistance

For any $G=(V,E)$ and any vector of resistances $\boldsymbol{\mathit{r}}$,

Our analysis of the $\widetilde{O}\left(m^{4/3}\right)$ algorithm will require the following lemma, which gives a lower bound on the effect that increasing the resistance of an edge can have on the effective resistance.

Let $f$ be an electrical $s$-$t$ flow on a graph $G$ with resistances $\boldsymbol{\mathit{r}}$. Suppose that some edge $h=(i,j)$ accounts for a $\beta$ fraction of the total energy of $f$, i.e.,

For some $\gamma>0$, define new resistances $\boldsymbol{\mathit{r}}^{\prime}$ such that $r_{h}^{\prime}=\gamma r_{h}$, and $r_{e}^{\prime}=r_{e}$ for all $e\neq h$. Then

If we ’’cut‘‘ the edge $h$ by setting $\gamma=\infty$, then

If we slightly increase the effective resistance of the edge $h$ by setting $\gamma=(1+\epsilon)$ with $\epsilon\leq 1$, then

The assumption that $h$ contributes a $\beta$ fraction of the total energy implies that, in the above expression,

A Simple O~(m3/2ϵ−5/2)\widetilde{O}\left(m^{3/2}\epsilon^{-5/2}\right)-Time Flow Algorithm

Before describing our $\widetilde{O}\left(m^{4/3}\epsilon^{-3}\right)$ algorithm, we will describe a simpler algorithm that finds a $(1-\epsilon)$-approximately maximum flow in time $\widetilde{O}\left(m^{3/2}\epsilon^{-5/2}\right)$. Our final algorithm will be obtained by carefully modifying the one described here.

The algorithm will employ the multiplicative weights update method . In our setting, one can understand the multiplicative weights method as a way of taking an algorithm that solves a flow problem very crudely and, by calling it repeatedly, converts it into an algorithm that gives a good approximation for the maximum flow in $G$. The crude algorithm is called as a black-box, so it can be thought of as an oracle that answers a certain type of query.

In this section, we provide a self-contained description of the multiplicative weights method when it is specialized to our setting. In Section 3.1, we will describe the requirements on the oracle, give an algorithm that iteratively uses it to obtain a $(1-\epsilon)$-approximately maximum flow, and state how the number of iterations required by the algorithm depends on the properties of the oracle. In Section 3.2, we will describe how to implement the oracle using electrical flows. Finally, in Section 3.3 we will provide a simple proof of the convergence bound set forth in Section 3.1.

For an $s$-$t$ flow $f$, we define the congestion of an edge $e$ to be the ratio

between the flow on an edge and its capacity. In particular, an $s$-$t$ flow is feasible if and only if $\mathsf{cong}_{f}(e)\leq 1$ for all $e\in E$.

The multiplicative weights method will use a subroutine that we will refer to as an $(\epsilon,\rho)$-oracle. This oracle will take as input a number $F$ and a vector $\boldsymbol{\mathit{w}}$ of edge weights. For any $F\leq F^{*}$, we know that there exists a way to route $F$ units of flow in $G$ so that all of the edge capacities are respected. Our oracle will provide a weaker guarantee: When $F\leq F^{*}$, it will satisfy all of the capacity constraints up to a multiplicative factor of $\rho$, Up to polynomial factors in $1/\epsilon$, the value of $\rho$ will be $\Theta(\sqrt{m})$ in this section, and $\widetilde{\Theta}(m^{1/3})$ later in the paper. and it will satisfy the average of these constraints, weighted by the $w_{i}$, up to a (much better) multiplicative factor of $(1+\epsilon)$. When $F>F^{*}$, the oracle will either output an $s$-$t$ flow satisfing the conditions above, or it will return ’’fail‘‘.

Formally, we will use the following definition:

For $\epsilon>0$ and $\rho>0$, an $(\epsilon,\rho)$ oracle is an algorithm that, given a real number $F>0$ and a vector $\boldsymbol{\mathit{w}}$ of edge weights with $w_{e}\geq 1$ for all $e$, returns an $s$-$t$ flow $f$ such that:

If $F\leq F^{*}$, then it outputs an $s$-$t$ flow $f$ satisfying:

$\sum_{e}w_{e}\mathsf{cong}_{f}(e)\leq(1+\epsilon)|\boldsymbol{\mathit{w}}|_{1}$, where $|\boldsymbol{\mathit{w}}|_{1}:=\sum_{e}w_{e}$;

If $F>F^{*}$, then it either outputs a flow $f$ satisfying conditions (i), (ii), (iii) or outputs ’’fail‘‘.

Our algorithm will be given a flow value $F$ as an input. If $F\leq F^{*}$, it will return a flow of value at least $(1-O(\epsilon))F$. If $F>F^{*}$, it will either return a flow of value at least $(1-O(\epsilon))F$ (which may occur if $F$ is only slightly greater than $F^{*}$) or it will return ’’fail‘‘. This allows us to find a $(1-O(\epsilon))$-approximation of $F^{*}$ using binary search. As outlined in Section 2.2, we can obtain a crude bound $B$ in time $O(m+n\log n)$ such that $B\leq F^{*}\leq mB$, so the binary search will only call our algorithm a logarithmic number of times.

In Figure 1, we present our simple algorithm, which applies the multiplicative weights update routine to approximate the maximum flow by calling an $(\epsilon,\rho)$-flow oracle. The algorithm initializes all of the weights to $1$ and calls the oracle with these weights. The call returns a flow that satisfies conditions (i), (ii), and (iii) defined above. It then multiplies the weight of each edge $e$ by $(1+\frac{\epsilon}{\rho}\mathsf{cong}_{f^{i}}(e))$. Note that if the congestion of an edge is poor, say close to $\rho$, then its weight will increase by a factor of $(1+\epsilon)$. On the other hand, if the flow on an edge is no more than its capacity, then the new weight of the edge is essentially unchanged. This will put a larger fraction of the weight on the violated constraints, so the oracle will be forced to return a solution that comes closer to satisfying them (possibly at the expense of other edges). In the end, we return the average of all of the flows as our answer.

The key point in analyzing this algorithm is that the total weight on $G$ does not grow too quickly, due to the average congestion constraint on the flows returned by the oracle $\mathit{O}$. However, if an edge $e$ consistently suffers large congestion in a sequence of flows returned by $\mathit{O}$, then its weight increases rapidly relative to the total weight, which will significantly penalize any further congestion the edge in the subsequent flows. If this were to occur too many times, its weight would exceed the total weight, which obviously cannot occur. In Section 3.3, we will prove the following theorem by showing that our algorithm converges in $2\rho\ln m/\epsilon^{2}$ iterations.

For any $0<\epsilon<1/2$ and $\rho>0$, given an $(\epsilon,\rho)$-flow oracle with running time $T(m,1/\epsilon,U)$, one can obtain an algorithm that computes a $(1-O(\epsilon))$-approximate maximum flow in a capacitated, undirected graph in time $\widetilde{O}\left(\rho\epsilon^{-2}\cdot T(m,1/\epsilon,U)\right)$.

Note that the number of iterations of the algorithm above grows linearly with the value of $\rho$, which we call the $\emph{width}$ of the oracle. Intuitively, this should be necessary because the final flow across an edge $e$ is equal to the average of the flows sent over it by all $f^{i}$. If we send $\rho\cdot u_{e}$ units of flow across the edge $e$ in some step, then we will need at least $\Omega(\rho)$ iterations to drop the average to $1$. Strictly speaking, it is possible that we could do better than this by sending a large amount of flow across the edge in the opposite direction. However, nothing in our algorithm aims to obtain this kind of cancellation, so we shouldn’t expect to be able to systematically exploit it.

2 Constructing an Oracle of Width 3​m/ϵ3\sqrt{m/\epsilon} Using Electrical Flows

Given Theorem 3.2, our problem is thus reduced to designing an efficient oracle that has a small width. In this subsection, we will give simple $\widetilde{O}\left(m\log\epsilon^{-1}\right)$ time implementation of an $(\epsilon,3\sqrt{m/\epsilon})$-flow oracle for any $0<\epsilon<1/2$. By Theorem 3.2, this will immediately yield an $\widetilde{O}\left(m^{3/2}\epsilon^{-5/2}\right)$ time algorithm for finding an approximately maximum flow.

for each edge $e$, and we use the procedure from Theorem 2.3 to approximate the electrical flow that sends $F$ units of flow from $s$ to $t$ in a network whose resistances are given by the $r_{e}$. The pseudocode for this oracle is shown in Figure 2.

We now show that the resulting flow $\widetilde{f}$ has the properties required by Definition 3.1. Since $|\widetilde{f}|=F$ by construction, we only need to demonstrate the bounds on the average congestion (weighted by the $w_{e}$) and the maximum congestion. We will use the basic fact that electrical flows minimize the energy of the flow. Our analysis will then compare the energy of $\widetilde{f}$ with that of an optimal max flow. Intuitively, the $w_{e}$ term in Equation (2) guarantees the bound on the average congestion, while the $\epsilon|\boldsymbol{\mathit{w}}|_{1}/(3m)$ term guarantees the bound on the maximum congestion.

Suppose $f^{*}$ is a maximum flow. By its feasibility, $\mathsf{cong}_{f^{*}}(e)\leq 1$ for all $e$, so

Since the electrical flow minimizes the energy, $\mathcal{E}_{\boldsymbol{\mathit{r}}}(f^{*})$ is an upper bound on the energy of the electrical flow of value $F$ whenever $F\leq F^{*}$. In this case, Theorem 2.3 implies that our $(\epsilon/3)$-approximate electrical flow satisfies

This shows that our oracle will never output ’’fail‘‘ when $F\leq F^{*}$. It thus suffices to show that the energy bound $\mathcal{E}_{\boldsymbol{\mathit{r}}}(\widetilde{f})>(1+\epsilon)|\boldsymbol{\mathit{w}}|_{1}$, which holds whenever the algorithm does not return ’’fail‘‘, implies the required bounds on the average and worst-case congestion. To see this, we note that the energy bound implies that

which is the required bound on the average congestion. Furthermore, Equation (5) and the fact that $\epsilon<1/2$ implies that

for all $e$, which establishes the required bound on the maximum congestion. So our algorithm implements an $(\epsilon,3\sqrt{m/\epsilon})$-oracle, as desired.

To bound the running time of this oracle, recall that we can assume all edge capacities lie between $1$ and $U=m^{2}/\epsilon$ and compute

This establishes an upper bound on the ratio of the largest resistance to the smallest resistance. Thus, by Theorem 2.3, the running time of this implementation is $\widetilde{O}\left(m\log R/\epsilon\right)=\widetilde{O}\left(m\log 1/\epsilon\right)$. Combining this with Theorem 3.2, we have shown

For any $0<\epsilon<1/2$, the maximum flow problem can be $(1-\epsilon)$-approximated in $\widetilde{O}\left(m^{3/2}\epsilon^{-5/2}\right)$ time.

3 The Convergence of Multiplicative Weights

In this section, we prove Theorem 3.2 by analyzing the multiplicative weights update algorithm shown in Figure 1.

Our analysis will be based on the potential function $\mu_{i}:=|\boldsymbol{\mathit{w}}^{i}|_{1}$. Clearly, $\mu_{0}=m$ and this potential only increases during the course of the algorithm. It follows from condition (1.ii) of Definition 3.1 that if we run the $(\epsilon,\rho)$-oracle $\mathit{O}$ with $F=F^{*}$, then

We start by upper bounding the total growth of $\mu_{i}$ thoughout the algorithm.

In particular, $\|\boldsymbol{\mathit{w}}^{N}\|_{1}=\mu_{N}\leq m\exp\left(\frac{(1+\epsilon)\epsilon}{\rho}N\right)=n^{O(1/\epsilon)}$.

where the last inequality follows from (9). Thus, we can conclude that

One of the consequences of the above lemma is that whenever we make a call to the oracle, the total weight $\|\boldsymbol{\mathit{w}}^{i}\|_{1}$ is at most $n^{O(1/\epsilon)}$. Thus, the running time of our algorithm is $\widetilde{O}\left(\rho\epsilon^{-2}\cdot T(m,1/\epsilon,U,m^{O(1/\epsilon)})\right)$ as claimed.

Next, we bound the final weight $w_{e}^{N}$ of a particular edge $e$ with the congestion $\mathsf{cong}_{\overline{f}}(e)$ that this edge suffers in our final flow $\overline{f}$.

In particular, $w_{e}^{N}\geq\exp\left(\frac{(1+\epsilon)\epsilon N}{(1-\epsilon)\rho}\mathsf{cong}_{\overline{f}}(e)\right)$.

where we used (10) and that for any $1/2>\epsilon>0$ and $x\in$:

Finally, by Lemmas 3.4 and 3.5, we conclude that for any edge $e$,

for every edge $e$. Thus, we see that $\overline{f}$ is a feasible $s$-$t$ flow and, since each $f^{i}$ has throughput $F^{*}$, the throughput $|\overline{f}|$ of $\overline{f}$ is $\frac{(1-\epsilon)^{2}}{(1+\epsilon)}F^{*}\geq(1-O(\epsilon))F^{*}$ for $1/2>\epsilon>0$, as desired.

An O~(mn1/3ϵ−11/3)\widetilde{O}\left(mn^{1/3}\epsilon^{-11/3}\right) Algorithm for Approximate Maximum Flow

In this section, we modify our algorithm to run in time $\widetilde{O}\left(m^{4/3}\epsilon^{-3}\right)$. We then combine this with the smoothing and sampling techniques of Karger to obtain an $\widetilde{O}\left(mn^{1/3}\epsilon^{-11/3}\right)$-time algorithm.

For fixed $\epsilon$, the algorithm in the previous section required us to compute $\widetilde{O}\left(m^{1/2}\right)$ electrical flows, each of which took time $\widetilde{O}\left(m\right)$, which led to a running time of $\widetilde{O}\left(m^{3/2}\right)$. To reduce this to $\widetilde{O}\left(m^{4/3}\right)$, we‘ll show how to find an approximate flow while computing only $\widetilde{O}\left(m^{1/3}\right)$ electrical flows.

Our analysis of the oracle from Section 3.2 was fairly simplistic, and one might hope to improve the running time of the algorithm by proving a tighter bound on the width. Unfortunately, the graph in Figure 1 shows that our analysis was essentially tight. The graph consists of $k$ parallel paths of length $k$ connecting $s$ to $t$, along with a single edge $e$ that directly connects $s$ to $t$. The max flow in this graph is $k+1$. In the first call made to the oracle by the multiplicative weights routine, all of the edges will have the same resistance. In this case, the electrical flow of value $k+1$ will send $(k+1)/2k$ units of flow along each of the $k$ paths and $(k+1)/2$ units of flow across $e$. Since the graph has $m=\Theta(k^{2})$, the width of the oracle in this case is $\Theta(m^{1/2})$.

The above example shows that it is possible for the electrical flow returned by the oracle to exceed the edge capacities by $\Theta(m^{1/2})$. However, we note that if one removes the edge $e$ from the graph in Figure 1, the electrical flow on the resulting graph is much better behaved, but the value of the maximum flow is only very slightly reduced. This demonstrates a phenomenon that will be central to our improved algorithm: while instances in which the electrical flow sends a huge amount of flow over some edges exist, they are somewhat fragile, and they are often drastically improved by removing the bad edges.

This motivates us to modify our algorithm as follows. We‘ll set $\rho$ to be some value smaller than the actual worst-case bound of $\widetilde{O}\left(m^{1/2}\right)$. (It will end up being $\widetilde{O}\left(m^{1/3}\right)$.) The oracle will begin by computing an electrical flow as before. However, when this electrical flow exceeds the capacity of some edge $e$ by a factor greater than $\rho$, we‘ll remove $e$ from the graph and try again, keeping all of the other weights the same. We‘ll repeat this process until we obtain a flow in which all edges flow at most a factor of $\rho$ times their capacity (or some failure condition is reached), and we‘ll use this flow in our multiplicative weights routine. When the oracle removes an edge, it is added to a set $H$ of forbidden edges. These edges will be permanently removed from the graph, i.e., they will not be included in the graphs supplied to future invocations of the oracle.

In Figures 3 and 4, we present the modified versions of the oracle and overall algorithm, where we have highlighted the parts that have changed from the simpler version shown in Figures 1 and 2.

2 Analysis of the New Algorithm

Before proceeding to a formal analysis of the new algorithm, it will be helpful to examine what is already guaranteed by the analysis from Section 3, and what we‘ll need to show to demonstrate the algorithm‘s correctness and bound its running time.

We first note that, by construction, the congestion of any edge in the flow $\widetilde{f}$ returned by the modified oracle from Figure 3 will be bounded by $\rho$. Furthermore, it enforces the bound $\mathcal{E}_{\boldsymbol{\mathit{r}}}(\widetilde{f})\leq(1+\epsilon)|\boldsymbol{\mathit{w}}|_{1}$; by Equations (4), (6), and (7) in Section 3.2, this guarantees that $\widetilde{f}$ will meet the weighted average congestion bound required for a $(\epsilon,\rho)$-oracle. So, as long as the modified oracle always successfully returns a flow, it will function as an $(\epsilon,\rho)$-oracle, and our analysis from Section 3 will show that the multiplicative update scheme employed by our algorithm will yield an approximate maximum flow after $\widetilde{O}\left(\rho\right)$ iterations.

Our problem is thus reduced to understanding the behavior of the modified oracle. To prove correctness, we will need to show that whenever the modified oracle is called with $F\leq F^{*}$, it will return some flow $\widetilde{f}$ (as opposed to returning ’’fail‘‘). To bound the running time, we will need to provide an upper bound on the total number of electrical flows computed by the modified oracle throughout the execution of the algorithm.

To this end, we will show the following upper bound on the cardinality $|H|$ and the capacity $u(H)$ of the set of forbidden edges, whose proof we postpone until the next section:

Throughout the execution of the algorithm,

If we plug in the value $\rho=(8m^{1/3}\ln^{1/3}m)/\epsilon$ used by the algorithm, Lemma 4.1 gives the bounds $|H|\leq\frac{15}{32}(m\ln m)^{1/3}$ and $u(H)\leq\ \frac{15}{256}\epsilon F<\epsilon F/12$.

Given the above lemma, it is now straightforward to show the following theorem, which establishes the correctness and bounds the running time of our algorithm.

For any $0<\epsilon<1/2$, if $F\leq F^{*}$ the algorithm in Figure 4 will return a feasible $s$-$t$ flow $\overline{f}$ of value $|\overline{f}|=(1-O(\epsilon))F$ in time $\widetilde{O}\left(m^{4/3}\epsilon^{-3}\right)$.

To bound the running time, we note that, whenever we invoke the algorithm from Theorem 2.3 , we either advance the number of iterations or we increase the cardinality of $H$, so the number of linear systems we solve is at most $N+|H|\leq N+\frac{15}{32}(m\ln m)^{1/3}$.

Equation (8) implies that the value of $R$ from Theorem 2.3 is $O((m/\epsilon)^{O(1)})$, so solving each linear system takes time at most $\widetilde{O}\left(m\log 1/\epsilon\right)$. This gives an overall running time of

It thus remains to prove correctness. For this, we need to show that if $F\leq F^{*}$, then the oracle does not return ’’fail‘‘, which would occur if we disconnect $s$ from $t$ or if $\mathcal{E}_{\boldsymbol{\mathit{r}}}(\widetilde{f})>(1+\epsilon)|\boldsymbol{\mathit{w}}|_{1}$. By Lemma 4.1 and the comment following it, we know that throughout the whole algorithm $G_{H}$ has maximum flow value of at least $F^{*}-\epsilon F/12\geq\left(1-\epsilon/12\right)F$ and thus, in particular, we will never disconnect $s$ from $t$.

Furthermore, this implies that there exists a feasible flow in our graph of value $\left(1-\epsilon/12\right)F$, even after we have removed the edges in $H$. There is thus a flow of value $F$ in which every edge has congestion at most $1/\left(1-\epsilon/12\right)$. We can therefore use the argument from Section 3.2 (Equation (3) and the lines directly preceding it) to show that we always have

The above theorem allows us to apply the binary search strategy that we used in Section 3.1. This yields our main theorem:

For any $0<\epsilon<1/2$, the maximum flow problem can be $(1-\epsilon)$-approximated in $\widetilde{O}\left(m^{4/3}\epsilon^{-3}\right)$ time.

3 The Proof of Lemma 4.1

All that remains is to prove the bounds given by Lemma 4.1 on the cardinality and capacity of $H$. To do so, we will use the effective resistance of the circuits on which we compute electrical flows as a potential function. The key insight is that we only cut an edge when its flow accounts for a nontrivial fraction of the energy of the electrical flow, and that cutting such an edge will cause a substantial change in the effective resistance. Combining this with a bound on how much the effective resistance can change during the execution of the algorithm will guarantee that we won‘t cut too many edges.

Let $\boldsymbol{\mathit{r}}^{j}$ be the resistances used in the $j^{\text{th}}$ electrical flow computed during the execution of the algorithm Note that $\boldsymbol{\mathit{r}}^{j}$ is not just the set of resistances arising from $\boldsymbol{\mathit{w}}^{j}$, since a single call to the oracle may compute multiple electrical flows as edges are added to $H$.. If an edge $e$ is not in $E$ or if $e$ has been added to $H$ by step $j$, set $r^{j}_{e}=\infty$. We define the potential function

where $f_{\boldsymbol{\mathit{r}}^{j}}$ is the (exact) electrical flow of value 1 arising from $\boldsymbol{\mathit{r}}^{j}$. Lemma 4.1 will follow easily from:

$\Phi(j)$ never decreases during the execution of the algorithm.

If we add an edge to $H$ between steps $j-1$ and $j$, then $(1-\frac{\epsilon\rho^{2}}{5m})\Phi(j)>\Phi(j-1)$.

The only way that the resistance $r^{j}_{e}$ of an edge $e$ can change is if the weight $w_{e}$ is increased by the multiplicative weights routine, or if $e$ is added to $H$ so that $r^{j}_{e}$ is set to $\infty$. As such, the resistances are nondecreasing during the execution of the algorithm. By Rayleigh Monotonicity (Corollary 2.5), this implies that the effective resistance is nondecreasing as well.

Proof of (2)

In the first linear system, $H=\emptyset$ and $r^{1}_{e}=\frac{1+\epsilon/3}{u_{e}^{2}}$ for all $e\in E$. Let $(S,V\setminus S)$ be the minimum $s$-$t$ cut of $G$. By the Max Flow-Min Cut Theorem (), we know that the capacity $u(S)=\sum_{e\in E(S)}u_{e}$ of this cut is equal to $F^{*}$. In particular,

for all $e\in E(S)$. As $f_{\boldsymbol{\mathit{r}}^{1}}$ is an electrical $s$-$t$ flow of value 1, it sends 1 unit of net flow across $(S,V\setminus S)$; so, some edge $e^{\prime}\in E(S)$ must have $f_{\boldsymbol{\mathit{r}}^{1}}(e^{\prime})\geq 1/m$. This gives

Since $F^{*}\leq mF$ by assumption, the desired inequality follows.

Proof of (3)

Suppose we add the edge $h$ to $H$ between steps $j-1$ and $j$. We will show that $h$ accounts for a substantial fraction of the total energy of the electrical flow with respect to the resistances $\boldsymbol{\mathit{r}}^{j-1}$, and our result will then follow from Lemma 2.6.

Let $\boldsymbol{\mathit{w}}$ be the weights used at step $j-1$, and let $\widetilde{f}$ be the flow we computed in step $j-1$. Because we added $h$ to $H$, we know that $\mathsf{cong}_{\widetilde{f}}(h)>\rho$. Since our algorithm did not return ’’fail‘‘ after computing this $\widetilde{f}$, we must have that

Using the definition of $r^{j-1}_{h}$, the fact that $\mathsf{cong}_{\widetilde{f}}(h)>\rho$, and Equation (12), we obtain:

The above inequalities establish that edge $h$ accounts for more than a $\frac{\epsilon\rho^{2}}{3(1+\epsilon)m}$ fraction of the total energy $\mathcal{E}_{\boldsymbol{\mathit{r}}^{i}}(\widetilde{f})$ of the flow $\widetilde{f}$.

The flow $\widetilde{f}$ is the approximate electrical flow computed by our algorithm, but our argument will require that an inequality like this holds in the exact electrical flow $f_{\boldsymbol{\mathit{r}}^{j-1}}$. This is guaranteed by part $b$ of Theorem 2.3, which, along with the facts that $\mathcal{E}_{\boldsymbol{\mathit{r}}}(\widetilde{f})\geq\mathcal{E}_{\boldsymbol{\mathit{r}}}(f_{\boldsymbol{\mathit{r}}^{j-1}})$, $\rho\leq 1$, and $\epsilon<1/2$, gives us that

Let $k$ be the cardinality of the set $H$ at the end of the algorithm. Let $\widetilde{f}$ be the flow that was produced by our algorithm just before $k$-th edge was added to $H$, let $j$ be the time when this flow was output, and let $\boldsymbol{\mathit{w}}$ be the corresponding weights.

As the energy required by an $s$-$t$ flow scales with the square of the value of the flow,

By the construction of our algorithm, it must have been the case that $\mathcal{E}_{\boldsymbol{\mathit{r}}^{j}}(\widetilde{f})\leq(1+\epsilon)|\boldsymbol{\mathit{w}}|_{1}$. This inequality together with equation (13) and part 2 of Lemma 4.4 implies that

Now, since up to time $j$ we had $k-1$ additions of edges to $H$, parts 1 and 3 of Lemma 4.4, and Lemma 3.4 imply that

where the last inequality used the fact that $\epsilon<1/2$. Rearranging the terms in the above inequality gives us that

where we used the inequalities $\epsilon<1/2$ and $\log(1-c)<-c$ for all $c\in(0,1)$. This establishes our bound on cardinality of the set $H$.

To bound the value of $u(H)$, let us note that we add an edge $e$ to $H$ only when we send at least $\rho u_{e}$ units of flow across it. But since we never flow more than $F$ units across any single edge, we have that $u_{e}\leq F/\rho$. Therefore, we may conclude that

4 Improving the Running Time to O~(mn1/3ϵ−11/3)\widetilde{O}\left(mn^{1/3}\epsilon^{-11/3}\right)

We can now combine our algorithm with existing methods to further improve its running time. In (see also ), Karger presented a technique, which he called ’’graph smoothing‘‘, that allows one to use random sampling to speed up an exact or $(1-\epsilon)$-approximate flow algorithm. More precisely, his techniques yield the following theorem, which is implicit in and stated in a more similar form in :

Let $T(m,n,\epsilon)$ be the time needed to find a $(1-\epsilon)$-approximately maximum flow in an undirected, capacitated graph with $m$ edges and $n$ vertices. Then one can obtain a $(1-\epsilon)$-approximately maximal flow in such a graph in time $\widetilde{O}\left(\epsilon^{2}m/n\cdot T(\widetilde{O}\left(n\epsilon^{-2}\right),n,\Omega(\epsilon))\right)$.

By applying the above theorem to our $\widetilde{O}\left(m^{4/3}\epsilon^{-3}\right)$ algorithm, we obtain our desired running time bound:

For any $0<\epsilon<1/2$, the maximum flow problem can be $(1-\epsilon)$-approximated in $\widetilde{O}\left(mn^{1/3}\epsilon^{-11/3}\right)$ time.

Given any weighted undirected graph $G=(V,E,w)$ with $n$ vertices and $m$ edges, Benczúr and Karger showed that one can construct a graph $G^{\prime}=(V,E^{\prime},w^{\prime})$ (called a sparsifier of $G$) on the same vertex set in time $\widetilde{O}\left(m\right)$ such that $|E^{\prime}|=O(n\log n/\epsilon^{2})$ and the capacity of any cut in $G^{\prime}$ is between $1$ and $(1+\epsilon)$ times its capacity in $G$. Applying our algorithm from Section 4 to a sparsifier of $G$ gives us an algorithm for $(1-\epsilon)$-approximating the value of the maximum $s$-$t$ flow on $G$ in time $\widetilde{O}\left(m+n^{4/3}\epsilon^{-3}\right)$.

We note that this only allows us to approximate the value of the maximum $s$-$t$ flow on $G$. It gives us a flow on $G^{\prime}$, not one on $G$. We do not know how to use an approximately maximum $s$-$t$ flow on $G^{\prime}$ to obtain one on $G$ in less time than would be required to compute a maximum flow in $G$ from scratch using the algorithm from Section 4.

For this reason, there is a gap between the time we require to find a maximum flow and the time we require to compute its value. We note, however, that this gap will not exist for the minimum $s$-$t$ cut problem, since an approximately minimum $s$-$t$ cut on $G^{\prime}$ will also be an approximately minimum $s$-$t$ cut $G$. We will present an algorithm for finding such a cut in the next section. By the Max Flow-Min Cut Theorem, this will provide us with an alternate algorithm for approximating the value of the maximum $s$-$t$ flow. It will have a slightly better dependence on $\epsilon$, which will allow us to approximate the value of the maximum $s$-$t$ flow in time $\widetilde{O}\left(m+n^{4/3}\epsilon^{-8/3}\right)$.

In this section, we‘ll describe a dual perspective that yields to an even simpler algorithm for computing an approximately minimum $s$-$t$ cut. Rather than using electrical flows to obtain a flow, it will use the electrical potentials to obtain a cut.

The algorithm will eschew the oracle abstraction and multiplicative weights machinery. Instead, it will just repeatedly compute an electrical flow, increase the resistances of edges according to the amount flowing over them, and repeat. It will then use the electrical potentials of the last flow computed to find a cut by picking a cutoff and splitting the vertices according to whether their potentials are above or below the cutoff.

The algorithm is shown in Figure 5. It finds a $(1+\epsilon)$-approximately minimum $s$-$t$ cut in time $\widetilde{O}\left(m^{4/3}\epsilon^{-8/3}\right)$; applying it to a sparsifier will give us:

For any $0<\epsilon<1/7$, we can find a $(1+\epsilon)$-approximate minimum $s$-$t$ cut in $\widetilde{O}\left(m+n^{4/3}\epsilon^{-8/3}\right)$ time.

We note that, in this algorithm, there is no need to deal explicitly with edges flowing more than $\rho$, maintain a set of forbidden edges, or average the flows from different steps. We will separately study edges with very large flow in our analysis, but the algorithm itself avoids the complexities that appeared in the improved flow algorithm described in Section 4.

We further note that the update rule is slightly modified from the one that appeared earlier in the paper. This is done to guarantee that the effective resistance increases substantially when some edge flows more than $\rho$, without having to explicitly cut it. Our previous rule allowed the weight (but not resistance) of an edge to constitute a very small fraction of the total weight; in this case, a significant multiplicative increase in the weight of an edge may not produce a substantial change in the effective resistance of the graph.

To analyze this algorithm, we will track the total weight placed on the edges crossing some minimum cut. The basic observation for our analysis is that the same amount of net flow must be sent across every cut, so edges in small cuts will tend to have higher congestion than edges in large cuts. Since our algorithm increases the weight of an edge according to its congestion, this will cause our algorithm to concentrate a larger and larger fraction of the total weight on the small cuts of the graph. This will continue until almost all of the weight is concentrated on approximately minimum cuts.

Of course, the edges crossing a minimum cut will also cross many other (likely much larger) cuts, so we certainly can‘t hope to obtain a graph in which no edge crossing a large cut has non-negligible weight. In order to formalize the above argument, we will thus need some good way to measure the extent to which the weight is ’’concentrated on approximately minimum cuts‘‘.

In Section 5.2, we will show how to use effective resistance to formulate such a notion. In particular, we will show that if we can make the effective resistance large enough then we can find a cut of small capacity. In Section 5.3, we will use an argument like the one described above to show that the resistances produced by the algorithm in Figure 5 converge after $N=\widetilde{O}\left(m^{1/3}\epsilon^{-8/3}\right)$ steps to one that meets such a bound.

2 Cuts, Electrical Potentials, and Effective Resistance

During the algorithm, we scale and translate the potentials of the approximate electrical flow so that $\boldsymbol{\widetilde{\mathit{\phi}}}_{s}=1$ and $\boldsymbol{\widetilde{\mathit{\phi}}}_{t}=0$. We then produce a cut by choosing $x\in$ and dividing the graph into the sets $S=\{v\in V\,|\,\phi_{v}>x\}$ and $V\setminus S=\{v\in V\,|\,\boldsymbol{\widetilde{\mathit{\phi}}}_{v}\leq x\}$. The following lemma upper bounds the capacity of the resulting cut in terms of the electrical potentials and edge capacities.

Consider choosing $x\in$ uniformly at random. The probability that an edge $(u,v)$ is cut is precisely $|\boldsymbol{\widetilde{\mathit{\phi}}}(u)-\boldsymbol{\widetilde{\mathit{\phi}}}(v)|$. So, the expected capacity of the edges in a random cut is given by (14), and so there is a cut of capacity at most (14). ∎

Now, suppose that one has a fixed total amount of resistance $\mu$ to distribute over the edges of a cut of size $F$. It is not difficult to see that the maximum possible effective resistance between $s$ and $t$ in such a case is $\frac{\mu}{F^{2}}$, and that this is achieved when one puts a resistance of $\frac{\mu}{F}$ on each of the edges. This suggests the following lemma, which bounds the quantity in Lemma 5.2 in terms of the effective resistance and the total resistance (appropriately weighted when the edges have non-unit capacities):

So, we can apply the Cauchy-Schwarz inequality to prove

for $\delta\leq 1/3$. The rest of the analysis follows from another application of Cauchy-Schwarz. ∎

3 The Proof that the Dual Algorithm Finds an Approximately Minimum Cut

We‘ll show that if $F\geq F^{*}$ then within $N=5\epsilon^{-8/3}m^{1/3}\ln m$ iterations, the algorithm in Figure 5 will produce a set of resistances $\boldsymbol{\mathit{r}}^{i}$ such that

Let $C$ be the set of edges crossing some minimum cut in our graph. Let $u_{C}=F^{*}$ denote the capacity of the edges in $C$. We will keep track of two quantities: the weighted geometric mean of the weights of the edges in $C$,

of the edges of the entire graph. Clearly $\nu^{i}\leq\max_{e\in C}{w_{e}^{i}}$. In particular,

The total weight $\mu^{i}$ doesn‘t get too large over the course of the algorithm [Lemma 5.4].

The quantity $\nu^{i}$ increases significantly in any iteration in which no edge has congestion more than $\rho$ [Lemma 5.5]. Since $\mu^{i}$ doesn‘t get too large, and $\nu^{i}\leq\mu^{i}$, this will not happen too many times.

The effective resistance increases significantly in any iteration in which some edge has congestion more than $\rho$ [Lemma 5.6]. Since $\mu^{i}$ does not get too large, and the effective resistance is assumed to be bounded in terms of the total weight $\mu^{i}$, this cannot happen too many times.

The combined bounds from 2 and 3 will be less than $N$, which will yield a contradiction.

By Theorem 2.3, the approximate electrical flow $\widetilde{f}$ has energy at most $(1+\delta)$ times the energy of $f$,

Applying the Cauchy-Schwarz inequality, we find

If $\mathsf{cong}_{f^{i}}(e)\leq\rho$ for all $e$, then

To bound the increase of $\nu^{i+1}$ over $\nu^{i}$, we use the inequality

which holds for $\epsilon$ and $x$ between $0$ and $1$. We apply this inequality with $x=\mathsf{cong}_{\widetilde{f}^{i}}(e)/\rho$. As $\widetilde{f}^{i}$ is a flow of value $F$ and $C$ is a cut, $\sum_{e\in C}{\left|\widetilde{f}_{e}^{i}\right|}\geq F$. We now compute

If $i=0$ we have $1\geq\epsilon$. For $i>0$, we have

We now show that an edge $e$ for which $\mathsf{cong}_{\widetilde{f}^{i}}(e)\geq\rho$ contributes a large fraction of the energy to the true electrical flow of value $F$. By the assumptions of the lemma, the energy of the true electrical flow of value $F$ is

On the other hand, the energy of the edge $e$ in the approximate electrical flow is

As a fraction of the energy of the true electrical flow, this is at least

By part $b$ of Theorem 2.3, the fraction of the energy that $e$ accounts for in the true flow is at least

we have increased the weight of edge $e$ by a factor of at least $(1+\epsilon)$. So, by Lemma 2.6,

We now combine these lemmas to obtain our main bound:

Before proving Lemma 5.7, we note that combining it with Lemmas 5.2 and 5.3 immediately implies our main result:

On input $\epsilon<1/7$, the algorithm in Figure 5 runs in time $\widetilde{O}\left(m^{4/3}\epsilon^{-8/3}\right)$. If $F\geq F^{*}$, then it returns a cut of capacity at most $F/(1-7\epsilon)$, where $F^{*}$ is the minimum capacity of an $s$-$t$ cut.

To use this algorithm to find a cut of approximately minimum capacity, one should begin as described in Section 2.2 by crudely approximating the minimum cut, and then applying the above algorithm in a binary search. Crudely analyzed, this incurs a multiplicative overhead of $O(\log m/\epsilon)$.

Let $A\subseteq\{1,\dots,N\}$ be the set of $i$ for which $\mathsf{cong}_{\widetilde{f}^{i}}(e)\leq\rho$ for all $e$, and let $B\subseteq\{1,\dots,N\}$ be the set of $i$ for which there exists an edge $e$ with $\mathsf{cong}_{\widetilde{f}^{i}}(e)>\rho$. Let $a=|A|$ and $b=|B|$, and note that $a+b=N$. We will obtain a contradiction by proving bounds on $a$ and $b$ that add up to something less than $N$.

We begin by bounding $a$. By applying Lemma 5.5 to all of the steps in $A$ and noting that $\nu^{i}$ never decreases during the other steps, we obtain

Since $\nu^{N}\leq\mu^{N}$, we can combine Equations (17) and (18) to obtain

Taking logs of both sides and solving for $a$ yields

Taking logs and rearranging terms gives us

Adding the inequalities in Equations (19) and (20), grouping terms, and plugging in the values of $\rho$ and $N$, yields

This is our desired contradiction, which completes the proof. ∎

References

Appendix A Computing Electrical Flows

Without loss of generality, we may scale the resistances so that they lie between $1$ and $R$. This gives the following relation between $F$ and the energy of the electrical $s$-$t$ flow of value $F$:

Let $\boldsymbol{\mathit{L}}$ be the Laplacian matrix for this electrical flow problem. Note that all off-diagonal entries of $\boldsymbol{\mathit{L}}$ lie between $-1$ and $-1/R$. Recall that the vector of optimal vertex potentials $\boldsymbol{\mathit{\phi}}$ of the electrical flow is the solution to the following linear system:

For any $\epsilon>0$, the algorithm of Koutis, Miller and Peng provides in time $O\left(m\log^{2}m\log^{2}\log m\log\epsilon^{-1}\right)$ a set of potentials $\boldsymbol{\widehat{\phi}}$ such that