Fault-Tolerant Edge-Disjoint Paths – Beyond Uniform Faults

09/10/2020 ∙ by David Adjiashvili, et al. ∙ 0

The overwhelming majority of survivable (fault-tolerant) network design models assume a uniform fault model. Such a model assumes that every subset of the network resources (edges or vertices) of a given cardinality k may fail. While this approach yields problems with clean combinatorial structure and good algorithms, it often fails to capture the true nature of the scenario set coming from applications. One natural refinement of the uniform model is obtained by partitioning the set of resources into vulnerable and safe resources. The scenario set contains every subset of at most k faulty resources. This work studies the Fault-Tolerant Path (FTP) problem, the counterpart of the Shortest Path problem in this fault model and the Fault-Tolerant Flow problem (FTF), the counterpart of the ℓ-disjoint Shortest s-t Path problem. We present complexity results alongside exact and approximation algorithms for both models. We emphasize the vast increase in the complexity of the problem with respect to the uniform analogue, the Edge-Disjoint Paths problem.

READ FULL TEXT VIEW PDF
POST COMMENT

Comments

There are no comments yet.

Authors

page 1

page 2

page 3

page 4

This week in AI

Get the week's most popular data science and artificial intelligence research sent straight to your inbox every Saturday.

1 Introduction

The Minimum-Cost Edge-Disjoint Path (EDP) problem is a classical network design problem, defined as follows. Given an edge-weighted directed graph , two terminals and an integer parameter , find edge-disjoint paths connecting and with minimum total cost. EDP is motivated by the following survivable network design problem: what is the connection cost of two nodes in a network, given that any edges can be a-posteriori removed from the graph. The implicit assumption in EDP is that every edge in the graph in equally vulnerable. Unfortunately, this assumption is unrealistic in many applications, hence resulting in overly-conservative solutions. Our goal is to advance the understanding of non-uniform models for network design problems in order to avoid solutions that are too conservative and hence, too costly. To this end we study a natural generalization of the EDP problem called the Fault-Tolerant Path (FTP) problem, in which we consider a subset of the edges to be vulnerable. The problem asks for a minimum-cost subgraph of a given graph that contains an - path after removing any vulnerable edges from the graph. Formally, it is defined as follows.

Fault-Tolerant Path (FTP) Instance: edge-weighted directed graph , two nodes , subset of vulnerable edges, and integer . Task: Find minimum-cost set , such that contains an - path for every with .

Observe that FTP becomes EDP when . We will also study EDP with a simpler, but still non-uniform, fault model: The problem Fault-Tolerant Flow (FTF) asks for fault-tolerant disjoint - paths, assuming that only a single edge can be a-posteriori removed from the graph. The problem is defined as follows.

Fault-Tolerant Flow (FTF)
Instance: edge-weighted directed graph , two nodes , set of vulnerable arcs, and integer .
Task: Find minimum cost set , such that contains disjoint - paths for every .

1.1 Results

A well-known polynomial algorithm for EDP works as follows. Assign unit capacities to all edges in and find a minimum-cost -flow from to . The integrality property of the Minimum-Cost - Flow (MCF) problem guarantees that an extreme-point optimal solution is integral, hence it corresponds to a subset of edges. It is then straightforward to verify that this set is an optimal solution of the EDP problem (for a thorough treatment of this method we refer to the book of Schrijver [18]).

The latter algorithm raises two immediate questions concerning FTP. The first question is whether FTP admits a polynomial time algorithm. In this paper we give a negative answer conditioned on , showing that FTP is -hard. In fact, the existence of constant-factor approximation algorithms is unlikely already for the restricted case of directed acyclic graphs. Consequently, it is natural to ask whether polynomial algorithms can be obtained for restricted variants of FTP to this question. In particular we provide polynomial-time algorithms for arbitrary graphs and , directed acyclic graphs and fixed

and series-parallel graphs. A second question concerns the natural fractional relaxation FRAC-FTP of FTP, in which the task is to find a minimum cost capacity vector

such that for every set of at most vulnerable edges, the maximum - flow in , capacitated by , is at least one. As we previously observed, one natural relaxation of EDP is the MCF problem. This relaxation admits an integrality gap of one, namely the optimal integral solution value is always equal to the corresponding optimal fractional value. We later show that, in contrast to MCF, the integrality gap of FRAC-FTP is bounded by . Furthermore, we show that this bound is tight, namely that there exists an infinite family of instances with integrality gap arbitrarily close to . This result also leads to a simple -approximation algorithm for FTP, which we later combine with an algorithm for the case to obtain a -approximation algorithm for FTP.

The second variant of the EDP we study is FTF, which asks for disjoint - paths in the presence of non-uniform faults. Note that if we consider uniform faults (every edge is vulnerable), an optimal solution is a minimum-cost - flow of value , which can be computed in polynomial time. We show that, again, the presence of non-uniform faults makes the problem much harder. In fact, it is as hard to approximate as FTP, despite the restriction to single-arc faults (the same result holds for FTF on undirected graphs). On the positive side, we give a simple polynomial-time -approximation algorithm for FTF which computes a MCF with appropriately chosen capacities.

