On Structural Parameterizations of the Edge Disjoint Paths Problem

In this paper we revisit the classical Edge Disjoint Paths (EDP) problem, where one is given an undirected graph G and a set of terminal pairs P and asks whether G contains a set of pairwise edge-disjoint paths connecting every terminal pair in P. Our focus lies on structural parameterizations for the problem that allow for efficient (polynomial-time or fpt) algorithms. As our first result, we answer an open question stated in Fleszar, Mnich, and Spoerhase (2016), by showing that the problem can be solved in polynomial time if the input graph has a feedback vertex set of size one. We also show that EDP parameterized by the treewidth and the maximum degree of the input graph is fixed-parameter tractable. Having developed two novel algorithms for EDP using structural restrictions on the input graph, we then turn our attention towards the augmented graph, i.e., the graph obtained from the input graph after adding one edge between every terminal pair. In constrast to the input graph, where EDP is known to remain NP-hard even for treewidth two, a result by Zhou et al. (2000) shows that EDP can be solved in non-uniform polynomial time if the augmented graph has constant treewidth; we note that the possible improvement of this result to an fpt-algorithm has remained open since then. We show that this is highly unlikely by establishing the W[1]-hardness of the problem parameterized by the treewidth (and even feedback vertex set) of the augmented graph. Finally, we develop an fpt-algorithm for EDP by exploiting a novel structural parameter of the augmented graph.


Introduction
The Edge Disjoint Paths (EDP) and Node Disjoint Paths (NDP) are fundamental routing graph problems. In the EDP (NDP) problem the input is a graph G, and a set P containing k pairs of vertices and the objective is to decide whether there is a set of k pairwise edge disjoint (respectively vertex disjoint) paths connecting each pair in P . These problems and their optimization versions -MaxEDP and MaxNDP -have been at the center of numerous results in structural graph theory, approximation algorithms, and parameterized algorithms [5,11,14,18,22,24,27,29,31]. When k is a part of the input, both EDP and NDP are known to be NP-complete [21]. Robertson and Seymour's seminal work in the Graph Minors project [29] provides an O(n 3 ) time algorithm for both problems for every fixed value of k. In the realm of Parameterized Complexity, their result can be interpreted as fixed-parameter algorithms for EDP and NDP parameterized by k. Here, one considers problems associated with a certain numerical parameter k and the central question is whether the problem can be solved in time f (k)·n O(1) where f is a computable function and n the input size; algorithms with running time of this form are called fpt-algorithms [6,8,15].
While the aforementioned research considered the number of paths to be the parameter, another line of research investigates the effect of structural parameters of the input graphs on the complexity of these problems. Fleszar, Mnich, and Spoerhase [14] initiated the study of NDP and EDP parameterized by the feedback vertex set number (the size of the smallest feedback vertex set) of the input graph and showed that EDP remains NP-hard even on graphs with feedback vertex set number two. Since EDP is known to be polynomial time solvable on forests [18], this left only the case of feedback vertex set number one open, which they conjectured to be polynomial time solvable. Our first result is a positive resolution of their conjecture. A key observation behind the polynomial-time algorithm is that an EDP instance with a feedback vertex set {x} is a yes-instance if and only if, for every tree T of G − {x}, it is possible to connect all terminal pairs in T either to each other or to x through pairwise edge disjoint paths in T .The main ingredient of the algorithm is then a dynamic programming procedure that determines whether such a set S T exists for a tree T of G − {x}.
Continuing to explore structural parameterizations for the input graph of an EDP instance, we then show that even though EDP is NP-complete when the input graph has treewidth two, it becomes fixed-parameter tractable if we additionally parameterize by the maximum degree.
Theorem 2. EDP is fixed-parameter tractable parameterized by the treewidth and the maximum degree of the input graph.
Having explored the algorithmic applications of structural restrictions on the input graph for EDP, we then turn our attention towards similar restrictions on the augmented graph of an EDP instance (G, P ), i.e., the graph obtained from G after adding an edge between every pair of terminals in P . Whereas EDP is NP-complete even if the input graph has treewidth at most two [27], it can be solved in non-uniform polynomial time if the treewidth of the augmented graph is bounded [31]. It has remained open whether EDP is fixed-parameter tractable parameterized by the treewidth of the augmented graph; interestingly, this has turned out to be the case for the strongly related multicut problems [19]. Surprisingly, we show that this is not the case for EDP, by establishing the W[1]-hardness of the problem parameterized by not only the treewidth but also by the feedback vertex set number of the augmented graph. Motivated by this strong negative result, our next aim was to find natural structural parameterizations for the augmented graph of an EDP instance for which the problem becomes fixed-parameter tractable. Towards this aim, we introduce the fracture number, which informally corresponds to the size of a minimum vertex set S such that the size of every component in the graph minus S is small (has size at most |S|). We show that EDP is fixed-parameter tractable parameterized by this new parameter.
Theorem 4. EDP is fixed-parameter tractable parameterized by the fracture number of the augmented graph.

XX:4
On Structural Paramerizations of EDP function defined on Σ * . Then L parameterized by p denotes the parameterized problem { (x, p(x)) | x ∈ L } where x ∈ Σ * . For a problem instance (x, k) ∈ Σ * × N we call x the main part and k the parameter. A parameterized problem P is fixed-parameter tractable (FPT in short) if a given instance (x, k) can be solved in time O(f (k) · p(|x|)) where f is an arbitrary computable function of k and p is a polynomial function; we call algorithms running in this time fpt-algorithms.
Parameterized complexity classes are defined with respect to fpt-reducibility. A parameterized problem P is fpt-reducible to Q if in time f (k) · |x| O (1) , one can transform an instance (x, k) of P into an instance (x , k ) of Q such that (x, k) ∈ P if and only if (x , k ) ∈ Q, and k ≤ g(k), where f and g are computable functions depending only on k. Owing to the definition, if P fpt-reduces to Q and Q is fixed-parameter tractable then P is fixedparameter tractable as well. Central to parameterized complexity is the following hierarchy of complexity classes, defined by the closure of canonical problems under fpt-reductions: All inclusions are believed to be strict. In particular, FPT = W [1] under the Exponential Time Hypothesis.
The class W [1] is the analog of NP in parameterized complexity. A major goal in parameterized complexity is to distinguish between parameterized problems which are in FPT and those which are W[1]-hard, i.e., those to which every problem in W [1] is fpt-reducible. There are many problems shown to be complete for W [1], or equivalently W[1]-complete, including the Multi-Colored Clique (MCC) problem [8]. We refer the reader to the respective monographs [6,8,15] for an in-depth introduction to parameterized complexity.

Integer Linear Programming
Our algorithms use an Integer Linear Programming (ILP) subroutine. ILP is a wellknown framework for formulating problems and a powerful tool for the development of FPT-algorithms for optimization problems.
Definition 2 (p-Variable Integer Linear Programming Optimization). Let A ∈ Z q×p , b ∈ Z q×1 and c ∈ Z 1×p . The task is to find a vector x ∈ Z p×1 which minimizes the objective function c ×x and satisfies all q inequalities given by A and b, specifically satisfies A ·x ≥ b. The number of variables p is the parameter.
Lenstra [25] showed that p-ILP, together with its optimization variant p-OPT-ILP (defined above), are in FPT. His running time was subsequently improved by Kannan [20] and Frank and Tardos [16] (see also [13]). Theorem 3 ( [13,16,20,25]). p-OPT-ILP can be solved using O(p 2.5p+o(p) · L) arithmetic operations in space polynomial in L, L being the number of bits in the input.

