Width Helps and Hinders Splitting Flows

Minimum flow decomposition (MFD) is the NP-hard problem of finding a smallest decomposition of a network flow/circulation X on a directed graph G into weighted source-to-sink paths whose weighted sum equals X. We show that, for acyclic graphs, considering the width of the graph (the minimum number of paths needed to cover all of its edges) yields advances in our understanding of its approximability. For the version of the problem that uses only non-negative weights, we identify and characterise a new class of width-stable graphs, for which a popular heuristic is a O(log Val (X))-approximation (Val(X) being the total flow of X), and strengthen its worst-case approximation ratio from \(\Omega (\sqrt {m})\) to Ω (m/log m) for sparse graphs, where m is the number of edges in the graph. We also study a new problem on graphs with cycles, Minimum Cost Circulation Decomposition (MCCD), and show that it generalises MFD through a simple reduction. For the version allowing also negative weights, we give a (⌈ log ‖ X ‖ ⌉ +1)-approximation (‖ X ‖ being the maximum absolute value of X on any edge) using a power-of-two approach, combined with parity fixing arguments and a decomposition of unitary circulations (‖ X ‖ ≤ 1), using a generalised notion of width for this problem. Finally, we disprove a conjecture about the linear independence of minimum (non-negative) flow decompositions posed by Kloster et al. [2018], but show that its useful implication (polynomial-time assignments of weights to a given set of paths to decompose a flow) holds for the negative version.


Introduction
Minimum flow decomposition (MFD) is the problem of finding a smallest sized decomposition of a network flow X on directed graph G = (V, E) into weighted source-to-sink paths whose superposition equals X.We focus on the case where path weights are restricted to be integers.It is a textbook result [1] that if G is acyclic (a DAG) a decomposition using no more than m = |E| paths always exists.However, MFD is strongly NP-hard [28], even on DAGs, and even when the flow values come only from {1, 2, 4} [14].Recent work has shown that the problem is FPT in the size of the minimum decomposition [17] and that it can be formulated as an ILP of quadratic size [7].
While difficult to solve, MFD is a key step in many applications.For example, MFD on DAGs is used to reconstruct biological sequences such as RNA transcripts [21,26,13,3,25,29,6] and viral strains [2].MFD can also be used to model problems in networking [28,14,18] and transportation planning [19], although in some of these applications there may be cycles in the input.Despite the ubiquity of the MFD problem, the gap in our knowledge about the approximability of MFD is large.It is known [14] that MFD (even on DAGs) is APX-hard (i.e., there is some > 0 such that it is NP-hard to approximate within a (1 + ) factor), so in particular, MFD does not admit a PTAS, unless P=NP.Furthermore, the best known approximation ratio is λ log X log X [18], where λ is the length of the longest source-to-sink path and X is the largest flow value in the network.In this work, we attempt to fill in some of the gaps between these results.
A natural lower bound for the size of an MFD of a DAG is the size of a minimum path cover of the set of edges with non-zero flow (i.e., the minimum number of paths such that every such edge appears in at least one path)-this size is called the width of the network.This trivially holds because every flow decomposition is also such a path cover.These two notions are analogies of the more standard notions of path cover and width of the node set.The node-variants are classical concepts, with algorithmic results dating back to Dilworth and Fulkerson [8,10].Despite this, the width has not been given any attention in the MFD problem, and in particular it has never been used in approximation algorithms to our knowledge.In this paper, we show that the width can play a key role both in the analysis of popular heuristics, and in obtaining the first approximation algorithm for a natural generalisation of MFD.
We start by considering the connections between the width and a popular heuristic algorithm for MFD N which we call greedy-weight1 [28], which builds a flow decomposition by successively choosing the path that can carry the largest flow.Greedy-weight is commonly used in applications (see e.g., [26,2,21] among many), and it seems to be mentioned in nearly every publication addressing flow decomposition.First, on sparse graphs we improve (i.e., increase) the worst-case lower bound for the greedy-weight approximation factor from Ω( √ m) [14], showing for the first time that greedy-weight can be exponentially worse than the optimum: Theorem 1.The approximation ratio for greedy-weight on MFD N is Ω(m/ log m) for sparse graphs, in the worst case.
For this we use a class of sparse graphs where the optimum flow decomposition has size O(log m) whereas the greedy-weight algorithm returns a solution of size Ω(m), only a constant factor away from the trivial decomposition.The key to this new bound is to design an input where the width increases exponentially when a path is greedily removed.We also show that the same bound also holds for other greedy heuristics choosing instead the longest or shortest paths.Second, we identify a new class of graphs, defined by the property that their width does not increase as source-to-sink paths are removed (see Definition 11 of width-stable graphs).We show a relation of width-stable graphs to funnels: precisely, a graph is not width-stable if it contains a funnel subgraph and a certain central path.This is precisely the structure of the class of sparse graphs improving the approximation ratio of greedy-weight in Theorem 1.We also show that width-stability enables greedy-weight to remove paths of large enough flow (Lemma 13), leading to the following result, with |X| being equal to the total flow of the graph: Theorem 2. Let G = (V, E) be a width-stable graph and X : E → N a flow.Greedy-weight is a O(log |X|)-approximation for MFD N on (G, X).
A notable example of width-stable graphs is the class of series-parallel graphs; see [9,27] for fast recognition algorithms and pointers to other NP-hard problems that are easier on this class of graphs.Series-parallel graphs are also of great interest for network flow problems (see, e.g., [15,4]).Theorems 1 and 2 show that greedy-weight's approximation ratio is highly linked to the width stability of the graph.
In Section 4 we continue with a generalised version of MFD, Minimum Cost Circulation Decomposition (MCCD), on directed graphs with cycles and no sinks or sources, and a cost function on the edges.Instead of decomposing a flow into weighted paths, we decompose a circulation into weighted circulations and minimise the total cost of the circulations, and instead of the width, a natural lower bound for this problem is the minimum cost of a circulation cover (mccc).Decomposing into circulations rather than paths is a natural generalisation, as paths can be considered as value 1 flows themselves.Additionally, we also consider a relaxation in which the flow/circulation decomposition might use negative integer weights on flows/circulations, rather than strictly positive weights as has traditionally been considered [28,14,17].An important observation that we leverage for this variant (unlike the positive-only version) is that the width/mccc stays constant as flow is chosen and removed.Using this, we give a ( log X + 1)-approximation algorithm for this variant.
We denote all versions by MCCD N and MCCD Z as well as MFD N and MFD Z throughout the paper.While MCCD Y and MFD Z are natural versions of the problem, they have not been previously considered in the MFD literature to our knowledge.However, MFD Z can also have natural applications, since by applying MFD Z on the difference between two flows, one can minimally explain the differences between them, e.g. to explain the differences in RNA expression between two tissue samples with the fewest number of up/down regulated transcripts, which is often the goal of RNA sequencing experiments [24].Our approximation follows a power-of-two approach where the weights of the flows/circulations chosen are (positive or negative) powers of two.More specifically, observe that if all circulation values are even, then one can divide them by 2 and obtain a circulation X with smaller X whose decomposition can be transformed back into a decomposition of X.In order to obtain such an even circulation, we prove a basic property that can be of independent interest: given any integer circulation X, there exists a unitary circulation (its values are 0, +1, or −1) Y , such that X + Y is even on every edge (Lemma 21).In addition, given a unitary circulation Y , we show that Y can be decomposed into circulations of total cost no more than mccc (Lemma 23).We obtain the ( log X + 1)-approximation ratio (Theorem 3) by iteratively removing the unitary circulation, dividing all circulation values by 2, and preprocessing the graph so that the mccc is a lower bound on the size of the MCCD Z .Summarised, we show:

23:4
Width Helps and Hinders Splitting Flows Theorem 3. MCCD Z can be approximated with a factor of log X + 1 in runtime By Corollary 26 we additionally obtain the result for MFD Z .Notably, the runtime of the algorithm does not depend on the cost function.
Finally, in Section 5 we consider a closely related problem, called k-Flow Weight Assignment [17].In addition to the flow X, in this problem we are also given a set of k paths, and we need to decide if there is an assignment of weights to the paths such that they form a decomposition of X.If the weights belong to N, this was shown to be NP-complete in [17].In this work, we first observe that in the same way that allowing negative integer weights simplifies the approximability of MFD, allowing weights to belong to Z fully changes the complexity of the k-Flow Weight Assignment Problem, making it polynomial.This is due to the fact that the linear system defined by the given paths loses its only inequality of restricting the weights to positive integers.It thus transforms an ILP to a system of linear diophantine equations, which can be solved in polynomial time (see e.g.[22]).Second, we consider a conjecture from [17] stating that if the weights belong to N, and k is the size of a MFD N for X, then the problem admits a unique solution (i.e., a unique assignment of weights to the given paths).If true, this would speed up the FPT algorithm of [17] for MFD N , because a step solving an ILP could be executed by solving a standard linear program returning a rational solution and checking if the (supposedly unique) solution to this system is integer.Moreover, the same conjecture (with the same implication) was also a motivation behind the greedy algorithm of [23] for MFD N .In this paper, we disprove the conjecture of [17], further corroborating the gap between MFD N and MFD Z .

Preliminaries
In Sections 3 and 5 we are given a directed acyclic graph G = (V, E).Without loss of generality, we assume a unique source s and a unique sink t with no in-edges and no out-edges respectively; otherwise, the graph can be converted to such a graph by adding a pseudo source and sink and connecting them to all sources and sinks respectively.We denote by deg + (v) and deg − (v) the out-and indegree of a vertex v, respectively.While Minimum Flow Decompositions are also studied for graphs with cycles (see, e.g., [28,14]), the task is still to decompose into simple paths, and so our inapproximability result on DAGs in Section 3 also applies for graphs with cycles.In Section 4 we consider directed graphs G = (V, E, c) with no sources or sinks, where c : E → R ≥0 is a cost function.Such graphs can not be acyclic.We use n and m to denote the number of nodes and edges of G, respectively.For both kinds of graphs, we call functions X : E → Y pseudo-flows,2 where Y is some set of allowed flow values (numbers).We treat pseudo-flows as vectors over E and use the notation X + Y and aX to denote the (element-wise) sum of pseudo-flows and multiplication by a scalar, respectively.The numbers 0 and 1 also denote (depending on context) pseudo-flows that are 0 (resp.1) on every edge.We write X ≤ Y (and similarly <) to mean Given a DAG G, a flow is a pseudo-flow satisfying conservation of flow (incoming flow equal to outgoing flow) on internal nodes V \ {s, t}.A pseudo-flow satisfying the conservation of flow on all nodes is called a circulation.We sometimes refer to the value X(e) for a s(a 1 ) The reduction of 3-Partition to MFD from [28].The 3-Partition instance consists of a set A = {a1, . . ., a3q}, where every ai has a positive integer size s(ai), and a positive integer B, such that B/4 < s(ai) < B/2 holds for every ai ∈ A. The question is whether A can be partitioned into q disjoint subsets, each of 3 elements and of size B. The MFD series-parallel (see Definition 15) reduction consists of a subgraph obtained by the parallel composition of 3q edges with flow values s(a1), . . ., s(a3q), and a subgraph obtained by the parallel composition of q edges, each with flow value B. These two graphs are composed with the series composition.Intuitively, because B/4 < s(ai) < B/2 holds for every ai, the MFD consists of exactly 3q paths of weights s(a1), . . ., s(a3q), and each edge on the right-hand subgraph is traversed by exactly three paths whose weights sum to B, giving thus the partition of A. Moreover, since the first 3q edges need to be decomposed, the previous decomposition is minimum even if negative weights are allowed, making MFD Z NP-hard.
flow/circulation X as the flow of the edge e.It is known that the sum of two flows/circulations X + Y , the multiplication of a flow/circulation with by a scalar aX, and the empty pseudoflow 0 are themselves flows/circulations.Let |X| denote the total flow out of s (or by flow conservation, equivalently into t) for a flow X.Note that |X| can be negative.Given an s-t path P , denote by P [u..v] the subpath of P going from u ∈ V to v ∈ V and let P also denote the flow defined by setting 1 to every edge in P and 0 to every other edge.With these definitions, we are ready to formally define MFD.Definition 4. Given a flow X, a flow decomposition of (G, X) of size k is a family of s-t paths P = (P 1 , . . ., P k ) with weights (w 1 , . . ., w k ) ∈ Y k such that X = w 1 P 1 + • • • + w k P k .Definition 5. Given a flow X, let mfd Y (G, X) be the smallest size of a flow decomposition of (G, X) with weights in Y.
We omit Y if it is clear from the context.We call the problem of producing a flow decomposition of (G, X) of minimum size the minimum flow decomposition (MFD) problem.
In Section 3 we study MFD N (0 ∈ N), and in Section 4 we study MFD Z and its generalisation MCCD Z .Note that the reduction showing MFD N to be strongly NP-hard from [28] also holds for MFD Z (see Figure 1).However, a flow with non-negative values may admit a decomposition using fewer paths if negative weights are allowed, as shown in Figure 2. We explore further differences between MFD N and MFD Z in Sections 4 and 5. Let