Note that our positive results for FTP imply a polynomial-time algorithm for FTF and . Hence it is natural to investigate the dependence of the complexity of FTF on the number of disjoint paths. To this end, we fix and study the corresponding slice Fault-Tolerant -Flow of FTF. Our main result in this setting is a 2-approximation algorithm for Fault-Tolerant -Flow. In a nutshell, the algorithm first computes minimum-cost -flow and then makes the resulting disjoint paths fault tolerant by solving the corresponding augmentation problem. We solve the augmentation problem by reducing it to a shortest path problem; it is basically a dynamic programming algorithm in disguise. The reduction is quite involved: in order to construct the instance of Shortest --Path, we solve at most instances of the Min-cost Strongly Connected Subgraphs problem on terminal pairs, all of which can be done in polynomial time since is fixed.

Given our approximation results, one may wonder whether Fault-Tolerant -Flow might admit a polynomial-time algorithm (assuming , say). An indication in this direction is that for number of problems with a similar flavor, including robust paths [3], robust matchings [15] or robust spanning trees [2], hardness results were obtained by showing that the corresponding augmentation problems are hard. In the light of our results above this approach does not work for Fault-Tolerant -Flow. On the other hand, we show that such a polynomial-time algorithm for Fault-Tolerant -Flow implies polynomial-time algorithms for 1-2-connected Directed Steiner Tree and a special case of 2-connected Directed Steiner Tree. Whether these two problems are -hard or not are long-standing open questions.

1.2 Related Work

The shortest path problem is one of the

classical problems in combinatorial optimization, and as such, it has received considerable attenation also in the context of fault tolerance/robustness, see for example

[4, 5, 9, 12, 17, 19, 20]. Considering FTP and FTF, one of the most relevant notions of robustness is bulk-robust, introduced by Adjiashvili, Stiller and Zenklusen [3]. Here, we are given a set of failure scenarios, that is, a set of subsets of resources that may fail simultaneously. The task is to find a minimum-cost subset of the resources, such that a desired property (e.g., connectivity of a graph) is maintained, no matter which failure scenario emerges. Both FTP and FTF are special cases of this model. Adjiashvili, Stiller and Zenklusen considered bulk-robust counterparts of the Shortest Path and Minimum Matroid basis problems. For bulk-robust shortest paths on undirected graphs they give a -approximation algorithm, where is the maximum size of a failure scenario. However, not that the running-time of this algorithm is exponential in . Note that their bulk-robust shortest path problem generalizes FTP, and therefore the same approximation guarantee holds for FTP. Our approximation algorithm for FTP significantly improves on this bound, on both the approximation guarantee and the running-time.

The robustness model used in this paper is natural for various classical combinatorial optimization problems. Of particular interest is the counterpart of the Minimum Spanning Tree problem. This problem is closely related to the Minimum -Edge Connected Spanning Subgraph (-ECSS) problem, a well-understood robust connection problem. There are numerous results for the unweighted version of -ECSS. Gabow, Goemans, Tardos and Williamson [11] developed a polynomial time -approximation algorithm for -ECSS, for some fixed constant . The authors also show that for some constant , the existence of a polynomial time -approximation algorithm implies . An intriguing property of -ECSS is that the problem becomes easier to approximate when grows. Concretely, while for every fixed , -ECSS is -hard to approximate within some factor , the latter result asserts that there is function tending to one as tends to infinity such that -ECSS is approximable within a factor . This phenomenon was already discovered by Cheriyan and Thurimella [8], who gave algorithms with a weaker approximation guarantee. The more general Generalized Steiner Network problem admits a polynomial -approximation algorithm due to Jain [16]. This is also the best known bound for weighted -ECSS.

Adjiashvili, Hommelsheim and Mühlenthaler[2] considered the bulk-robust minimum spanning tree problem with non-uniform single-edge failures. Their main result is a -approximation algorithm for this problem. A problem of a similar flavor but with a uniform fault model is Weighted Robust Matching Augmentation, which was studied by Hommelsheim, Mühlenthaler and Schaudt [15]. The task is to find a minimum-cost subgraph, such that after the removal of any single edge, the resulting graph contains a perfect matching. They show that this problem is as hard to approximate as Directed Steiner Forest, which is known to admit no -approximation algorithm unless  [14]. We will later show that FTF generalizes Weighted Robust Matching Augmentation.

1.3 Notation

We mostly consider directed graphs, which we denote by , where is the set of vertices set and the set of arcs. Undirected graphs are denoted by , where is a set of edges. An orientation of a set of undirected edges is an arc-set that orients each edge as an arc or . For some vertex set we denote by . For two vertex sets we write for the set of edges joining and (the graph should be clear from the context). In a directed graph we simply replace by . In this paper we usually consider edge-weighted graphs and assume throughout that weights are non-negative. The arcs of that are not vulnerable are called safe, denoted by .

For the sake of a clearer presentation, we moved proofs of results marked by to the appendix. A preliminary version of this paper can be found here [1].

1.4 Organization