Treewidth
T is a tree such that:

XX:5
The width of a tree-decomposition is max t∈V (T ) |B t | − 1. The treewidth [23] of G is the minimum width taken over all tree-decompositions of G and it is denoted by tw(G). We call the elements of V (T ) nodes and B t bags.
While it is possible to compute the treewidth exactly using an fpt-algorithm [2], the asymptotically best running time is achieved by using the recent state-of-the-art 5-approximation algorithm of Bodlaender et al. [3]. Fact 1 ( [3]). There exists an algorithm which, given an n-vertex graph G and an integer k, in time 2 O(k) · n either outputs a tree-decomposition of G of width at most 5k + 4 and O(n) nodes, or correctly determines that tw(G) > k.
It is well known that, for every clique over Z ⊆ V (G) in G, it holds that every treedecomposition of G contains an element B t such that Z ⊆ B t [23]. Furthermore, if t separates a node t from another node t in T , [23]; this inseparability property will be useful in some of our later proofs. A treedecomposition (T, B t : t ∈ V (T )) of a graph G is nice if the following conditions hold:

1.
T is rooted at a node r such that |B r | = ∅. 2. Every node of T has at most two children.

3.
If a node t of T has two children t 1 and t 2 , then B t = B t1 = B t2 ; in that case we call t a join node. 4. If a node t of T has exactly one child t , then exactly one of the following holds: in that case we call t a forget node.

5.
If a node t of T is a leaf, then |B t | = 1; we call these leaf nodes.
The main advantage of nice tree-decompositions is that they allow the design of much more transparent dynamic programming algorithms, since one only needs to deal with four specific types of nodes. It is well known (and easy to see) that for every fixed k, given a tree-decomposition of a graph G = (V, E) of width at most k and with O(|V |) nodes, one can construct in linear time a nice tree-decomposition of G with O(|V |) nodes and width at most k [4]. Given a node t in T , we let Y t be the set of all vertices contained in the bags of the subtree rooted at t, i.e., Y t = B t ∪ p is separated from the root by t B p .

Closing the Gap on Graphs of Feedback Vertex Number One
In this section we develop a polynomial-time algorithm for EDP restricted to graphs with feedback vertex set number one. We refer to this particular variant as Simple Edge Disjoint Paths (SEDP): given an EDP instance (G, P ) and a FVS X = {x}, solve (G, P ).

Simple Edge Disjoint Paths (SEDP)
Input: A graph G, a minimal FVS X = {x} ⊆ V (G) for G and a set P of terminal pairs, i.e., a set of subsets of V (G) of size two. Question: Is there a set of pairwise edge disjoint paths connecting every set of two terminals in P ?
Additionally to our standard assumptions about EDP (given in Subsection 2.2), we will assume that: (1) every neighbor of x in G is a leaf in G − X, (2) x is not a terminal, i.e., x / ∈ P , and (3) every tree T in G − X is rooted in a vertex r that is not a terminal. Property (1) can be ensured by an additional leaf vertex l to any non-leaf neighbor n of x, removing the edge {n, x} and adding the edge {l, x} to G. Property (2) can be ensured by adding an additional leaf vertex l to x and replacing x with l in P and finally (3) can be ensured by adding a leaf vertex l to any non-terminal vertex r in T and replacing r with l in P .
A key observation behind our algorithm for SEDP is that whether or not an instance I = (G, P, X) has a solution merely depends on the existence of certain sets of pairwise edge disjoint paths in the trees T in G − X. In particular, as we will show in Lemma 1 later on, I has a solution if and only if every tree T in G − X is ∅-connected (see Definition 4). The main ingredient of the algorithm is then a bottom-up dynamic programming algorithm that determines whether a tree T in G−X is ∅-connected. We now define the various connectivity states of subtrees of T that we need to keep track of in the dynamic programming table.
Definition 4. Let T be a tree in G − X rooted at r (recall that we can assume that r is not in P ), t ∈ V (T ), and let S be a set of pairwise edge disjoint paths in G[T t ∪ X] and P ⊆ P (T t ), where T t is the subtree of T rooted at t.
We say that the set S γ ∅ -connects P in G[T t ∪ X] if for every a ∈ P ∩ T t , the set S either contains an a-x path disjoint from b, or it contains an a-b path disjoint from x, where {a, b} ∈ P . Moreover, for ∈ {γ X } ∪ P (T t ), we say that the set S -connects T t if S γ ∅ -connects P (T t ) \ { } and additionally the following conditions hold. If = γ X then S also contains a path from t to x. If = p for some p ∈ P (T t ) then: If p ∩ T t = {a, b} then S contains a t-a path disjoint from x and a b-x path disjoint from a or S contains a t-b path disjoint from x and an a-x path disjoint from b.
Informally, a tree T t is: γ ∅ -connected if all its terminal pairs can be connected in G[T t ∪ X] either to themselves or to x, γ X -connected if it is γ ∅ -connected and additionally there is a path from its root to x (which can later be used to connect some terminal not in T t to x via the root of T ), γ p -connected if all but one of its terminals, i.e., one of the terminals in p, can be connected in G[T t ∪ X] either to themselves or to x, and additionally one terminal in p can be connected to the root of T t (from which it can later be connected to x or the other terminal in p).

Lemma 1. (G, X, P ) has a solution if and only if every tree
Proof. Let S be a solution for (G, X, P ), i.e., a set of pairwise edge disjoint paths between all terminal pairs in P . Consider the set S of pairwise edge disjoint paths obtained from S after splitting all paths in S between two terminals a and b that intersect x, into two paths, one from a to x and the other from x to b. Then the restriction of S to any tree T in G − X shows that T is γ ∅ -connected.
In the converse direction, for every tree T in G − X, let S T be a set of pairwise edge disjoint paths witnessing that T is γ ∅ -connected. Consider a set p = {a, b} ∈ P and let T a and T b be the tree containing a and b, respectively. If T a = T b then either S Ta contains an a-b path or S Ta contains an a-x path and a b-x path. In both cases we obtain an a-b path in G. Similarly, if T a = T b then S Ta contains an a-x path and S T b contains a b-x path, whose concatenation gives us an a-b path in G. Since the union of all S T over all trees T in G − X is a set of pairwise edge disjoint paths, this shows that (G, X, P ) has a solution. This completes the proof of the lemma.
Due to Lemma 1, our algorithm to solve EDP only has to determine whether every tree in G − X is γ ∅ -connected. For a tree T in G − X, our algorithm achieves this by computing a set of labels L(t), where L(t) is the set of all labels ∈ {γ ∅ , γ X } ∪ P (T t ) such that T t is -connected, via a bottom-up dynamic programming procedure. We begin by arguing that for a leaf vertex l, the value L(l) can be computed in constant time. Proof. Since l is a leaf vertex, we conclude that T l is γ ∅ -connected if and only if either l / ∈ P or l ∈ P and (l, x) ∈ E(G). Similarly, T l is γ X -connected if and only if l / ∈ P and (l, x) ∈ E(G). Finally, T l is -connected for some ∈ P (T l ) if and only if l ∈ P . Since all these properties can be checked in constant time, the statement of the lemma follows.
We will next show how to compute L(t) for a non-leaf vertex t ∈ V (T ) with children t 1 , . . . , t l .