Definition 6. Given S ⊆ E, we define width S (G) as the minimum number of s-t paths in a DAG G needed to cover all edges of S. If S = E we just write width(G).
The width is the main combinatorial tool that we use for our approximation results, and we will show in Section 3 that it is highly linked to the approximation performance of greedy-weight.Just like its more common node variant, width(G) can be computed in O(mn) time.As described by, e.g., [1,5]   with demand one on every edge; the minimum flow of this instance is width(G), and the flow can be found by reduction to a max-flow instance.Moreover, the problem can be relaxed to only require the coverage of S ⊆ E and solved in the same running time by setting the demands only on the edges of S.

Lemma 7 ([1, 20]). Let G = (V, E) be a DAG, and
The flow C with total flow width S (G) suffices and we do not need to calculate a path cover achieving that minimum.However, we note that it can be directly computed given the flow C. We can think of this path cover as a flow decomposition of C into width S (G) weight-one paths, which can be found by greedily removing such paths from C until it is completely decomposed.Since each path has no more than n − 1 edges and since width S (G) ≤ m, the overall runtime of finding the path cover is O(mn).Similarly, every path cover P 1 , . . ., P of G defines a flow C on G: C = P 1 + • • • + P , and we say that C is the induced flow of the path cover (P i ) i .Definition 8.In a directed graph G = (V, E) we call a subset C ⊆ E an antichain of G if all edges in C are pairwise parallel, that is there exists for no pair of edges in C a path in G leading from one edge to the other.
It can be shown with straight forward arguments that width(G) = |C| for a maximum (sized) antichain C of G.

Width matters for greedy approaches
Since the difference of two flows is still a flow, it is very natural to consider successively removing the simplest type of flow -that is to say, paths -as an algorithmic strategy for MFD N .Indeed, the particular greedy path removal strategy of finding a heaviest path (greedy-weight) is commonly used as a heuristic in applications (e.g., [21,2,26,14]) and it seems to be mentioned in nearly every paper addressing flow decomposition.More formally, a path P is said to carry flow p if X(u, v) ≥ p for all edges (u, v) of P (in particular, a v-v path carries infinite flow).A heaviest path is an s-t path carrying the largest flow.Such a path can be easily found in linear time in the size of the DAG by dynamic programming (see, e.g., [28]).
are defined to enter (resp.leave) the source (resp.sink) node of (G −1 , X −1,B ).The central edge has flow B and is part of the backbone (bold edges).

Width hinders greedy on MFD N
We define a family of MFD N instances (G , X ,B ), depending on two parameters ∈ N \ {0} and B ∈ N. The family is defined recursively on .The base case (G 1 , X 1,B ) for = 1 is shown in Figure 3a.For > 1, we build (G , X ,B ) from two disjoint copies of (G −1 , X −1,B ), by adding 5 extra edges and flow values as shown in Figure 3b.We call the edge connecting the two copies of G −1 a central edge.Edges whose flow value depends on B are called backbone edges, and they form a s-t path.By choosing B = 2 +1 , we show that the flow X ,2 +1 can be decomposed using a number of paths linear in , thanks to the heavy backbone edges, whereas the greedy-weight algorithm fully saturates the central edges with its first path and is left with a remaining flow requiring 2 +1 paths to be decomposed.
Proof.We first show that the heaviest path in X ,2 +1 follows every backbone edge from s to t. Certainly this path carries 2 +1 flow, and no more, since every backbone edge has flow at least 2 +1 and every central edge has flow exactly 2 +1 .To see that there is no heavier path, observe that all the non-backbone edges have flow value strictly less than 2 +1 by construction.After removing that path with weight 2 +1 , all the central edges are completely decomposed.The remaining graph and flow, without central edges, has 2 +1 weight-1 edges that are pairwise non-reachable using only non-zero flow edges (4 edges for each of the 2 −1 copies of G 1 ), each of which must be covered by a different path of weight 1 (and these paths fully decompose the flow).
Lemma 10.Let G with flow X ,2 +1 be constructed as described before.It is possible to decompose X ,2 +1 using 2 + 2 paths.
Proof.Using induction, we first prove that we can use 2 + 1 paths to decompose all of the flow of X ,2 +1 on the non-backbone edges of G , and that these paths have total weight 2 +2 − 3. When = 1 (see Figure 3c), we can decompose both the flow-1 edges with a single path of weight 1 which goes through the central edge.Moreover, we can decompose the C V I T 2 0 1 6

