Concave Flow on Small Depth Directed Networks

TL;DR

This paper presents an efficient approximation algorithm for maximum flow problems in small depth directed networks with concave edge weights, extending previous methods to handle concave functions.

Contribution

It introduces a novel scaling algorithm that approximates maximum weighted flow with concave weights in small depth networks, generalizing prior matchings algorithms.

Findings

Achieves a (1 - ε)-approximation in time proportional to mDε^{-1}

Extends the scaling algorithm to concave weight functions

Provides a unified approach for various small depth network problems

Abstract

Small depth networks arise in a variety of network related applications, often in the form of maximum flow and maximum weighted matching. Recent works have generalized such methods to include costs arising from concave functions. In this paper we give an algorithm that takes a depth $D$ network and strictly increasing concave weight functions of flows on the edges and computes a $(1 - \epsilon)$-approximation to the maximum weight flow in time $mD \epsilon^{-1}$ times an overhead that is logarithmic in the various numerical parameters related to the magnitudes of gradients and capacities. Our approach is based on extending the scaling algorithm for approximate maximum weighted matchings by [Duan-Pettie JACM`14] to the setting of small depth networks, and then generalizing it to concave functions. In this more restricted setting of linear weights in the range $[w_{\min}, w_{\max}]$, it produces a $(1 - \epsilon)$-approximation in time $O(mD \epsilon^{-1} \log( w_{\max} /w_{\min}))$. The algorithm combines a variety of tools and provides a unified approach towards several problems involving small depth networks.

Equations

$$w_{\min }\ge \frac{ϵw_{\max }}{O\left(m^2\cdot {\sum }_e{c}_e\right)},$$

$$\hat{w}\stackrel{\mathrm{def}}{=}\underset{e}{\max }f\left(\frac{ϵ}{m^2}\right).$$

$${\overline{f}}_e\left(x\right)\stackrel{\mathrm{def}}{=}{f}_e\left(x\right)+x\cdot \frac{ϵ\hat{w}}{{\sum }_{e^{\prime }}{c}_{e^{\prime }}}.$$

$${\hat{f}}_e\left(x\right)\stackrel{\mathrm{def}}{=}\{\begin{array}{ll}{\overline{f}}_e\left(x\right)& \text{if x≥m2ϵ, and}\\ \frac{x{m}^2}{ϵ}\cdot {\overline{f}}_e\left(\frac{ϵ}{m^2}\right)& \text{if x≤m2ϵ}\end{array}.$$

$$\frac{x{m}^2}{ϵ}\cdot {\overline{f}}_e\left(\frac{ϵ}{m^2}\right)\le O\left(m^2{ϵ}^{-1}\hat{w}\right).$$

$$\left(1-ϵ\right)\overline{x}+ϵx^{\prime }$$

$$f_e(x_e)=w_e{x}_e$$

$$\max$$

$$\forall u,$$

$$\forall e,$$

$$\min$$

$$\forall e,$$

$$p_s=p_t$$

$$\forall e,$$

$$y_e\ge w_e+p_u-p_v,$$

$$w_e^p=w_e+p_u-p_v.$$

$$\sum _e{w}_e{x}_e=\sum _e{w}_e^p{x}_e.$$

$$\sum _e{w}_e^p{x}_e=\sum _e{w}_e{x}_e+\sum _{e=uv}{x}_e{p}_u-\sum _{e=uv}{x}_e{p}_v.$$

$$\sum _u{p}_u\left(\sum _{uv}{x}_{uv}-\sum _{vu}{x}_{vu}\right),$$

$$\sum _e{w}_e{x}_e\ge \left(1-ϵ\right)\sum _e{w}_e{x}_e^{\ast }.$$

$$x_e{w}_e^p\ge x_e^{\ast }{w}_e^p.$$

$$x_e{w}_e^p=0\ge x_e^{\ast }\left(w_e^p-\delta \right).$$

$$x_e{w}_e^p\ge x_e^{\ast }{w}_e^p-ϵw_e{x}_e^{\ast }.$$

$$\sum _e{x}_e{w}_e=\sum _e{x}_e{w}_e^p\ge \sum _e{x}_e^{\ast }{w}_e^p-ϵ\sum _e{x}_e^{\ast }{w}_e=\left(1-ϵ\right)\sum _e{x}_e^{\ast }{w}_e.$$

$$T=\log \left(w_{\max }/w_{\min }\right).$$

$$p_t=D{w}_{max}/2^i+2D{\delta }_i$$

$$p_t=D{w}_{max}/2^{i+1}.$$

$$w_e^{p^{\prime }}\le {\delta }_i=2{\delta }_{i+1}.$$

$$w_e^p\ge -3l_e({\delta }_e-{\delta }_i)-{\delta }_i$$

$$-3l_e({\delta }_e-{\delta }_i)-{\delta }_i-l_e{\delta }_i$$

$$=-3l_e{\delta }_e+2l_e{\delta }_i-{\delta }_i$$

$$=-3l_e{\delta }_e+4l_e{\delta }_{i+1}-2{\delta }_{i+1}$$

$$\ge -3l_e({\delta }_e-{\delta }_{i+1})-{\delta }_{i+1}.$$

$$x=\sum _{P\in \mathcal{P}}{x}_P.$$

Full text

Our approach is based on extending the scaling algorithm for approximate maximum weighted matchings by [Duan-Pettie JACM‘14] to the setting of small depth networks, and then generalizing it to concave functions. In this more restricted setting of linear weights in the range $[\boldsymbol{\mathit{w}}_{\min},\boldsymbol{\mathit{w}}_{\max}]$, it produces a $(1-\epsilon)$-approximation in time $O(mD\epsilon^{-1}\log(\boldsymbol{\mathit{w}}_{\max}/\boldsymbol{\mathit{w}}_{\min}))$. The algorithm combines a variety of tools and provides a unified approach towards several problems involving small depth networks.

1 Introduction

Combinatorial problems have traditionally been solved using combinatorial methods, e.g., see [Sch03]. Aside from providing many state-of-the-art results, these methods also have the advantages of simplicity and interpretability of intermediate solutions. Recently, algorithms that utilize continuous methods have led to performances similar or better than these combinatorial methods [CKM*+*11, Mad13, ZO15]. A significant advantage of continuous approaches is that they extend naturally to general objective functions, whereas in combinatorial algorithms there is much difference, for example, between even finding a maximum flow and a minimum cost flow.

This paper is motivated by recent works that used accelerated gradient descent to obtain $O(m\epsilon^{-1}\log{n})$ time routines for computing approximate solutions of positive linear programs [ZO15, WRM15]. Such linear programs include in particular (integral) maximum weighted matchings on bipartite graphs, and fractional weighted matchings on general graphs. These algorithms, as well as earlier works using continuous methods for the maximum weighted matching problems [AG14], represent a very different approach that obtained bounds similar to the result by Duan and Pettie [DP14]; the latter computed similar approximations using combinatorial methods. We study this connection in the reverse direction to show that the augmenting path based approaches can be extend to

1. small depth, acyclic networks, and
2. more general cost objectives. Formally, given a DAG with source $s$ and sink $t$, along with capacities $\boldsymbol{\mathit{c}}_{e}$ and differentiable concave functions $f_{e}$ on each edge, we want to find a flow from $s$ to $t$ that obeys capacity $\boldsymbol{\mathit{c}}_{e}$ and maximizes the function $\sum_{e}f_{e}(\boldsymbol{\mathit{x}}_{e})$. Our main result to this direction is:

Theorem 1.1**.**

Given a depth $D$ acyclic network with positive capacities and concave cost functions whose derivatives are between $\boldsymbol{\mathit{w}}_{\min}$ and $\boldsymbol{\mathit{w}}_{\max}$ and queryable in $O(1)$ time, ConvexFlow returns a $(1-\epsilon)$-approximation to the maximum weighted flow in $O\left(Dm\epsilon^{-1}\log({\boldsymbol{\mathit{w}}_{\max}}/{\boldsymbol{\mathit{w}}_{\min}})\log n\right)$ time.

We note that the logarithmic dependency on $\boldsymbol{\mathit{w}}_{\max}/\boldsymbol{\mathit{w}}_{\min}$ is common in scaling algorithms for flows: the case of linear costs corresponds to $f_{e}(\boldsymbol{\mathit{x}}_{e})=\boldsymbol{\mathit{w}}_{e}\boldsymbol{\mathit{x}}_{e}$ for scalars $\boldsymbol{\mathit{w}}_{e}$, and in turn $\boldsymbol{\mathit{w}}_{\min}=\min_{e}\boldsymbol{\mathit{w}}_{e}$ and $\boldsymbol{\mathit{w}}_{\max}=\max_{e}\boldsymbol{\mathit{w}}_{e}$. We will discuss the relation between this formulation and other flow problems, as well this dependency on weights in Section 1.2.

The main components of our algorithm are in Figure 1. It involves the construction and flow routing on an eligiblility graph, which consists of all positive capacitiated edges calculated from a set of eligibility rules. Note that aside from the blocking-flow computation on this graph in Step 2(a)ii, all other steps are local steps based on values on an edge, potentials of its two end points, and an overall step size. This algorithm in its fullest generalization is in Figure 8 in Section 4.

The paper is organized as follows. In Section 2 we describe the simplest variant: max weight flow on unit-capacity, small depth networks where the cost functions on edges are linear. The main reason for presenting this simple setting is to show how we trade running time with accuracy by appropriately relaxing eligibility conditions for edges. In Section 3, we extend our algorithm to situations with widely varying edge weights via a scaling scheme. We then extend the result to concave functions in Section 4, leading to our main result as stated in Theorem 1.1.

1.1 Our Techniques

Our main technical contribution is a method for combining augmenting paths algorithms with primal-dual schemes for flows with costs. We combine blocking flows, which are essentially maximal sets of augmenting paths, with the weight functions on edges via eligibility rules that dictate which edge in the residual graph can admit flow based on the current primal / dual solution. Invariants that follow from these eligibility rules then allow us to maintain approximate complementary slackness between the primal and dual solutions. In turn, these yield approximation guarantees.

Our eligibility rules are directly motivated by the scaling algorithms for approximate maximum matching [DP14], which is in turn based on scaling algorithms for maximum weighted matchings [GT89, GT91, Gab17]. However, the fact that augmenting paths can contain edges from different depth levels pose several challenges. Foremost is the issue that a very heavily weighted edge may cause flow to go through a lightly weighted edge. As a result, we need to find a way to work around the key idea from [DP14] of relating the weight of an edge to the first time a flow passes through it. We do so by using paths as the basic unit by which we analyze our flows, and analyzing the entire history of paths going through an edge (see Section 3.3 for details).

We will develop our algorithms first in the case where all weights on edges are linear, and then extend them to concave functions. These extensions are obtained by viewing each edge with non-linear cost functions as a collection of edges with differing weights and infinitesimal capacities, and then simulating a continuous version of our linear algorithm through blocking flows.

1.2 Related Works

As our results combine techniques applicable to a wide range of combinatorial problems, our results have similarities, but also differ, from many previous works. An incomplete list of them is in Figure 2. In order to save space, we use $\tilde{O}(f(n))$ to hide terms that are $polylog(f(n))$: this is a widely used convention for the more numerical variants of these objectives, and here mostly hides factors of $\log{n}$.

While the guarnatees of many of the algorithms listed here are stated for inputs with integer capacities / costs [GT89, GR98, LS14], their running times are equivalent to producing $1\pm\epsilon$-approximates with $\text{poly}(\log(\epsilon^{-1}))$ overhead in running time.

Our guarantees, which contain $\text{poly}(\epsilon^{-1})$ in the running time terms, closest resemble the approximation algorithms for weighted matchings [DP14, ZO15, AG14] and flows on small depth networks [Coh95]. These running times only outperform the routines with $\text{poly}(\log(\epsilon^{-1}))$ depdencies for mild ranges of $\epsilon$. In such cases, the solution can differ significantly point-wise from the optimum: for example, deleting $\epsilon$-fraction of a maximum cardinality matching still gives a solution that’s within $1\pm\epsilon$ of the optimum. As a result, the barriers towards producing exact solutions in strongly polynomial time [Hoc07] are circumvented by these assumptions, especially the bounds on the minimum and maximum gradients. These bounds are natural generalizations of the bounds on costs in scaling algorithms for flows with costs [GT89]. In some cases, they can also be removed via preprocessing steps that find $\text{poly}(n)$ crude approximations to the optimum, and trim edge weights via those values [CKM*+*11, DP14, Pen16]. In particular, if all the capacities are integers, we can increase the minimum weight, or gradient, in a way analogous to the matching algorithm from [DP14].

Lemma 1.2**.**

If all capacities are integers and the functions $f_{e}$ are non-negative and increasing, then we can assume

[TABLE]

or $\boldsymbol{\mathit{w}}_{\max}/\boldsymbol{\mathit{w}}_{\min}\leq O(\frac{m^{2}}{\epsilon}\cdot\sum_{e}\boldsymbol{\mathit{c}}_{e})$ without perturbing the objective by a factor of more than $1\pm\epsilon$.

Proof.

First, note that the assumption about integral capacities means that there exists a feasible flow that routes at least $1/m^{2}$ per edge, and such a flow, $\boldsymbol{\mathit{x}}^{\prime}$, can be produced using a single depth-first search in $O(m)$ time.

We will fix the gradients to create functions $\overline{f}$ whose gradients are all within $poly(m,\epsilon^{-1})$ of

[TABLE]

First, note that $OPT\geq\widehat{w}$ since the functions are non-negative. So we can add $\frac{\epsilon\widehat{w}}{\sum_{e}\boldsymbol{\mathit{c}}_{e}}$ to the gradient of all the functions without changing the optimum by more than $\epsilon\widehat{w}\leq\epsilon OPT$ additively. Formally the functions:

[TABLE]

with associated maximum $\overline{OPT}$ satisfies $OPT\leq\overline{OPT}\leq(1+\epsilon)OPT$.

To fix the maximum gradient, consider the truncated functions

[TABLE]

It can be checked that $\widehat{f}_{e}(x)\leq\overline{f}_{e}(x)$ at all points, and that the maximum gradient of $\widehat{f}_{e}(x)$ is bounded by

[TABLE]

So it remains to show that $\widehat{OPT}$, the maximum with the functions $\widehat{f}$ satisfies $\widehat{OPT}\geq(1-\epsilon)\overline{OPT}$. For this, consider the optimum solution to $\overline{OPT}$, $\overline{\boldsymbol{\mathit{x}}}$, the solution

[TABLE]

is feasible because it’s a linear combination of two feasible solutions, has objective at least $1-\epsilon$ times the objective of $\overline{\boldsymbol{\mathit{x}}}$ due to the concavity and monotonicity of $f$, and has flow at least $\epsilon/m^{2}$ per edge. The result then follows from observing that $\widehat{f}_{e}(x)=\overline{f}_{e}(x)$ for all $x\geq\epsilon/m^{2}$. ∎

Remark

By Lemma 1.2, if all capacities are integer, the running time of our result can be written as $\tilde{O}(Dm\epsilon^{-1}\log C)$, where $C$ is the largest capacity.

Our assumption on the topology of the graph follows the study of small depth networks from [Coh95], which used the depth of the network to bound the number of (parallel) steps required by augmenting path finding routines. From an optimization perspective, small depth is also natural because it represents the number of gradient steps required to pass information from $s$ to $t$. Gradient steps, in the absence of preconditioners, only pass information from a node to its neighbor, so diameter is kind of required for any purely gradient based methods The acyclicity requirement is a consequence of our adaptation of tools from approximating weighted matchings [DP14], and represent a major shortcoming of our result compared to exact algorithms for minimum cost flow [Orl93] and convex flows [Hoc07, Vég12]. However, as we will discuss in Appendix A, there are many applications of flows where the formulations naturally lead to small depth networks.

2 Simple Algorithm for Unit Capacities and Linear Weights

In this section, we propose a simple $(1-\epsilon)$ approximation algorithm for the case of $f_{e}(\cdot)$ being linear functions, and all capacities are unit. This assumption means we can write the cost functions as:

[TABLE]

for some $\boldsymbol{\mathit{w}}_{e}\geq 0$. Under these simplifications, the linear program (LP) that we are solving and its dual become:

[TABLE]

[TABLE]

We add a dummy directed edge from $t$ to $s$ with infinite capacity to ensure flow conservation at each vertex. For every edge $e$ we mention in the paper, we implicitly assume that $e=uv$ is an edge in the original network and $e\not=ts$, unless otherwise stated. The dual inequality involving $\boldsymbol{\mathit{y}}_{e}$ is equivalent to:

[TABLE]

The RHS is critical for our algorithm and its analysis. We will define it as the reduced weight of the edge, $\boldsymbol{\mathit{w}}_{e}^{\boldsymbol{\mathit{p}}}$:

[TABLE]

Note that the choice of $\boldsymbol{\mathit{w}}_{e}^{\boldsymbol{\mathit{p}}}$ uniquely determines the optimum choice of $\boldsymbol{\mathit{y}}_{e}$ through $\boldsymbol{\mathit{y}}_{e}\leftarrow\max\left(0,\boldsymbol{\mathit{w}}_{e}^{\boldsymbol{\mathit{p}}}\right)$.

To find an optimum flow on these networks it is sufficient to obtain feasible pairs $\boldsymbol{\mathit{x}}$ and $\boldsymbol{\mathit{p}},\boldsymbol{\mathit{y}}$ that satisfy the following complementary slackness conditions:

For all $e$, if $\boldsymbol{\mathit{x}}_{e}=0$, then $\boldsymbol{\mathit{y}}_{e}=0$, which is equivalent to $\boldsymbol{\mathit{w}}^{\boldsymbol{\mathit{p}}}_{e}\leq 0$. 2. 2.

For all $e$, if $\boldsymbol{\mathit{x}}_{e}=1$ then $\boldsymbol{\mathit{y}}_{e}=\boldsymbol{\mathit{w}}^{\boldsymbol{\mathit{p}}}_{e}$, which is equivalent to $\boldsymbol{\mathit{w}}^{\boldsymbol{\mathit{p}}}_{e}\geq 0$.

The role of these values of $\boldsymbol{\mathit{w}}_{e}^{\boldsymbol{\mathit{p}}}$ can be further illustrated by the following Lemma, which is widely used in scaling algorithms.

Lemma 2.1**.**

For any flow $\boldsymbol{\mathit{x}}$ for which the flow conservation is satisfied, and any potential $\boldsymbol{\mathit{p}}$ such that $\boldsymbol{\mathit{p}}_{t}=\boldsymbol{\mathit{p}}_{s}$, we have:

[TABLE]

Proof.

Expanding the summation gives

[TABLE]

Rearranging the last terms gives

[TABLE]

which we know is [math] for every $u\neq s,t$. We also have that the amount of flow leaving $s$ is same as the amount of flow entering $t$, and $\boldsymbol{\mathit{p}}_{s}=\boldsymbol{\mathit{p}}_{t}$ so the total contribution of these terms is [math]. ∎

Note that if $\boldsymbol{\mathit{p}}_{s}=0$ and $\boldsymbol{\mathit{w}}_{e}^{\boldsymbol{\mathit{p}}}$ is close to [math] for each $e$ in a path from $s$ to some $u$, the total reduced cost of the path is close to $\boldsymbol{\mathit{p}}_{u}$. This is the view taken by most primal-dual algorithms for approximate flows: conditions are imposed on valid paths in order to make $\boldsymbol{\mathit{p}}_{u}$s emulate max weight residual paths to the source. These routines then start with $\boldsymbol{\mathit{p}}_{t}$ set to very large, and maintaining a complementary primal/dual pair while gradually reducing $\boldsymbol{\mathit{p}}_{t}$. Shortest path algorithms such as the network simplex method and the Hungarian algorithm fall within this framework  [AMO93, Chapter 12]. Such algorithms produce exact answers, but may take $\Omega(n)$ steps to converge even in the unit weighted case due to very long augmenting paths.

The central idea in our algorithms is to regularize these complementary slackness conditions. Specifically, we relax the $\boldsymbol{\mathit{x}}_{e}=0$ case from $\boldsymbol{\mathit{w}}_{e}^{\boldsymbol{\mathit{p}}}\leq 0$ to $\boldsymbol{\mathit{w}}_{e}^{\boldsymbol{\mathit{p}}}\leq\delta$, for some $\delta$ which we eventually set to $\epsilon\boldsymbol{\mathit{w}}_{\min}$. We may assume that all the weights are integer multiples of $\delta$ since the additive rounding error of each weight $\boldsymbol{\mathit{w}}_{e}$ is at most $\epsilon\boldsymbol{\mathit{w}}_{e}$. We use a set of eligibility rules to define when we can send flows along edges, or whether an arc is eligible. The modified eligibility conditions are shown in Figure 3.

These rules leads our key construct, the eligible graph:

Definition 2.2**.**

Given a graph $G$ and a set of eligibility rules, the eligible graph consists of all eligible residual arcs with positive capacities, equaling to the amount of flow that can be routed on them. A vertex $v$ is an eligible vertex if there exists a path from $s$ to $v$ in the eligible graph.

The main idea behind working on this graph is that this approximate invariant can be maintained analogously to exact complementary slackness.

This leads to an instantiation of the algorithmic template from Figure 1. Its pseudocode is given in Figure 5.

The key property given by the introduction of $\delta$ is after sending $1$ unit of flow along a maximal collection of paths, $t$ is no longer reachable from $s$ in the eligible graph. We can show this from the observation that all edges in a path that we augment along become ineligible. For an eligible forward edge $uv$, $\boldsymbol{\mathit{x}}_{uv}=0$ and $\boldsymbol{\mathit{w}}_{uv}^{\boldsymbol{\mathit{p}}}=\delta$. Therefore, after augmentation, $\boldsymbol{\mathit{x}}_{uv}=1$ and $vu$ is ineligible. A similar argument can be applied for an eligible backward edge $vu$ to show that after augmentation the residual forward edge $uv$ is also ineligible.

This fact plays an important role in our faster convergence rate:

Lemma 2.3**.**

The running time of the algorithm given in Figure 5 is $O(D\boldsymbol{\mathit{w}}_{\max}m/\epsilon\boldsymbol{\mathit{w}}_{\min})$ where $D$ is the depth of the network.

Proof.

The algorithm starts with $\boldsymbol{\mathit{p}}_{t}=D\boldsymbol{\mathit{w}}_{max}$ and in each iteration, $\boldsymbol{\mathit{p}}_{t}$ is decreased by $\delta$. Therefore, the number of iterations is $D\boldsymbol{\mathit{w}}_{\max}/\delta$. Since in each iteration it takes $O(m)$ to find a maximal set of disjoint augmenting paths using depth-first search, the total running time is $O(D\boldsymbol{\mathit{w}}_{\max}m/\epsilon\boldsymbol{\mathit{w}}_{\min})$. ∎

We also need to check that our eligibility rules and augmentation steps indeed maintain the invariants throughout this algorithm.

Lemma 2.4**.**

Throughout the algorithm, the invariants from Figure 4 are maintained.

Proof.

It is easy to check that at the beginning of the algorithm, the invariants are satisfied. We will show by induction that dual adjustments and augmentations do not break them. Assume the two conditions hold before a dual adjustment step. Notice that a dual adjustment can only change reduced weights of edges that have exactly one eligible endpoint. For an edge $e=uv$, we consider 2 cases:

• •

$u$ is eligible, and $v$ is ineligible: a dual adjustment step decreases $\boldsymbol{\mathit{p}}_{v}$, and thus increases $\boldsymbol{\mathit{w}}^{\boldsymbol{\mathit{p}}}_{e}$. Condition (A1) still holds because the reduced weight increases. Condition (A2) still holds because reduced weight can only increase until it is equal to $\delta$ and both $u$ and $v$ are eligible.

• •

$v$ is eligible, and $u$ is ineligible: a dual adjustment step decreases $\boldsymbol{\mathit{p}}_{u}$, and thus decreases $\boldsymbol{\mathit{w}}^{\boldsymbol{\mathit{p}}}_{e}$. Condition (A1) still holds because the reduced weight can only decrease until it is equal to 0 and both $u$ and $v$ are eligible. Condition (A2) still holds because the reduced weight decreases.

Now assume that the two conditions hold before an augmentation step, and notice that we only send flow along eligible edges. For an edge $e$ with $\boldsymbol{\mathit{x}}_{e}=0$ before augmentation, the eligibility condition is $\boldsymbol{\mathit{w}}_{e}^{\boldsymbol{\mathit{p}}}=\delta$, thus after augmentation $\boldsymbol{\mathit{x}}_{e}=1$ and condition (A1) is satisfied. For an edge $e$ with $\boldsymbol{\mathit{x}}_{e}=1$ before augmentation, the eligibility condition is $\boldsymbol{\mathit{w}}_{e}^{\boldsymbol{\mathit{p}}}=0$, thus after augmentation $\boldsymbol{\mathit{x}}_{e}=0$ and condition (A2) is satisfied. ∎

It remains to bound the quality of the solution produced. Once again, the invariants from Figure 4 play crucial roles here.

Lemma 2.5**.**

If all the invariants and feasibility conditions hold when the algorithm terminates with $\boldsymbol{\mathit{p}}_{s}=\boldsymbol{\mathit{p}}_{t}$, then the solution produced, $\boldsymbol{\mathit{x}}$, is feasible and $(1-\epsilon)$-optimal.

Proof.

The flow $\boldsymbol{\mathit{x}}$ is feasible because in each augmentation step we only send one unit of flow along a path in the residual graph.

Let $\boldsymbol{\mathit{x}}^{*}$ be any other $st$ flow obeying the capacities. Our goal is to show that

[TABLE]

To do so, we first invoke Lemma 2.1, which allows us consider the weights $\boldsymbol{\mathit{w}}_{e}^{\boldsymbol{\mathit{p}}}$ instead. We invoke the invariants based on the two cases:

If $\boldsymbol{\mathit{x}}_{e}=1$, then $\boldsymbol{\mathit{x}}^{*}_{e}\leq\boldsymbol{\mathit{x}}_{e}$ since the edges are unit capacitated. The invariant also gives $\boldsymbol{\mathit{w}}_{e}^{\boldsymbol{\mathit{p}}}\geq 0$, which implies

[TABLE] 2. 2.

If $\boldsymbol{\mathit{x}}_{e}=0$, then $\boldsymbol{\mathit{w}}_{e}^{\boldsymbol{\mathit{p}}}\boldsymbol{\mathit{x}}_{e}=0$. The invariant gives $\boldsymbol{\mathit{w}}_{e}^{\boldsymbol{\mathit{p}}}\leq\delta$, which combined with $\boldsymbol{\mathit{x}}^{*}_{e}\geq 0$ gives:

[TABLE]

Furthermore, since $\delta\leq\epsilon\boldsymbol{\mathit{w}}_{e}$, this also implies

[TABLE]

Summing the implications of these invariants across all edges gives

[TABLE]

∎

3 Scaling Algorithm for Linear Weights

In this section, we show how to improve the running time of the algorithm in the previous section through scaling. The scaling algorithm makes more aggressive changes to vertex potentials $\boldsymbol{\mathit{p}}_{u}$ at the beginning, and moves to progressively smaller changes. To be more precise, the algorithm starts with $\delta_{0}=\epsilon\boldsymbol{\mathit{w}}_{max}$ and ends with $\delta_{T}=\epsilon\boldsymbol{\mathit{w}}_{min}$, and the value of $\delta$ is halved each scale. Assume $\epsilon$ and $\boldsymbol{\mathit{w}}_{\max}/\boldsymbol{\mathit{w}}_{\min}$ are powers of 2, this immediately implies

[TABLE]

The vertex potentials are also initialized in a similar way, i.e $\boldsymbol{\mathit{p}}_{u}=\boldsymbol{\mathit{w}}_{\max}\cdot l_{u}$ for all $u$. Scale $i>0$ starts with

[TABLE]

and ends when

[TABLE]

The change in step sizes leads to more delicate invariants. Instead of having a sharp cut-off at $\delta$ as in the single-scale routine, we further utilize $\delta_{i}$ to create a small separation between edges eligible in the forward and backward directions.

Between scales, we make adjustments to all potentials to maintain the invariants. Pseudocode of this routine is given in Figure 6.

The rest of this section is a more sophisticated analysis built upon Section 2 and the scaling algorithms from [DP14], leading to the following main claim:

Theorem 3.1**.**

For any $\epsilon<1/10$, ScalingFlow returns $\boldsymbol{\mathit{x}}$ that is an $(1-8\epsilon)$-approximation in $O\left({Dm\epsilon^{-1}}\log({\boldsymbol{\mathit{w}}_{max}}/{\boldsymbol{\mathit{w}}_{min}})\log n\right)$ time.

A main issue in setting up the invariants, as well as the overall proof, is that errors from the iterations accumulate. Here we need an additional definition about the last time forward flow as pushed on an edge.

Definition 3.2**.**

During the course of the algorithm, for each edge $e=uv$, define $scale(e)$ to be the the largest scale $j$ such that $j$ is at most $i$, the current scale, and there is a forward flow from $u$ to $v$ at scale $j$. Define $scale^{f}(e)$ to be the final value of $scale(e)$ when the algorithm terminates.

Note that $scale(e)$ resets to $i$ if $uv$ is used in the blocking flow generated on Line 2(a)ii at scale $i$. For simplicity, we use $\delta_{e}$ to denote $\delta_{scale({e})}$, $\delta^{f}_{e}$ to denote $\delta_{scale^{f}({e})}$, and $l_{e}$ to denote $l_{v}-l_{u}$. The key eligibility rules and invariants are in Figure 7.

The intricacies in Condition (B1) is closely related to the changes in the dual rescaling step from Line 2(b)i. In particular, Condition (B2), $\boldsymbol{\mathit{w}}_{e}^{\boldsymbol{\mathit{p}}}<2\delta_{i}$, may be violated if $\delta_{i}$ is halved. The dual rescaling on Line 2(b)i is in place precisely to fix this issue by lowering $\boldsymbol{\mathit{w}}_{e}^{\boldsymbol{\mathit{p}}}$. It on the other hand causes further problems for lower bounds on $\boldsymbol{\mathit{w}}_{e}^{\boldsymbol{\mathit{p}}}$, leading to modifications to Condition (B1) as well. We first verify that these modified invariants are preserved by the dual rescaling steps.

3.1 Dual Rescaling Steps

Lemma 3.3**.**

The dual rescaling step on Line 2(b)i of Figure 7 maintain invariants (B1) and (B2).

Proof.

We start with Condition (B2). If $\boldsymbol{\mathit{w}}_{e}^{\boldsymbol{\mathit{p}}}\leq 2\delta_{i}$, then if we pick $\boldsymbol{\mathit{p}}^{\prime}$ such that $\boldsymbol{\mathit{w}}_{e}^{\boldsymbol{\mathit{p}}^{\prime}}\leq\boldsymbol{\mathit{w}}_{e}^{\boldsymbol{\mathit{p}}}-\delta_{i}$, we get:

[TABLE]

This is done by updating vertex potential $\boldsymbol{\mathit{p}}_{u}\leftarrow\boldsymbol{\mathit{p}}_{u}+\delta_{i}l_{u}$ for each vertex $u$ at the end of scale $i$.

It remains to check that the condition

[TABLE]

does not break by decreasing $\boldsymbol{\mathit{p}}_{u}-\boldsymbol{\mathit{p}}_{v}$ by $l_{e}\delta_{i}$:

[TABLE]

where the last line follows because $l_{e}\geq 1$. ∎

3.2 Blocking Flows

Our algorithm also incorporates more general capacities $\boldsymbol{\mathit{c}}_{e}$. The changes caused by this in the linear programming formulations are:

In the primal, the capacity constraints become $0\leq\boldsymbol{\mathit{x}}_{e}\leq\boldsymbol{\mathit{c}}_{e}$, 2. 2.

the dual objective becomes $\sum_{e}\boldsymbol{\mathit{c}}_{e}\boldsymbol{\mathit{y}}_{e}$.

This extension can be incorporated naturally: instead of finding a maximal set of edge-disjoint augmenting paths, we find a blocking flow from $s$ to $t$. Blocking flows can also be viewed as maximal sets of paths when the edges are broken down into multi-edges of infinitesimal capacities. They can be found in $O(m\log{n})$ time using dynamic trees [ST83], and therefore offer similar levels of theoretical algorithmic efficiency.

In the unit capacity case, an augmentation along any path in the residual graph destroys all eligible edges in the path, and the asymmetry of the eligibility condition means the new reverse edges are also ineligible. However, when we move to general capacities, an augmentation may destroy just a single edge on the path. As a result, it’s simpler to work with the following equivalent definition of blocking flows.

Definition 3.4**.**

A blocking flow on a graph $G$ is a flow such that every path from $s$ to $t$ goes through a fully saturated edge.

We first verify that this definition also maintains all the invariants both after augmentation and dual adjustments. These proofs closely mirror those of Lemma 2.4.

Lemma 3.5**.**

An augmentation by a blocking flow in the eligible graph, as on Line 2(a)ii, maintains the invariant.

Proof.

The algorithm only sends flow through eligible edges. Consider an edge $uv$ on a blocking flow

If the augmentation sends flow from $u$ to $v$, then $uv$ is an eligible forward edge, and $\boldsymbol{\mathit{w}}_{uv}^{\boldsymbol{\mathit{p}}}\geq\delta_{i}$. After augmentation, condition (B1) must hold. 2. 2.

If the augmentation sends flow from $v$ to $u$, then $vu$ is an eligible backward edge, and $0\geq\boldsymbol{\mathit{w}}^{\boldsymbol{\mathit{p}}}_{uv}$. After augmentation, condition (B2) must hold.

Therefore, all edges on a blocking flow satisfy the set of reduced weight conditions after augmentation. ∎

Lemma 3.6**.**

A dual adjustment step, as specified on Line 2(b)i, maintains the invariant.

Proof.

Notice that a dual adjustment can only change the effective reduce weights of edges that have exactly one eligible endpoint. For an edge $e=uv$ in the graph, we consider 2 cases:

• •

$u$ is eligible, and $v$ is ineligible: a dual adjustment step decreases $\boldsymbol{\mathit{p}}_{v}$, and thus increases $\boldsymbol{\mathit{w}}^{\boldsymbol{\mathit{p}}}_{e}$.

• –

if $\boldsymbol{\mathit{x}}_{e}=\boldsymbol{\mathit{c}}_{e}$ then condition (B1) still holds because $\boldsymbol{\mathit{w}}^{\boldsymbol{\mathit{p}}}_{e}$ increases.

• –

if $\boldsymbol{\mathit{x}}_{e}<\boldsymbol{\mathit{c}}_{e}$ then we know that $uv$ is in the residual graph and ineligible. Since $uv$ is ineligible, $\boldsymbol{\mathit{w}}^{\boldsymbol{\mathit{p}}}_{e}$ must be less than $\delta_{i}$. Condition (B2) still holds because $\boldsymbol{\mathit{w}}^{\boldsymbol{\mathit{p}}}_{e}$ can only increase until it is at least $\delta_{i}$ and $e$ becomes eligible.

• •

$v$ is eligible, and $u$ is ineligible: a dual adjustment step decreases $\boldsymbol{\mathit{p}}_{u}$, and thus decreases $\boldsymbol{\mathit{w}}^{\boldsymbol{\mathit{p}}}_{e}$.

• –

if $\boldsymbol{\mathit{x}}_{e}>0$ then we know that $vu$ is in the residual graph and ineligible. Since $vu$ is ineligible, $\boldsymbol{\mathit{w}}^{\boldsymbol{\mathit{p}}}_{e}$ must be greater than [math]. Condition (B1) still holds because $\boldsymbol{\mathit{w}}^{\boldsymbol{\mathit{p}}}_{e}$ can only decrease until it is at most [math] and $vu$ becomes eligible.

• –

if $\boldsymbol{\mathit{x}}_{e}=0$ then condition (B2) still holds because $\boldsymbol{\mathit{w}}^{\boldsymbol{\mathit{p}}}_{e}$ decreases.

∎

Note that at the beginning of the algorithm, $\boldsymbol{\mathit{x}}_{e}=0$ and $\boldsymbol{\mathit{w}}_{e}^{\boldsymbol{\mathit{p}}}=\boldsymbol{\mathit{w}}_{e}-l_{e}\boldsymbol{\mathit{w}}_{\max}\leq 0$ for each edge $e$. Therefore, the invariants (B2) holds. Induction then gives that these invariants hold throughout the course of the algorithm.

3.3 Bounding Weights of Paths

We can now turn our attention to the approximation factor. The main difficulty in this proof is due to cancellations of flows pushed at previous scales. Our proof relies on performing a path decomposition on each blocking flow in the history of the final solution $\boldsymbol{\mathit{x}}$. We will view the final flow, $\boldsymbol{\mathit{x}}$, as a sum of flows from the collection $\mathcal{P}$.

[TABLE]

Note here that $\boldsymbol{\mathit{x}}_{P}$ is a quantity that specifies the amount of flow on that path. We also define $F_{P}$ to be the set of edges going forward on $P$, and $B_{P}$ to be the set of edges going backward on $P$. We use this decomposition to map backward flow to forward flow in an earlier scale. We will also use $scale({P})$ to denote the scale at which $P$ was pushed, and $\delta_{P}$ to denote $\delta_{scale(P)}$.

Note that we will likely push flows on an edge in forward and backward directions many times throughout the course of the algorithm. Each of these instances belong to a different path, and is taken care of separately in the summation. We first establish a lower bound on the weight of each path using the eligibility criteria: we show that the weight of the path routed at phase $i$ can be lower bounded by terms involving $\delta_{i}$, the step size at that phase.

Lemma 3.7**.**

[TABLE]

Proof.

Let $\boldsymbol{\mathit{p}}$ be the vertex potentials from when flow was pushed along $P$. Note that $\boldsymbol{\mathit{p}}$ may not be the final potentials. By the definition of $\boldsymbol{\mathit{w}}_{e}^{\boldsymbol{\mathit{p}}}$, we have

[TABLE]

For the edges on the path, the eligibility rules give

• •

$\boldsymbol{\mathit{w}}^{\boldsymbol{\mathit{p}}}_{e}\geq\delta_{P}\geq 0$ if $e\in F_{P}$, and

• •

$-\boldsymbol{\mathit{w}}^{\boldsymbol{\mathit{p}}}_{e}\geq 0$ if $e\in B_{P}$.

Furthermore, our outer loop condition on Line 2a ensures that at scale $i$, $\boldsymbol{\mathit{p}}_{t}$ is at least $D\boldsymbol{\mathit{w}}_{max}/2^{i+1}=D\delta_{i}/2\epsilon$, while $\boldsymbol{\mathit{p}}_{s}$ is always [math]. Therefore the total is at least $D\delta_{i}/2\epsilon$. ∎

This allows us to map the final inaccuracies of weights caused by the Condition (B2) of the invariants to $\epsilon$ of the total weights. The following proof hinges on path decompositions

Lemma 3.8**.**

Let $\boldsymbol{\mathit{x}}$ be the final answer. Then we have

[TABLE]

Proof.

Let $\boldsymbol{\mathit{x}}_{P}$ be the amount of flow sent through $P.$ The definition of $\boldsymbol{\mathit{x}}$ and summation of flows gives

[TABLE]

reversing the ordering of summation, and aggregating per edge gives:

[TABLE]

For each edge $e$,

[TABLE]

Consider the set of paths $P_{1},\ldots P_{k}$ sending flow on edge $e$ (in both directions) in the order of index $i$ for $i=1\ldots k$. Whenever a flow is sent from $v$ to $u$ (a backward direction), there must be some existing flow from $u$ to $v$. By breaking a path into multiple paths carrying smaller amounts of flow, we may assume that for each $P_{i}$ such that $e\in B_{P_{i}}$, there exists $P_{j}$ such that $j<i$, $e\in F_{P_{j}}$ and $\boldsymbol{\mathit{x}}_{P_{i}}=\boldsymbol{\mathit{x}}_{P_{j}}$. We define a function that maps $i$ to $j$. Since $j<i$, we must have $\delta_{P_{j}}\geq\delta_{P_{i}}$. It follows that

[TABLE]

We apply the following modifications to the RHS of equation (1). For each pair $(i,j)$ such that $i$ is mapped to $j$, we increase the multiplication factor of $\boldsymbol{\mathit{x}}_{P_{i}}$ from $\delta^{f}_{e}$ to $\delta_{P_{i}}$ and the multiplication factor of $\boldsymbol{\mathit{x}}_{P_{j}}$ from $\delta^{f}_{e}$ to $\delta_{P_{j}}$. Finally, for the remaining forward flows that are not canceled, we increase $\delta^{f}_{e}$ to the value $\delta_{P}$ of the path containing them. Such modifications can only increase the value of the RHS of (1). Therefore, for each edge $e$,

[TABLE]

Plugging back to the summation, we have

[TABLE]

Changing the order of summation and notice that for each path $P$

[TABLE]

which by Lemma 3.7 is bounded by $2\epsilon\left(\sum_{e\in F_{P}}\boldsymbol{\mathit{w}}_{e}-\sum_{e\in B_{P}}\boldsymbol{\mathit{w}}_{e}\right)$. Summing over all paths $P\in\mathcal{P}$ then gives the result. ∎

3.4 Putting Things Together

It remains to put these together through the use of reduced costs in a way analogous to Lemma 2.5.

Proof.

(of Theorem 3.1) The number of iterations in each scale is ${D}/{2\epsilon}+2D=O(D/{\epsilon})$. The number of scales is $\log({\boldsymbol{\mathit{w}}_{max}}/{\boldsymbol{\mathit{w}}_{min}})$. Each iteration takes $O(m\log n)$ to find a blocking flow. Therefore, the total running time is $O\left(({Dm\log n}/{\epsilon})\log({\boldsymbol{\mathit{w}}_{max}}/{\boldsymbol{\mathit{w}}_{min}})\right)$.

For the approximation guarantees, consider any optimal flow $\boldsymbol{\mathit{x}}^{*}$. Let $\boldsymbol{\mathit{p}}$ denote the final potentials. Once again, Lemma 2.1 gives $\sum_{e}\boldsymbol{\mathit{w}}_{e}^{\boldsymbol{\mathit{p}}}\boldsymbol{\mathit{x}}_{e}=\sum_{e}\boldsymbol{\mathit{w}}_{e}\boldsymbol{\mathit{x}}_{e}$ and $\sum_{e}\boldsymbol{\mathit{w}}_{e}^{\boldsymbol{\mathit{p}}}\boldsymbol{\mathit{x}}^{*}_{e}=\sum_{e}\boldsymbol{\mathit{w}}_{e}\boldsymbol{\mathit{x}}^{*}_{e}$.

We will incorporate the invariants from Figure 7 through two cases:

If $\boldsymbol{\mathit{x}}_{e}<\boldsymbol{\mathit{x}}^{*}_{e}$, then $\boldsymbol{\mathit{x}}_{e}<\boldsymbol{\mathit{c}}_{e}$, and the invariant gives $\boldsymbol{\mathit{w}}_{e}^{\boldsymbol{\mathit{p}}}\leq 2\delta_{T}$, which implies

[TABLE]

Since $\delta_{T}=\epsilon\boldsymbol{\mathit{w}}_{\min}\leq\boldsymbol{\mathit{w}}_{e}$, this implies

[TABLE] 2. 2.

If $\boldsymbol{\mathit{x}}_{e}>\boldsymbol{\mathit{x}}^{*}_{e}$, then $\boldsymbol{\mathit{x}}_{e}>0$, and the invariant gives

[TABLE]

which combined with $\boldsymbol{\mathit{x}}^{*}_{e}\leq\boldsymbol{\mathit{x}}_{e}$ gives:

[TABLE]

Combining these gives

[TABLE]

and the result then follows from Lemma 3.8.

∎

4 Non-Linear Networks

We now move to the non-linear setting with arbitrary capacities. The primal objective becomes:

[TABLE]

Here we will let $\boldsymbol{\mathit{w}}_{e}(\boldsymbol{\mathit{x}}_{e})$ denote the weight of $e$ when $\boldsymbol{\mathit{x}}_{e}$ units are on it, i.e.,

[TABLE]

Since $f_{e}(\cdot)$ is concave, we know that $\boldsymbol{\mathit{w}}_{e}(\boldsymbol{\mathit{x}}_{e})$ is monotonically decreasing. Pseudocode of our algorithm is in Figure 8, and its eligibility rules are in Figure 9. Note that the eligibility rules in the pseudocode is a shorter version of the one in Figure 9.

We remark that the cost of finding $L_{e}$ and $U_{e}$, the maximum amount the flow can increase/decrease before the gradient of $f_{e}(\boldsymbol{\mathit{x}}_{e})$ changes by $\Delta$, depends on the structures of $f_{e}(\cdot)$. In case of simple functions such as quadratics, they can be calculated in closed form. For more complex functions, finding these points can be viewed as analogs of line searches [BV04].

Conceptually, we divide each edge $uv$ into multiple imaginary parallel edges between $u$ and $v$, each with a linear weight function. This can be viewed as approximating $\boldsymbol{\mathit{w}}_{e}(\boldsymbol{\mathit{x}}_{e})$ by a decreasing step function. To be precise, for each edge $e$, we break it into $k$ parallel edges $e_{1},\ldots,e_{k}$ such that:

$\boldsymbol{\mathit{w}}_{e_{1}}=\lfloor\boldsymbol{\mathit{w}}_{e}(0)/\delta_{T}\rfloor\delta_{T}$, $\boldsymbol{\mathit{w}}_{e_{k}}=\lfloor\boldsymbol{\mathit{w}}_{e}(\boldsymbol{\mathit{c}}_{e})/\delta_{T}\rfloor\delta_{T}$ and $\boldsymbol{\mathit{w}}_{e_{i}}=\boldsymbol{\mathit{w}}_{e_{i-1}}-\delta_{T}$ for all $1<i<k$. 2. 2.

$\boldsymbol{\mathit{c}}_{e_{i}}=\boldsymbol{\mathit{x}}_{i}-\boldsymbol{\mathit{x}}_{i-1}$ where $\boldsymbol{\mathit{x}}_{i}$s are such that $\boldsymbol{\mathit{x}}_{0}=0$, $\boldsymbol{\mathit{x}}_{k}=\boldsymbol{\mathit{c}}_{e}$ and $\boldsymbol{\mathit{w}}_{e}(\boldsymbol{\mathit{x}}_{i})=\boldsymbol{\mathit{w}}_{e_{i}}$ for all $0<i<k$.

Let $G=(V,E)$ be the original network, and $\overline{G}=(V,\overline{E})$ be the network with multiedges. We say that a flow $\overline{\boldsymbol{\mathit{x}}}$ in $\overline{G}$ is well-ordered if the following condition holds for every $e$:

[TABLE]

A flow $\overline{\boldsymbol{\mathit{x}}}$ in $\overline{G}$ is equivalent with a flow $\boldsymbol{\mathit{x}}$ in $G$ if:

[TABLE]

Notice that the well-ordered property ensures that there is a unique reverse mapping from $\boldsymbol{\mathit{x}}_{e}$ to $\boldsymbol{\mathit{x}}_{e_{1}}\ldots\boldsymbol{\mathit{x}}_{e_{k}}$ as well.

Lemma 4.1**.**

Let $(\boldsymbol{\mathit{x}},\boldsymbol{\mathit{p}})$ be a flow-potential pair at some point in the course of ConcaveFlow on input $G$. ScalingFlow on input $\overline{G}$ can maintain a flow-potential pair $(\overline{\boldsymbol{\mathit{x}}},\boldsymbol{\mathit{p}})$ such that:

$\overline{\boldsymbol{\mathit{x}}}$* is well-ordered.* 2. 2.

$\overline{\boldsymbol{\mathit{x}}}$* and $\boldsymbol{\mathit{x}}$ are equivalent.*

Proof.

It suffices to prove that the above claim holds in an Eligibility Labeling and an Augmentation step.

Consider an edge $uv$ that is eligible in forward direction in ConcaveFlow algorithm. Since $\overline{\boldsymbol{\mathit{x}}}$ is well-ordered and equivalent to $\boldsymbol{\mathit{x}}$, there are some eligible multiedges between $u$ and $v$ in ScalingFlow. Moreover, the first condition in Figure 9 guarantees that the amount of flow allowed on $uv$ is equal to sum of capacities of all eligible parallel edges from $u$ to $v$ in the multiedges setting. This follows because

The value of $\boldsymbol{\mathit{w}}_{e}(\boldsymbol{\mathit{x}}_{e}+\Delta)$ such that $\boldsymbol{\mathit{w}}^{\boldsymbol{\mathit{p}}}_{e}(\boldsymbol{\mathit{x}}_{e}+\Delta)=\delta_{i}$ is a multiple of $\delta_{i}$, since $\boldsymbol{\mathit{p}}_{u}$ and $\boldsymbol{\mathit{p}}_{v}$ are also multiples of $\delta_{i}$ assuming $\epsilon$ is a power of 2. 2. 2.

A weight of each edge in $\overline{G}$ is a multiple of $\delta_{T}$ by construction.

A similar argument can be applied to the backward eligibility case. Specifically, the amount of flow that can be pushed back on $uv$ in ConcaveFlow is equal to sum of capacities of all eligible multiedges from $v$ to $u$ in ScalingFlow.

It follows that a blocking flow in the eligible graph in ConcaveFlow is also a blocking flow in the eligible graph in ScalingFlow. Given a blocking flow $\boldsymbol{\mathit{z}}$ in the single-edge setting, we can distribute $\boldsymbol{\mathit{z}}_{uv}$ among eligible multiedges between $u$ and $v$ such that the resulting flow $\overline{\boldsymbol{\mathit{x}}}$ in ScalingFlow is still well-order, and still equivalent to the resulting flow $\boldsymbol{\mathit{x}}$ in ConcaveFlow. ∎

This mapping then allows us to bound the result of the continuous process, leading to our main result.

Proof.

(Of Theorem 1.1)

Let $\boldsymbol{\mathit{x}}^{*}$ be the optimal solution in the concave flow problem in $G$, and $\boldsymbol{\mathit{x}}$ be the final solution returned by ConcaveFlow. Let $\overline{\boldsymbol{\mathit{x}}}^{*}$ be a solution in $\overline{G}$ such that $\overline{\boldsymbol{\mathit{x}}}^{*}$ is well-ordered and equivalent to $\boldsymbol{\mathit{x}}^{*}$. By Lemma 4.1, ScalingFlow on input $\overline{G}$ can produce a solution $\overline{\boldsymbol{\mathit{x}}}$ in such that $\overline{\boldsymbol{\mathit{x}}}$ is well-ordered and equivalent to $\boldsymbol{\mathit{x}}$. At the end of the algorithm, the invariant in Section 3 must hold for the solution $\overline{\boldsymbol{\mathit{x}}}$. By Theorem 3.1,

[TABLE]

Since $\boldsymbol{\mathit{x}}$ is equivalent to $\overline{\boldsymbol{\mathit{x}}}$ and the step function defined by $\left\{\boldsymbol{\mathit{w}}_{e_{i}},\boldsymbol{\mathit{c}}_{e_{i}}\right\}$ is always below the function $\boldsymbol{\mathit{w}}_{e}$,

[TABLE]

Notice that the step function defined by $\left\{\boldsymbol{\mathit{w}}_{e_{i}}+\delta_{T},\boldsymbol{\mathit{c}}_{e_{i}}\right\}$, however, is always above the function $\boldsymbol{\mathit{w}}_{e}$. Since $\boldsymbol{\mathit{x}}^{*}$ is equivalent to $\overline{\boldsymbol{\mathit{x}}}^{*}$,

[TABLE]

Since $\delta_{T}=\epsilon\boldsymbol{\mathit{w}}_{\min}\leq\epsilon\boldsymbol{\mathit{w}}_{e}$ for all $e\in\overline{G}$, we have $\boldsymbol{\mathit{w}}_{e}+\delta_{T}\leq\boldsymbol{\mathit{w}}_{e}(1+\epsilon)$. It follows that

[TABLE]

Putting everything together,

[TABLE]

Finally, by applying a similar argument as in Theorem 3.1, it is easy to see that the running time of ConcaveFlow is $O\left({Dm}\epsilon^{-1}\log({\boldsymbol{\mathit{w}}_{max}}/{\boldsymbol{\mathit{w}}_{min}})\log n\right)$. ∎

5 Discussion

We extended the Duan-Pettie framework for approximating weighted matchings [DP14] to flows on small depth networks [Coh95]. Our approach can be viewed as viewing the length of augmenting paths as a regularizing parameter on the weights of augmenting paths. For general concave weight functions, the routine can also be viewed as a dynamical system that adjusts flows based on the gradient of the current weight functions [BMV12, BBD*+*13, SV16]. Also, we believe our approach can be parallelized, and extends to non-bipartite graphs: here the challenge is mostly with finding an approximate extension of blocking flow routines.

Another related application with small depth networks is finding high density subgraphs in networks [GT15, MPP*+*15, BHNT15]. These problems can be solved using parameteric maximum flows or binary searching over maximum flows [Gol84]. In both of these cases, the networks have constant depth, but the reductions also change the notions of approximation. Weights represents an additional tool in such routines, and we plan to further investigate its applications.

Appendix A Applications

We now outline some concrete applications of our formulation on small depth networks: many of them are discussed in more details in the survey by Ahuja et al. [AMOR95].

A.1 Assignment Problems

Our techniques are directly motivated by those developed for approximate max weight matchings [DP14]. This problem, when phrased as the assignment problem, has applications in matching objects across snapshots as well as direct uses in assignment indicated by its name. Names of some of these applications, as enumerated in Application 16-18 of  [AMOR95], include locating objects in space, matching moving objects, and rewiring typewriters.

The problem of finding matchings in large scale graphs has received much attention in experimental algorithm design [LMSV11, MAG*+*13, KMVV15]. These instances often involve capacities on both sides, as well as edges in between. They are related to $b$-matchings, and have been studied as generalized matchings. Previous works that incorporated concave costs include:

• •

[VVS10] studied Adwords matching using concave objective functions, and showed several stability and robustness properties of these formulations.

• •

[TTL*+*12] utilized concave networks to perform assignments of experts to queries with additional constraints on groups of experts as well as queries. This leads to a depth $4$ network with $3$ layers corresponding to node groups respectively.

• •

[DJ12] considered a generalization of the well-known Adwords problem, which asks for maximizing the sum of budgeted linear functions of agents. In the generalization, the utility of each agents is a concave function (of her choice) of her total allocation. The objective is to maximize the sum of budgeted utilities, and an optimal online algorithm is given for this generalization.

Another instance of concave cost matching is matrix balancing (Application 28 in [AMOR95]): given a fractional matrix, we would like to find a matrix with a specified row /column sum while minimizing distance under some norm. Here a bipartite network can be constructed by turning the rows into left vertices, columns into right vertices. The concave functions can then go onto the edges as costs.

Our algorithm is able to handle such generalizations, and lead to bounds similar to those from recent improvements to positive packing linear programs [ZO15].

Generalizations of matching and assignment lead naturally to small depth networks. One such generalization is 3-Dimensional matching which is NP-hard [Kar72]. Here the generalization of edges is $3$-tuples of the form $(x,y,z)$, with one element each from sets $X$, $Y$, and $Z$, and 3-dimensional matching asks for the maximum weighted set of tuples that uses each element in $X$, $Y$, and $Z$ at most once.

A restriction of this problem on the other hand is in $P$: the set of acceptable tuples are given by pairs of edges between $XY$ and $YZ$. Specifically, a tuple $(x,y,z)$ can be used iff $xy\in E_{XY}$ and $yz\in E_{YZ}$, and its cost is given by the sum of the two edges. This version can be solved by maximum cost flow on a depth $5$ network:

• •

For each element $x,y$ or $z$, create an in and out vertex, connected by an edge with unit capacity.

• •

Connect $X_{out}$ to $Y_{in}$ and $Y_{out}$ to $Z_{in}$ with edges corresponding to $E_{XY}$ and $E_{YZ}$.

• •

Connect $s$ to $X_{in}$ and $Z_{out}$ to $t$.

A.2 Mincost Flow

Minimum cost flow asks to minimize the cost instead of maximizing it. This is perhaps the most well-known formulation of our problem. However, it doesn’t tolerate approximations very well: if we stay with non-negative costs, we need to specify the amount of flow. If this is done exactly, it becomes flow feasiblity on a small depth network. There are known reductions of directed maximum flows to this instance (e.g. [Mad13], Section 3).

One way to limit the total amount of flow is to associate a reward with each unit sent from $s$ to $t$. Specifically, let $\boldsymbol{\mathit{q}}_{e}>0$ be the cost of one unit of flow on $e$, and $Q>0$ be the reward of one unit sent from $s$ to $t$, the objective function is

[TABLE]

where $f$ is the total amount of flow from $s$ to $t$. In this case, negating the cost brings us back to the maximum weight flow problem. The approximation factor on the other hand becomes additive:

Lemma A.1**.**

Let $(\boldsymbol{\mathit{x}}^{*},f^{*})$ be the optimal solution to the above mincost flow problem, The algorithm ScalingFlow in Section 3 gives a solution $(\boldsymbol{\mathit{x}},f)$ such that:

[TABLE]

A proof of Lemma A.1 can be found in Appendix B. Applications of minimum cost flows that lead to small depth networks include:

• •

Job scheduling, or optimal loading of a hopping airplane (application 13 from [AMOR95]): When phrased as scheduling, this can be viewed as completing a maximum set of jobs each taking place between days $[s_{i},t_{i}]$ and giving gain $c_{i}$ so that at no point more than $u_{i}$ jobs are being done simultaneously on day $i$.

This can be solved with a maximum cost flow whose depth is the number of days:

• –

The days become a path, with capacity $u_{i}$,

• –

For each job, create a node (connected to source with capacity $1$) with two edges, one with cost [math] to $t_{i}$, and one with cost $c_{i}$ to $s_{i}$.

• –

Each node on the path has an edge to sink, $t$, with capacity equalling the number of jobs ending that day.

This leads to a network whose depth is the number of days, or number of stops. Both of these quantities are small in real instances.

• •

Balancing of schools (Application 15 from [AMOR95]): the goal is to assign students from varying backgrounds to schools, belong to several districts, so that each school as well as each district has students with balanced backgrounds. Furthermore, the cost corresponds to the distance the student needs to travel to the schools. This leads to a depth $3$ network where the layers are the students, schools, and districts respectively.

Finally, we believe several applications can benefit from the incorporation of non-linear weight functions. As an instance, we can solve the following problem using our framework: Let $G$ be a network with $k$ sources, $\{s_{i},1\leq i\leq k\}$, and a sink, $t$, and let $f_{i}$ be a concave function for each $1\leq i\leq k$. We wish to maximize $\sum_{i}{f_{i}(F_{i})}$, where $F_{i}$ is the amount of flow sent from $s_{i}$ to $t$.

Appendix B Negative Weight Functions

We consider the case where our network can have negative weights. For simplicity, we only study linear weight functions. The analysis, however, can be extended to the case of concave function as in Section 4. Here, we assume that the absolute values of the weights are bounded:

[TABLE]

Lemma B.1**.**

Let $\boldsymbol{\mathit{x}}$ be a solution returned by ScalingFlow, and let $\boldsymbol{\mathit{x}}^{*}$ be the optimal solution

[TABLE]

Proof.

A key observation is that the Lemmas 3.7 and 3.8 are robust under negative weights. Using an argument similar to as in Theorem 3.1, we have:

If $\boldsymbol{\mathit{x}}_{e}<\boldsymbol{\mathit{x}}^{*}_{e}$, then $\boldsymbol{\mathit{x}}_{e}<\boldsymbol{\mathit{c}}_{e}$, and the invariant gives $\boldsymbol{\mathit{w}}_{e}^{\boldsymbol{\mathit{p}}}\leq 2\delta_{T}$, which implies

[TABLE]

Since $\delta(T)\leq\epsilon\boldsymbol{\mathit{w}}_{\min}\leq\epsilon|\boldsymbol{\mathit{w}}_{e}|$ for all $e$, we consider 2 cases:

[TABLE] 2. 2.

If $\boldsymbol{\mathit{x}}_{e}>\boldsymbol{\mathit{x}}^{*}_{e}$, then $\boldsymbol{\mathit{x}}_{e}>0$, and the invariant gives $\boldsymbol{\mathit{w}}_{e}^{\boldsymbol{\mathit{p}}}\geq-3l_{e}\delta_{e}^{f}$, which combined with $\boldsymbol{\mathit{x}}^{*}_{e}\leq\boldsymbol{\mathit{x}}_{e}$ gives:

[TABLE]

Combining these then gives

[TABLE]

and the result then follows from Lemma 3.8.

∎

Proof.

(Of Lemma A.1) Let $\boldsymbol{\mathit{w}}_{e}=-\boldsymbol{\mathit{q}}_{e}$ for every $e$, and add a directed edge from $t$ to a dummy vertex $t^{\prime}$ with $\boldsymbol{\mathit{w}}_{tt^{\prime}}=Q$. By Lemma B.1, a solution returned by ScalingFlow on that instance has the following guarantee:

[TABLE]

Negating both sides gives

[TABLE]

∎