The remainder of this paper is organized as follows: We present our results on the problem FTP in Section 2 and our results on the problem FTF in Section 3. In Section 2.1, we show that FTF on undirected graphs is a special case of FTF on directed graphs. We study the approximation hardness of FTF in Section 2.2 and we provide some exact polynomial algorithms for special cases in Section 2.3. In Section 2.4 we relate FTP and FRAC-FTP by proving a tight bound on the interagrality gap and show how this result leads to a -approximation algorithm for FTP. In Section 3.1 we prove approximation hardness of FTF. We then give an -approximation algorithm in Section 3.2, followed by a 2-approximation algorithm for FTF with a fixed flow value . Furthermore, in Section 3.3, we relate the complexity of FTF with fixed flow value to other problems of open complexity status. Section 4 concludes the paper and mentions some interesting open problems.

2 Fault-Tolerant Paths

2.1 Directed Versus Undirected Graphs

The classical shortest path problem is set on directed graphs. Assuming non-negative edge-weights, undirected graphs are a special case, since we may replace each undirected edge by two antiparallel directed edges and conclude that any shortest path in the resulting digraph corresponds to a shortest path in the original undirected graph. Here, we show that the same is true for FTP. The main insight is that, even if at most vulnerable edges may fail, no undirected edge is used in both directions. As a consequence, all our positive results for directed graphs in this section also hold for FTF on undirected graphs.

Proposition 1.

Let be a feasible solution to an instance of FTP on an undirected graph . Then there is an orientation of such that contains a directed - path for every with .

Proof.

Let us assume for a contradiction that there is no such orientation. A set of (undirected and directed) edges is a partial orientation of if there is a partition of into sets and , such that , where is an orientation of . Let be a partial orientation of that maximizes the number of directed edges, such that contains a directed - path for every with . By our assumption, there is at least one undirected edge in . Furthermore, there are two sets of vertices, such that , , and . Note that and .

Since is needed in both directions for to be feasible, there is some , , such that contains an - path that must leave via . Therefore, the cut contains at most edges and all of them except possibly are vulnerable. The same holds for and therefore we have . From the feasibility of and the fact that all edges in and except possibly are vulnerable, it follows that and . By the submodularity of the cut function we have

and it follows that

(1)

The cut-function satisfies the following identity

but the observation that is an edge connecting and , together with (1) yields a contradiction to the previous identity. ∎

2.2 Complexity of FTP

Our first observation is that FTP generalizes the Directed -Steiner Tree Problem (-DST). The input to -DST is a weighted directed graph , a source node , a collections of terminals and an integer . The goal is to find a minimum-cost arboresence rooted at , that contains a directed path from to some subset of terminal.

The -DST is seen to be a special case of FTP as follows. Given an instance of -DST define the following instance of FTP. The graph is augmented by new zero-cost arcs connecting every terminal to a new node . Finally, we set and . The goal is to find a fault-tolerant path from to in the new graph. It is now straightforward to see that a solution to the FTP instance is feasible if and only if contains a feasible solution to the -DST problem (we can assume that all arcs in are in any solution to the FTP instance).

The latter observation implies an immediate conditional lower bound on the approximability of FTP. Halperin and Krauthgamer [14] showed that -DST cannot be approximated within a factor for every , unless . As a result we obtain the following.

Proposition 2.

FTP admits no polynomial-time approximation algorithms with ratio for every , unless .

The reduction above can be easily adapted to obtain a -approximation algorithm for FTP for the special case that using the algorithm of Charikar et. al. [6]. In fact, any approximation algorithm with factor for FTP is an approximation algorithm with factor for -DST. The best known algorithm for the latter problem is due to Charikar et. al. [6]. Their result is an approximation scheme attaining the approximation factor of for every .

We end this discussion by showing that FTP contains a more general Steiner problem, which we call Simultaneous Directed -Steiner Tree (-SDST), as a special case. An input to -SDST specifies two arc-weighted graphs and on the same set of vertices , a source , a set of terminals and an integer . The goal is to find a subset of terminals and two arboresences and connecting to in the respective graphs, so as to minimize . -SDST is seen to be a special case of FTP via the following reduction. Given an instance of -SDST, construct a graph as follows. Take a disjoint union of and , where the direction of every arc in is reversed. Connect every copy of a terminal in to its corresponding copy in with an additional zero-cost arc . Finally, set and . A fault-tolerant path connecting the copy of in to the copy of in corresponds to a feasible solution to the -SDST instance with the same cost, and vice-versa.

2.3 Polynomial Special Cases

This section is concerned with tractable restrictions of FTP. Concretely we give polynomial algorithms for arbitrary graphs and and directed acyclic graphs (DAGs) and fixed and for Series-parallel graphs. We denote the problem FTP restricted to instances with some fixed by -FTP.

-Ftp

We start by giving the following structural insight.

Lemma 3 ().

Let be an optimal solution to FTP on the instance . The minimum - flow in the graph capacitated by the vector if and , otherwise is at least .

An - bipath in the graph is a union of two - paths In the context of -FTP, we call a bipath robust, if it holds that . Note that every robust - bipath in is a feasible solution to the -FTP instance. Indeed, consider any vulnerable edge . Since it holds that either , or . It follows that contains some - path. The next lemma shows that every feasible solution of the -FTP instance contains a robust - bipath.