Definition 5.
We define the following three sets.
is the set of those children t i such that T i is γ X -connected and V t is the set comprising the remaining children. Observe that {V t , V ¬γ ∅ t , V γ X t } forms a partition of {t 1 , . . . , t l } and moreover γ ∅ ∈ L(t) and γ X / ∈ L(t) for every t ∈ V t . Let H(t) be the graph with vertex set V t ∪ V ¬γ ∅ t having an edge between t i and t j (for i = j) if and only if L(t i ) ∩ L(t j ) = ∅ and not both t i and t j are in V t . The following lemma is crucial to our algorithm, because it provides us with a simple characterization of L(t) for a non-leaf vertex t ∈ V (T ).
Lemma 3. Let t be a non-leaf vertex of T with children t 1 , . . . , t l . Then T t is: γ ∅ -connected if and only if L(t ) = ∅ for every t ∈ {t 1 , . . . , t l } and H(t) has a matching M such that |V ¬γ ∅ \ V (M )| ≤ |V γ X t |, γ X -connected if and only if L(t ) = ∅ for every t ∈ {t 1 , . . . , t l } and H(t) has a matching M such that Proof. Towards showing the forward direction let S be a set of pairwise edge disjoint paths witnessing that T t is -connected for some ∈ {γ ∅ , γ X } ∪ P (T t ). Then S contains the following types of paths: (T1) A path between a and b that does not contain x, where {a, b} ∈ P (T t ), (T2) A path between a and x, which does not contain b, where {a, b} ∈ P (T t ), (T3) A path between x and t (only if = γ X ), (T4) A path between a and t, which does not contain x, (only if = p for some p ∈ P (T t ) and a ∈ p), For every i with 1 ≤ i ≤ l, let S i be the subset of S containing all paths that use at least one vertex in T ti and let S i be the restriction of all paths in S i to G[T ti ∪ X]. Consider an i with 1 ≤ i ≤ l. Because the paths in S are pairwise edge disjoint, we obtain that at most one path in S contains the edge (t i , t). We start with the following observations.
(O1) If S i contains no path that contains the edge (t i , t), then S i shows that T ti is γ ∅ -connected. (O2) If S i contains a path say s i that contains the edge (t i , t), then the following statements hold.
(O21) If s i is a path of Type (T1) for some p ∈ P (T t ), then S i shows that T ti is p-connected, (O22) If s i is a path of Type (T2) for some p ∈ P (T t ), then the following statements hold.
and S contains a path that contains both edges (t i , t) and (t, t j ). We claim that M is a matching of H(t). Since an edge (t i , t) can be used by at most one path in S, it follows that the pairs in M are pairwise disjoint and it remains to show that Hence s is of Type (T1) for some terminal-pair p ∈ P (T t ), which implies that T ti and T tj are p-connected, as required.
In the following let t i ∈ V ¬γ ∅ . Because of Observation (O1), we obtain that S i contains a path, say s i , using the edge (t i , t) (otherwise T ti is γ ∅ -connected). Moreover, together with Observations (O2)-(O4), we obtain that either: (P1) s i is a path of Type (T1) for some p ∈ P (T t ), (P2) s i is a path of Type (T2) for some p ∈ P (T t ) and the endpoint of Because t is not connected to x and t is not a terminal, we obtain that if We now distinguish three cases depending on . If = ∅, then S contains no path of type (T4) and hence for every t i ∈ V ¬γ ∅ t either (P1) or (P2) has to hold. In particular, for this is not achievable contradicting our assumption that S is a witness to the fact that T t is γ ∅ -connected. If = γ X , then S contains a path of Type (T3), which due to Observation (O3) uses the edge (t , t) for some t ∈ V γ X t . Since again (P1) or (P2) has to hold for every Ganian, S. Ordyniak, and M.S. Ramanujan and this is not achievable contradicting our assumption that S is a witness to the fact that T t is γ X -connected.
Finally, if = p for some p ∈ P (T t ), then S contains a path of Type (T4), which due to Observation (O4) uses the edge (t , t) for some t ∈ {t 1 , . . . , t l } with p ∈ L(t ). Observe that t cannot be matched by M and hence M is also a matching of H(t) − {t }. Moreover, Since (P1) or (P2) has to hold for every | then this is not achievable contradicting our assumption that S is a witness to the fact that T t is p-connected.
Towards showing the reverse direction we will show how to construct a set S of pairwise edge disjoint paths witnessing that T t is -connected.
Then the set S of pairwise edge disjoint paths witnessing that T t is γ ∅ -connected is obtained as follows.
arbitrarily and let S 1 and S 2 be sets of pairwise edge disjoint paths witnessing that T ti and T tj are p-connected, respectively. Moreover, let s 1 ∈ S 1 and s 2 ∈ S 2 be the unique paths connecting a terminal in p with t i and t j , respectively. Then add all path in ( arbitrarily and let S 1 be a set of pairwise edge disjoint paths witnessing that T ti is p-connected. Moreover, let s 1 be the unique path in S 1 connecting a terminal in p with t i . Furthermore, let S 2 be a set of pairwise edge disjoint paths witnessing that T α(ti) is γ X -connected and let s 2 be the unique path in S 2 connecting x with α(t i ). Then add all path in (S 1 \{s 1 })∪(S 2 \{s 2 }) and additionally the path It is straightforward to verify that S witnesses that T t is γ ∅ -connected. If = γ X , then the set S of pairwise edge disjoint paths witnessing that T t is γ Xconnected is defined analogously to the case where = ∅ only that now step (S2) is replaced by: Let S be a set of pairwise edge disjoint paths witnessing that T t is γ X -connected and let s be the unique path in S connecting t with x. Then add all paths in S \ s to S and additionally the path obtained from s after adding the edge (t , t). Finally, for every child in Finally, if = p for some p ∈ P (T t ), then let t i be a child with p ∈ L(t i ) and let M be a matching of Then the set S of pairwise edge disjoint paths witnessing that T t is p-connected is obtained analogously to the case where = ∅ above only that we do not execute the steps (S1)-(S4) for t i but instead do the following: (S0) Let S be a set of pairwise edge disjoint paths witnessing that T ti is p-connected and let s be the unique path in S connecting a terminal in p to t i . Then we add all path in S \ {s } and additionally the path s This completes the proof of Lemma 3.
The following two lemmas show how the above characterization can be employed to compute L(t) for a non-leaf vertex t of T . Since the matching employed in Lemma 3 needs to maximize the number of vertices covered in V ¬γ ∅ , we first show how such a matching can be computed efficiently. Proof. We reduce the problem to Maximum Weighted Matching problem, which can be solved in time O( |V ||E|) [26]. The reduction simply assigns weight two to every edge that is completely contained in S, weight one to every edge between S and V (G) \ S, and weight zero otherwise. The correctness of the reduction follows because the weight of any matching M in the weighted graph equals the number of vertices in S covered by M .
. This can be achieved according to Lemma 4 respectively. For any ∈ P (T t ), again in accordance with Lemma 3, we compute for every child t of t with ∈ P (T t ), a matching M in Since t has at most two children t with ∈ P (T t ) and due to Lemma 4 such a matching can be computed in time O( √ ll 2 ), this is also the total running time for this step of the algorithm. If one of the at most two such matchings M satisfies |V ¬γ ∅ \ V (M )| ≤ |V γ X t |, we add to L(t) and otherwise we do not. This completes the description of the algorithm whose total running time can be obtained as the time required to construct H(t) (O(l 2 |P (T t )|) plus |P (T t )| + 2 times the time required to compute the required matching in H(t) (O( √ ll 2 )), which results in a total running time of We are now ready to put everything together into an algorithm that decides whether a tree T is γ ∅ -connected.
Proof. The algorithm computes the set of labels L(t) for every vertex t ∈ V (T ) using a bottom-up dynamic programming approach. Starting from the leaves of T , for which the set of labels can be computed due to Lemma 2 in constant time, it uses Lemma 5 to compute L(t) for every inner node t of Proof. We first employ Lemma 6 to determine whether every tree T of G−X is γ ∅ -connected. If so we output Yes and otherwise No. Correctness follows from Lemma 1.

Treewidth and Maximum Degree
The goal of this section is to obtain an fpt-algorithm for EDP parameterized by the treewidth ω and maximum degree ∆ of the input graph.
where ω, ∆ and n are the treewidth, maximum degree and number of vertices of the input graph G, respectively.
Proof. Let (G, P ) be an instance of EDP and let (T, B) be a nice tree-decomposition of G of width at most k = 5ω + 4; recall that such (T, B) can be computed in time 2 O(k) by Fact 1. Consider the following leaf-to-root dynamic programming algorithm Å, executed on T . At each bag B t associated with a node t of T , Å will compute a table M t of records, which are tuples of the form {(used, give, single)} where: used is a multiset of subsets of B t of cardinality 2 with each subset occurring at most ∆ times, give is a mapping from subsets of B t of cardinality 2 to [∆], and single is a mapping which maps each terminal a i ∈ Y t such that its counterpart b i ∈ Y t to an element of B t .
Before we proceed to describe the steps of the algorithm itself, let us first introduce the semantics of a record. For a fixed t, we will consider the graph G t obtained from G[Y t ] by removing all edges with both endpoints in B t (we note that this "pruned" definition of G t is not strictly necessary for the algorithm, but makes certain steps easier later on). Then α = {(used, give, single)} ∈ M t if and only if there exists a set of edge disjoint paths Q in G t and a surjective mapping τ from terminal pairs occurring in Y t to subsets of B t of size two with the following properties: For each terminal pair ab that occurs in Y t : • Q either contains a path whose endpoints are a and b, or • Q contains an a-x 1 path for some x 1 ∈ B t and a b-x 2 path for some x 2 ∈ B t which is distinct from x 1 , and furthermore τ (ab) = {x 1 , x 2 } ∈used; for each terminal pair ab such that a ∈ Y t but b ∈ Y t : • Q contains a path whose endpoints are a and x ∈ B t , where (a, x) ∈ single; In the above case, we say that Q witnesses α. It is important to note that the equivalence between the existence of records and sets Q of pairwise edge disjoint paths only holds because of the bound on the maximum degree. That is because every vertex of G has degree at most ∆, it follows that any set Q of pairwise edge disjoint paths can contain at most ∆ paths containing a vertex in the boundary. Moreover, we note that by reversing the above considerations, given a set of edge disjoint paths Q in G t satisfying a certain set of conditions, we can construct in time 3 ∆k a set of records in M t that are witnessed by Q (one merely needs to branch over all options of assigning paths in α which end in the boundary: they may either contribute to give or to single or to used). These conditions are that each path either (i) connects a terminal pair, (ii) connects a terminal pair to two vertices in B t , (iii) connects two vertices in B t , or (iv) connects a terminal a ∈ Y t whose counterpart b / ∈ Y t to a vertex in B t . Å runs as follows: it begins by computing the records M t for each leaf t of T . It then proceeds to compute the records for all remaining nodes in T in a bottom-up fashion, until it computes M r . Since B r = ∅, it follows that (G, P ) is a yes-instance if and only if (∅, ∅, ∅) ∈ M r . For each record α, it will keep (for convenience) a set Q α of edge disjoint paths witnessing α. Observe that while for each specific α there may exist many possible choices of Q α , all of these interact with B t in the same way.
We make one last digression before giving the procedures used to compute M t for the four types of nodes in nice tree-decompositions. First, observe that the size of one particular record is at most ∆k 2 + ∆k 2 + |single|. Since the number of edge disjoint paths in G t ending in B t is upper-bounded by ∆k, it follows that each record in M t satisfies |single| ≤ ∆k and in particular each such record has size at most O(∆k 2 ). As a consequence, |M t | ≤ 2 O(∆k 2 ) for each node t in T , which is crucial to obtain an upper-bound on the running time of Å. 1. for each x, y ∈ B t , we set give(xy) := give p (xy) + give q (xy); 2. for each terminal pair v, w such that (v, ? v ) ∈ single p and (w, ? w ) ∈ single q where ? v =? w , • we delete (v, ? v ) from single p and • we delete (w, ? w ) from single q ; 3. for each terminal pair v, w such that (v, ? v ) ∈ single p and (w, ? w ) ∈ single q where ? v =? w , • we delete (v, ? v ) from single p and • we delete (w, ? w ) from single q and • we add {? v , ? w } to used; 4. we set used := used ∪ used p ∪ used q ; 5. we set single := single p ∪ single q ; 6. finally, we restore the records in M p and M q to their original state as of step 1 (i.e., we restore all deleted items).
Case 4: t is a forget node: Let p by the child of t in T and let v be the vertex forgotten at t, i.e., v ∈ B p \ B t . We note that this will be the by far most complicated step, since we are forced to account for the edges between v and its neighbors in B t . Let us begin by considering how the records in M t can be obtained from those in M p ; in particular, let us fix an arbitrary α = (used t , give t , single t ) ∈ M t . This means that there exists a set Q α of edge disjoint paths (along with a mapping τ ) in G t satisfying the conditions i.e., E v is the set of edges which are not present in G p but are present in G t . The crucial observation is that for each set Q α , there exists a set Q β of edge disjoint paths satisfying the conditions given by some β = (used p , give p , single p ) ∈ M p such that Q α can be obtained by merely "extending" Q β using the edges in E v ; in particular, E v can increase the number of paths contributing to give p , change the endpoints of paths captured by used p , and also change the endpoints of paths captured by single p .
Formally, we will proceed as follows. For each β ∈ M p , we begin with the witness Q β stored by Å, and then branch over all options of how the addition of the edges in E v may be used to augment the paths in Q β . In particular, since |E v | ≤ k, there are at most k + 1 vertices incident to an edge in E v , and due to the degree bound of ∆ it then follows that there are at most ∆(k + 1) distinct paths in Q β which may be augmented by E v . Since each edge in E v may either be assigned to extend one such path or form a new path, we conclude that there exist at most k O(∆k) possible resulting sets of edge-disjoint paths in G t . For each such set Q of edge-disjoint paths, we then check that conditions (i)-(iv) for constructing records witnessed by Q hold, and in the positive case we construct these records in time 3 ∆k as argued earlier and add them to M t .

Summary and running time.
Algorithm Å begins by invoking Fact 1 to compute a tree-decomposition of width at most k = 5ω + 4 and O(n) nodes, and then converts this into a nice tree-decomposition (T, B) of the same width and also O(n) nodes. It then proceeds to compute the records M t (along with corresponding witnesses) for each node t of T in a leaves-to-root fashion, using the procedures described above. The number of times any procedure is called is upper-bounded by O(n), and the running time of every procedure is upper-bounded by the worst-case running time of the procedure for forget nodes. There, for each record β in the data table of the child of t, the algorithm takes its witness Q β and uses branching to construct at most k O(∆k) new witnesses (after the necessary conditions are checked). Each such witness Q α gives rise to a set of records that can be computed in time 3 ∆k , which are then added to M t (unless they are already there). All in all, the running time of this procedure is upper-bounded by 2 O(∆k 2 ) · k O(∆k) · 3 ∆k = 2 O(∆k 2 ) , and the run-time of the algorithm follows.

Lower Bounds of EDP for Parameters of the Augmented Graph
In this section we will show that EDP parameterized by the feedback vertex set number (and hence also parameterized by the treewidth) of the augmented graph is W[1]-hard. This nicely complements the result in [31] showing that EDP is solvable in polynomial time for bounded treewidth and also provides a natural justification for the fpt-algorithm presented in the next section, since it shows that more general parameterizations such as treewidth are unlikely to lead to an fpt-algorithm for EDP. On the way towards this result, we provide hardness results for several interesting versions of the multidimensional subset sum problem (parameterized by the number of dimensions) which we believe are interesting in their own right. In particular, we note that the hardness results also hold for the well-known and more general multidimensional knapsack problem [17]. Our first auxiliary result shows hardness for the following problem.

Multidimensional Subset Sum (MSS)
Input: An integer k, a set S = {s1, . . . , sn} of item-vectors with si ∈ N k for every i with 1 ≤ i ≤ n and a target vector t ∈ N k . Parameter: k Question: Is there a subset S ⊆ S such that s∈S s = t?
Lemma 7. MSS is W[1]-hard even if all integers in the input are given in unary.
Proof. We prove the lemma by a parameterized reduction from Multicolored Clique, which is well-known to be W[1]-complete [28]. Given an integer k and a k-partite graph G with partition V 1 , . . . , V k , the Multicolored Clique problem ask whether G contains a k-clique. In the following we denote by E i,j the set of all edges in G with one endpoint in V i and the other endpoint in V j , for every i and j with 1 ≤ i < j ≤ k. To show the lemma, we will construct an instance I = (k , S, t) of MSS in polynomial time with k = 2 k 2 + k and all integers in I are bounded by a polynomial in |V (G)| such that G has a k-clique if and only if I has a solution.
For our reduction we will employ so called Sidon sequences of natural numbers. A Sidon sequence is a sequence of natural numbers such that the sum of every two distinct numbers in the sequence is unique. For our reduction we will need a Sidon sequence of |V (G)| natural numbers, i.e., containing one number for each vertex of G. Since the numbers in the Sidon sequence will be used as numbers in I, we need to ensure that the largest of these numbers is bounded by a polynomial in |V (G)|. Indeed [12] shows that a Sidon sequence containing n elements and whose largest element is at most 2p 2 , where p is the smallest prime number larger or equal to n, can be constructed in polynomial time. Together with Bertrand's postulate [1], which states that for every natural number n there is a prime number between n and 2n, we obtain that a Sidon sequence containing |V (G)| numbers and whose largest element is at most 8|V (G)| 2 can be found in polynomial time. In the following we will assume that we are given such a Sidon sequence S and we denote by S(i) the i-th element of S for any i with 1 ≤ i ≤ |V (G)|. Moreover, we denote by max(S) and max 2 (S) the largest element of S and the maximum sum of any two numbers in S, respectively. We will furthermore assume that the vertices of G are identified by numbers between 1 and |V (G)| and therefore S(v) is properly defined for every v ∈ V (G).
We are now ready to construct the instance I = (k , S, t). We set k = 2 k 2 + k and t is the vector whose first k 2 entries are all equal to max 2 (S) + 1 and whose remaining k 2 + k entries are all equal to 1. For every i and j with 1 ≤ i < j ≤ k, we will use I(i, j) as a means of enumerating the indices in a sequence of two-element tuples; formally, I(i, j) = ( l<i l=1 (k − l)) + (j − 1). Note that the vector t and its indices can then be visualized as follows: We now proceed to the construction of S, which will contain one element for each edge and for each vertex in G. In particular, the set S of item-vectors contains the following elements: for every i with 1 ≤ i ≤ k and every v ∈ V i , a vector s v such that all entries with index in { I(l, r) | 1 ≤ l < r ≤ k ∧ l = i } ∪ { I(l, r) | 1 ≤ l < r ≤ k ∧ r = i } are equal to S(v) (informally, this corresponds to all indices where at least one element of the tuple (l, r) is equal to i), the 2 k 2 + i-th entry is equal to 1, and all other entries are equal to 0, for every i and j with 1 ≤ i < j ≤ k and every e = {u, v} ∈ E(i, j), a vector s e such that the entry I(i, j) is equal to (max 2 (S) + 1) − (S(u) + S(v)), the k 2 + I(i, j)-th entry is equal to 1, and all other entries are equal to 0.
This completes the construction of I. It is clear that I can be constructed in polynomial time and moreover every integer in I is at most max 2 (S) + 1 and hence polynomially bounded in |V (G)|. Intuitively, the construction relies on the fact that since the sum of each pair of vertices is unique, we can uniquely associate each pair with an edge between these vertices whose value will then be the remainder to the global upper-bound of max 2 (S).
It remains to show that G has k-clique if and only if I has a solution. Towards showing the forward direction, let C be a k-clique in G with vertices v 1 , .
Towards showing the reverse direction, let S be a subset of S such that s∈S s = t. Because the last k entries of t are equal to 1 and for every i with 1 ≤ i ≤ k, it holds that the only vectors in S that have a non-zero entry at the i-th last position are the vectors in Using a similar argument for the entries of t with indices between k 2 +1 and 2 k 2 , we obtain that S contains exactly one vector say e i,j in { s e | e ∈ E i,j } for every i and Observe that because any solution S of the constructed instance in the previous lemma must be of size exactly k = 2 k 2 + k, it follows that the above proof also shows W[1]-hardness of the following problem.

Restricted Multidimensional Subset Sum (RMSS)
Input: An integer k, a set S = {s1, . . . , sn} of item-vectors with si ∈ N k for every i with 1 ≤ i ≤ n, a target vector t ∈ N k , and an integer k . Parameter: k + k Question: Is there a subset S ⊆ S with |S | = k such that s∈S s = t?
Using an fpt-reduction from the above problem, we will now show that also the following more relaxed version is W[1]-hard.

Multidimensional Relaxed Subset Sum (MRSS)
Input: An integer k, a set S = {s1, . . . , sn} of item-vectors with si ∈ N k for every i with 1 ≤ i ≤ n, a target vector t ∈ N k , and an integer k . Parameter: k + k Question: Is there a subset S ⊆ S with |S | ≤ k such that s∈S s ≥ t?
showing that S is a solution for I.
Towards showing the reverse direction, let S ⊆ S be a solution for I , i.e., |S | ≤ k and s∈S s ≥ t. We claim that the set S = { s | s ∈ S } is a solution for I. Because S is a solution for I , we obtain for every i with 1 ≤ i ≤ k that:  (1), observe that |S | > k − 1 and in particular |S | = k . Then by using this, we obtain that k t

It follows from (1) and (2) that s∈S s[i] = t[i]
and hence S is a solution for I of size k , as required.
Our next step is to move from subset sum problems to EDP variants, with a final goal of showing the hardness of EDP parameterized by the feedback vertex set number of the augmented graph. We will first show that the following directed version, which also allows for multiple instead of just one path between every terminal pair, is W[1]-hard parameterized by the feedback vertex set number of the augmented graph and the number of terminal pairs.

Multiple Directed Edge Disjoint Paths (MDEDP)
Input: A directed graph G, a set P of triples (si, ti, ni) with 1 ≤ i ≤ , si, ti ∈ V (G), and ni ∈ N. Question: Is there a set of pairwise edge disjoint paths containing ni paths from si to ti for every i with 1 ≤ i ≤ ? Lemma 9. MDEDP is W[1]-hard parameterized by the following parameter: the feedback vertex set number of the undirected augmented graph plus the number of terminal triples. Furthermore, this holds even for acyclic instances when all integers on the input are given in unary.
Proof. We prove the lemma by a parameterized reduction from MRSS. Namely, given an instance I = (k, S, t, k ) of MRSS we construct an equivalent instance I = (G, P ) of MDEDP in polynomial time such that |P | ≤ k + 1, fvs(G P ) ≤ 2k + 2 and G is acyclic.
We start by introducing a gadget G(s) for every item-vector s ∈ S. G(s) is a directed path (p s 1 , . . . , p s l ), where l = 2( 1≤i≤k s[i]) + 2. We let P contain one triple (s, t, |S| − k ) as well as one triple (s i , t i , t[i]) for every i with 1 ≤ i ≤ k. Then G is obtained from the disjoint union of G(s) for every s ∈ S plus the vertices {s, t, s 1 , t 1 , . . . , s k , t k }. Moreover, G contains the following edges: one edge from s to the first vertex of G(s) for every s ∈ S, one edge from the last vertex of G(s) to t for every s ∈ S, for every i with 1 ≤ i ≤ k and every s ∈ S an edge from s i to the vertex p s j (in G(s)), This completes the construction of (G, P ). Since G P − {s, t, s 1 , t 1 , . . . , s k , t k } is a disjoint union of directed paths, i.e., one path G(s) for every s ∈ S, we obtain that G P has a feedback vertex set, i.e., the set {s, t, s 1 , t 1 , . . . , s k , t k }, of size at most 2(k + 1) = 2k + 2. Moreover, G is clearly acyclic and |P | ≤ k + 1. It hence only remains to show that (k, S, t, k ) has a solution if and only if so does (G, P ).
Towards showing the forward direction let S ⊆ S be a solution for I. Then we construct a set Q of pairwise edge-disjoint paths in G containing |S| − k path from s to t as well as t[i] paths from s i to t i , i.e., a solution for I , as follows. For every s ∈ S \ S , Q contains the path (s, G(s), t), which already accounts for the |S| − k paths from s to t. Moreover, for every i with 1 ≤ i ≤ k and s ∈ S , Q contains the path (s i , p j , p j+1 , t i ) for every j with 1 + 2( 1≤j<i s[j]) < j ≤ 1 + 2( 1≤j<i s[j]) + 2(s[i]) and j is even. This concludes the definition of Q. Note that Q now contains s∈S s[i] paths from s i to t i for every i with 1 ≤ i ≤ k and since S is a solution for I, it holds that s∈S s[i] ≥ t[i]. Consequently, Q is a solution for I .
Towards showing the reverse direction, let Q be a solution for I . Then Q must contain |S| − k pairwise edge disjoint paths from s to t. Because every path from s to t in G must have the form (s, G(s), t) for some s ∈ S, we obtain that all the edges of exactly |S| − k gadgets G(s) for s ∈ S are used by the paths from s to t in G. Let S ⊆ S be the set containing all s ∈ S such that G(s) is not used by a path from s to t in Q. We claim that S is a solution for I. Clearly, |S | = k and it remains to show that s∈S s ≥ t. Towards showing this observe that for every i with 1 ≤ i ≤ k, a path from s i to t i has to use at least one edge {p s j , p s j+1 } from some s ∈ S and j with 1 + 2( 1≤j<i s[i]) < j ≤ 1 + 2( 1≤j≤i s[i]) and j is odd. Since G(s) for every s ∈ S has at most s[i] of those edges, we obtain that for every s ∈ S , Q contains at most s[i] path from s i to t i using edges in G(s). Because the paths in Q from s i to t i cannot use any edge from G(s) such that s / ∈ S ; this is because all edges of such G(s) are already used by the paths from s to t in Q. Hence the total number of paths in Q from s i to t i is at most s∈S s[i] and since Q contains t[i] paths from s i to Our next aim is now to reduce from MDEDP to the following undirected version of MDEDP.

Multiple Undirected Edge Disjoint Paths (MUEDP)
Input: An undirected graph G, a set P of triples (si, ti, ni) with 1 ≤ i ≤ , si, ti ∈ V (G), and ni ∈ N. Question: Is there a set of pairwise edge disjoint paths containing ni paths from si to ti for every i with 1 ≤ i ≤ ?
To do so we first need the following auxiliary lemma.
Lemma 10. Let I = (G, P ) be an instance of MDEDP such that G is acyclic. Then in polynomial time we can construct an instance I = (G , P ) such that: (P1) I has a solution if and only if so does I , (P2) G is acyclic and the graph G (P ) is Eulerian, where G is the graph obtained from G after adding n edges from t to s for every (s, t, n) ∈ P , (P3) |P | ≤ |P | + 1 and fvs(G ) ≤ fvs(G) + 2.
Proof. The construction of I is based on the construction of (G , H ) from (G, H) in [30,Theorem 2]. Namely, for every and ρ D (v) denote the number of outneighbors respectively in-neighbors of a vertex v in a directed graph D. . Then We now construct the instance I = (G , P ) from (G, P ) by adding one triple (s, t, q) to P as well as adding the vertices s and t together with α(v) edges from s to v and β(v) edges from v to t for every v ∈ V (G). It is straightforward to verify that I satisfies Properties (P2) and (P3). Moreover, the reverse direction of Property (P1) is trivial. Towards showing the forward direction of Property (P1), assume that I has a solution S and let G be the graph obtained from G after removing all edges appearing in a path in S. Then G ({(s, t, q)}) is Eulerian and G is acyclic, hence there are q pairwise edge-disjoint paths in G from s to t.
We are now ready to show that MUEDP is W[1]-hard parameterized by the combined parameter the feedback vertex set number of the augmented graph and the number of terminal triples.
Lemma 11. MUEDP is W[1]-hard parameterized by the following parameter: the feedback vertex set number of the augmented graph plus the number of terminal triples. Furthermore, this holds even when all integers on the input are given in unary.
Proof. We prove the lemma by a parameterized reduction from MDEDP. Namely, given an instance I = (G, P ) of MDEDP we construct an equivalent instance I = (H, Q) of MUEDP in polynomial time such that |Q| ≤ |P | + 1, fvs(H Q ) ≤ fvs(G P ). The result then follows from Lemma 9.
Let (G , P ) be the instance of MDEDP obtained from (G, P ) by Lemma 10. Then I = (H, P ) is simply obtained from (G , P ) by disregarding the directions of all edges in G . Because of Lemma 10, we obtain that |Q| ≤ |P | + 1 and fvs(H Q ) ≤ fvs(G P ) and it hence only remains to show the equivalence of I and I . Note that because of Lemma 10, it holds that (G , P ) is acyclic and G (P ) is Eulerian. It now follows from [30, Lemma 5] that (G , P ) and (H, P ) are equivalent, i.e., any solution for (G , P ) is a solution for (H, P ) and vice versa. Together with the equivalency between (G, P ) and (G , P ) (due to Lemma 10) this shows that I and I are equivalent and concludes the proof of the lemma.
Finally, using a very simple reduction from MUEDP we are ready to show that EDP is W[1]-hard parameterized by the feedback vertex set number of the augmented graph. Proof. We prove the lemma by a parameterized reduction from MUEDP. Namely, given an instance I = (G, P ) of MUEDP we construct an equivalent instance I = (G , P ) of EDP in polynomial time such that fvs(G P ) ≤ fvs(G P ) + 2|P |. The result then follows from Lemma 11.
I is obtained from I as follows. For every (s, t, n) ∈ P , we add 2n new vertices s 1 , . . . , s n and t 1 , . . . , t n to G and an edge between s i and s as well as an edge between t i and t for every 1 ≤ i ≤ n. Moreover, for every i with 1 ≤ i ≤ n, we add the terminal pair (s i , t i ) to P . It is straightforward to verify that I and I are equivalent. Moreover, if F is a feedback vertex set for G P , then F ∪ { s, t | (s, t, n) ∈ G } is a feedback vertex set for G P and hence fvs(G P ) ≤ fvs(G P ) + 2|P |, which concludes the proof of the theorem.

An fpt-Algorithm for EDP using the Augmented Graph
In light of Theorem 3, it is natural to ask whether there exist natural structural parameters of the augmented graph which would give rise to fpt-algorithms for EDP but which cannot be used on the input graph. In other words, does considering the augmented graph instead of the input graph provide any sort of advantage in terms of fpt-algorithms? In this section we answer this question affirmatively by showing that EDP is fixed-parameter tractable parameterized by the so-called fracture number of the augmented graph. We note that a parameter similar to the fracture number has recently been used to obtain fpt-algorithms for Integer Linear Programming [10].

Definition 6.
A vertex subset X of a graph H is called a fracture modulator if each connected component in H \ V contains at most |X| vertices. We denote the size of a minimum-cardinality fracture modulator in H as frac(H) or the fracture number of H.
Note the the fracture number is always at most the treewidth of the augmented graph and even though it is known that EDP parameterized by the treewidth of the augmented graph is in XP [31], it open whether it is in FPT. Moreover, [14,Theorem 6] shows that EDP parameterized by the fracture number of the input graph is paraNP-hard. We begin by making a simple structural observation about fracture modulators. Lemma 7. Let (G, P ) be an instance of EDP and let k be the fracture number of its augmented graph. Then there exists a fracture modulator X of G P of size at most 2k such that X does not contain any terminal vertices. Furthermore, such a fracture modulator X can be constructed from any fracture modulator of size at most k in linear time.
Proof. Let X be arbitrary fracture modulator of size k and let P ⊆ P be the set of terminal pairs p such that p ∩ X = ∅. Consider the set X = X \ P ∪ { N G (a) | a ∈ P }. Because every terminal a ∈ P has at most one neighbor in G (recall our assumption on (G, P ) given in Subsection 2.2), it holds that |X| ≤ 2|X |. Moreover, for vertex a that we removed from X , it holds that a is in a component of size two in G P \ X, i.e., the component consisting of a and b where {a, b} ∈ P . Consequently, every component of G P − X either has size two or it is a subset of a component of G P − X .
We note that the problem of computing a fracture modulator of size at most k is closely related to the Vertex Integrity problem [9], and that a variant of it has been recently considered in the context of Integer Linear Programming [10]. If G is connected and |V (G)| ≤ c, the algorithm returns the empty set as a solution. Otherwise, i.e., if G is connected but |V (G)| > c the algorithm first computes a set D of c+1 vertices of G such that G[D] is connected. This can for instance be achieved by a depth-first search that starts at any vertex of G and stops as soon as c+1 vertices have been visited. The algorithm then branches on the vertices in D, i.e., for every v ∈ D the algorithm recursively computes a solution for the instance (G−{v}, k−1). It then returns the solution of minimum size returned by any of those recursive calls, or NO if none of those calls return a solution. This completes the description of the algorithm. The correctness of the algorithm follows immediately from the above observations. Moreover the running time of the algorithm is easily seen to be dominated by the maximum time required for the case that at each step of the algorithm G is connected. In this case the running time can be obtained as the product of the number of branching steps times the time spent on each of those. Because at each recursive call the parameter k is decreased by at least one and the number of branching choices is at most c + 1, we obtain that there are at most (c + 1) k = (k + 1) k branching steps. Furthermore, the time at each branching step is dominated by the time required to check whether G is connected, which is linear in the number of edges of G. Putting everything together, we obtain O((k + 1) k |E(G)|) as the total time required by the algorithm, which completes the proof of the lemma.
We note that the depth-first search algorithm in the above proof can be easily transformed into a polynomial time approximation algorithm for finding fracture modulators, with an approximation ratio of k+1. In particular, instead of branching on the vertices of a connected subgraph D of G with k + 1 vertices, this algorithm would simply add all the vertices of D into the current solution.
For the rest of this section, let us fix an instance (G, P ) of EDP with a fracture modulator X of G P of cardinality k which does not contain any terminals. Furthermore, since the subdivision of any edge (i.e., replacing an edge by a path of length 2) in (G, P ) does not change the validity of the instance, we will assume without loss of generality that G[X] is edgeless; in particular, any edges that may have had both endpoints in X will be subdivided, creating a new connected component of size 1.
Our next step is the definition of configurations. These capture one specific way a connected component C of G P − X may interact with the rest of the instance. It will be useful to observe that for each terminal pair ab there exists precisely one connected component C of G P − X which contains both of its terminals; we say that ab occurs in C. For a connected component C, we let C + denote the induced subgraph on G P [C ∪ X].
A trace is a tuple (x 1 , . . . , x ) of elements of X. A configuration is a tuple (α, β) where α is a multiset of at most k traces, and β is a mapping from subsets of X of cardinality 2 to [k 2 ].
A component C of G P admits a configuration (α, β) if there exists a set of edge disjoint paths F in C + and a surjective mapping τ (called the assignment) from α to the terminal pairs that occur in C with the following properties.
For each terminal pair st that occurs in C: F either contains a path whose endpoints are s and t, or F contains an s-x 1 path for some x 1 ∈ X and a t-x 2 path for some distinct x 2 ∈ X and there exists a trace L = (x 1 , . . . , x 2 ) ∈ α such that τ (L) = st.
for each distinct a, b ∈ X, F contains precisely β({a, b}) paths from a to b. F contains no other paths than the above.
Intuitively, α stores information about how one particular set of edge disjoint paths A which originate in C is routed through the instance: they may either be routed only through C + (in which case they don't contribute to α), or they may leave C + (in which case α stores the order in which these paths visit vertices of X, i.e., their trace). On the other hand, β stores information about how paths that originate outside of C can potentially be routed through C (in a way which does not interfere with A). Observe that for any particular α there may exist several distinct configurations ((α, β 1 ), (α, β 2 ) and so forth); similarly, for any particular β there may exist several distinct configurations ((α 1 , β), (α 2 , β) and so forth).
If a set F of edge disjoint paths in C + satisfies the conditions specified above for a configuration (α, β), we say that F gives rise to (α, β). Clearly, given F and (α, β), it is possible to determine whether F gives rise to (α, β) in time polynomial in |V (C)|.
While configurations capture information about how a component can interact with a set of edge disjoint paths, our end goal is to have a way of capturing all important information about a component irrespective of any particular selection of edge disjoint paths. To this end, we introduce the notion of signatures. A signature of a component C, denoted sign(C), is the set of all configurations which C admits. The set of all configurations is denoted by Λ.

Lemma 9. Given a component C, it is possible to compute sign(C) in time at most
Proof. We begin with the latter claim. The number of traces is k! + (k − 1)! + · · · + 1!, which is upper-bounded by 2 · k!. Consequently, the number of choices for α is upper-bounded by . On the other hand, the number of choices for β is upper-bounded by (k 2 ) k 2 . Since the number of configurations is upper-bounded by the number of choices for α times the number of choices for β, we obtain |Λ| ≤ k O(k 2 ) . Note that it is possible to exhaustively construct Λ in the same time bound.
For the former claim, observe that C + contains at most 2k 2 edges. Consider the following exhaustive algorithm on C + . The algorithm exhaustively tries all assignments of edges in C + to labels from {∅} ∪ [2k 2 ]. For each such assignmentF, it checks that each label forms a path in C + ; if this is the case, then F is a collection of edge disjoint paths of C + . We can then loop through each configuration (α, β) in Λ, check whether F gives rise to (α, β), and if yes we add (α, β) to sign(C). In total, this takes time at most Our next step is the formulation of a clear condition linking configurations of components in G P − X and solving (G, P ). This condition will be of importance later, since it will be checkable by an integer linear program. For a trace α, we say that a, b occur consecutively in α if elements a and b occur consecutively in the sequence α (regardless of their order), i.e., α = (. . . , a, b, . . . ) or α = (. . . , b, a, . . . ). Let D be the set of connected components of G P − X.
A configuration selector is a function which maps each connected component C in G P −X to a configuration (α, β) ∈ sign(C). We say that a configuration selector S is valid if it satisfies the condition that dem(ab) ≤ sup(ab) for every {a, b} ⊆ X, where dem (demand) and sup (supply) are defined as follows: dem(ab) is the number of traces in C∈D S(C) where ab occur consecutively. sup(ab) is the sum of all the values β(a, b) in C∈D S(C).
For completeness, we provide the formal definitions of sup(ab) and dem(ab) below. dem(ab): let the multiset A 0 be the restriction of the multiset C∈D S(C) to the first component of each configuration. Then we set A = α∈A 0 α, i.e., A is the multiset of all traces which occur in configurations originating from S. Finally, let A ab be the restriction of A only to those traces where ab occurs consecutively, and we set dem(ab) = |A ab |. sup(ab): Stated formally, let the multiset B 0 be the restriction of the multiset C∈D S(C) to the second component of each configuration. Then we set B = β∈B 0 β, i.e., B is the multiset of all mappings which occur in configurations originating from S. Finally, we set sup(ab) = β∈B β(ab).
The next, crucial lemma links the existence of a valid configuration selector to the existence of a solution for EDP.

Lemma 10. (G, P ) is a yes-instance if and only if there is a valid configuration selector.
Proof. Assume (G, P ) is a yes-instance and let Q be a solution, i.e., Q is a set of edge disjoint paths in G which link each terminal pair in P . We will construct a valid configuration selector S. First, consider a connected component C of G P − X. Observe that Q restricted to C + forms a set of edge disjoint paths Q C which consists of: paths starting and ending in X, paths starting and ending at terminals of a terminal pair, and paths starting at terminals of a terminal pair and ending in X.
We will use Q C to construct a configuration (α C , β C ) of C, as follows. For each {x, y} ⊆ X, β C ({x, y}) will map each tuple {x, y} to the number of paths in Q C whose endpoints are precisely x and y. On the other hand, for each pair of paths in Q C which start at terminals s, t of a terminal pair and end at x, y ∈ X, we add the trace (x, z 1 , . . . , z , y) to α, where z i is the (i + 1)-th vertex visited by the s-t path of Q in X. For example, if the s-t path used by the solution intersects with vertices in X in the order (a, b, c, d), then we add the trace (a, b, c, d) to α C . As witnessed by Q C , the resulting configuration (α C , β C ) is a configuration of C and in particular (α C , β C ) ∈ sign(C).
Let S be a configuration selector which maps each connected component C to (α C , β C ) constructed as above. We claim that S is valid. Indeed, for each {a, b} ∈ X, dem(ab) is the number of terminal-to-terminal paths in Q which consecutively visit a and then b in X (or vice-versa, b and then a). At the same time, sup(ab) is the number of path segments in Q whose endpoints are a and b. Clearly, dem(ab) = sup(ab).
On the other hand, assume we have a valid configuration selector S. We will use S to argue the existence of a set Q of edge disjoint paths which connect all terminal pairs in (G, P ). For each component C we know that C admits S(C) = (α C , β C ) and hence there exists a set of edge disjoint paths, say F C , which satisfies the following conditions: For each terminal pair st in C, F C either contains a path whose endpoints are s and t or two paths from s and t to two distinct endpoints in X; For each distinct a, b ∈ X, F C contains precisely β C ({a, b}) paths from a to b.
Let F = C∈D F C , and let τ C be the surjective assignment function for C which goes with F C . We will now construct the set Q from F as follows. For each terminal pair s, t in some component C, we add a s-t path L into Q, where L is obtained as follows. If F C contains a path whose endpoints are s and t, then we set this to L. Otherwise, L is composed of the following segments: the two paths in F C whose endpoints are s and t, and for each x, y ∈ X which occur consecutively in the trace τ −1 C (st), we choose an arbitrary x-y path segment from F, use it for L, and then delete this path segment from F.
First of all, observe that since S is valid, there will always be enough x-y path segments in F to choose from in the construction of L. Furthermore, each L is an s-t path, and all the paths in Q are edge disjoint. Hence (G, P ) is indeed a yes-instance and the lemma holds.

Lemma 11.
There exists an algorithm which takes as input an EDP instance (G, P ) and a fracture modulator X of G P and determines whether there exists a valid configuration selector S in time at most 2 2 k O(k 2 ) · |V (G)|.
Proof. Consider the following instance of Integer Linear Programming. For each signature η such that there exists a connected component C of G P − X where sign(C) = η, and for each configuration (α, β) ∈ η, we create a variable z η (α,β) , and for each we add a constraint requiring it to be nonnegative. The first set of constraints we create is as follows: for each signature η, we set (α,β)∈η z η (α,β) = d η , Towards showing the reverse direction, let S be a solution for I , i.e., a set of pairwise edge disjoint paths containing one path, denoted by P p for every terminal pair p ∈ P . Observe that if p = (s i 1 , t i 1 ) for some i with 1 ≤ i ≤ n 1 , then P p contains a path between s 1 and t 1 in G. The same applies if p = (s i 2 , t i 2 ) for some i with 1 ≤ i ≤ n 2 and p = (s i 3 , t i 3 ) for some i with 1 ≤ i ≤ n 3 . Hence the set S containing the restriction of every path P p in S to G contains n 1 paths between s 1 and t 1 , n 2 paths between s 2 and t 2 in G, and n 3 paths between s 3 and t 3 , which are all pairwise edge disjoint. Hence S is a solution for I.

Conclusion
Our results close a wide gap in the understanding of the complexity landscape of EDP parameterized by structural parameterizations. On the positive side we present three novel algorithms for the classical EDP problem: a polynomial-time algorithm for instances with a FVS of size one, an fpt-algorithm w.r.t. the treewidth and maximum degree of the input graph, and an fpt-algorithm for instances that have a small deletion set into small components in the augmented graph. On the negative side we solve a long-standing open problem concerning the complexity of EDP parameterized by the treewidth of the augmented graph: unlike related multicut problems [19], EDP is W[1]-hard parameterized by the feedback vertex set number of the augmented graph.