- Email: [email protected]
Labeled cuts in graphs
Theoretical Computer Science 648 (2016) 34–39
Contents lists available at ScienceDirect
Theoretical Computer Science www.elsevier.com/locate/tcs
Labeled cuts in graphs Tridib Dutta a , Lenwood S. Heath b , V.S. Anil Kumar a,∗ , Madhav V. Marathe a a b
Department of Computer Science, and Biocomplexity Institute, Virginia Tech, Blacksburg, VA, United States Department of Computer Science, Virginia Tech, Blacksburg, VA, United States
a r t i c l e
i n f o
Article history: Received 22 December 2010 Received in revised form 25 July 2016 Accepted 29 July 2016 Available online 9 August 2016 Communicated by T. Erlebach Keywords: Labeled graphs Minimum cut Regular languages
a b s t r a c t In this paper, we study labeled extensions of the classical s, t-mincut problem, in which we are given a graph G = ( V , E ), two specific vertices s, t ∈ V , a set L of labels, and a labeling : E → L of the edges. The goal is to choose a subset L ⊆ L of labels, so that s and t become disconnected when deleting the edges with labels in L . We give √ an algorithm with an O (n2/3 ) approximation factor guarantee, which improves the O ( m) approximation guarantee of Zhang et al. (2009) [16]. We also consider variants in which selected subsets of paths between s and t have to be removed (instead of all paths). These labeled cut problems are much harder than the classical mincut problem. © 2016 Published by Elsevier B.V.
1. Introduction Labeled graphs arise in a number of applications, e.g., edges in social contact graphs can be labeled by the time of contact [12]. The focus of this paper is on two classes of cut problems in labeled graphs that generalize the classical s, t-mincut problem in a natural manner. Let G = ( V , E ) denote a directed graph, and let L denote a set of labels. Let : E → L denote a labeling function. The first problem we consider is the s, t-Labeled Mincut Problem (LCP), which involves choosing the smallest subset L ⊂ L such that two given nodes s and t are disconnected in the graph G = ( V , E \ {e : (e ) ∈ L }), obtained by deleting all edges with labels in the set L . The LCP problem is used in the context of “attack graphs” in intrusion detection by Jha et al. [11]; in this case, the edge labels represent possible attacks, and a labeled mincut is the smallest set of attacks that disconnect two selected terminals. The complexity of LCP was first studied by Zhang et al. [16], who show that, unlike the classical mincut problem, this problem is NP-complete even to approximate within a factor 1−o (1)
of O 2log
n
√
, where n = | V |. They also present a greedy algorithm that achieves an approximation factor of O ( m)
for edge weighted graphs. In this paper, we present an algorithm with an approximation factor of O (n2/3 ) for unweighted graphs, improving the result of [16] when m = (n4/3+ ) for > 0. The second class of labeled cut problems we consider is called the s, t-Language Constrained Labeled Cut (LCLC) problem. Here, we are given a formal language L defined on the set L. For a path P in G, let ( P ) denote the word formed by concatenating the labels on the edges in P . The LCLC problem involves choosing the smallest subset L ⊂ L of labels, such that E \ {e : (e ) ∈ L } contains no paths P from s to t with ( P ) ∈ L. In this paper, we assume that L is a regular language, which is a language that can be accepted by a finite automaton (see, e.g., [8]). The above versions of the labeled cut problems are all quite hard in general, even for special classes of graphs, e.g., bounded treewidth graphs. Natural duals of these problems can be defined, which are variants of the classical flow problem.
*
Corresponding author. E-mail addresses: [email protected] (T. Dutta), [email protected] (L.S. Heath), [email protected] (V.S.A. Kumar), [email protected] (M.V. Marathe).
http://dx.doi.org/10.1016/j.tcs.2016.07.040 0304-3975/© 2016 Published by Elsevier B.V.
T. Dutta et al. / Theoretical Computer Science 648 (2016) 34–39
35
Fig. 1. An example illustrating the LCP and LCLC problems. Let s = v 1 and t = v 6 . L = {a, b, c , d} denotes the set of labels. The optimum LCP solution is the set {c }, while the minimum unlabeled cut has cost 2. Let L be the language of strings a∗ c. The set P (G , L, s, t ) of L-respecting paths consists of only two paths, v 1 , v 2 , v 4 , v 6 and v 1 , v 2 , v 5 , v 6 , and either {a} or {c } is an optimal solution to the LCLC problem. Observe that the solution {a} keeps s and t still connected.
The dual for the LCP problem is a flow with capacities associated with labels, instead of with individual edges. The dual of the LCLC problem is a maximum flow problem in which only flow paths whose labels form words in the language L can be used. Unlike classical flows, the maxflow-mincut duality does not hold, and there can be a large gap between these quantities—this follows from the gap between flows and cuts for length constrained paths [3] (we note that the LCLC problem generalizes the problem of cutting length constrained paths). Labeled versions of a few other combinatorial problems have been studied. One of the earliest such problems is the minimum label spanning tree (MinLST) problem, in which the goal is to choose a spanning tree, whose cost, measured by the sum of the costs of the labels of the edges in the spanning tree, is minimized. Krumke et al. [13] give an O (log n) approximation bound for this problem. Carr et al. [5] show that MinLST is a special case of the Red–Blue Set Cover problem and study its complexity. Another labeled problem is the minimum label s, t path (MinLP) problem, in which the objective is to find a path from s to√t, minimizing the combined cost of its labels. Hassin et al. [7] show that MinLP can be approximated within a factor of O ( n). The closest prior work related to the LCLC problem is by Barrett et al. [4], who study the problem of finding a shortest language constrained path in a labeled graph. For regular languages, they reduce this problem to shortest paths in an appropriately defined product graph. Applications of language constrained shortest paths include multi-modal routing, formulating database queries [1], and web searches [14]. LCP is a special case of the Submodular Cut problem, in which the cost of a cut is defined by a submodular function (for LCP, define the cost of a cut as the number of distinct labels on the edges in the cut). This was studied recently by Jegelka et al. [10], who show that this problem is difficult to approximate within a factor of O (n1/3 ) in general. Our Contributions. In this paper, we study the complexity of the LCP and LCLC problems. For the LCP problem, we present an algorithm, ApproxLCP, with an approximation guarantee of O (n2/3 ), which improves upon the result of Zhang et al. [16] for unweighted graphs with m ≥ n4/3+ , for any > 0. ApproxLCP is based on rounding a linear program for hitting all paths of length at most D, where D is a parameter (instead of all paths, as in the case of LCP). This LP has exponential size, and the separation oracle (which arises in the use of the Ellipsoid method [15]) corresponds to the Minimum Label s, t path 1 −
log n (MinLP) problem [7], which is difficult to solve even approximately within a factor of ( some > 0. 2 1−1/ log)logfor cn n For the LCLC problem, we show that it cannot be approximated within a factor of o 2log , for any c < 1/2, by
extending the hardness result for LCP [16]. Using the product graph construction √ of Barrett et al. [4], we show that the LCLC problem can be reduced to LCP for regular languages. This leads to an O (min{ N m, (nN )2/3 }) approximation algorithm for LCLC, where N denotes the number of states in a finite state machine for the language L. 2. Preliminaries Let G = ( V , E ) denote a directed graph, and let n = | V | and m = | E |. Let s, t ∈ V be a given pair of nodes. Let L denote a set of edge labels. Let : E → L denote an edge labeling function. For a path P = e 1 , . . . , ek in G, ( P ) = (e 1 ) ◦ · · · ◦ (ek ) denotes the word formed by concatenating the labels on the edges on P ; here “◦” denotes the concatenation operator. Sometimes, we abuse the notation and also use ( P ) as the set of labels on P , whenever it is clear from the context. Given a regular language L defined on the alphabet L, we say that a path P is L-constrained (or L-respecting) if ( P ) ∈ L. For a pair of nodes s, t in G, let P (G , s, t ) denote the set of all s-t paths in G, and let P (G , L, s, t ) denote the set of all L-respecting paths from s to t. The Labeled Cut Problem (LCP) is to choose a smallest set L ⊂ L of labels so that no path in P (G , s, t ) remains after deleting all the edges with labels in L . The Language Constrained Minimum Cut (LCLC) problem is to choose the smallest subset L ⊂ L of labels so that the graph G = ( V , E \ {e : (e ) ∈ L }), resulting from the deletion of edges with labels in L , contains no L-constrained s-t paths (equivalently, P (G , L, s, t ) = ∅). Fig. 1 shows an example for both the LCP and LCLC problems. Note that the optimal solutions to these problems cost less than the solutions to the (unlabeled) minimum s, t-cut. In a graph with all edges having the same label, the LCP and LCLC solutions have cost 1, which can be arbitrarily smaller than the cost of the minimum unlabeled solution.
36
T. Dutta et al. / Theoretical Computer Science 648 (2016) 34–39
3. Improved approximation algorithm for LCP We discuss Algorithm 1 (ApproxLCP) for approximating LCP. Step 1 involves optimizing over the polytope Q , which corresponds to an “approximate” hitting set for all the s, t-paths in P (G , s, t ) of length at most D: for each such path, we only require that x(a) ≥ 1/ D for some a ∈ ( P ), instead of requiring that a∈( P ) x(a) ≥ 1. The parameter D will be selected
to be n2/3 later. The polytope Q is not convex and has high complexity, so that optimizing over it is challenging. Lemma 1 below uses the Ellipsoid method (see, e.g., [15,9]) to find the solution x. As we discuss below, the solution x computed in this manner has a special structure, which is crucial in the approximation guarantee of our algorithm. Algorithm 1 Algorithm ApproxLCP. ApproxLCP Input: (i) graph G = ( V , E ), (ii) set L of labels, (iii) labeling function : E → L, (iv) nodes s, t ∈ V , and (v) parameter D, which will be fixed when the algorithm is invoked. Output: L ⊆ L such that s and t are disconnected in the graph resulting from the deletion of all edges with labels in the set L . 1: Let Q denote the polytope {x ∈ [0, 1] L : for all P ∈ P (G , s, t ), with | P | ≤ D, there exists a ∈ ( P ) with x(a) ≥ 1/ D }. Find a fractional solution x ∈ Q which minimizes a∈ L x(a), using the method described in Lemma 1. 2: Let L 1 = {a ∈ L : x(a) ≥ 1/ D }. 3: Let E = {e ∈ E : (e ) ∈ / L 1 } be the set of edges that result from the deletion of all edges with labels in set L 1 . Compute an s, t-minimum (unlabeled) cut, E , in the graph G = ( V , E ). Let L 2 be the set of labels on edges in E . 4: Return L = L 1 ∪ L 2 .
Lemma 1. It is possible to compute an approximate fractional solution x ∈ Q in Step 1 of Algorithm 1 in polynomial time with the following properties: (i) for each path P ∈ P (G , s, t ) with | P | ≤ D, there exists a ∈ ( P ) such that x(a) ≥ 1/ D and (ii) a ∈ L x(a ) ≤ O P T (1 + ), where O P T denotes the cost of the optimum solution to the LCP instance, and > 0 is a constant. The proof of Lemma 1 uses the Ellipsoid method, in a slightly non-standard manner. We discuss this below, and a specific variant needed, before giving the proof of Lemma 1. The Ellipsoid method. We first briefly describe the ellipsoid method for finding a feasible solution x from a convex polytope K ⊆ R N ; see [15] for a detailed discussion. Given a point c ∈ R N and a positive definite N-dimensional matrix C , an ellipsoid E (c , C ) is defined as E (c , C ) = {x ∈ R N : (x − c )T C −1 (x − c ) ≤ 1}. The algorithm starts with an ellipsoid E0 (c 0 , C 0 ) ⊇ K for some c 0 , C 0 , which can be found efficiently, if K is a polyhedron of the form “ Ax ≤ b”. If c 0 ∈ K , we are done. Else, the algorithm refines the ellipsoid in the following manner: 1. M is selected to be a polynomial in N and the encoding length of K (as described below). / K and i < M: 2. While c i ∈ (a) Find a “separating hyperplane” s T x ≤ d that is valid for all x ∈ K , but s T c i > d; (b) Compute c i +1 , C i +1 (see [15]). 3. If i < M: return x = c i as the feasible solution. Else, return “K is empty”. A “separation oracle” A is an algorithm that either decides that a given point y is in the polytope K , or finds a separating hyperplane s T x ≤ d such that s T x ≤ d < s T y for all x ∈ K . The ellipsoid is updated based on this separating hyperplane so that vol(Ei +1 (c i +1 , C i +1 ))/ vol(Ei (c i , C i )) ≤ e −1/(5N ) , which ensures that the volume of the ellipsoid after k iterations satisfies vol(Ek (ck , C k )) ≤ vol(E0 (c 0 , C 0 ))e −k/(5N ) , provided that the algorithm has not yet terminated. It can be shown that the algorithm terminates in M = O ( N log( vol(E0 (c 0 , C 0 ))/ v min )) iterations, where E0 (c 0 , C 0 ) is the initial ellipsoid that is guaranteed to contain K , and v min is a lower bound on the volume of K . When the Ellipsoid method terminates, either it finds a feasible solution, or guarantees that K has volume less than v min . If K is a full-dimensional non-empty polyhedron, it can be shown that its volume is at least v min . Therefore, if the method terminates with the guarantee that K has volume less than v min , there is no feasible solution. For the case where K is of the form “ Ax ≤ b”, it can be shown that log vol(E0 (c 0 , C 0 )) = O ( N log N ) and v min ≥ e − O ( N log N ) , where N is a polynomial in N and the maximum length of encoding of any row of the matrix [ Ab], leading to the polynomial time bound of the algorithm; we refer to [15] (section 13.2) for further details of the Ellipsoid method. Approximate separation oracle. Often, even solving the separation problem is challenging, e.g., [5,9]. In such cases, we consider an approximate version of the separation problem, which can also be used in the ellipsoid algorithm. Jansen [9] considers a polyhedron which is defined as the intersection of a polyhedron Ax ≤ b and another polyhedron B, where A is an R × N matrix, x ∈ R N , b ∈ R R , b > 0, B ⊆ R N , for some R , N. Let K α be an approximation of K , defined as the intersection of Ax ≤ α · b, and the polyhedron B, where α > 1. Jansen assumes that there exists a separation oracle for B, and shows that the problem of finding a feasible solution from K α can be reduced to designing an approximate separation oracle that, given a point y ∈ R N , is able to either (i) decide y ∈ K α , or (ii) find a vector d such that d T x < d T y for all x ∈ K . The specific structure we need for Lemma 1 is different (e.g., we don’t have a packing program, unlike [9]). Therefore, we discuss the specific form we need below.
T. Dutta et al. / Theoretical Computer Science 648 (2016) 34–39
37
N Lemma 2. Let K = B 1 ∩ B 2 be a polyhedron where B 1 is a nonnegative polyhedron Ax ≥ b. Let K approx (α ) denote the set of all x ∈ R such that x ∈ B 2 and for each constraint A x ≥ b in the system Ax ≥ b, we have x ≥ 1 / α for some index j ∈ { k : A = 0 }. i j ik j ij j
Let A be a polynomial time approximate separation oracle that, given y ∈ R N , either returns a violated constraint s T x ≥ d, or asserts that y ∈ K approx (α ). Then, the ellipsoid algorithm performs a polynomial number of calls to the approximate separation oracle A, and either returns a point y ∈ K approx (α ), or asserts that the volume of K is bounded by some parameter δ > 0. Proof. As in Jansen [9], the proof follows on the same lines as the ellipsoid method [15]. The algorithm starts with the estimate of the parameter M for the upper bound on the number of iterations (recall that M = O ( N log( vol(E0 (c 0 , C 0 ))/ v min ))), an initial E0 (c 0 , C 0 ) ⊇ K for some c 0 , C 0 . In the ith iteration, A checks if c i ∈ K approx (α ). If c i ∈ / K approx (α ), A finds a violated constraint s T x ≥ d, which is used to compute c i +1 and C i +1 as before. As a result, the bound of vol(Ei +1 (c i +1 , C i +1 ))/ vol(Ei (c i , C i )) ≤ e −1/(5N ) still holds [15]. Therefore, if the algorithm terminates in O ( M ) iterations, it finds c i ∈ K approx (α ), which is returned as the approximate solution. If the algorithm has not terminated in O ( M ) iterations, the volume of the ellipsoid (and hence the volume of K ) becomes smaller than some bound δ = e − O ( M / N ) vol(E0 (c 0 , C 0 )) = v min , and the lemma follows. As discussed earlier, if the volume of K is bounded by δ , then K is empty. Proof of Lemma 1. Let Q 1 denote the polyhedron formed by the following constraints (3.1) and (3.2):
x(a) ≥ 1 for P ∈ P (G , s, t ), | P | ≤ D
(3.1)
a∈( P )
0 ≤ x(a) ≤ 1
for a ∈ L
(3.2)
ˆ , where zˆ ∈ [ O P T , O P T (1 + )] is a “guess” of a∈ L x(a) ≤ z
Let Q 2 denote the polyhedron formed by the constraint O P T , within a factor of (1 + ). Let Q = Q 1 ∩ Q 2 . Since Q 1 has exponentially many constraints, we need to use the ellipsoid method to optimize over it. We now apply Lemma 2 with B 1 = Q 1 , B 2 = Q 2 and α = D; note that Q approx (α ) is precisely the polytope Q ∩ Q 2 , where Q is the polytope defined in Algorithm 1. We design the following approximate separation oracle for a given point x ∈ R N : all edges with labels in L 1 (as in Algorithm 1). (i) Let L 1 = {a : x(a) ≥ 1/ D }. Let G denote the graph obtained by deleting , and If there exists no path of length at most D from s to t in G x (a) ≤ zˆ , we return x as the solution. a ∈ L ˆ , we return this as the violated constraint for Q . (ii) If a∈ L x(a) > z (iii) If there is a shortest path P from s to t with | P | ≤ D in G , we return the constraint a∈( P ) x(a) ≥ 1 as the violated constraint for Q . Clearly, the above algorithm can be implemented in polynomial time. We first consider the cases when the separation oracle returns a violated constraint. In case (ii) above, it is clear that the cost constraint is violated for Q . In case (iii) above, it must be the case that ( P ) ⊆ L − L 1 , and therefore, x(a) < 1/ D for all a ∈ ( P ). This implies x ( a∈( P ) a) < | P |/ D ≤ 1, and this is a violated constraint for Q . ˆ . Further, if P is a path from s Finally, we consider case (i), where the algorithm returns point x. Clearly, a∈ L x(a) ≤ z to t in G with | P | ≤ D, there exists a label a ∈ L with x(a) ≥ 1/ D (since P was hit when the labels in L 1 are deleted), which implies x ∈ Q approx (α ) = Q ∩ Q 2 , thereby satisfying the requirements of the approximate separation oracle in Lemma 2. Theorem 1. ApproxLCP gives a solution with cost within a factor of O (n2/3 ) of the optimum. 2/ 3 Proof. We consider the solution x returned by Algorithm follows that 1 (ApproxLCP) with D = n . From Lemma 1, it the point y defined as: y (a) = min{ Dx(a), 1} satisfies y ( a ) ≥ 1 for all P ∈ P (G , s, t ), | P | ≤ D, and a∈( P ) a∈ L y (a) ≤ D (1 + ) O P T . This implies that | L 1 | = |{a : x(a) ≥ 1/ D }| = |{a : y (a) = 1}| ≤ D (1 + ) O P T = O (n2/3 O P T ). By construction, no s, t-paths of length less than D remain in the graph G , and the distance d(s, t ) > D in G . Let the s, t mincut in G have size k; by Menger’s theorem, this implies paths from s to t. By [6], it follows that the shortest √ that there are k edge-disjoint √ of these k paths has length at most n/ k, i.e., d(s, t ) ≤ n/ k. For D = n2/3 , we get k ≤ n2/3 . The set L 2 consists of all the labels on the edges in the min s, t cut in G , and so | L 2 | ≤ n2/3 . Since the solution chosen by ApproxLCP is L 1 ∪ L 2 , its cost is within a factor of O (n2/3 ) of the optimum. The theorem now follows.
4. Approximation algorithm and hardness for the LCLC problem We now consider the LCLC problem (recall the definitions from Section 2). A language L is regular if it can be accepted by a finite automaton (see, e.g., [8]). We derive an approximation algorithm for the LCLC problem when L is regular, by a reduction to LCP, using a product graph construction from [4]. We are not aware of any prior bounds for the LCLC problem. We also discuss the hardness of approximation for the LCLC problem.
38
T. Dutta et al. / Theoretical Computer Science 648 (2016) 34–39
Theorem 2. Given an instance of the LCLC problem, involving a graph G = ( V , E ), nodes √ s, t ∈ V , set L of labels, a labeling function : E → L, and a regular language L, we can obtain an approximation factor of O (min{ N m, (nN )2/3 }) in time polynomial in n, m and N, where N denotes the number of states in a finite state machine that accepts L. Proof. Our proof is by a reduction from the LCLC problem to the LCP problem by means of a product graph construction. Let M = ( Q , L , δ, q0 , F ) be a (non-deterministic) FSM for the regular language L, where (i) Q is the set of states, with N = | Q |, (ii) L is the alphabet, (iii) δ : Q × L → 2 Q denotes the state transition function, (iv) q0 is the start state and (v) F denotes the set of accepting states. Note that, without loss of generality, we can assume that M has no -transitions, i.e., transitions involving the empty string (if not, M can be transformed into an equivalent non-deterministic FSM without any -transitions, and without increasing the number of states, following a standard construction based on -closure, as shown in Theorem 2.2 of [8]). First, we discuss the case when F consists of a single state q f . We construct a product graph H = ( V , E ) of the original labeled graph G = ( V , E ) and the FSM M in the following manner: we have V = V × Q , and ((u , q1 ), ( v , q2 )) ∈ E if and only if (u , v ) ∈ E and q2 ∈ δ(q1 , (u , v )); therefore, we have | V | = nN and | E | ≤ mN 2 . We have the same set L of labels for the edges in E , and the labeling function is defined as ((u , q1 ), ( v , q2 )) = (u , v ). Finally, we define the LCP instance on the labeled graph H with the terminals (s, q0 ) and (t , q f ), label set L and label function : E → L. It is easy to verify that (i) a path P in G from s to t has ( P ) ∈ L if and only if the corresponding “image” P of P in the labeled graph H is a path connecting (s, q0 ) to (t , q f ), and (ii) any feasible solution L ⊂ L of the LCLC problem on G is a feasible solution for the LCP instance defined on H , and vice-versa. Putting these together, and √ using Theorem 1 and the result of [16], it follows that the LCLC problem can be approximated within a factor of O (min{ N m, (nN )2/3 }). Next, we consider the case where | F | > 1; let F = {q1f , . . . , qkf }. In this case we modify the graph H constructed above slightly, in the following manner. We add a “super-sink” t . Each (t , q if ) is connected to t by | L | parallel edges, with each of these edges having a distinct label from L; let this be denoted by graph H . It is easy to see that the optimum solution in H that separates all paths from (s, q0 ) to t must separate all the paths from (s, q0 ) to (t , qif ) for all i = 1, . . . , k in H .
1−1/ log logc n
Next, we prove that the LCLC problem is hard to approximate within a factor of g (n) = o 2log
n
, for any
c < 1/2. Our result is based on that of [16], which shows that the LCP is hard to approximate within an g (n)-factor, by a gap preserving reduction from the LABELCOVER problem [2]. We exhibit a gap preserving reduction from LCP to LCLC.
1−1/ log logc n
Theorem 3. The LCLC problem is hard to approximate within a factor of o 2log
n
, for any c < 1/2.
Proof. We give a reduction from LCP to LCLC. Consider an LCP instance I specified by graph G = ( V , E ), set L, a labeling (·), and s, t ∈ V . We construct an LCLC instance I on the same labeled graph, with the language L consisting of all words in L of length at least 1. Clearly, this can be done in polynomial time. Observe that all the paths in G from s to t are L-respecting. Therefore, any set L ⊆ L such that the deletion of all edges with labels in L disconnects s and t, is a feasible solution for both instances I and I . This implies the optimum solution has the same cost in both instances. Therefore, the gap-preserving approximation hardness of LCP in [16] implies that LCLC 1−1/ log logc n
is also hard to approximate within a factor of o 2log
n
, for any c < 1/2.
Acknowledgements We thank the reviewers for reading the paper very carefully, and pointing out errors in earlier versions. The work of Tridib Dutta, Vullikanti S. Anil Kumar and Madhav V. Marathe has been partially supported by NSF Nets Grant CNS-0626964, NSF HSD Grant SES-0729441, NSF PetaApps Grant OCI-0904844, NSF NETS Grant CNS-0831633, NSF CNS-0845700, NSF Netse Grant CNS-1011769, NSF SDCI Grant OCI-1032677, DTRA R&D Grant HDTRA1-0901-0017, DTRA CNIMS Grant HDTRA1-07-C-0113, DOE Grant DE-SC0003957. References [1] [2] [3] [4] [5] [6] [7] [8] [9]
S. Abiteboul, V. Vianu, Regular path queries with constraints, J. Comput. Systems 58 (1999) 428–452. S. Arora, C. Lund, Hardness of approximations, in: D. Hochbaum (Ed.), Approximation Algorithms for NP-complete Problems, PWS Publisher, 1995. G. Baier, Flows with Path Restrictions, PhD thesis, Technical University, Berlin, 2003. C.L. Barrett, R. Jacob, M.V. Marathe, Formal-language-constrained path problems, SIAM J. Comput. 30 (2000) 809–837. R. Carr, S. Doddi, G. Konjevod, M. Marathe, On the red–blue set cover problem, in: Proceedings of the 11th Annual ACM-SIAM Symposium on Discrete Algorithms, 2000, pp. 345–353. Z. Galil, X. Yu, Short length versions of Menger’s theorem, in: Proc. 27th Annual ACM Symposium on Theory of Computing, 1995, pp. 499–508. R. Hassin, J. Monnot, D. Segev, Approximation algorithms and hardness results for labeled connectivity problems, J. Comb. Optim. 14 (2007) 437–453. J.E. Hopcroft, J.D. Ullman, Introduction to Automata Theory, Languages, and Computation, Addison–Wesley Publishing Company, 1979. K. Jansen, Approximate strong separation with application in fractional graph coloring and preemptive scheduling, Theoret. Comput. Sci. (2003) 239–256.
T. Dutta et al. / Theoretical Computer Science 648 (2016) 34–39
39
[10] S. Jegelka, J. Bilmes, Cooperative cuts: graph cuts with submodular edge weights, Tech. Rep. TR-189, Max Planck Institute for Biological Cybernetics, 2010. [11] S. Jha, O. Sheyner, J. Wing, Two formal analyses of attack graphs, in: Proceedings of the 15th IEEE Computer Security Foundations Workshop, 2002, pp. 49–63. [12] D. Kempe, J.M. Kleinberg, A. Kumar, Connectivity and inference problems for temporal networks, J. Comput. System Sci. 64 (2002) 820–842. [13] S. Krumke, H. Wirth, On the minimum label spanning tree problem, Inform. Process. Lett. (1998) 81–85. [14] A.O. Mendelzon, P.T. Wood, Finding regular simple paths in graph databases, SIAM J. Comput. 24 (1995) 1235–1258. [15] A. Schrijver, Theory of Linear and Integer Programming, Wiley, 1986. [16] P. Zhang, J.-Y. Cai, L.-Q. Tang, W.-B. Zhao, Approximation and hardness results for label cut and related problems, J. Comb. Optim. (2009).
Contents lists available at ScienceDirect
Theoretical Computer Science www.elsevier.com/locate/tcs
Labeled cuts in graphs Tridib Dutta a , Lenwood S. Heath b , V.S. Anil Kumar a,∗ , Madhav V. Marathe a a b
Department of Computer Science, and Biocomplexity Institute, Virginia Tech, Blacksburg, VA, United States Department of Computer Science, Virginia Tech, Blacksburg, VA, United States
a r t i c l e
i n f o
Article history: Received 22 December 2010 Received in revised form 25 July 2016 Accepted 29 July 2016 Available online 9 August 2016 Communicated by T. Erlebach Keywords: Labeled graphs Minimum cut Regular languages
a b s t r a c t In this paper, we study labeled extensions of the classical s, t-mincut problem, in which we are given a graph G = ( V , E ), two specific vertices s, t ∈ V , a set L of labels, and a labeling : E → L of the edges. The goal is to choose a subset L ⊆ L of labels, so that s and t become disconnected when deleting the edges with labels in L . We give √ an algorithm with an O (n2/3 ) approximation factor guarantee, which improves the O ( m) approximation guarantee of Zhang et al. (2009) [16]. We also consider variants in which selected subsets of paths between s and t have to be removed (instead of all paths). These labeled cut problems are much harder than the classical mincut problem. © 2016 Published by Elsevier B.V.
1. Introduction Labeled graphs arise in a number of applications, e.g., edges in social contact graphs can be labeled by the time of contact [12]. The focus of this paper is on two classes of cut problems in labeled graphs that generalize the classical s, t-mincut problem in a natural manner. Let G = ( V , E ) denote a directed graph, and let L denote a set of labels. Let : E → L denote a labeling function. The first problem we consider is the s, t-Labeled Mincut Problem (LCP), which involves choosing the smallest subset L ⊂ L such that two given nodes s and t are disconnected in the graph G = ( V , E \ {e : (e ) ∈ L }), obtained by deleting all edges with labels in the set L . The LCP problem is used in the context of “attack graphs” in intrusion detection by Jha et al. [11]; in this case, the edge labels represent possible attacks, and a labeled mincut is the smallest set of attacks that disconnect two selected terminals. The complexity of LCP was first studied by Zhang et al. [16], who show that, unlike the classical mincut problem, this problem is NP-complete even to approximate within a factor 1−o (1)
of O 2log
n
√
, where n = | V |. They also present a greedy algorithm that achieves an approximation factor of O ( m)
for edge weighted graphs. In this paper, we present an algorithm with an approximation factor of O (n2/3 ) for unweighted graphs, improving the result of [16] when m = (n4/3+ ) for > 0. The second class of labeled cut problems we consider is called the s, t-Language Constrained Labeled Cut (LCLC) problem. Here, we are given a formal language L defined on the set L. For a path P in G, let ( P ) denote the word formed by concatenating the labels on the edges in P . The LCLC problem involves choosing the smallest subset L ⊂ L of labels, such that E \ {e : (e ) ∈ L } contains no paths P from s to t with ( P ) ∈ L. In this paper, we assume that L is a regular language, which is a language that can be accepted by a finite automaton (see, e.g., [8]). The above versions of the labeled cut problems are all quite hard in general, even for special classes of graphs, e.g., bounded treewidth graphs. Natural duals of these problems can be defined, which are variants of the classical flow problem.
*
Corresponding author. E-mail addresses: [email protected] (T. Dutta), [email protected] (L.S. Heath), [email protected] (V.S.A. Kumar), [email protected] (M.V. Marathe).
http://dx.doi.org/10.1016/j.tcs.2016.07.040 0304-3975/© 2016 Published by Elsevier B.V.
T. Dutta et al. / Theoretical Computer Science 648 (2016) 34–39
35
Fig. 1. An example illustrating the LCP and LCLC problems. Let s = v 1 and t = v 6 . L = {a, b, c , d} denotes the set of labels. The optimum LCP solution is the set {c }, while the minimum unlabeled cut has cost 2. Let L be the language of strings a∗ c. The set P (G , L, s, t ) of L-respecting paths consists of only two paths, v 1 , v 2 , v 4 , v 6 and v 1 , v 2 , v 5 , v 6 , and either {a} or {c } is an optimal solution to the LCLC problem. Observe that the solution {a} keeps s and t still connected.
The dual for the LCP problem is a flow with capacities associated with labels, instead of with individual edges. The dual of the LCLC problem is a maximum flow problem in which only flow paths whose labels form words in the language L can be used. Unlike classical flows, the maxflow-mincut duality does not hold, and there can be a large gap between these quantities—this follows from the gap between flows and cuts for length constrained paths [3] (we note that the LCLC problem generalizes the problem of cutting length constrained paths). Labeled versions of a few other combinatorial problems have been studied. One of the earliest such problems is the minimum label spanning tree (MinLST) problem, in which the goal is to choose a spanning tree, whose cost, measured by the sum of the costs of the labels of the edges in the spanning tree, is minimized. Krumke et al. [13] give an O (log n) approximation bound for this problem. Carr et al. [5] show that MinLST is a special case of the Red–Blue Set Cover problem and study its complexity. Another labeled problem is the minimum label s, t path (MinLP) problem, in which the objective is to find a path from s to√t, minimizing the combined cost of its labels. Hassin et al. [7] show that MinLP can be approximated within a factor of O ( n). The closest prior work related to the LCLC problem is by Barrett et al. [4], who study the problem of finding a shortest language constrained path in a labeled graph. For regular languages, they reduce this problem to shortest paths in an appropriately defined product graph. Applications of language constrained shortest paths include multi-modal routing, formulating database queries [1], and web searches [14]. LCP is a special case of the Submodular Cut problem, in which the cost of a cut is defined by a submodular function (for LCP, define the cost of a cut as the number of distinct labels on the edges in the cut). This was studied recently by Jegelka et al. [10], who show that this problem is difficult to approximate within a factor of O (n1/3 ) in general. Our Contributions. In this paper, we study the complexity of the LCP and LCLC problems. For the LCP problem, we present an algorithm, ApproxLCP, with an approximation guarantee of O (n2/3 ), which improves upon the result of Zhang et al. [16] for unweighted graphs with m ≥ n4/3+ , for any > 0. ApproxLCP is based on rounding a linear program for hitting all paths of length at most D, where D is a parameter (instead of all paths, as in the case of LCP). This LP has exponential size, and the separation oracle (which arises in the use of the Ellipsoid method [15]) corresponds to the Minimum Label s, t path 1 −
log n (MinLP) problem [7], which is difficult to solve even approximately within a factor of ( some > 0. 2 1−1/ log)logfor cn n For the LCLC problem, we show that it cannot be approximated within a factor of o 2log , for any c < 1/2, by
extending the hardness result for LCP [16]. Using the product graph construction √ of Barrett et al. [4], we show that the LCLC problem can be reduced to LCP for regular languages. This leads to an O (min{ N m, (nN )2/3 }) approximation algorithm for LCLC, where N denotes the number of states in a finite state machine for the language L. 2. Preliminaries Let G = ( V , E ) denote a directed graph, and let n = | V | and m = | E |. Let s, t ∈ V be a given pair of nodes. Let L denote a set of edge labels. Let : E → L denote an edge labeling function. For a path P = e 1 , . . . , ek in G, ( P ) = (e 1 ) ◦ · · · ◦ (ek ) denotes the word formed by concatenating the labels on the edges on P ; here “◦” denotes the concatenation operator. Sometimes, we abuse the notation and also use ( P ) as the set of labels on P , whenever it is clear from the context. Given a regular language L defined on the alphabet L, we say that a path P is L-constrained (or L-respecting) if ( P ) ∈ L. For a pair of nodes s, t in G, let P (G , s, t ) denote the set of all s-t paths in G, and let P (G , L, s, t ) denote the set of all L-respecting paths from s to t. The Labeled Cut Problem (LCP) is to choose a smallest set L ⊂ L of labels so that no path in P (G , s, t ) remains after deleting all the edges with labels in L . The Language Constrained Minimum Cut (LCLC) problem is to choose the smallest subset L ⊂ L of labels so that the graph G = ( V , E \ {e : (e ) ∈ L }), resulting from the deletion of edges with labels in L , contains no L-constrained s-t paths (equivalently, P (G , L, s, t ) = ∅). Fig. 1 shows an example for both the LCP and LCLC problems. Note that the optimal solutions to these problems cost less than the solutions to the (unlabeled) minimum s, t-cut. In a graph with all edges having the same label, the LCP and LCLC solutions have cost 1, which can be arbitrarily smaller than the cost of the minimum unlabeled solution.
36
T. Dutta et al. / Theoretical Computer Science 648 (2016) 34–39
3. Improved approximation algorithm for LCP We discuss Algorithm 1 (ApproxLCP) for approximating LCP. Step 1 involves optimizing over the polytope Q , which corresponds to an “approximate” hitting set for all the s, t-paths in P (G , s, t ) of length at most D: for each such path, we only require that x(a) ≥ 1/ D for some a ∈ ( P ), instead of requiring that a∈( P ) x(a) ≥ 1. The parameter D will be selected
to be n2/3 later. The polytope Q is not convex and has high complexity, so that optimizing over it is challenging. Lemma 1 below uses the Ellipsoid method (see, e.g., [15,9]) to find the solution x. As we discuss below, the solution x computed in this manner has a special structure, which is crucial in the approximation guarantee of our algorithm. Algorithm 1 Algorithm ApproxLCP. ApproxLCP Input: (i) graph G = ( V , E ), (ii) set L of labels, (iii) labeling function : E → L, (iv) nodes s, t ∈ V , and (v) parameter D, which will be fixed when the algorithm is invoked. Output: L ⊆ L such that s and t are disconnected in the graph resulting from the deletion of all edges with labels in the set L . 1: Let Q denote the polytope {x ∈ [0, 1] L : for all P ∈ P (G , s, t ), with | P | ≤ D, there exists a ∈ ( P ) with x(a) ≥ 1/ D }. Find a fractional solution x ∈ Q which minimizes a∈ L x(a), using the method described in Lemma 1. 2: Let L 1 = {a ∈ L : x(a) ≥ 1/ D }. 3: Let E = {e ∈ E : (e ) ∈ / L 1 } be the set of edges that result from the deletion of all edges with labels in set L 1 . Compute an s, t-minimum (unlabeled) cut, E , in the graph G = ( V , E ). Let L 2 be the set of labels on edges in E . 4: Return L = L 1 ∪ L 2 .
Lemma 1. It is possible to compute an approximate fractional solution x ∈ Q in Step 1 of Algorithm 1 in polynomial time with the following properties: (i) for each path P ∈ P (G , s, t ) with | P | ≤ D, there exists a ∈ ( P ) such that x(a) ≥ 1/ D and (ii) a ∈ L x(a ) ≤ O P T (1 + ), where O P T denotes the cost of the optimum solution to the LCP instance, and > 0 is a constant. The proof of Lemma 1 uses the Ellipsoid method, in a slightly non-standard manner. We discuss this below, and a specific variant needed, before giving the proof of Lemma 1. The Ellipsoid method. We first briefly describe the ellipsoid method for finding a feasible solution x from a convex polytope K ⊆ R N ; see [15] for a detailed discussion. Given a point c ∈ R N and a positive definite N-dimensional matrix C , an ellipsoid E (c , C ) is defined as E (c , C ) = {x ∈ R N : (x − c )T C −1 (x − c ) ≤ 1}. The algorithm starts with an ellipsoid E0 (c 0 , C 0 ) ⊇ K for some c 0 , C 0 , which can be found efficiently, if K is a polyhedron of the form “ Ax ≤ b”. If c 0 ∈ K , we are done. Else, the algorithm refines the ellipsoid in the following manner: 1. M is selected to be a polynomial in N and the encoding length of K (as described below). / K and i < M: 2. While c i ∈ (a) Find a “separating hyperplane” s T x ≤ d that is valid for all x ∈ K , but s T c i > d; (b) Compute c i +1 , C i +1 (see [15]). 3. If i < M: return x = c i as the feasible solution. Else, return “K is empty”. A “separation oracle” A is an algorithm that either decides that a given point y is in the polytope K , or finds a separating hyperplane s T x ≤ d such that s T x ≤ d < s T y for all x ∈ K . The ellipsoid is updated based on this separating hyperplane so that vol(Ei +1 (c i +1 , C i +1 ))/ vol(Ei (c i , C i )) ≤ e −1/(5N ) , which ensures that the volume of the ellipsoid after k iterations satisfies vol(Ek (ck , C k )) ≤ vol(E0 (c 0 , C 0 ))e −k/(5N ) , provided that the algorithm has not yet terminated. It can be shown that the algorithm terminates in M = O ( N log( vol(E0 (c 0 , C 0 ))/ v min )) iterations, where E0 (c 0 , C 0 ) is the initial ellipsoid that is guaranteed to contain K , and v min is a lower bound on the volume of K . When the Ellipsoid method terminates, either it finds a feasible solution, or guarantees that K has volume less than v min . If K is a full-dimensional non-empty polyhedron, it can be shown that its volume is at least v min . Therefore, if the method terminates with the guarantee that K has volume less than v min , there is no feasible solution. For the case where K is of the form “ Ax ≤ b”, it can be shown that log vol(E0 (c 0 , C 0 )) = O ( N log N ) and v min ≥ e − O ( N log N ) , where N is a polynomial in N and the maximum length of encoding of any row of the matrix [ Ab], leading to the polynomial time bound of the algorithm; we refer to [15] (section 13.2) for further details of the Ellipsoid method. Approximate separation oracle. Often, even solving the separation problem is challenging, e.g., [5,9]. In such cases, we consider an approximate version of the separation problem, which can also be used in the ellipsoid algorithm. Jansen [9] considers a polyhedron which is defined as the intersection of a polyhedron Ax ≤ b and another polyhedron B, where A is an R × N matrix, x ∈ R N , b ∈ R R , b > 0, B ⊆ R N , for some R , N. Let K α be an approximation of K , defined as the intersection of Ax ≤ α · b, and the polyhedron B, where α > 1. Jansen assumes that there exists a separation oracle for B, and shows that the problem of finding a feasible solution from K α can be reduced to designing an approximate separation oracle that, given a point y ∈ R N , is able to either (i) decide y ∈ K α , or (ii) find a vector d such that d T x < d T y for all x ∈ K . The specific structure we need for Lemma 1 is different (e.g., we don’t have a packing program, unlike [9]). Therefore, we discuss the specific form we need below.
T. Dutta et al. / Theoretical Computer Science 648 (2016) 34–39
37
N Lemma 2. Let K = B 1 ∩ B 2 be a polyhedron where B 1 is a nonnegative polyhedron Ax ≥ b. Let K approx (α ) denote the set of all x ∈ R such that x ∈ B 2 and for each constraint A x ≥ b in the system Ax ≥ b, we have x ≥ 1 / α for some index j ∈ { k : A = 0 }. i j ik j ij j
Let A be a polynomial time approximate separation oracle that, given y ∈ R N , either returns a violated constraint s T x ≥ d, or asserts that y ∈ K approx (α ). Then, the ellipsoid algorithm performs a polynomial number of calls to the approximate separation oracle A, and either returns a point y ∈ K approx (α ), or asserts that the volume of K is bounded by some parameter δ > 0. Proof. As in Jansen [9], the proof follows on the same lines as the ellipsoid method [15]. The algorithm starts with the estimate of the parameter M for the upper bound on the number of iterations (recall that M = O ( N log( vol(E0 (c 0 , C 0 ))/ v min ))), an initial E0 (c 0 , C 0 ) ⊇ K for some c 0 , C 0 . In the ith iteration, A checks if c i ∈ K approx (α ). If c i ∈ / K approx (α ), A finds a violated constraint s T x ≥ d, which is used to compute c i +1 and C i +1 as before. As a result, the bound of vol(Ei +1 (c i +1 , C i +1 ))/ vol(Ei (c i , C i )) ≤ e −1/(5N ) still holds [15]. Therefore, if the algorithm terminates in O ( M ) iterations, it finds c i ∈ K approx (α ), which is returned as the approximate solution. If the algorithm has not terminated in O ( M ) iterations, the volume of the ellipsoid (and hence the volume of K ) becomes smaller than some bound δ = e − O ( M / N ) vol(E0 (c 0 , C 0 )) = v min , and the lemma follows. As discussed earlier, if the volume of K is bounded by δ , then K is empty. Proof of Lemma 1. Let Q 1 denote the polyhedron formed by the following constraints (3.1) and (3.2):
x(a) ≥ 1 for P ∈ P (G , s, t ), | P | ≤ D
(3.1)
a∈( P )
0 ≤ x(a) ≤ 1
for a ∈ L
(3.2)
ˆ , where zˆ ∈ [ O P T , O P T (1 + )] is a “guess” of a∈ L x(a) ≤ z
Let Q 2 denote the polyhedron formed by the constraint O P T , within a factor of (1 + ). Let Q = Q 1 ∩ Q 2 . Since Q 1 has exponentially many constraints, we need to use the ellipsoid method to optimize over it. We now apply Lemma 2 with B 1 = Q 1 , B 2 = Q 2 and α = D; note that Q approx (α ) is precisely the polytope Q ∩ Q 2 , where Q is the polytope defined in Algorithm 1. We design the following approximate separation oracle for a given point x ∈ R N : all edges with labels in L 1 (as in Algorithm 1). (i) Let L 1 = {a : x(a) ≥ 1/ D }. Let G denote the graph obtained by deleting , and If there exists no path of length at most D from s to t in G x (a) ≤ zˆ , we return x as the solution. a ∈ L ˆ , we return this as the violated constraint for Q . (ii) If a∈ L x(a) > z (iii) If there is a shortest path P from s to t with | P | ≤ D in G , we return the constraint a∈( P ) x(a) ≥ 1 as the violated constraint for Q . Clearly, the above algorithm can be implemented in polynomial time. We first consider the cases when the separation oracle returns a violated constraint. In case (ii) above, it is clear that the cost constraint is violated for Q . In case (iii) above, it must be the case that ( P ) ⊆ L − L 1 , and therefore, x(a) < 1/ D for all a ∈ ( P ). This implies x ( a∈( P ) a) < | P |/ D ≤ 1, and this is a violated constraint for Q . ˆ . Further, if P is a path from s Finally, we consider case (i), where the algorithm returns point x. Clearly, a∈ L x(a) ≤ z to t in G with | P | ≤ D, there exists a label a ∈ L with x(a) ≥ 1/ D (since P was hit when the labels in L 1 are deleted), which implies x ∈ Q approx (α ) = Q ∩ Q 2 , thereby satisfying the requirements of the approximate separation oracle in Lemma 2. Theorem 1. ApproxLCP gives a solution with cost within a factor of O (n2/3 ) of the optimum. 2/ 3 Proof. We consider the solution x returned by Algorithm follows that 1 (ApproxLCP) with D = n . From Lemma 1, it the point y defined as: y (a) = min{ Dx(a), 1} satisfies y ( a ) ≥ 1 for all P ∈ P (G , s, t ), | P | ≤ D, and a∈( P ) a∈ L y (a) ≤ D (1 + ) O P T . This implies that | L 1 | = |{a : x(a) ≥ 1/ D }| = |{a : y (a) = 1}| ≤ D (1 + ) O P T = O (n2/3 O P T ). By construction, no s, t-paths of length less than D remain in the graph G , and the distance d(s, t ) > D in G . Let the s, t mincut in G have size k; by Menger’s theorem, this implies paths from s to t. By [6], it follows that the shortest √ that there are k edge-disjoint √ of these k paths has length at most n/ k, i.e., d(s, t ) ≤ n/ k. For D = n2/3 , we get k ≤ n2/3 . The set L 2 consists of all the labels on the edges in the min s, t cut in G , and so | L 2 | ≤ n2/3 . Since the solution chosen by ApproxLCP is L 1 ∪ L 2 , its cost is within a factor of O (n2/3 ) of the optimum. The theorem now follows.
4. Approximation algorithm and hardness for the LCLC problem We now consider the LCLC problem (recall the definitions from Section 2). A language L is regular if it can be accepted by a finite automaton (see, e.g., [8]). We derive an approximation algorithm for the LCLC problem when L is regular, by a reduction to LCP, using a product graph construction from [4]. We are not aware of any prior bounds for the LCLC problem. We also discuss the hardness of approximation for the LCLC problem.
38
T. Dutta et al. / Theoretical Computer Science 648 (2016) 34–39
Theorem 2. Given an instance of the LCLC problem, involving a graph G = ( V , E ), nodes √ s, t ∈ V , set L of labels, a labeling function : E → L, and a regular language L, we can obtain an approximation factor of O (min{ N m, (nN )2/3 }) in time polynomial in n, m and N, where N denotes the number of states in a finite state machine that accepts L. Proof. Our proof is by a reduction from the LCLC problem to the LCP problem by means of a product graph construction. Let M = ( Q , L , δ, q0 , F ) be a (non-deterministic) FSM for the regular language L, where (i) Q is the set of states, with N = | Q |, (ii) L is the alphabet, (iii) δ : Q × L → 2 Q denotes the state transition function, (iv) q0 is the start state and (v) F denotes the set of accepting states. Note that, without loss of generality, we can assume that M has no -transitions, i.e., transitions involving the empty string (if not, M can be transformed into an equivalent non-deterministic FSM without any -transitions, and without increasing the number of states, following a standard construction based on -closure, as shown in Theorem 2.2 of [8]). First, we discuss the case when F consists of a single state q f . We construct a product graph H = ( V , E ) of the original labeled graph G = ( V , E ) and the FSM M in the following manner: we have V = V × Q , and ((u , q1 ), ( v , q2 )) ∈ E if and only if (u , v ) ∈ E and q2 ∈ δ(q1 , (u , v )); therefore, we have | V | = nN and | E | ≤ mN 2 . We have the same set L of labels for the edges in E , and the labeling function is defined as ((u , q1 ), ( v , q2 )) = (u , v ). Finally, we define the LCP instance on the labeled graph H with the terminals (s, q0 ) and (t , q f ), label set L and label function : E → L. It is easy to verify that (i) a path P in G from s to t has ( P ) ∈ L if and only if the corresponding “image” P of P in the labeled graph H is a path connecting (s, q0 ) to (t , q f ), and (ii) any feasible solution L ⊂ L of the LCLC problem on G is a feasible solution for the LCP instance defined on H , and vice-versa. Putting these together, and √ using Theorem 1 and the result of [16], it follows that the LCLC problem can be approximated within a factor of O (min{ N m, (nN )2/3 }). Next, we consider the case where | F | > 1; let F = {q1f , . . . , qkf }. In this case we modify the graph H constructed above slightly, in the following manner. We add a “super-sink” t . Each (t , q if ) is connected to t by | L | parallel edges, with each of these edges having a distinct label from L; let this be denoted by graph H . It is easy to see that the optimum solution in H that separates all paths from (s, q0 ) to t must separate all the paths from (s, q0 ) to (t , qif ) for all i = 1, . . . , k in H .
1−1/ log logc n
Next, we prove that the LCLC problem is hard to approximate within a factor of g (n) = o 2log
n
, for any
c < 1/2. Our result is based on that of [16], which shows that the LCP is hard to approximate within an g (n)-factor, by a gap preserving reduction from the LABELCOVER problem [2]. We exhibit a gap preserving reduction from LCP to LCLC.
1−1/ log logc n
Theorem 3. The LCLC problem is hard to approximate within a factor of o 2log
n
, for any c < 1/2.
Proof. We give a reduction from LCP to LCLC. Consider an LCP instance I specified by graph G = ( V , E ), set L, a labeling (·), and s, t ∈ V . We construct an LCLC instance I on the same labeled graph, with the language L consisting of all words in L of length at least 1. Clearly, this can be done in polynomial time. Observe that all the paths in G from s to t are L-respecting. Therefore, any set L ⊆ L such that the deletion of all edges with labels in L disconnects s and t, is a feasible solution for both instances I and I . This implies the optimum solution has the same cost in both instances. Therefore, the gap-preserving approximation hardness of LCP in [16] implies that LCLC 1−1/ log logc n
is also hard to approximate within a factor of o 2log
n
, for any c < 1/2.
Acknowledgements We thank the reviewers for reading the paper very carefully, and pointing out errors in earlier versions. The work of Tridib Dutta, Vullikanti S. Anil Kumar and Madhav V. Marathe has been partially supported by NSF Nets Grant CNS-0626964, NSF HSD Grant SES-0729441, NSF PetaApps Grant OCI-0904844, NSF NETS Grant CNS-0831633, NSF CNS-0845700, NSF Netse Grant CNS-1011769, NSF SDCI Grant OCI-1032677, DTRA R&D Grant HDTRA1-0901-0017, DTRA CNIMS Grant HDTRA1-07-C-0113, DOE Grant DE-SC0003957. References [1] [2] [3] [4] [5] [6] [7] [8] [9]
S. Abiteboul, V. Vianu, Regular path queries with constraints, J. Comput. Systems 58 (1999) 428–452. S. Arora, C. Lund, Hardness of approximations, in: D. Hochbaum (Ed.), Approximation Algorithms for NP-complete Problems, PWS Publisher, 1995. G. Baier, Flows with Path Restrictions, PhD thesis, Technical University, Berlin, 2003. C.L. Barrett, R. Jacob, M.V. Marathe, Formal-language-constrained path problems, SIAM J. Comput. 30 (2000) 809–837. R. Carr, S. Doddi, G. Konjevod, M. Marathe, On the red–blue set cover problem, in: Proceedings of the 11th Annual ACM-SIAM Symposium on Discrete Algorithms, 2000, pp. 345–353. Z. Galil, X. Yu, Short length versions of Menger’s theorem, in: Proc. 27th Annual ACM Symposium on Theory of Computing, 1995, pp. 499–508. R. Hassin, J. Monnot, D. Segev, Approximation algorithms and hardness results for labeled connectivity problems, J. Comb. Optim. 14 (2007) 437–453. J.E. Hopcroft, J.D. Ullman, Introduction to Automata Theory, Languages, and Computation, Addison–Wesley Publishing Company, 1979. K. Jansen, Approximate strong separation with application in fractional graph coloring and preemptive scheduling, Theoret. Comput. Sci. (2003) 239–256.
T. Dutta et al. / Theoretical Computer Science 648 (2016) 34–39
39
[10] S. Jegelka, J. Bilmes, Cooperative cuts: graph cuts with submodular edge weights, Tech. Rep. TR-189, Max Planck Institute for Biological Cybernetics, 2010. [11] S. Jha, O. Sheyner, J. Wing, Two formal analyses of attack graphs, in: Proceedings of the 15th IEEE Computer Security Foundations Workshop, 2002, pp. 49–63. [12] D. Kempe, J.M. Kleinberg, A. Kumar, Connectivity and inference problems for temporal networks, J. Comput. System Sci. 64 (2002) 820–842. [13] S. Krumke, H. Wirth, On the minimum label spanning tree problem, Inform. Process. Lett. (1998) 81–85. [14] A.O. Mendelzon, P.T. Wood, Finding regular simple paths in graph databases, SIAM J. Comput. 24 (1995) 1235–1258. [15] A. Schrijver, Theory of Linear and Integer Programming, Wiley, 1986. [16] P. Zhang, J.-Y. Cai, L.-Q. Tang, W.-B. Zhao, Approximation and hardness results for label cut and related problems, J. Comb. Optim. (2009).