The Inapproximability of Maximum Single-Sink Unsplittable, Priority and Confluent Flow Problems

We consider single-sink network flow problems. An instance consists of a capacitated graph (directed or undirected), a sink node $t$ and a set of demands that we want to send to the sink. Here demand $i$ is located at a node $s_i$ and requests an amount $d_i$ of flow capacity in order to route successfully. Two standard objectives are to maximise (i) the number of demands (cardinality) and (ii) the total demand (throughput) that can be routed subject to the capacity constraints. Furthermore, we examine these maximisation problems for three specialised types of network flow: unsplittable, confluent and priority flows. In the {\em unsplittable flow} problem (UFP), we have edge capacities, and the demand for $s_i$ must be routed on a single path. In the {\em confluent flow} problem, we have node capacities, and the final flow must induce a tree. Both of these problems have been studied extensively, primarily in the single-sink setting. However, most of this work imposed the {\em no-bottleneck assumption} (that the maximum demand $d_{max}$ is at most the minimum capacity $u_{min}$). Given the no-bottleneck assumption (NBA), there is a factor $4.43$-approximation algorithm due to Dinitz et al. for the unsplittable flow problem. Under the stronger assumption of uniform capacities, there is a factor $3$-approximation algorithm due to Chen et al. for the confluent flow problem. However, unlike the UFP, we show that a constant factor approximation algorithm cannot be obtained for the single-sink confluent flows even {\bf with} the NBA. Without NBA, we show that maximum cardinality single-sink UFP is hard to approximate to within a factor $n^{.5-\epsilon}$ even when all demands lie in a small interval $[1,1+\Delta]$ where $\Delta>0$ (but has polynomial input size). This is very sharp since when $\Delta=0$, this becomes a maximum flow problem.


Introduction
In this paper we improve known lower bounds (and upper bounds) on the approximability of the maximization versions of the single-sink unsplittable flow, single-sink priority flow and single-sink confluent flow problems. In the single-sink network flow problem, we are given a directed or undirected graph G = (V, E) with n nodes and m edges that has edge capacities u(e) or node capacities u(v). There are a collection of demands that have to be routed to a unique destination sink node t. Each demand i is located at a source node s i (multiple demands could share the same source) and requests an amount d i of flow capacity in order to route. We will primarily focus on the following two well-known versions of the single-sink network flow problem: • Unsplittable Flow: Each demand i must be sent along a unique path P i from s i to t i .
• Confluent Flow: Any two demands that meet at a node must then traverse identical paths to the sink. In particular, at most one edge out of each node v is allowed to carry flow. Consequently, the support of the flow is a tree in the undirected graphs, and an arborescence rooted at t in directed graphs.
Confluent flows were introduced to study the effects of next-hop routing [11]. In that application, routers are capacitated and, consequently, nodes in the confluent flow problem are assumed to have capacities but not edges. In contrast, in the unsplittable flow problem it is the edges that are assumed to be capacitated. We follow these conventions in this paper. In addition, we will also examine a third network flow problem called Priority Flow (defined in Section 1.2).
In the literature, subject to network capacities, there are two standard maximization objectives: • Cardinality: Maximize the total number of demands routed.
• Throughput: Maximize satisfied demand, that is, the total flow carried by the routed demands.
These objectives can be viewed as special cases of the profit-maximimisation flow problem. There each demand i has a profit π i in addition to its demand d i . The goal is to route a subset of the demands of maximum total profit. The cardinality model then corresponds to the unit-profit case, w i = 1 for every demand i; the throughput model is the case π i = d i . Clearly the lower bounds we will present also apply to the more general profit-maximisation problem.

Previous Work
The unsplittable flow problem has been extensively studied since its introduction by Cosares and Saniee [15] and Kleinberg [21]. However, most positive results have relied upon the nobottleneck assumption (nba) where the maximum demand is at most the minimum capacity, that is, d max ≤ u min . Given the no-bottleneck assumption, the best known result is a factor 4.43approximation algorithm due to Dinitz, Garg and Goemans [16] for the maximum throughput objective.
The confluent flow problem was first examined by Chen, Rajaraman and Sundaram [11]. There, and in variants of the problem [10,17,26], the focus was on uncapacitated graphs. 1 The current best result for maximum confluent flow is a factor 3-approximation algorithm for maximum throughput in uncapacitated networks [10].
Observe that uncapacitated networks (i.e. graphs with uniform capacities) trivially also satisfy the no-bottleneck assumption. Much less is known about networks where the no-bottleneck assumption does not hold. This is reflected by the dearth of progress for the case of multiflows (that is, multiple sink) without the nba. It is known that a constant factor approximation algorithm exists for the case in which G is a path [5], and that a poly-logarithmic approximation algorithm exists for the case in which G is a tree [7]. The extreme difficulty of the unsplittable flow problem is suggested by the following result of Azar and Regev [3]. This is the first (and only) super-constant lower bound for the maximum single-sink unsplittable flow problem.