Lemma 4 ().

Every feasible solution to an -FTP instance contains a robust - bipath.

We can conclude from the previous discussion and Lemma 4 that all minimal feasible solutions to the -FTP instance are robust bipaths. This observations leads to the simple algorithm, which is given in the proof of the following theorem.

Theorem 5 ().

1-FTP admits a polynomial-time algorithm.

-FTP and Directed Acyclic Graphs

Let us first consider the case of a layered graph. The generalization to a directed acyclic graph is done via a standard transformation, which we describe later. Recall that a layered graph is a graph with a partitioned vertex set and a set of edges satisfying . We assume without loss of generality that and . For every we let .

Analogously to the algorithm in the previous section, we reduce -FTP to a shortest path problem in a larger graph. The following definition sets the stage for the algorithm.

Definition 6.

An -configuration is a vector satisfying . We let . For an -configuration and an -configuration we let

We say that an -configuration precedes an -configuration if the following flow problem is feasible. The graph is defined as . The demand vector and the capacity vector are given by

respectively. If precedes we say that the link exists. Finally, the cost of this link is set to be minimum value over all , for which the previous flow problem is feasible, when restricted to the set of edges .

The algorithm constructs a layered graph with layers . For every the set of vertices contains all -configurations. Observe that and contain one vertex each, denoted by and , respectively. The edges correspond to links between configurations. Every edge is directed from the configuration with the lower index to the one with the higher index. The cost is set according to Definition 6. The following lemma provides the required observation, which immediately leads to a polynomial algorithm.

Lemma 7 ().

Every - path in corresponds to a fault-tolerant path with , and vise-versa.

Finally, we observe that the number of configurations is bounded by , which implies that -FTP can be solved in polynomial time on layered graphs.

To obtain the same result for directed acyclic graphs we perform the following transformation of the graph. Let be a topological sorting of the vertices in . Replace every edge () with a path of length by subdividing it sufficiently many times. Set the cost of the first edge on the path to and set the costs of all other edges on the path to zero. In addition, create a new set of faulty edges , which contains all edges in a path if . It is straightforward to see that the new instance of FTP is equivalent to the original one, while the obtained graph after the transformation is layered. We summarize the result as follows.

Theorem 8.

There is a polynomial algorithm for -FTP restricted to instances with a directed acyclic graph.

Series-Parallel Graphs

Recall that a graph is called series-parallel (SRP) with terminal and if it can be composed from a collection of disjoint edges using the series and parallel compositions. The series composition of two SRP graphs with terminals , and respectively, takes the disjoint union of the two graphs, and identifies with . The parallel composition takes the disjoint union of the two graphs and identifies with and with . Given a SRP graph it is easy to obtain the aforementioned decomposition.

The algorithm we present has linear running time whenever the robustness parameter is fixed. The algorithm is given as Algorithm 1. In fact, the algorithms computes the optimal solutions for all parameters . The symbol is returned if the problem is infeasible.

0:   a series-parallel graph, and , .
0:  Optimal solution to FTP for parameters .
1:  if  then
2:     Return
3:  if  then
4:     Return is a composition of .
5:   FTP-SeriesParallel
6:   FTP-SeriesParallel
7:  if  is a series composition of  then
8:     for  do
9:        if  then
10:           
11:        else
12:           
13:  if  is a parallel composition of  then
14:     
15:     
16:     for  do
17:        if  then
18:           
19:        else
20:                             
21:           
22:  Return
Algorithm 1 : FTP-SeriesParallel()
Theorem 9 ().

Algorithm 1 returns an optimal solution to the FTP problem on SRP graphs. The running time of Algorithm 1 is .

2.4 Integrality Gap and Approximation Algorithms

In this section we study the natural fractional relaxation of FTP. We prove a tight bound on the integrality gap of this relaxation. This results also suggests a simple approximation algorithm for FTP with ratio . We later combine this algorithm with the algorithm for -FTP to obtain a -approximation algorithm.

Fractional FTP and Integrality Gap

Let us start by introducing the fractional relaxation of FTP, which we denote by FRAC-FTP. The input to FRAC-FTP is identical to the input to FTP. The goal in FRAC-FTP is to find a capacity vector of minimum cost such that for every of size at most , the maximum - flow in , capacitated by is at least one. Note that by the Max-Flow Min-Cut Theorem, the latter condition is equivalent to requiring that the minimum - cut in has capacity of at least one. We will use this fact in the proof of the main theorem in this section.

Observe that by requiring we obtain FTP, hence FRAC-FTP is indeed a fractional relaxation of FTP.

In the following theorem by ’integrality gap’ we mean the maximum ratio between the optimal solution value to an FTP instance, and the optimal value of the corresponding FRAC-FTP instance.

Theorem 10 ().

The integrality gap of FTP is bounded by . Furthermore, there exists an infinite family of instances of FTP with integrality gap arbitrarily close to .

The proof of Theorem 10 implies a simple -approximation algorithm for FTP. This algorithm simply solves the integer minimum-cost flow problem, defined in proof of the theorem, and returns the set of edges corresponding to the support of an optimal integral flow as the solution. This result is summarized in the following corollary.