23:8
Width Helps and Hinders Splitting Flows ) with a 2 + 2 = 6 flow decomposition.Orange (weight 1) and dark and light blue (weight 2) decompose the non-backbone edges in the two copies of G1. Green and pink (weight 4) decompose the non-backbone edges added in G2.Dark red (weight 3) is the additional path needed to fully decompose the flow.
flow-2 edges with two paths of weight 2, without using the central edge.These paths have 5 = 2 1+2 − 3 total flow.We now assume that the claims hold for = k and prove it for = k + 1.Consider the graph G k+1 .By assumption, the non-backbone edges in every copy of G k are fully decomposed by 2k + 1 paths, and the total flow of those paths is 2 k+2 − 3. Note that these paths are s-t paths in G k , but they must be extended to be s-t paths in G k+1 .Because there is a central edge with weight 2 (k+1)+1 = 2 k+2 > 2 k+2 − 3 from one copy of G k to the other, it is possible to route the 2k + 1 paths from the first G k to the second using the central edge.Additionally, the backbone edges from s to the first copy of G k and from the second copy of G k to t have flow 2 k+1 + 2 k+2 , so they can be used to complete the routing of the paths from s to t.Then we can use two additional paths of weight 2 k+1 each to decompose the flow of the two new non-backbone edges; one using the backbone path of the upper G k (extended by the upper edges of G k+1 ), and analogously, the other through the backbone path of the lower G k , which is possible since the paths obtained inductively only decompose 2 k+1 of the backbone flow of G k whereas now 2 k+2 backbone flow must be decomposed.As such, we use 2k + 1 + 2 = 2(k + 1) + 1 paths with total flow 2 k+2 − 3 + 2(2 k+1 ) = 2 (k+1)+2 − 3, as required.By the previous, given any graph G , we can decompose all non-backbone edges using 2 + 1 paths.Note that removing these weighted paths from X ,2 +1 yields a flow on G (of value 3).Because the remaining edges (all backbone) form a path from s to t, and the remaining edge values form a flow on G , all remaining edges must have the same flow value, and can be covered by one path.Thus, 2 + 2 paths are sufficient to decompose X ,2 +1 .See Figure 4 for an example when = 2.
Theorem 1.The approximation ratio for greedy-weight on MFD N is Ω(m/ log m) for sparse graphs, in the worst case.
Proof.By Lemmas 9 and 10, greedy-weight uses Θ(2 ) paths to decompose the flow X ,2 +1 described above, whereas it is possible to decompose the flow with only Θ( ) paths.It can be easily verified by induction that the number of edges of G is 7 • 2 − 5.So the ratio between greedy-weight and the optimal for this instance is Ω( m log m ).While greedy-weight is most commonly used in applications, the approach was first presented as part of a general framework [28]: pick any optimality criteria for s-t paths that is saturating (i.e., fully decomposes at least one edge), and successively remove optimal paths.Since each path is saturating, the algorithm must decompose the flow in m or fewer paths.Another optimality criterion sometimes used in DNA assembly (e.g., in vg-flow [2]) is the longest path (with its maximum possible flow so that it is saturating).To adapt our construction of (G , X ,2 +1 ) so that this approach yields the same approximation ratio, consider (G * , X * ,2 +1 ), constructed as in (G , X ,2 +1 ) except that we split every backbone edge (u, v) into two edges, (u, w) and (w, v).See Figure 5 for an example.Then the path along the backbone edges will be the longest from s to t and the previous asymptotic analysis still holds, since we no more than doubled the number of edges (and the number of edges of the new construction is still Θ(2 )).Yet another optimality criterion, studied in [14] for its application to network routing, is the shortest path (again with its maximum possible flow).(G * , X * ,2 +1 ) will also force this approach to take an exponential number of paths, since first the algorithm will decompose all 2 +1 weight-1 edges with 2 +1 different paths.

Greedy approximation for width-stable graphs
As exploited in Section 3.1, one sticking point for greedy path removal algorithms is the fact that the width of a graph can increase after an edge is fully decomposed.We now identify a new class of graphs, in which the graph does not increase its width during the execution of the algorithm.We show that greedy-weight decomposes "enough" flow at each step in these graphs, giving a O(log |X|)-approximation for MFD N .
If X ≥ 0 is a flow on a DAG G, we write G| X (G restricted to X) to mean the spanning subgraph of G made up of the edges e ∈ E such that X(e) = 0. Conversely, if S is a subgraph of G, we write X| S (X restricted to S) to mean the pseudo-flow X only on the edges of S. In the case of MFD N , once an edge is fully decomposed, it cannot be used in future paths, possibly increasing the width of the graph that can be used to decompose the rest of the flow and sometimes triggering an increase of the size of a minimum flow decomposition as well.We call a graph width-stable if it does not have this issue.
Definition 11 (Width-stable graph).We say that a graph G is width-stable if, for any non-negative flows X ≤ Y on G, it holds that width(G| X ) ≤ width(G| Y ).Many useful MFD N instances satisfy Definition 11.For example, the first proof of MFD's NP-hardness [28] was a reduction to a very simple graph of this form, as shown in Figure 1; this means that MFD N restricted to width-stable graphs is also NP-hard.Definition 12 ([12]).We call an s-t DAG G funnel if every s-t path has a private edge that is not contained in any other s-t path.