Our Results
The main focus of this paper is on single-sink flow problems where the no-bottleneck assumption does not hold. It turns out that the hardness of approximation bounds are quite severe even in the (often more tractable) single-sink setting. In some cases they match the worst case bounds for PIPs (general packing integer programs). In particular, we strengthen Theorem 1.1 in four ways. First, as noted by Azar and Regev, the proof of their result relies critically on having directed graphs. We prove it holds for undirected graphs, even planar undirected graphs. Second, we show the result also applies to the confluent flow problem. Theorem 1.2 If P = N P then, for any > 0, there is no O(m 1− )-approximation algorithm for the cardinality objective of the single-sink unsplittable and confluent flow problems in undirected graphs. Moreover for unsplittable flows, the lower bound holds even when we restrict to planar inputs.
Third, Theorems 1.1 and 1.2 rely upon the use of exponentially large demands -we call this the large demand regime. A second demand scenario that has received attention in the literature is the polynomial demand regime -this regime is studied in [20], basically to the exclusion of the large demand regime. We show that strong hardness results apply in the polynomial demand regime; in fact, they apply to the small demand regime where the demand spread dmax d min = 1 + ∆, for some "small" ∆ > 0. (Note that d min ≤ u min and so the demand spread of an instance is at least the bottleneck value dmax u min .) Fourth, by considering the case where ∆ > 0 is arbitrarily small we obtain similar hardness results for the throughput objective for the single-sink unsplittable and confluent flow problems. Formally, we show the following m 1 2 − -inapproximability result. We note however that the hard instances have a linear number of edges (so one may prefer to call this an n 1 2 − -inapproximability result). Theorem 1.3 Neither cardinality nor throughput can be approximated to within a factor of O(m 1 2 − ), for any > 0, in the single-sink unsplittable and confluent flow problems. This holds for undirected and directed graphs even when instances are restricted to have demand spread dmax d min = 1 + ∆, where ∆ > 0 is arbitrarily small. Again for the unsplittable flow problem this hardness result applies even in planar graphs. Theorems 1.2 and 1.3 are the first super-constant hardness for any undirected version of the single-sink unsplittable flow problem, and any directed version with small-demands. We also remark that the extension to the small-demand regime is significant as suggested by the sharpness of the result. Specifically, suppose ∆ = 0 and, thus, the demand spread is one. We may then scale to assume that d max = d min = 1. Furthermore, we may then round down all capacities to the nearest integer as any fractional capacity cannot be used. But then the single-sink unsplittable flow problem can be solved easily in polynomial time by a max-flow algorithm!
To clarify the what is happening in the change from ∆ > 0 to ∆ = 0, we introduce and examine an intermediary problem, the maximum priority flow problem. Here, we have a graph G = (V, E) with a sink node t, and demands from nodes s i to t. These demand are unitdemands, and thus ∆ = 0. However, a demand may not traverse every edge. Specifically, we have a partition of E into priority classes E i . Each demand also has a priority, and a demand of priority i may only use edges of priority i or better (i.e., edges in E 1 ∪E 2 ∪. . . E i ). The goal is to find a maximum routable subset of the demands. Observe that, for this unit-demand problem, the throughput and cardinality objectives are identical. Whilst various priority network design problems have been considered in the literature (cf. [6,13]), we are not aware of existing results on maximum priority flow. Our results immediately imply the following.
The single-sink maximum priority flow problem cannot be approximated to within a factor of m 1 2 − , for any > 0, in planar directed or undirected graphs.
The extension of the hardness results for single-sink unsplittable flow to undirected graphs is also significant since it appears to have been left unnoticed even for general multiflow instances. In [20]: "...the hardness of undirected edge-disjoint path remains an interesting open question. Indeed, even the hardness of edge-capacitated unsplittable flow remains open" 2 Our result resolves this question by showing polynomial hardness (even for single-sink instances). We emphasize that this is not the first super-constant hardness for general multiflows however. A polylogarithmic lower bound appeared in [2] for the maximum edge-disjoint paths (MEDP) problem (this was subsequently extended to the regime where edge congestion is allowed [1]). Moreover, a polynomial lower bound for MEDP seems less likely given the recent O(1)-congestion polylog-approximation algorithms [12,14]. In this light, our hardness results for single-sink unsplittable flow again highlight the sharp threshold involved with the no-bottleneck assumption. That is, if we allow some slight variation in demands and capacities within a tight range [1, 1 + ∆] we immediately jump from (likely) polylogarithmic approximations for MEDP to (known) polynomial hardness of the corresponding maximum unsplittable flow instances.
We next note that Theorems 1.1 and 1.2 are stronger than Theorem 1.3 in the sense that they have exponents of 1 − rather than 1 2 − . Again, this extra boost is due to their use of exponential demand sizes. One can obtain a more refined picture as to how the hardness of cardinality single-sink unsplittable/confluent flow varies with the demand sizes, or more precisely how it varies on the bottleneck value dmax u min . 3 Specifically, combining the approaches used in Theorems 1.2 and 1.3 gives: Theorem 1.5 Consider any fixed > 0 and d max /u min > 1. It is NP-hard to approximate cardinality single-sink unsplittable/confluent flow to within a factor of O(m Once again we see the message that there is a sharp cutoff for d max /u min > 1 even in the large-demand regime. This is because if the bottleneck value is at most 1, then the nobottleneck assumption holds and, consequently, the single-sink unsplittable flow problem admits a constant-factor approximation (not √ m hardness). We mention that a similar hardness bound cannot hold for the maximum throughput objective, since one can always reduce to the case where d max /u min is small with a polylogarithmic loss, and hence the lower bound becomes at worst O(m 1 2 − · log m). We feel the preceding hardness bound is all the more interesting since known greedy techniques yield almost-matching upper bounds, even for general multiflows. We next present one hardness result for confluent flows assuming the no-bottleneck-assumption. Again, recall that for the maximum single-sink unsplittable flow problem there is a constant factor approximation algorithm given the no-bottleneck-assumption. We prove this is not the case for the single-sink confluent flow problem by providing a super-constant lower bound. Its proof is more complicated but builds on the techniques used for our previous results. Theorem 1.7 Given the no-bottleneck assumption, the single-sink confluent flow problem cannot be approximated to within a factor O(log 1− n), for any > 0, unless P = N P . This holds for both the maximum cardinality and maximum throughput objectives in undirected and directed graphs.
Finally, we include a hardness result for the congestion minimization problem for confluent flows. That is, the problem of finding the minimum value α ≥ 1 such that all demands can be routed confluently if all node capacities are multiplied by α. This problem has two plausible variants.
An α-congested routing is an unsplittable flow for the demands where the total load on any node is at most α times its associated capacity. A strong congestion algorithm is one where the resulting flow must route on a tree T such that for any demand v the nodes on its path in T must have capacity at least d(v). A weak congestion algorithm does not require this extra constraint on the tree capacities. Both variants are of possible interest. If the motive for congestion is to route all demands in some limited number α of rounds of admission, then each round should be feasible on T -hence strong congestion is necessary. On the other hand, if the objective is to simply augment network capacity so that all demands can be routed, weak congestion is the right notion. In Section 3.1.3 we show that it is hard to approximate strong congestion to within polynomial factors. Theorem 1.8 It is NP-hard to approximate the minimum (strong) congestion problem for single-sink confluent flow instances (with polynomial-size demands) to factors of at most m .5− for any > 0.

Overview of Paper
At the heart of our reductions are gadgets based upon the capacitated 2-disjoint paths problem. We discuss this problem in Section 2. In Section 3, we prove the √ m hardness of maximum single-sink unsplittable/confluent flow in the small demand regime (Theorem 1.3); we give a similar hardness for single-sink priority flow (Corollary 1.4). Using a similar basic construction, we prove, in Section 4, the logarithmic hardness of maximum single-sink confluent flow even given the no-bottleneck assumption (Theorem 1.7). In Section 5, we give lower bounds on the approximability of the cardinality objective for general demand regimes (Theorems 1.2 and 1.5). Finally, in Section 6, we present an almost matching upper bound for unsplittable flow (Theorem 1.6). and priority flow.

The Two-Disjoint Paths Problem
Our hardness reductions require gadgets based upon the capacitated 2-disjoint paths problem. Before describing this problem, recall the classical 2-disjoint paths problem: 2-Disjoint Paths (Uncapacitated): Given a graph G and node pairs {x 1 , y 1 } and {x 2 , y 2 }. Does G contain paths P 1 from x 1 to y 1 and P 2 from x 2 to y 2 such that P 1 and P 2 are disjoint?
Observe that this formulation incorporates four distinct problems because the graph G may be directed or undirected and the desired paths may be edge-disjoint or node-disjoint. In undirected graphs the 2-disjoint paths problem, for both edge-disjoint and node disjoint paths, can be solved in polynomial time -see Robertson and Seymour [25]. In directed graphs, perhaps surprisingly, the problem is NP-hard. This is the case for both edge-disjoint and node disjoint paths, as shown by Fortune, Hopcroft and Wyllie [19].
In general, the unsplittable and confluent flow problems concern capacitated graphs. Therefore, our focus is on the capacitated version of the 2-disjoint paths problem.

2-Disjoint Paths (Capacitated):
Let G be an graph whose edges have capacity either α or β, where β ≥ α. Given node pairs {x 1 , y 1 } and {x 2 , y 2 }, does G contain paths P 1 from x 1 to y 1 and P 2 from x 2 to y 2 such that: (i) P 1 and P 2 are disjoint.
(ii) P 2 may only use edges of capacity β. (P 1 may use both capacity α and capacity β edges.) For directed graphs, the result of Fortune et al. [19] immediately implies that the capacitated version is hard -simply assume every edge has capacity β. In undirected graphs, the case of node-disjoint paths was proven to be hard by Guruswami et al. [20]. The case of edge-disjoint paths was recently proven to be hard by Naves, Sonnerat and Vetta [23], even in planar graphs.
These results are summarised in Table 1.

Directed
Undirected Node-Disjoint NP-hard [19] NP-hard [20] Edge-Disjoint NP-hard [19] NP-hard [23]  Recall that the unsplittable flow problem has capacities on edges, whereas the confluent flow problem has capacities on nodes. Consequently, our hardness reductions for unsplittable flows require gadgets based upon the hardness for edge-disjoint paths [23]; for confluent flows we require gadgets based upon the hardness for node-disjoint paths [20].

Polynomial Hardness of Single-Sink Unsplittable, Confluent and Priority Flow
In this section, we establish that the single-sink maximum unsplittable and confluent flow problems are hard to approximate within polynomial factors for both the cardinality and throughput objectives. We will then show how these hardness results extend to the single-sink maximum priority flow problem. We begin with the small demand regime by proving Theorem 1.3. Its proof introduces some core ideas that are used in later sections in the proofs of Theorems 1.5 and 1.7.

√ n-Hardness in the Small Demand Regime
Our approach uses a grid routing structure much as in the hardness proofs of Guruswami et al. [20]. Specifically: (1) We introduce a graph G N that has the following properties. There is a set of pairwise crossing paths that can route demands of total value, N i=1 (1 + iδ) = N + δ 1 2 N (N + 1). On the other hand, any collection of pairwise non-crossing paths can route at most d max = 1 + N δ units of the total demand. For a given ∆ ∈ (0, 1) we choose δ to be small enough so that (2) We then build a new network G by replacing each node of G N by an instance of the capacitated 2-disjoint paths problem. This routing problem is chosen because it induces the following properties. If it is a YES-instance, then a maximum unsplittable (or confluent) flow on G corresponds to routing demands in G N using pairwise-crossing paths. In contrast, if it is a NO-instance, then a maximum unsplittable or confluent flow on G corresponds to routing demands in G N using pairwise non-crossing paths.
Since G N contains n = O(N 2 ) nodes, it follows that an approximation algorithm with guarantee better than Θ( √ n) allows us to distinguish between YES-and NO-instances of our routing problem, giving an inapproximability lower bound of Ω( √ n). Furthermore, at all stages we show how this reduction can be applied using only undirected graphs. This will prove Theorem 1.3.
Let's begin by defining the graph G N . There are N rows (numbered from top to bottom) and N columns (numbered from left to right). We call the leftmost node in the i th row s i , and the bottom node in the j th column t j . There is a demand of size c i := 1 + iδ located at s i . Recall, that δ is chosen so that all demands and capacities lie within a tight range [1, 1 + ∆] for fixed ∆ small. All the edges in the i th row and all the edges in the i th column have capacity c i . The i th row extends as far as the i th column and vice versa; thus, we obtain a "half-grid" that is a weighted version of the network considered by Guruswami et al. [20]. Finally we add a sink t. There is an edge of capacity c j between t j to t. The complete construction is shown in Figure 1.
For the unsplittable flow problem we have edge capacities. We explain later how the node capacities are incorporated for the confluent flow problem. We also argue about the undirected and directed reductions together. For directed instances we always enforce edge directions to be downwards and to the right.
Note that there is a unique s i − t path P * i consisting only of edges of capacity c i , that is, the hooked path that goes from s i along the i th row and then down the i th column to t. We call this the canonical path for demand i. Claim 3.1 Take two feasible paths Q i and Q j for demands i and j. If i < j, then the paths must cross on row j, between columns i and j − 1.
Proof. Consider demand i originating at s i . This demand cannot use any edge in columns 1 to i − 1 as it is too large. Consequently, any feasible path Q i for demand i must include all of row i. Similarly, Q j must contain all of row j. Row j cuts off s i from the sink t, so Q i must meet Q j on row j. Demand i cannot use an edge in row j as demand j is already using up all the capacity along that row. Thus Q i crosses Q j at the point they meet. As above, this meeting cannot occur in columns 1 to i − 1. Thus the crossing point must occur on some column between i and j − 1 (by construction of the half-grid, column j only goes as high as row j so the crossing cannot be there).
2 By Claim 3.1, if we are forced to route using pairwise non-crossing paths, then only one demand can route. Thus we can route at most a total of c N = 1 + δN < 2 units of demand.

The Instance G
We build a new instance G by replacing each degree 4 node in G N with an instance of the 2disjoint paths problem. For the unsplittable flow problem in undirected graphs we use gadgets H corresponding to the capacitated edge-disjoint paths problem. Observe that a node at the intersection of column i and row j (with j > i) in G N is incident to two edges of capacity c i and to two edges of weight c j . We construct G by replacing each such node of degree four with the routing graph H. We do this in such a way that the capacity c i edges of G N are incident to x 1 and y 1 , and the c j edges are incident to x 2 and y 2 . We also let α = c i and β = c j .
For the confluent flow problem in undirected graphs we use gadgets H corresponding to the capacitated node-disjoint paths problem. We must now use node instead of edge capacities.
To do this, we may simply subdivide each edge of H, and the new node inherits the edge's capacity. Again x 1 and y 1 are given capacity c i whilst x 2 and y 2 have capacity c j .
For directed graphs, the mechanism is simpler as the gadgets may now come from the uncapacitated disjoint paths problem. Thus the hardness comes from the directedness and not from the capacities. Specifically, we may set the edge capacities to be C = max{c i , c j }. Moreover, for unsplittable flow we may perform the standard operation of splitting each node in H into two, with the new induced arc having capacity of C. It follows that if there are two flow paths through H, each carrying at least c i ≥ c j flow, then they must be from x 1 to y 1 and x 2 to y 2 . These provide a solution to the node-disjoint directed paths problem in H.
The hardness result will follow once we see how this construction relates to crossing and non-crossing collections of paths. Proof. If H is a YES-instance, then we can use its paths to produce paths in G, whose images in G N , are free to cross at any node. Hence we can produce paths in G whose images are the canonical paths P This results in a flow of value greater than N . Note that in the confluent case, these paths yield a confluent flow as they only meet at the root t.
Now suppose H is a NO-instance. Take any flow and consider two pathsQ i andQ j in G for demands i and j, where i < j. These paths also induce two feasible paths Q i and Q j in the half-grid G N . By Claim 3.1, these paths cross on row j of the half-grid (between columns i and j − 1). In the directed case (for unsplittable or confluent flow) if they cross at a grid-node v, then the paths they induce in the copy of H at v must be node-disjoint. This is not possible in the directed case since such paths do not exist for (x 1 , y 1 ) and (x 2 , y 2 ).
In the undirected confluent case, we must also have node-disjoint paths through this copy of H. As we are in row j and a column between column i and j − 1, we have β = c j and c i ≤ α ≤ c j−1 . Thus, demand j can only use the β-edges of H. This contradicts the fact that H is a NO-instance. For the undirected case of unsplittable flow the two paths through H need to be edge-disjoint, but now we obtain a contradiction as our gadget was derived from the capacitated edge-disjoint paths problem.
It follows that no such pairQ i andQ j can exist and, therefore, the confluent/unsplittable flow routes at most one demand and, hence, routes a total demand of at most 1 + ∆.
2 We then obtain our hardness result.  Proof. It follows that if we could approximate the maximum (unsplittable) confluent flow problem in G to a factor better than N , we could determine whether the optimal solution is at least N or at most 1 + ∆. This in turn would allow us to determine whether H is a YES-or a NO-instance.

Priority Flows and Congestion
We now show the hardness of priority flows. To do this, we use the same half-grid construction, except we must replace the capacities by priorities. This is achieved in a straight-forward manor: priorities are defined by the magnitude of the original demands/capacities. The larger the demand or capacity in the original instance, the higher its priority in the new instance.
(Given the priority ordering we may then assume all demands and capacities are set to 1.) In this setting, observe that Claim 3.1 also applies for priority flows.
Claim 3.2 Consider two feasible paths Q i and Q j for demands i and j in the priority flow problem. If i < j, then the paths must cross on row j, between columns i and j − 1.
Proof. Consider demand i originating at s i . This demand cannot use any edge in columns 1 to i − 1 as they do not have high enough priority. Consequently, any feasible path Q i for demand i must include all unit capacity edges of row i. Similarly, Q j must contain all of row j. Row j cuts off s i from the sink t, so Q i must meet Q j on row j. Demand i cannot use an edge in row j as demand j is already using up all the capacity along that row. Thus Q i crosses Q j at the point they meet. As above, this meeting cannot occur in columns 1 to i − 1. Thus the crossing point must occur on some column between i and j − 1. 2 Repeating our previous arguments, we obtain the following hardness result for priority flows. (Again, it applies to both throughput and cardinality objectives as they coincide for priority flows.) Corollary 1.4. The maximum single-sink priority flow problem cannot be approximated to within a factor of m 1 2 − , for any > 0, in planar directed or undirected graphs. 2 We close the section by establishing Theorem 1.8. Consider grid instance built from a YES instance of the 2 disjoint path problem. As before we may find a routing of all demands with congestion at most 1. Otherwise, suppose that the grid graph is built from a NO instance and consider a tree T returned by a strong congestion algorithm. As it is a strong algorithm, the demand in row i must follow its canonical path horizontally to the right as far as it can. As it is a confluent flow, all demands from rows > i must accumulate at this rightmost node in row i. Inductively this implies that the total load at the rightmost node in row 1 has load > N . As before, for any > 0 we may choose N sufficiently large so that N ≥ n .5− . Hence we have a YES instance of 2 disjoint paths if and only if the output from a n .5− -approximate strong congestion algorithm returns a solution with congestion ≤ N .

Logarithmic Hardness of Single-Sink Confluent Flow with the No-Bottleneck Assumption
We now prove the logarithmic hardness of the confluent flow problem given the no-bottleneck assumption. A similar two-step plan is used as for Theorem 1.3 but the analysis is more involved.
(1) We introduce a planar graph G N which has the same structure as our previous half-grid, except that its edge weights are changed. As before we have demands associated with the s i 's, but we assume these demands are tiny -this guarantees that the no-bottleneck assumption holds. We thus refer to the demands located at an s i as the packets from s i . We define G N to ensure that there is a collection of pairwise crossing "trees" (to be defined) that can route packets of total value equal to the harmonic number H N ≈ log N . On the other hand, any collection of pairwise non-crossing trees can route at most one unit of packet demand.
(2) We then build a new network G by replacing each node of G N by an instance of the 2-disjoint paths problem. Again, this routing problem is chosen because it induces the following properties. If it is a YES-instance, then we can find a routing that corresponds to pairwise crossing trees. Hence we are able to route H N demand. In contrast, if it is a NO-instance, then a maximum confluent flow on G is forced to route using a non-crossing structure and this forces the total flow to be at most 1.
It follows that an approximation algorithm with guarantee better than logarithmic would allow us to distinguish between YES-and NO-instances of our routing problem, giving a lower bound of Ω(log N ). We will see that this bound is equal to Θ(log 1− n).

An Updated Half-Grid Graph.
Again we take the graph G N with N rows (now numbered from bottom to top) and N columns (now numbered from right to left). All the edges in the i th row and all the edges in the i th column have capacity 1 i . The i th row extends as far as the i th column and vice versa; thus, we obtain a half-grid similar to our earlier construction but with updated weights. Then we add a sink t. There is an edge of capacity 1 i to t from the bottom node (called t i ) in column i. Finally, at the leftmost node (called s i ) in row i there is a collection of packets ("sub-demands") whose total weight is 1 i . These packets are very small. In particular, they are much smaller than 1 n , so they satisfy the no-bottleneck assumption. The complete construction is shown in Figure 2. In the directed setting, edges are oriented to the right and downwards.
Again, there is a unique s-t path P * i consisting only of edges of weight 1 i , that is, the hooked path that goes from s i along the ith row and then down the ith column to t. Moreover, for i = j, the path P * i intersects P * j precisely once. If we route packets along the paths P * = {P * 1 , P * 2 , . . . , P * N }, then we obtain a flow of total value H N = 1 + 1 2 + . . . edge incident to t is used in P * with its maximum capacity, this solution is a maximum singlesink flow. Clearly, each P * i is a tree, so this routing corresponds to our notion of routing on "crossing trees".
We then build G as before by replacing the degree four nodes in the grid by our disjointpaths gadgets. Our first objective is to analyze the maximum flow possible in the case where our derived instance G is made from NO-instances. Consider a confluent flow in G. If we contract the pseudo-nodes, this results in some leaf-to-root paths in the subgraph G N . We define T i as the union of all such leaf-to-root paths terminating at t i . If we have a NO-instance, then the resulting collection T = {T 1 , T 2 , . . . , T N } forms non-crossing subgraphs. That is, if i = j, then there do not exist leaf-to-root paths P i ∈ T i and P j ∈ T j which cross in the standard embedding of G N . Since we started with a confluent flow in G, the flow paths within each T i are edge-confluent. That is, when two flow paths share an edge, they must thereafter follow the same path to t i . Note that they could meet and diverge at a node if they use different incoming and outgoing edges. In the following, we identify the subgraph T i with its edge-confluent flow.
The capacity of a T i is the maximum flow from its leaves to t i . The capacity of a collection T is then the sum of these capacities. We first prove that the maximum value of a flow (i.e., capacity) is significantly reduced if we require a non-crossing collection of edge-confluent flows. One should note that as our demands are tiny, we may essentially route any partial amount x ≤ 1 i from a node s i ; we cannot argue as though we route the whole 1 i . On the other hand, any packets from s i must route on the same path, and in particular s i lies in a unique T j (or none at all). Another subtlety in the proof is to handle the fact that we cannot apriori assume that there is at most one leaf s j in a T i . Hence such a flow does not just correspond to a maximum uncrossed unsplittable flow. In fact, because the packets are tiny, it is easy to verify that all the packets may be routed unsplittably even if they are required to use non-crossing paths. Proof. Let t i 1 , t i 2 , ..., t i k be the roots of the subgraphs T i which support the edge-confluent flow, where wlog i 1 > i 2 > · · · > i k . We argue inductively about the topology of where these supports live in G N . For i ≤ j we define a subgrid G(i, j) of G N induced by columns and rows whose indices lie in the range [i, j]. For instance, the rightmost column of G(i, j) has capacity 1 i and the leftmost column 1 j ; similarly, the lowest row of G(i, j) has capacity 1 i and the highest row 1 j . Obviously all the T i 's route in G(1, N ) = G(r 1 , 1 ) where we define r 1 = 1, 1 = N . Consider the topologically highest path P i 1 in T i 1 , and let r 1 be the highest row number where this path intersects column n 1 = t i 1 . We define r 2 = r 1 + 1 and 2 = n 1 − 1 and consider the subgrid G(r 2 , 2 ). Observe that in the undirected case it is possible that P i 1 routes through the subgrid G(r 2 , 2 ); see Figure 3(b). In the directed case this cannot happen; see Figure 3(a). Figure 3 In addition, it is possible that T i 2 completely avoids routing through the subgrid G(r 2 , 2 ). But, for this to happen, it must have a cut-edge (containing all its flow) in column t i 1 ; conse-quently, its total flow is then at most 1 i 1 . It is also possible that it has some flow which avoids G(r 1 , 1 ) and some that does not. Since T i 1 also has maximum flow at most 1 i 1 , it follows that in every case the total flow is at most 2 i 1 plus the maximum size of a confluent flow in the subproblem G(r 2 , 2 ). Note that in this subproblem, its "first" rooted subgraph may be at t i 2 or t i 3 depending on which of the two cases above occurred for T i 2 .
If we iterate this process, at a general step i we have a edge-confluent flow in the subgrid G(r i , i ) whose lower-left corner is in row r i and column i (hence r i ≤ i ). Let T n i be its subgraph rooted at a t n i with n i maximized (that is, furthest to the left on bottom row). As before, the total flow in this sub-instance is at most 2 n i plus a maximum edge-confluent flow in some G(r i+1 , i+1 ). Since each new sub-instance has at least one less rooted flow, this process ends after at most k * ≤ k steps. Now, we know that r i ≤ n i ≤ i . Moreover, by construction, we have r i > r i+1 (recall that columns are ordered increasingly from right to left). Since r 1 = 1, we may inductively deduce that r i ≥ i for all i. Thus r 1 ≥ r 2 ≥ · · · ≥ r k * ≥ k * . The total flow in our instance is then at most The lemma follows. 2 We can now complete the proof of the approximation hardness. Observe that any node of degree four in G N is incident to two edges of weight 1 i and to two edges of weight 1 j , for some j < i. Again, we construct a graph G by replacing each node of degree four with an instance H of the 2 node-disjoint paths problem, where the weight 1 i edges of G N are incident to x 1 and y 1 , and the weight 1 j edges are incident to x 2 and y 2 . In the undirected case we require capacitated node-disjoint paths and set α = 1 i and β = 1 j . More precisely, since we are dealing with node capacities in confluent flows, we actually subdivide each edge of H and the new node inherits the edge's capacity. The nodes x 1 and y 1 also have capacity 1 i whilst the nodes x 2 and y 2 have capacity 1 j in order to simulate the edge capacities of G N .

Lemma 4.2
If H is a YES-instance, then the maximum single-sink confluent flow in G has value H N . If H is a NO-instance, then the maximum confluent flow in G has value at most 2.
Proof. It is clear that if H is a YES-instance, then the two feasible paths in H can be used to allow paths in G N to cross at any node without restrictions on their values. This means we obtain a confluent flow of value H N by using the canonical paths P * i , 1 ≤ i ≤ N . Now suppose that H is a NO-instance and consider how a confluent flow T = {T 1 , . . . , T n } routes packets through the gadgets. As it is a NO-instance, the image of the trees (after contracting the H's to single nodes) in G N yields a non-crossing edge-confluent flow. The capacity of this collection in G N is at least that in G. By Lemma 4.1, their capacity is at most 2, completing the proof. 2 Theorem 1.7. Given the no-bottleneck assumption, the single-sink confluent flow problem cannot be approximated to within a factor O(log 1− n), for any > 0, unless P = N P . This holds for both the maximum cardinality and maximum throughput objectives in undirected and directed graphs.
Proof. It follows that if we could approximate the maximum confluent flow problem in G to a factor better than H N /2, we could determine whether the optimal solution is 2 or H N . This in turn would allow us to determine whether H is a YES-or a NO-instance.
Note that G has n = Θ(pN 2 ) edges, where p = |V (H)|. If we take N = Θ(p 2 Similarly, if we are restricted to consider only flows that decompose into k disjoint trees then it is not hard to see that: Theorem 4.3 Given the no-bottleneck assumption, there is a Ω(log k) hardness of approximation, unless P = N P , for the problem of finding a maximum confluent flow that decomposes into at most k disjoint trees. 2

Stronger Lower Bounds for Cardinality Single-Sink Unsplittable Flow with Arbitrary Demands
In the large demand regime even stronger lower bounds can be achieved for the cardinality objective. To see this, we explain the technique of Azar and Regev [3] (used to prove Theorem 1.1) in Section 5.1 and show how to extend it to undirected graphs and to confluent flows. Then in Section 5.2, we combine their construction with the half-grid graph to obtain lower bounds in terms of the bottleneck value (Theorem 1.5). Proof. We begin by describing the construction of Azar and Regev for directed graphs. They embed instances of the uncapacitated 2-disjoint paths problem into a directed path. Formally, we start with a directed path z 1 , z 2 , . . . , z where t = z forms our sink destination for all demands. In addition, for each i < , there are two parallel edges from z i−1 to z i . One of these has capacity 2 i and the other has a smaller capacity of 2 i − 1. There is a demand s i from each z i , i < to z of size 2 i+1 . Note that this unsplittable flow instance is feasible as follows. For each demand s j , we may follow the high capacity edge from z j to z j+1 (using up all of its capacity) and then use low capacity edges on the path z j+1 , z j+2 , . . . , z . Call these the canonical paths for the demands. The total demand on the low capacity edge from z j is then i≤j 2 i = 2 j+1 − 1, as desired. Now replace each node z j , 1 ≤ j < , by an instance H j of the uncapacitated directed 2-disjoint paths problem. Each edge in H j is given capacity 2 j+1 . Furthermore: (i) The tail of the high capacity edge out of z j is identified with the node y 2 .
(ii) The tail of the low capacity edge out of z j is identified with y 1 . (iii) The heads of both edges into z j (if they exist) are identified with x 1 . (iv) The node x 2 becomes the starting point of the demand s j from z j . This construction is shown in Figure 4. Now if we have a YES-instance of the 2-disjoint paths problem then we may then simulate the canonical paths in the standard way. The demand in H j uses the directed path from x 2 to y 2 in H j ; it then follows the high capacity edge from y 2 to the x 1 -node in the next instance H j+1 . All the total demand arriving from upstream H i 's entered H j at its node x 1 and follows the directed path from x 1 to y 1 . This total demand is at most i≤j 2 i and thus fits into the low capacity edge from H j into H j+1 . Observe that this routing is also confluent in our modified instance because the paths in the H j 's are node-disjoint. Hence, if we have a YES-instance of the 2-disjoint paths problem, both the unsplittable and confluent flow problems have a solution routing all of the demands. Now suppose that we have a NO-instance, and consider a solution to the unsplittable (or confluent) flow problem. Take the highest value i such that the demand from H i is routed.
By construction, this demand must use a path P 2 from x 2 to y 2 . But this saturates the high capacity edge from y 2 . Hence any demand from H j , j < i must pass from y 1 to x 1 while avoiding the edges of P 2 . This is impossible, and so we route at most one demand.
This gives a gap of for the cardinality objective. Azar-Regev then choose = |V (H)| 1 to obtain a hardness of Ω(n 1− ). Now consider undirected graphs. Here we use an undirected instance of the capacitated 2-disjoint paths problem. We plug this instance into each H j , and use the two capacity values of β = 2 j+1 and α = 2 j+1 − 1. A similar routing argument then gives the lower bound.
2 We remark that it is easy to see why this approach does not succeed for the throughput objective. The use of exponentially growing demands implies that high throughput is achieved simply by routing the largest demand.

Lower Bounds for Arbitrary Demands
By combining paths and half-grids we are able to refine the lower bounds in terms of the bottleneck value (or demand spread).
Theorem 1.5. Consider any fixed > 0 and d max /u min > 1. It is NP-hard to approximate cardinality single-sink unsplittable/confluent flow to within a factor of O( log( dmax u min ) · m same conditions required in Theorem 1.3 to show that at most one demand in total can feasibly route. It follows that we cannot approximate the cardinality objective to better than a factor pq.
Note that the construction contains at most m = O((qp + p 2 ) · |E(H)|) edges, where H is the size of the 2-disjoint paths instance. Now we select p and q such that q ≥ p and pq ≥ |E(H)| 1 .
Then, for some constant C, we have Therefore, since we cannot approximate to within pq, we cannot approximate the cardinality objective to better than a factor O( log( dmax u min ) · m 1 2 − ). 2

Upper Bounds for Flows with Arbitrary Demands
In this section we present upper bounds for maximum flow problems with arbitrary demands.

Unsplittable Flow with Arbitrary Demands
One natural approach for the cardinality unsplittable flow problem is used repeatedly in the literature (even for general multiflows). Group the demands into at most O(log dmax d min ) ≥ log( dmax u min ) bins, and then consider each bin separately. This approach can also be applied to the throughput objective (and to the more general profit-maximisation model). This immediately incurs a lost factor relating to the number of bins, and this feels slightly artificial. In fact, given the no-bottleneck assumption regime, there is no need to lose this extra factor: Baveja et al [4] gave an O( √ m) approximation for profit-maximisation when d max ≤ u min . On the other hand, our lower bound in Theorem 1.5 shows that if d max > u min we do need to lose some factor dependent on d max . But how large does this need to be? The current best upper bound is O(log( dmax u min ) · √ m log m) by Guruswami et al. [20], and this works for the general profitmaximisation model. 4 For the cardinality and throughput objectives, however, we can obtain a better upper bound. The proof combines analyses from [4] and [22] (which focus on the nobottleneck assumption case). We emphasize that the following theorem applies to all multiflow problems not just the single-sink case. Theorem 1.6. There is an O( √ m log( dmax u min )) approximation algorithm for cardinality unsplittable flow and an O( √ m log n) approximation algorithm for throughput unsplittable flow, in both directed and undirected graphs.
Proof. We apply a result from [20] which shows that for cardinality unsplittable flow, with d max ≤ ∆d min , the greedy algorithm yields a O(∆ √ m) approximation. Their proof is a technical extension of the greedy analysis of Kolliopoulos and Stein [22]. We first find an approximation for the sub-instance consisting of the demands at most u min . This satisfies the no-bottleneck assumption and an O( √ m)-approximation is known for general profits [4]. Now, either this sub-instance gives half the optimal profits, or we focus on demands of at least u min . In the remaining demands, by losing a log( dmax u min ) factor, we may assume d max ≤ ∆d min , for some ∆ = O(1). The greedy algorithm above then gives the desired guarantee for the cardinality problem. The same approach applies for the throughput objective, since all demands within the same bin have values within a constant factor of each other. Moreover, we require only log n bins as demands of at most dmax n may be discarded as they are not necessary for obtaining high throughput. 2 As alluded to earlier, this upper bound is not completely satisfactory as pointed out in [8]. Namely, all of the lower bound instances have a linear number of edges m = O(n). Therefore, it is possible that there exist upper bounds dependent on √ n. Indeed, for the special case of MEDP in undirected graphs and directed acyclic graphs O( √ n)-approximations have been developed [9,24]. Such an upper bound is not known for general directed MEDP however; the current best approximation is min{ √ m, n 2/3 }.

Priority Flow with Arbitrary Demands
Next we show that the lower bound for the maximum priority flow problem is tight.
Theorem 6.1 Consider an instance of the maximum priority flow problem with k priority classes. There is a polytime algorithm that approximates the maximum flow to within a factor of O(min{k, √ m}).
Proof: First suppose that k ≤ √ m. Then for each class i, we may find the optimal priority flow by solving a maximum flow problem in the subgraph induced by all edges of priority i or better. This yields a k-approximation. Next consider the case where √ m < k. Then we may apply Lemma 6.2, below, which implies that the greedy algorithm yields a O( √ m)-approximation. The theorem follows.
2 The following proof for uncapacitated networks follows ideas from the greedy analysis of Kleinberg [21], and Kolliopoulos and Stein [22]. One may also design an O( √ m)-approximation for general edge capacities using more intricate ideas from [20]; we omit the details.

Lemma 6.2 A greedy algorithm yields a O(
√ m)-approximation to the maximum priority flow problem.
Proof: We now run the greedy algorithm as follows. On each iteration, we find the demand s i which has a shortest feasible path in the residual graph. Let P i be the associated path, and delete its edges. Let greedy solution have cardinality t. Let O be the optimal maximum priority flow and let Q be those demands which are satisfied in some optimal solution but not by the greedy algorithm. We aim to upper bound the size of Q.
Let Q be a path used in the optimal solution satisfying some demand in Q. Consider any edge e and the greedy path using it. We say that P i blocks an optimal path Q if i is the least index such that P i and Q share a common edge e. Clearly such an i exists or else we could still route on Q.
Let l i denote the length of P i . Let k i denote the number of optimal paths (corresponding to demands in Q ) that are blocked by P i . It follows that k i ≤ l i . But, by the definition of the greedy algorithm, we have that each such blocked path must have length at least l i at the time when P i was packed. Hence it used up at least l i ≥ k i units of capacity in the optimal solution. Therefore the total capacity used by the unsatisfied demands from the optimal solution is at least t i=1 k 2 i . As the total capacity is at most m we obtain where the first inequality is by Cauchy-Schwarz. Since i k i = |Q| = |O| − t, we obtain (|O|−t) 2 t ≤ m. One may verify that if t < |O| √ m then this inequality implies |O| = O( √ m) and, so, routing a single demand yields the desired approximation. 2

Conclusion
It would be interesting to improve the upper bound in Theorem 1.6 to be in terms of √ n rather than √ m. Resolving the discrepancy with Theorem 1.5 between log( dmax u min ) and log( dmax u min ) would also clarify the complete picture.