Corollary 11.

There is a polynomial -approximation algorithm for FTP.

A -Approximation Algorithm

In this paragraph we improve the approximation algorithm from the previous paragraph. The new algorithm can be seen as a generalization of the algorithm for 1-FTP to arbitrary FTP instances. The main observation is the following. The reason why the approximation algorithm implied by Theorem 10 gives an approximation ratio of is that the capacity of edges in is set to , hence, if the flow uses such edges to their full capacity, the cost incurred is times the cost of these edges. This implies that the best possible lower bound on the cost is , where denotes the optimal solution value of the corresponding FRAC-FTP instance. To improve the algorithm we observe that the edges in , which carry a flow of are cut-edges in the obtained solution.

To conveniently analyze our new algorithm let us consider a certain canonical flow defined by minimal feasible solutions.

Definition 12.

Consider an inclusion-wise minimal feasible solution of an instance of FTP. A flow induced by is any integral - -flow in respecting the capacity vector

To this end consider an optimal solution to the FTP instance and consider any corresponding induced flow . Define

As we argued before, every edge in must be a bridge in disconnecting and . Let denote the tail vertex of an edge . Since every edge constitutes an - cut in , it follows that the vertices in can be unambiguously ordered according to the order in which they appear on any - path in , traversed from to . Let be this order. Except for and , every vertex in constitutes a cut-vertex in . Divide into subgraphs by letting contain the union of all - paths in . We observe the following property.

Proposition 13.

For every the set is an optimal solution to the FTP instance .

Consider some and let denote the flow , restricted to edges in . Note that can be viewed as a - -flow. Exactly one of the following cases can occur. Either contains a single edge , or

In the former case, the edge is the shortest - path in . In the latter case we can use a slightly updated variant of the algorithm in Corollary 11 to obtain a -approximation of the optimal FTP solution on instance . Concretely, the algorithm defines the capacity vector

and finds an integral minimum-cost - -flow in , and returns the support of the flow as the solution. The existence of the flow guarantees that , while the fact that the maximum capacity in the flow problem is bounded by gives . It follows that this algorithm approximates the optimal solution to the FTP instance to within a factor .

To describe the final algorithm it remains use the blueprint of the algorithm for 1-FTP. There is only one slight difference. Instead of finding two edge-disjoint - paths, the new algorithm solves the aforementioned flow problem. We summarize the main result of this section in the following theorem. The proof is omitted, as it is identical to that of Theorem 5, with the exception of the preceding discussion.

Theorem 14.

There is a polynomial -approximation algorithm for FTP.

3 Fault-Tolerant Flows

In this section we present our results on the problem FTF. We show that it admits no -approximation under standard complexity assumptions. We then investigate its complexity for flows of fixed value . Our main result is a polynomial-time algorithm for the corresponding augmentation problem, which we use to obtain a 2-approximation for Fault-Tolerant -Flow. Finally, we show that a polynomial-time algorithm for Fault-Tolerant -Flow implies polynomial-time algorithms for two problems whose complexity status is open.

3.1 Approximation Hardness of FTF

We show that FTF is as hard to approximate as Directed Steiner Forest by using an approximation hardness result from [15] for the problem Weighted Robust Matching Augmentation. The problem Weighted Robust Matching Augmentation asks for the cheapest edge-set (assuming non-negative costs) to add to a bipartite graph such that the resulting graph is bipartite and contains a perfect matching after a-posteriori removing any single edge. The idea of our reduction is similar to that of the classical reduction from the Bipartite Maximum Matching problem to the Max - Flow problem. Note that since matchings are required to be perfect, we may assume that both parts of the input graph have the same size. We add to the bipartite input graph ) on vertices of a Weighted Robust Matching Augmentation instance two terminal vertices and , and connect to each vertex of as well as each vertex of to by an arc. Now we add all possible arcs from to , marking those as vulnerable that correspond to an edge in . It is readily observed that a fault-tolerant -flow corresponds to a feasible solution to the given Weighted Robust Matching Augmentation instance (after removing all arcs incident to or ). We thus obtain the following hardness result.

Lemma 15 ().

A polynomial-time approximation algorithm for FTF implies a polynomial-time -approximation algorithm for Weighted Robust Matching Augmentation, where is the number of vertices in the Weighted Robust Matching Augmentation instance.

We combine Proposition 15 with two results from [15] and [14] to obtain the following approximation hardness result for FTF.

Theorem 16 ().

FTF admits no polynomial-time -factor approximation algorithm for every , unless .

Note that all results presented in this section also hold for the undirected variant of FTF.

3.2 Approximation Algorithms

We first present a simple polynomial-time -approximation algorithm for FTF, which is very similar to the -approximation for FTP. The algorithm computes (in polynomial time) a minimum-cost - flow of value on the input graph with the following capacities: each vulnerable arc receives capacity and any other arc capacity . To see that for this choice of capacities we obtain a feasible solution, recall that the value of any - cut upper-bounds the value of any - flow. Therefore, each - cut has value at least , so contains either at least safe arcs or at least arcs. To prove the approximation guarantee, we show that any optimal solution to an FTF instance contains an - flow of value and observe that we over-pay for safe arcs by a factor of at most . We obtain the following result.