C V I T
Funnels are simple graphs in the sense that they admit a unique flow decomposition [16].We use funnels in Lemma 13 to characterize graphs that are not width-stable.Funnels generalise in/out-forests: along any s-t path nodes v first satisfy deg . For a funnel subgraph F of G we call a path in G from a merging node in F to a forking node in F a central path of the funnel.The graphs (G , X ,B ) in Section 3.1 are precisely funnels with central paths.
The next property that we need is that there is always, during the execution of the greedy-weight algorithm, a path carrying "enough" flow from s to t.

Lemma 13. Let G be an s-t DAG. The following statements are equivalent:
1. G is width-stable, 2. G has paths of large weight: for any flow X ≥ 0 on G, there exists an s-t path in G| X carrying |X|/width(G| X ) flow, 3. G has no funnel subgraph with a central path.
See Figure 6 for an example.2): Let G = (V, E) be an s-t DAG with flow X ≥ 0 for which there is no s-t path in G| X carrying b = |X|/width(G| X ) flow.We will show that G is not width-stable.For simplicity, we assume G = G| X , the result follows immediately for any supergraph of G. Let S be the set of vertices reachable from s by a path carrying b flow.By assumption, t / ∈ S, so (S, V \ S) is an s, t-cut and X(u, v) < b for any edge (u, v) with u ∈ S, v ∈ V \ S. Define T to be the set of vertices that can reach t via a path involving vertices only from V \ S:

Proof. (1) =⇒ (
Since S ⊆ V \ T , (V \ T, T ) is an s, t-cut.Note that if (u, v) is an edge with u ∈ V \ T and v ∈ T , then also u ∈ S and v ∈ V \ S and thus X(u, v) < b.The set C defined by is an s, t-cut set (a set of edges that every s-t path has to cross) and we have X(e) < b for every e ∈ C.This implies |C| > width(G).
We construct a new flow Y ≥ 0 on G for which C is an antichain in G| Y .Initially, Y := X. Define the following paths: p s (u) for all u ∈ S: an s-u path with all nodes in S, p t (v) for all v ∈ T : a v-t path with all nodes in T .We keep the invariant that the paths exist and do not change in G| Y throughout the construction of Y .Let denote a path from v ∈ T to u ∈ S, all of whose internal nodes are from V \ (S ∪ T ), as b(v, u), and note that such a path exists iff C is not an antichain.Assume it carries flow µ > 0 (i.e., µ is the minimum flow along b(v, u)), we then perform the following operation on Y : Note that after the operation Y remains a flow and that none of the three paths have pairwise intersecting edges.The process does not violate the invariant and repeating eventually it destroys all paths from T to S, making C an antichain in G| Y .This shows that G is not width-stable: Y ≤ X + Y and width(G| Y ) > width(G| X+Y ) = width(G).
(2) =⇒ ( 3): Assume that G has a funnel subgraph F with a central path P .Let C be a maximum antichain of F , and note that every maximum antichain of a funnel consists of private edges only.We define flows Z stable , Z unstable and Z: Z stable is defined to be the flow induced3 by the minimum path cover of F4 (i.e., G| Z stable = F ). Z unstable is defined to be the flow induced by the following path cover of the graph consisting of F and P : One s-t path goes along P , covering two edges in C5 , and the other paths cover F avoiding P , this is possible with additional |C| − 2 paths.
but all s-t paths in G carry no more flow than 2, because C is an s, t-cut set of G and all Z flow values on C are 2.
(3) =⇒ (1): Assume that G = (V, E) is not width-stable, let Y ≥ X ≥ 0 be flows on G with width(G| X ) > width(G| Y ) and let C be a maximum antichain of G| X .Let F be a funnel subgraph of G| X containing C as maximum antichain, and let C be the rightmost maximum antichain of F (that is, the head of every edge in C is t or is merging).Since C is not an antichain of G| Y , there must be a path P in G| Y connecting two edges in C, and it starts at a merging node.It must also enter a forking node, because otherwise adding the path would not decrease the width.This shows that a prefix path of P is a central path of F .Finally, we show that series-parallel graphs are width-stable, and thus greedy-weight is a O(log |X|)-approximation on them.Proof.Using Theorem 2, it remains to prove that any series-parallel graph G = (V, E) with any flow X : E → N is width-stable.We prove it using structural induction.The base case is when G is single edge from s to t, and they are trivially width-stable.
Suppose now that G is obtained by the composition of series-parallel graphs G 1 , G 2 , and let X ≤ Y by any non-negative flows on G.
If the composition operation is parallel composition, then width(G) = width(G 1 ) + width(G 2 ) (since edges of G 1 cannot reach edges of G 2 , and vice versa) and width(G| X ) = x 1 + x 2 , width(G| Y ) = y 1 + y 2 (since G| X and G| Y are also series-parallel), and G is width-stable by the inductive hypothesis that x i ≤ y i , for i = 1, 2.
If the composition operation is series composition, width-stability follows analogously to the parallel composition by replacing sum with maximum.However, note that there are width-stable graphs that are not series-parallel.

4
Width helps solve MCCD Z In this section we give an approximation algorithm for mfd Z (G, X).We will obtain this for a more general problem variant, which can be defined as follows.We are given directed a graph G = (V, E, c) with no sink or source nodes, with (cost) a function c : E → R ≥0 .The cost of a circulation X is defined as c(X) = e∈E c(e)X(e).Note that c(•) is a linear function: c(X + Y ) = c(X) + c(Y ) for any two circulations X, Y on G.
Decomposition or MCCD Y and we write mccd Y (G, X) for the minimum cost.
Decomposing into non-negative weighted circulations rather than paths is a natural generalisation, as paths can also be seen as flows with value 1 along the path.The following reduction (Figure 7) shows that MFD Y can be regarded as a special case of MCCD Y .

Lemma 18. MCCD Y is NP-hard.
Proof.Given an s-t DAG G = (V, E) and flow X : E → Y, we define a graph G = (V, E , c) with E = E ∪ {(t, s)} and c : E → {0, 1}, c(u, v) = 1 ⇐⇒ (u, v) = (t, s), i.e. cost 1 only for the edge (t, s).Let X : E → Y, X (e) = X(e) for e ∈ E and X (t, s) = |X| be a circulation on G .The cost of a Minimum Cost Circulation Decomposition (Y 1 , w 1 ), . . ., The idea behind our approximation algorithm for MCCD Z is that a circulation X : E → Z on a graph G can always be decomposed into circulations of total cost ( log X +1)•mccc(G).

23:14 Width Helps and Hinders Splitting Flows
We show this using two key facts: first, that X can be decomposed into ( log X + 1) circulations with a particular structure, and, second, that each of these circulations can be further decomposed into circulations of total cost of at most mccc(G).A key step in proving both these facts is a subroutine which, given an input circulation X, finds another circulation Y with values from {0, ±1} only (a unitary circulation) that matches the parity of X on all edges.Intuitively, given an input circulation X, such a unitary circulation Y can be added to X to "fix" its odd edges to be even, with only a small change to X.

Proof. Consider the undirected graph
Notice that every node of G odd has even degree due to the conservation of circulation.Thus, G odd can be written as the edge-disjoint union of cycles.Assign an arbitrary orientation to each cycle and let E + odd be the set of edges oriented in this way.Define Notice that Y is a circulation decomposed as a sum of circulations, each along one of the edge-disjoint cycles.Moreover, X ≡ 2 Y and Y ≤ 1 by construction.
Repeatedly applying Lemma 21 and dividing the resulting even circulation by 2, we obtain the the first key ingredient of the approach.

Corollary 22. Any (non-zero) circulation
Proof.If ||X|| ≤ 1 the result follows.Otherwise apply Lemma 21 to obtain Y 0 such that X ≡ 2 Y and Y 0 ≤ 1.Since X ≡ 2 Y 0 , we can define X = (X −Y 0 )/2, and thus X = 2X +Y 0 .Recursively repeat this procedure on The following result is the second key ingredient of our approach.It guarantees that any unitary circulation can be decomposed into two circulations of total cost of at most mccc(G) (see Figure 8 for an example).This is by no means obvious since, among other problems, a unitary circulation may contain positive and negative values which merge and cancel each other out (as in Figure 8b).

Lemma 23. For any circulation
Proof.Take C such that C ≥ 1 and c(C) = mccc(G), according to Lemma 20.Take D such that D ≡ 2 X + C and D ≤ 1, according to Lemma 21.Also, assume c(D) ≥ 0 without loss of generality (otherwise, take −D, which satisfies the same properties).
Since       Finally, expressing any circulation as a sum of at most log X + 1 unitary circulations (Corollary 22), and decomposing each unitary circulation into two circulations with cost of at most mccc(G) (Lemma 23), we can decompose the circulation into circulations of total cost no more than log X + 1 whose weights are positive and negative powers of two.

Notice that
Theorem 24.Given a graph G = (V, E, c) and a circulation X : E → Z with k := log X , there exist circulations A i , B i for i = 0, . . ., k and weights {w 0 , . . ., Proof.Combine Corollary 22 and Lemma 23, getting The proof of Theorem 24 suggests a straightforward algorithm for MCCD Z , which we detail in Algorithm 2 and describe at a high level here.First, iteratively decompose X, yielding log X + 1 unitary circulations.Then use Lemma 23 to decompose each into two circulations of cost at most mccc(G).However, mccc(G) is not necessarily a lower bound on C V I T 2 0 1 6 Algorithm 1 Unitary(G,X): Produces a unitary circulation Y from an input circulation X such that X ≡2 Y , as in Lemma 21 1: E odd ← odd edges of G, undirected 2: C ← a decomposition of G odd = (V, E odd ) into cycles, oriented arbitrarily else 10: end if 12: end for 13: return Y MCCD Z if the circulation is 0 on some edges, and thus this approach does not directly derive an approximation.To overcome this issue, we instead find a circulation decomposition of a spanning subgraph G of G for which mccc(G ) lower bounds mccd Z (G, X).Namely, we first find a minimum cost circulation cover in G of the subset S of edges with non-zero flow in O(n log m(m + n log n)) time (according to Lemma 20), and then remove from G any edge not covered by the circulation, obtaining G .By construction, the cost of this circulation cover is a lower bound of mccd Z (G, X).Moreover, the cost of this circulation cover is exactly mccc(G ), since every circulation cover of G is also a circulation cover of S in G.
To prove the correctness of Algorithm 2, we first define a a subroutine implementing Lemma 21.Proof.The correctness of the algorithm is given by Lemma 21.Finally, the first 3 subroutines as well as the entire for-loop takes O(m) time.
Theorem 3. MCCD Z can be approximated with a factor of log X + 1 in runtime O(n log m(m + n log n) + m log X ).
Proof.By Theorem 24 and our previous discussion, Algorithm 2 returns a circulation decomposition for X with no more cost than ( log With the reduction given in Lemma 18, we obtain an approximation algorithm of the same ratio for MFD Z .However, we can improve the runtime of Lemma 20: Concatenate A and B to P Proof.This is directly achieved by using Theorem 3 with Lemma 18 and by calculating the width(G) according to Lemma 7. Note that the flows A and B need to be trivially decomposed into at most width(G) paths, causing the additional factor in the runtime.
A theorem analogous to Theorem 24 for MCCD N is desirable, but cannot be achieved directly with the previous methods, as Lemma 21 makes use of negative weights.However, the approach can be adapted for MCCD N if the input flows are width-stable (Definition 11), and if it is possible to "fix" the odd flows to be even with only mccc(G) unitary flows, which we leave as an open question.

Solving the k-Flow Weight Assignment Problem
In this section, we consider a restriction of MFD from [17] (see Figure 9 for an example).
Definition 27 (k-Flow Weight Assignment).Given a flow X : E → Y on a graph G = (V, E) and a set of s-t paths {P 1 , . . ., P k }, the problem of finding an assignment of weights to the paths, such that they form a flow decomposition of (G, X), is called k-Flow Weight Assignment (k-FWA).We write k-FWA Y if we require the path weights to belong to Y.
Given k s-t paths, k-FWA can be solved by a linear system defined by Lw = X, where X j ∈ Y is equal to the flow X(e j ) of the edge e j (we identify flows X : E → Y with vectors X ∈ Y m ) and L is the m × k 0/1 matrix with L i,j = 1 if and only if path P j crosses edge e i .The resulting solution w ∈ Y k is the weight assignment to each path.We shortly discuss how to solve k-FWA Z .The linear system defined by the paths is a system of linear Diophantine equations.It is well known that integer solutions to such systems can be found in polynomial time; see, e.g., [22,Chapter 5].

23:18 Width Helps and Hinders Splitting Flows
Solving k-FWA N turns out to be more difficult, its the linear system contains the inequality w ≥ 0. In fact, it was shown [17] that k-FWA N is NP-hard.The program Toboggan [17] implements a linear FPT algorithm for MFD N .and one step of the algorithm is to solve k-FWA N using an ILP [17].The authors state the following conjecture.
In case of a fractional decomposition (in which the weights of the paths are allowed to be rational non-negative numbers), it is indeed true that the induced linear system is of full rank k [28].As mentioned in the introduction, if the conjecture turned out to be true for natural numbers, Toboggan could avoid resorting to solving an ILP, since just solving the standard linear system at hand would return its unique solution.As observed by the authors, this would decrease the asymptotic worst case upper bound of Toboggan.
We show that this conjecture is false using a counterexample.Consider the input for k-FWA N from Figure 9 and the solution therein.We now give another solution for k-FWA N on this input, namely the following path weights: a 0 = 5, b 0 = 1, and a i = 6 2i + 2, b i = 6 2i+1 + 4, for i = 1, 2, 3.One can easily verify that this is another solution to k-FWA N on the input in Figure 9, thus proving that the rank of the corresponding linear system is strictly less than 8.
To disprove Conjecture 28, it remains to show that any flow decomposition contains at least 8 paths.Due to the technicality of this proof (and its exhaustive case-by-case analysis), we only explain the intuition behind the construction in Figure 9 and behind the correctness proof.However, as an additional check we also ran both Toboggan [17] and a recently developed ILP solver for MFD N [7] on this instance, both returning mfd N (G, X) = 8.
The intuition is as follows.The graph can be divided into two parts: the graph induced by the first 5 vertices in topological order (left part) and the one induced by the last 4 (right part).We say that a path is fixed if every minimum flow decomposition of the graph contains this path.The paths A i and B i have expoentially growing weight for growing i and get shuffled around with different permutations of the paired labels A i B j on the left part.Due to the exponential growth, ensuring the correct parity on all edges of the right part, we can fix the paths A i and B i for i = 1, 2, 3.This allows us to interpret flow decompositions of less than 8 paths as decompositions with 8 paths, where either A 0 or B 0 carries weight 0. Consider a flow decomposition where we assign two paths of weights λ 1 and λ 2 on the edges labeled A 0 B 0 .For any δ ≥ 0, (λ 1 − δ) + (λ 2 + δ) = a 0 + b 0 and equivalently for all other edges on the left part.If we decrease λ 1 by some δ > 0, the weights of B 1 , B 2 and B 3 each increase by δ/2.And thus, δ must be even.Due to the parity of a 0 and b 0 , they can never reach 0.

Conclusions
In this paper we have shown for the first time that width, a natural lower bound for MFD, is also useful when investigating its approximability.On the one hand, using width is a key insight in understanding where greedy path removal heuristics fail.On the other hand, graphs where width is well-behaved (e.g., series-parallel graphs) have a guaranteed approximation factor.Moreover, we generalised MFD to the problem to minimising the cost of a circluation decompisition, and showed that the integer version can be approximated even better by combining parity arguments of unitary circulations and a decomposition of such circulations of cost equal to the minimum cost to cover the graph.Finally, we have corroborated the complexity gap between the positive integer and the full integer case by disproving a conjecture from [17] (also motivating the heuristic in [23]), which would have had sped up their FPT algorithm for MFD N .
Our results open up new avenues for further research on MFD.For example, can the width help find larger classes of graphs for which some greedy path removal (or even some sort of greedy path cover removal) algorithms have a guaranteed approximation factor?Can we get Ω(n) worst case approximation ratio of greedy-weight for dense graphs without parallel edges?Can the power-of-two decomposition approach be applied with other factors besides two?Can better path cover-like lower bounds help (e.g., path covers which cannot use an edge more times than its flow value, also computable in polynomial time)?How do our algorithms perform in practice?

2 ( a )
, this is done by reduction to a min-flow instance If negative weights are allowed, the four paths decompose the flow with weights 4, 5, 8, and −3 (dark blue).

2 ( b )
With positive weights only, five paths are needed, since the edge (v1, v2) must be decomposed by a weight 1 path, leaving 4 edges that must be covered separately.The paths shown are one such decomposition.

Figure 2 A
Figure 2 A positive flow admitting a decomposition into four paths only if negative weights are allowed.
Decomposing the base case (G1, X 1,B ) ( = 1), for B = 2 +1 .All non-backbone edges can be decomposed with 2 +1 = 3 paths.The orange path has weight 1 and dark and light blue paths have weight 2. A fourth path (of weight 3) along the backbone is required to fully decompose the flow.

Figure 3
Figure 3 Construction for (G , X ,B ).Setting B = 2 +1 yields MFD N instances where greedyweight uses Θ( m log m ) times more paths than optimal to decompose the flow.

Figure 5
Figure 5By subdividing the backbone edges, choosing longest paths (orange) and shortest paths (blue) both give the same approximation ratio as choosing heaviest paths in the original flow X ,2 +1 .

Figure 6
Figure6MFD N instance with width(G) = 3, |X| = 7, |X|/width(G) = 7/3 > 2, but no path can carry more flow than 2. By Lemma 13, this is equivalent to G not being width-stable, there exists an s-t path saturating the central edge from v to u of weight 1, making the graph a funnel and increasing width(G) to 4.

Lemma 14 . 1 )
Let G = (V, E) be a width-stable graph, width(G) ≥ 2. Greedy-weight uses at most log |X|/ log width(G)  width(G)−1 + 1 paths to decompose any flow X :E → N. Proof.Let b = width(G).Since G is width-stable,greedy-weight removes a path of weight at least |X |/b at every step by Lemma 13, where X is the remaining flow of the corresponding step.As such, after c steps |X | ≤ |X| b−1 b c .If |X| b−1 b c < 1, then |X | = 0, since |X| and the weights of the removed paths belong to N. Solving for c we obtain c > log |X|/ log b b−1 .Therefore, greedy-weight takes (uses) at most c = log |X|/ log b b−1 + 1 steps (paths).Theorem 2. Let G = (V, E) be a width-stable graph and X : E → N a flow.Greedy-weight is a O(log |X|)-approximation for MFD N on (G, X).Proof.Assume X > 0 (otherwise, replace G by G| X ).Thus, b = width(G) ≤ mfd N (G, X), since any flow-decomposition of X induces a path cover of E. If b ≤ 1 greedy-weight finds an optimal solution.Otherwise b ≥ 2, and Lemma 14 implies that greedy-weight is a O( log |X| b log b b−=O(log |X|)-approximation for MFD N (b log b b−1 = O(1) for b ≥ 2).

1 Figure 7
Figure 7 Reduction in Lemma 18 of a graph with total flow 4 from MFD Y to MCCD Y .The bold edge is the addition to the DAG and is the only edge with cost 1 while all other edges have cost 0.

Definition 19 .
s) paths and assigning them weights w i yields a Flow Decomposition of (G, X), showing mccd Y (G , X ) ≥ mfd Y (G, X), and thus this Flow Decomposition is minimum.Given S ⊆ E and a graph G, we call a circulation C of minimum cost satisfying C(e) ≥ 1 for all e ∈ S Minimum Cost Circulation Cover of S, and we write mccc S (G) = c(C).If S = E, we use mccc(G) instead.Note that since every circulation decomposition of a graph G covers the edges of non-zero circulation, mccc S (G) ≤ mccd Y (G, X) with S = {e ∈ E | X(e) = 0}.This generalises the width lower bound of MFD Y to MCCD Y .Given an s-t DAG G, width(G) = mccc(G ) for the graph G obtained by the reduction in Lemma 18.We will need a Minimum Cost Circulation Cover for our approximation approach: Lemma 20 ([11], Theorem 3.6).Let G = (V, E, c) be a graph, and S ⊆ E. A Minimum Cost Circulation Cover of S can be computed in O(n log m(m + n log n)) time.
Unitary circulation X on a graph G and a decomposition into two non-negative circulations A and B, of weight 1 in orange (see (e)), and of weight −1 in blue (see (f)), respectively.
Unitary circulation D of cost 11 matching the parity of X +C, i.e., D ≡2 X + C (Lemma 21).

Figure 8
Figure 8 Example of Lemma 23 applied to a unitary circulation X on a graph G (for clarity, 0 circulation values are not shown).Non-negative circulations A and B can be constructed so that c(A) + c(B) ≤ mccc(G) holds.We obtain a decomposition of X by X = A − B.

Lemma 25 .
Algorithm 1 returns a unitary circulation from an input circulation Y such that X ≡ 2 Y , as in Lemma 21, in O(m) time.
analyse the runtime line by line.Lines 1 and 4 take O(n log m(m+n log n)) time by Lemma 20.The call to Algorithm 1 on line 5 takes O(m) time by Lemma 25, and checking the cost of D and flipping signs (if necessary) also takes O(m) time.By Corollary 22, the while loop on line 7 executes at most log X +1 times, meaning that the entire execution takes O(m log X ) time since line 8 takes O(m) time by Lemma 25.Since there are at most log X + 1 Y i 's, the for loop on line 13 executes at most log X + 1 times.Each execution of the for-loop finds two circulations of total cost of at most mccc(G ) in O(m) time, so the whole also loop takes O(m log X ) time.Thus, the overall runtime is O(n log m(m + n log n) + m log X ).

16 :Corollary 26 .
Concatenate 2 j and −2 j to W 17: end for 18: return (P, W) Algorithm 2 is also a log X + 1-approximation for MFD Z with runtime O(m(n + width(G) log X )).
For a flow graph (G, X), we denote by L Y = L Y (P 1 , . . ., P k ) = {w ∈ Y k |X = k j=1 P k w k } the linear system corresponding to the paths P 1 , . . ., P k .C V I T 2 0 1 6
[9]inition 15 (Series-parallel graph[9]).A graph is a two-terminal series-parallel ( seriesparallel for short) graph with terminal nodes s and t if: it consists of a single edge directed from s to t, and no other nodes, or it can be obtained from two (smaller) two-terminal series-parallel graphs G 1 and G 2 , with terminal nodes s 1 , t 1 , and s 2 , t 2 , respectively, by either identifying s = s 1 = s 2 and t = t 1 = t 2 ( parallel composition of G 1 and G 2 ), or identifying s = s 1 , t 1 = s 2 , and t = t 2 ( series composition of G 1 and G 2 ).Corollary 16.Greedy-weight is a O(log |X|)-approximation for MFD N on series-parallel graphs.