Theorem 17 ().

FTF admits a polynomial-time -factor approximation algorithm.

Note that we cannot simply use the dynamic programming approach as in the algorithm for 1-FTP to obtain an -approximation for FTF, since a solution to FTF in general does not have cut vertices, which are essential for the decomposition approach for the -approximation for FTP.

We now show that for a fixed number of disjoint paths, a much better approximation guarantee can be obtained. That is, we give a polynomial-time 2-approximation algorithm for Fault-Tolerant -Flow (however, its running time is exponential in ). The algorithm first computes a minimum-cost - flow of value and then augments it to a feasible solution by solving the following augmentation problem.

Fault-Tolerant -Flow Augmentation Instance: arc-weighted directed graph , two nodes , arc-set that contains disjoint - paths, and set of vulnerable arcs. Task: Find minimum weight set , such that for every , the set contains disjoint - dipaths.

Our main technical contribution is that Fault-Tolerant -Flow Augmentation can be solved in polynomial time for fixed . Our algorithm is based on a dynamic programming approach and it involves solving many instances of the problem Directed Steiner Forest, which asks for a cheapest subgraph connecting given terminal pairs. This problem admits a polynomial-time algorithm for fixed  [10], but it is -hard when parameterized in the number of terminal pairs, so it is likely not fixed-parameter tractable [13]. Roughly speaking, we traverse the disjoint - paths computed previously in parallel, proceeding one arc at a time. In order to deal with vulnerable arcs, at each step, we solve an instance of Directed Steiner Forest connecting the current vertices (one on each path) to destinations on the same path by using backup paths. That is, we decompose a solution to the augmentation problem into instances of Directed Steiner Forest connected by safe arcs. An optimal decomposition yields an optimal solution to the instance of the augmentation problem. We find an optimal decomposition by dynamic programming. Essentially, we give a reduction to a shortest path problem in a graph that has exponential size in .

Let us fix an instance of Fault-Tolerant -Flow Augmentation on a digraph with arc-weights and and terminals and . Let be disjoint - paths contained in . In fact, we assume without loss of generality, that is the union of . If contains an arc that is not on any of the paths, we remove from and assign to it weight 0.

We now give the reduction to the shortest path problem. We construct a digraph ; to distinguish it clearly from the graph of , we call the elements in () of vertices (arcs) and elements of () nodes (links). We order the vertices of each path , , according to their distance to on . For two vertices of , we write if is at least as close to on as . Let us now construct the node set . We add a node to for every -tuple of vertices in satisfying , for every . Note that the corresponding vertices of a node are not necessarily distinct, since the edge-disjoint paths may share vertices. We also define a (partial) ordering on the nodes in . For two nodes and we write if for every . Additionally, let be the sub-path of from a vertex to a vertex of .

We now construct the link set of as the union of two link-sets and , which we will define next. We add to an arc , if precedes and the subpaths of each from to contain no vulnerable arc. That is, we let

We now define the link set . For two nodes such that precedes , if there is some , such that contains at least one vulnerable arc, then we first need to solve an instance of Directed Steiner Forest on terminal pairs in order to know whether we add the link and, if so, at which cost. We construct an instance of Directed Steiner Forest as follows. The terminal pairs are . The input graph is given by , where , where are the arcs of in reversed direction The arc costs are given by

That is, for , we reverse the path connecting to and make the corresponding arcs available at zero cost. We then need to connect to without using arcs in . Since the number of terminal pairs is at most and thus constant, the Directed Steiner Forest instance can be solved in polynomial time by the algorithm of Feldman and Ruhl given in [10]. Let be the cost of an optimal solution to . We add a link to if the computed solution of is strongly connected. This completes the construction of .

For a link we let the weight be given by

We now argue that a shortest path from node to node in corresponds to an optimal solution to . For every link , we add the optimal solution to computed by the Feldman-Ruhl algorithm to our solution . A summary is given in Algorithm 2. Proving that Algorithm 2 is quite technical and requires another auxiliary graph and a technical lemma. The details can be found in Appendix D.

0:  instance of Fault-Tolerant -Flow Augmentation on a digraph
1:  Construct the graph
2:  Find a shortest path in from to
3:  For each link add the arcs of an optimal solution to to
4:  return  
Algorithm 2 : Exact algorithm for Fault-Tolerant -Flow Augmentation
Theorem 18 ().

The set computed by Algorithm 2 is an optimal solution to the instance of Fault-Tolerant -Flow Augmentation.

Algorithm 2 runs in polynomial time for a fixed number of disoint - paths, since it computes at most Min-cost Strongly Connected Subgraphs on terminal pairs, which can be done in polynomial time by a result of Feldman and Ruhl [10].

Theorem 19 ().

Algorithm 2 runs in time .

From theorems 18 and 19 we obtain a polynomial-time 2-approximation algorithm for Fault-Tolerant -Flow: Let be the cost of an optimal solution to an instance of Fault-Tolerant -Flow. The algorithm first computes a minimum-cost - flow and then runs Algorithm 2 using as initial arc-set. The algorithm returns the union of the arc-sets computed in the two steps. By Theorem 18 we can augment in polynomial time to a feasible solution to . Since we pay at most for the sets and , respectively, the total cost is at cost at most .

Corollary 20.

Fault-Tolerant -Flow admits a polynomial-time 2-factor approximation algorithm.

3.3 Relation to Other Problems of Open Complexity

In the previous section we showed that there is a polynomial-time algorithm for Fault-Tolerant -Flow Augmentation, from which we obtained a 2-approximation for Fault-Tolerant -Flow. Ideally, one would like to complement such an approximation result with a hardness or hardness-of-approximation result. Since Fault-Tolerant -Flow Augmentation admits a polynomial-time algorithm according to Theorem 19, we cannot use the augmentation problem in order to prove -hardness of Fault-Tolerant -Flow; an approach that has been used successfully for instance for robust paths [3], robust matchings [15] and robust spanning trees [2]. Hence, there is some hope that Fault-Tolerant -Flow might actually be polynomial-time solvable. However, we show that a polynomial-time algorithm for Fault Tolerant -Flow implies polynomial-time algorithms for two other problems with unknown complexity status, namely 1-2-connected Directed Steiner Tree and a special case of 2-connected Directed Steiner Tree.

We will first consider the relation of Fault-Tolerant -Flow and 2-connected Directed Steiner Tree, which asks for two disjoint directed paths connecting a root vertex with each terminal:

2-connected Directed Steiner Tree Instance: directed graph , cost function , root , and terminal vertices Task: find a minimum-cost set of edges , such that contains two edge-disjoint - paths for each .

We will denote the set of terminals by . According to [7], even the complexity of 1-2-connected Directed Steiner Tree is open, which is the following variant of 2-connected Directed Steiner Tree: we have only two terminals and and aim to find two disjoint - paths and one - path of minimal total cost. Note that 2-connected Directed Steiner Tree is a generalization of Directed Steiner Tree and therefore does not admit a polynomial-time approximation algorithm unless  [14]. However, there is a big gap between the complexity of Directed Steiner Tree and 2-connected Directed Steiner Tree if the number of terminals is fixed. While it is known that Directed Steiner Tree is fixed-parameter tractable when parameterized by the number of terminals (and therefore polynomial-time solvable for constant ), it is unknown whether 2-connected Directed Steiner Tree admits a polynomial-time algorithm even for (for , an optimal solution is a minimum-cost 2-flow). We now show that a special case of Fault-Tolerant -Flow corresponds to 2-connected Directed Steiner Tree with the additional constraint that every - cut contains at least edges.

Proposition 21 ().

A polynomial-time algorithm for Fault-Tolerant -Flow implies a polynomial-time algorithm for 2-connected Directed Steiner Tree with the additional constraint that every - cut contains at least edges.

Furthermore, we show that 1-2-connected Directed Steiner Tree is a special case of Fault Tolerant -Flow.

Proposition 22 ().

A polynomial-time algorithm for Fault Tolerant -Flow implies a polynomial-time algorithm for 1-2-connected Directed Steiner Tree.

4 Conclusions and Future Work

This paper presents two problems, FTP and FTF, which add a non-uniform fault model to the classical edge-disjoint paths problem. In this model, not all -subsets of edges can be removed from the graph after a solution is chosen, but rather a subset of vulnerable edges, which are provided as part of the input. Such an adaptation is natural from the point of view of many application domains. We observed a dramatic increase in the computational complexity due to the fault model with respect to EDP. At the same time we identified several classes of instances admitting a polynomial exact algorithm. These classes include the case , directed acyclic graphs and fixed and series-parallel graphs. Next, we defined a fractional counterpart of FTP and proved a tight bound on the corresponding integrality gap. This result lead to a -approximation algorithm for FTP. For FTF, our main results are a )-approximation algorithm and a 2-approximation algorithm for fixed .

One of the main tasks that remains is to improve the understanding of the approximability of FTP. In particular, it is interesting to see if the approximation guarantee for FTP can be improved to the approximation guarantees of the best known algorithms for the Steiner Tree problem. It is also interesting to relate FTP to more general problems such a Minimum-Cost Fixed-Charge Network Flow and special cases thereof. The complexity of -FTP in still unknown. It is interesting to see if the methods employed in the current paper for -FTP and -FTP on directed acyclic graphs can be extended to -FTP on general graphs. Another intriguing open question is whether Fault-Tolerant -Flow is -hard, which is open even for . We showed that a positive result in this direction implies polynomial-time algorithms for two Steiner problems whose complexity status is open.

References

  • [1] David Adjiashvili. Fault-tolerant shortest paths-beyond the uniform failure model. arXiv preprint arXiv:1301.6299, 2013.
  • [2] David Adjiashvili, Felix Hommelsheim, and Moritz Mühlenthaler. Flexible graph connectivity. In International Conference on Integer Programming and Combinatorial Optimization, pages 13–26. Springer, 2020.
  • [3] David Adjiashvili, Sebastian Stiller, and Rico Zenklusen. Bulk-robust combinatorial optimization. Mathematical Programming, 149(1-2):361–390, 2015.
  • [4] Hassene Aissi, Cristina Bazgan, and Daniel Vanderpooten. Approximation complexity of min-max (regret) versions of shortest path, spanning tree, and knapsack. In European Symposium on Algorithms, pages 862–873. Springer, 2005.
  • [5] Christina Büsing. Recoverable robust shortest path problems. Networks, 59(1), 2012.
  • [6] Moses Charikar, Chandra Chekuri, To-yat Cheung, Zuo Dai, Ashish Goel, Sudipto Guha, and Ming Li. Approximation algorithms for directed steiner problems. Journal of Algorithms, 33(1):73–91, 1999.
  • [7] Joseph Cheriyan, Bundit Laekhanukit, Guyslain Naves, and Adrian Vetta. Approximating rooted steiner networks. ACM Transactions on Algorithms (TALG), 11(2):1–22, 2014.
  • [8] Joseph Cheriyan and Ramakrishna Thurimella. Approximating minimum-size k-connected spanning subgraphs via matching. SIAM Journal on Computing, 30(2):528–560, 2000.
  • [9] Kedar Dhamdhere, Vineet Goyal, R Ravi, and Mohit Singh. How to pay, come what may: Approximation algorithms for demand-robust covering problems. In 46th Annual IEEE Symposium on Foundations of Computer Science (FOCS’05), pages 367–376. IEEE, 2005.
  • [10] Jon Feldman and Matthias Ruhl. The directed steiner network problem is tractable for a constant number of terminals. SIAM Journal on Computing, 36(2):543–561, 2006.
  • [11] Harold N Gabow and Suzanne R Gallagher. Iterated rounding algorithms for the smallest -edge connected spanning subgraph. SIAM Journal on Computing, 41(1):61–103, 2012.
  • [12] Daniel Golovin, Vineet Goyal, Valentin Polishchuk, R Ravi, and Mikko Sysikaski. Improved approximations for two-stage min-cut and shortest path problems under uncertainty. Mathematical Programming, 149(1-2):167–194, 2015.
  • [13] Jiong Guo, Rolf Niedermeier, and Ondřej Suchỳ. Parameterized complexity of arc-weighted directed steiner problems. SIAM Journal on Discrete Mathematics, 25(2):583–599, 2011.
  • [14] Eran Halperin and Robert Krauthgamer. Polylogarithmic inapproximability. In

    Proceedings of the 35th Annual ACM Symposium on Theory of Computing

    , pages 585–594, 2003.
  • [15] Felix Hommelsheim, Moritz Mühlenthaler, and Oliver Schaudt. How to secure matchings against edge failures. In 36th International Symposium on Theoretical Aspects of Computer Science. Schloss Dagstuhl-Leibniz-Zentrum für Informatik, 2019.
  • [16] Kamal Jain. A factor 2 approximation algorithm for the generalized Steiner network problem. Combinatorica, 21(1):39–60, 2001.
  • [17] Christina Puhl. Recoverable robust shortest path problems. Preprint, pages 034–2008, 2009.
  • [18] Alexander Schrijver. Combinatorial optimization: polyhedra and efficiency, volume 24. Springer Science & Business Media, 2003.
  • [19] Gang Yu and Jian Yang. On the robust shortest path problem. Computers and Operations Research, 25(6):457–468, Jun 1998.
  • [20] Paweł Zieliński. The computational complexity of the relative robust shortest path problem with interval data. European Journal of Operational Research, 158(3):570–576, Nov 2004.

Appendix A Proofs Omitted from Section 2.3

Proof of Lemma 3.

Assume the statement is not true. Then, by the Max-Flow Min-Cut Theorem there is some capacitated cut for some with and such that . By the definition of , this implies that does not contain safe edges. But then is a cut in of size at most , a contradiction. ∎

Proof of Lemma 4.

We assume without loss of generality that is a minimal feasible solution with respect to inclusion. Let be the set of bridges in . From feasibility of , we have . Consider any - path in . Let be be the set of vertices incident to . Let and be such that . (if such an edge does not exist, we have , which means that is a robust - bipath). Note that must contain two edge-disjoint - paths . Taking as the set together with all such pairs of paths results in a robust bipath. ∎

Proof of Theorem 5.

To solve -FTP we need to find the minimum cost robust - bipath. To this end let us define two length functions . For two vertices let denote the shortest path distance from to in the graph , and let denote the cost of the shortest pair of edge-disjoint - paths in . Clearly, both length functions can be computed in polynomial time (e.g. using flow techniques). Finally, set . Construct the complete graph on the vertex set and associate the length function with it. Observe that by definition of , any - path in this graph corresponds to a robust - bipath with the same cost, and vice versa. It remains to find the shortest - bipath by performing a single shortest - path in the new graph. For every edge in this shortest path, the optimal bipath contains the shortest - path in if , and the shortest pair of - paths in , otherwise. ∎

Proof of Lemma 7.

Consider first a fault-tolerant path . We construct a corresponding - path in as follows. Consider any - flow , induced by . Let be a path decomposition of and let (with ) be the corresponding flow values.

Since is layered, the path contains exactly one vertex from and one edge from