L On the Complexity of -reachability ∗ Balagopal Komarath Jayalal Sarma K. S. Sunil ∗ ∗ † January 13, 2017 7 1 0 Abstract 2 We initiate a complexity theoretic study of the language based graph reachability n problem (L–Reach) : Fix a language L. Given a graph whose edges are labelled with a J alphabetsymbolsofthelanguageLandtwospecialverticessandt, testifthereispath 2 P from s to t in the graph such that the concatenation of the symbols seen from s to t 1 in the path P forms a string in the language L. We study variants of this problem with ] different graph classes and different language classes and obtain complexity theoretic C characterizations for all of them. Our main results are the following: C . Restrictingthelanguageusingformallanguagetheoryweshowthatthecomplex- s • c ity of L–Reach increases with the power of the formal language class. We show [ that there is a regular language for which the L–Reach is NL-complete even for 1 undirected graphs. In the case of linear languages, the complexity of L–Reach v does not go beyond the complexity of L itself. Further, there is a deterministic 5 5 context-free language L for which L–DagReach is LogCFL-complete. 2 We use L–Reach as a lens to study structural complexity. In this direction 3 • 0 we show that there is a language A in TC0 for which A–DagReach is NP- 1. complete. Using this we show that P vs NP question is equivalent to P vs 0 DagReach 1(P)1 question. This leads to the intriguing possibility that by prov- − 7 ing DagReach 1(P) is contained in some subclass of P, we can prove an upward 1 − : translation of separation of complexity classes. Note that we do not know a way v to upward translate the separation of complexity classes. i X r a 1 Introduction Reachability problems in mathematical structures are a well-studied problem in space com- plexity. An important example is the graph reachability problem where given a directed ∗Apreliminaryversionofthisworkwithasubsetofresultswaspresentedat16th International Workshop on Descriptional Complexity of Formal Systems (DCFS 2014) and appears in [9]. †Department of Computer Science & Engineering, Indian Institute of Technology Madras, Chennai – 36, India. Email : baluks,jayalal,sunil @cse.iitm.ac.in The first author was supported by the TCS { } Ph.D. Fellowship. 1For any complexity class C, DagReach−1(C)= L:L–DagReach C . { ∈ } 1 graph G and two special vertices s and t, is there a path2 from s to t in the graph G. This problem exactly captures the space complexity of problems solvable in nondetermin- istic logarithmic space. Various restrictions of the problem have been studied - reachabil- ity in undirected graphs characterizes deterministic logspace [10], reachability in constant width graphs (even undirected) characterizes NC1 [3], reachability in planar constant width directed graphs characterizes ACC0 [5] and the version in upward planar constant width directed graphs characterizes AC0 [4]. A natural extension of the problem using formal language theory is the L–Reach prob- lem: Fix a language L defined over a finite alphabet Σ. Given a graph whose edges are labelled by alphabet symbols and two special vertices s and t, test if there is path from s to t in the graph such that the concatenation of the symbols seen from s to t forms a string in the language L. Indeed, if L is Σ , then the string on any path from s to t will be in the ∗ language. Hence the problem reduces to the graph reachability problem. Although L–Reach problem has not been studied from a space complexity theory per- spective, a lot is known about its complexity [11, 12, 16, 8, 2]. An immediate observation is that the L–Reach problem is at least as hard as the membership problem of L. Indeed, given a string x, to check for membership in L it suffices to test L–Reach in a simple path of length x where the edges are labelled by the symbols in x in that sequence. The literature | | on the problem is spread over two main themes. One is on restricting the language from the formal language perspective, and the other is by restricting the family of graphs in terms of structure. An important special case of the problem that was studied is when the language is restricted to be a context-free language (CFL). This is called the CFL–Reach. A primary motivation to study this problem is their application in various practical situations like inter-procedural slicing and inter-procedural data flow analysis [8, 11, 12]. These are used in code optimization, vectorization and parallelization phases of compiler design where one should have information about reaching definitions, available expressions, live variables, etc. associated with the program elements. The goal of inter-procedural analysis is to perform static examination of above properties of a program that consists of multiple procedures. Once a program is represented by its program dependence graph [11], the slicing problem is simply the CFL–Reach problem. Our Results: The results in this paper are in two flavors. Results based on Chomsky Hierarchy and Graph Classes: Firstly we study re- strictions of L–Reach problem when L is restricted using formal language hierarchy and the graph is restricted to various natural graph classes. Our results on this front are listed in Table 1 (for the sake of completeness, we include some known results too). Apart from the results in Table 1, we show the following theorem for the language class DCFL. Theorem 1. DCFL–DagReach is LogCFL-complete. 2We follow the convention that a path can have repeated vertices and edges. 2 Table 1: Formal language class restricted reachability Language Class Tree-Reach DAG-Reach UReach/Reach Regular L(cid:32) -complete[16] NL-complete[16] NL-complete (Theorem 4/[16]) Linear NL-complete NL-complete NL-complete (Theorem 5) (Theorem 5) (Theorem 5) Context-free LogCFL-complete LogCFL-complete P-complete (Prop. 2) (Prop. 2) (Theorem 7/[15]) Context-sensitive PSPACE-complete PSPACE-complete Undecidable (Prop. 3) (Prop. 3) ([2]) Results on the Structural Complexity front: Now we take a complexity theoretic view, where we study L–Reach as an operator on languages. It is shown in Barrett et. al. [2] that even for languages in logspace, the languages L–Reach and L–UReach are undecidable. Therefore inthis section, we consideronly DAGs. Note thatfor any languageL, the language L–DagReach is decidable. It is natural to ask whether increasing the complexity of L increases the complexity of L–DagReach. More concretely, does A L(cid:32) B = A–DagReach L(cid:32) B–DagReach? ≤m ⇒ ≤m The following theorem, along with the fact that there exists a language L (see Proposition 2) that is LogCFL-complete for which L–DagReach remains LogCFL-complete shows that such a result is highly unlikely. Theorem 2. There exists a language A TC0 for which A–DagReach is NP-complete. ∈ For any complexity class C, we consider the class of languages defined as, DagReach 1(C) = L : L–DagReach C − { ∈ } Note that for any class C, we have DagReach 1(C) C. We have the following theorems − ⊆ for different choices of C. Theorem : We show the following structural theorems: 1. (Theorem 9) DagReach 1(PSPACE) = PSPACE, DagReach 1(NP) = NP. − − 2. (Theorem 10) P = DagReach 1(P) P = NP. − (cid:54) ⇐⇒ (cid:54) 3. (Theorem 11) DagReach 1(NL) = NL NP = NL. − (cid:54) ⇐⇒ (cid:54) The above theorem shows that separating DagReach 1(P) from P would separate P − fromNP. Thisgivesusanupwardtranslationoflowerboundsoncomplexityclassesifwecan prove that DagReach 1(P) is contained in some subclass of P. Hence the question whether − we can identify some “natural” complexity class containing DagReach 1(P) becomes very − interesting. It is clear that DagReach 1(P) contains LogCFL-complete problems but is − 3 highlyunlikelytocontainsomeproblemsinL(cid:32) . IfDagReach 1(P)containssomeP-complete − problem, then proving that DagReach 1(P) is contained in some subclass of P would be − very hard. In this connection, we show the following: Theorem3. IfLisP-completeundersyntacticread-oncelogspacereductions, thenL–DagReach is NP-complete. If we are able to extend the above theorem to all types of reductions, then it implies that, assuming NP is not contained in P, DagReach 1(P) is unlikely to contain P-complete − problems. In other words, the above theorem could be interpreted as evidence (albeit very weak evidence) that DagReach 1(P) may indeed be contained in some subclass of P. − WealsoremarkthatTheorem10holdswithNLinsteadofP. However,sinceDagReach 1(NL) − contains NL-complete (under logspace reductions) languages, Theorem 11 is not as promising (as Theorem 10). A preliminary version of this with a subset of results appears [9]. In [9], we proved that there is a language A in logspace such that A–DagReach is NP-complete. In this extended version, we improve this bound to TC0 (from logspace, see Theorem 2). 2 Preliminaries In this section, we define language restricted reachability problems and make some observa- tions on their complexity. The definitions for standard complexity classes and their complete problems that we are using in this paper can be found in standard complexity theory text- books [1]. We use L(cid:32) and NL to stand for the complexity classes deterministic logspace and nondeterministic logspace respectively. All reductions (even ones used for defining complete- ness) in this paper are in logspace unless mentioned otherwise. Definition 1. For any language L Σ , we consider graph G where each edge in G is ∗ ⊆ labelled by an element from Σ. For any path in G we define the yield of the path as the string formed by concatenating the symbols found in the path in that order. Then we define the language L–Reach as the set of all (G,s,t) such that there exists a path from s to t in G with yield in L. By restricting the graph in Definition 1, we obtain similar definitions for L–DagReach (DAGs), L–UReach (Undirected Graphs) and L–TreeReach (Orientations of Undirected Trees). Let Σ and Γ be finite alphabets. A function f from Σ to Γ is called a projection if for ∗ ∗ all x Σ , the string f(x) = y is such that for all i [m], either y = x for some j [n] or ∗ i j ∈ ∈ ∈ y = 0 or y = 1, where m = y and n = x . A language L over Σ is said to be projection i i | | | | reducible to a language L over Γ if there is a projection f such that x L y = f(x) (cid:48) ∈ ⇐⇒ ∈ L and y is polynomial in x . (cid:48) | | | | Observation 1. Any language L is projection reducible to L–TreeReach. 4 Clearly, the above observation holds for any reachability variant based on the graph. This is because L–TreeReach is a restriction of the other reachability variants. In fact the following observation shows that L–TreeReach is not much harder than L. Observation 2. For any language L, the language L–TreeReach is logspace reducible to L. Observation 2 holds because in logspace we can find the unique path (and hence its yield) from s to t in some tree and run the algorithm for L on the yield. Next we define classes of languages based on language restricted reachability. Definition 2. For any class of languages C, we define the set of languages C–Reach as the class of all languages L–Reach where L is in C. Again, by restricting graphs in Definition 2, we obtain similar definitions for C–DagReach, C–UReach and C–TreeReach. Definition 3. For a class of languages C and a complexity class D, we say that C–Reach is complete for D if the following conditions are satisfied. For all L C, the language L–Reach is in D. • ∈ There exists a language L in C such that the language L–Reach is hard for D. • Definition 4. For any complexity class C, we define Reach 1(C) as the set of all languages − L such that L–Reach is in C. Again,byrestrictinggraphsinDefinition4,weobtainsimilardefinitionsforDagReach 1(C), − UReach 1(C) and TreeReach 1(C). − − NotethatbyObservation1,foranyclassCtherelationsReach 1(C) DagReach 1(C) − − TreeReach 1(C) C holds. In this paper, we will be mainly studyin⊆g DagReach 1(C) ⊆ − − ⊆ for many interesting complexity classes C. Our motivation in studying DagReach 1(C) is that it seems that it may be helpful − in proving upward translation of separation of complexity classes. Note that we already know, by a standard padding argument, how to translate separations of complexity classes downwards. For example, we know that NEXP = EXP = P = NP. The central question that we address is the following - For a class C, w(cid:54) hat is the⇒comp(cid:54) lexity of DagReach 1(C)? − Clearly DagReach 1(C) is contained in C. But for many natural complexity classes C, D − and E, if we can show that if DagReach 1(C) is contained in some subclass D of C, then − separating C and D is equivalent to separating C from some complexity class E that contains C. We use REG, CFL and CSL to stand for well-known formal language classes of regular, context-free and context-sensitive languages respectively[7]. The formal language class LIN, called the set of all linear languages, is the set of all languages with a context-free grammar where the right-hand side of each production consists of at most one non-terminal. The class 5 LIN can also be characterized as CFLs that can be decided by 1-turn PDAs (sub-family of PDAs where for any computation, the stack height switches only once from non-decreasing mode to non-increasing mode). We now state a known result with its proof idea which will be used later in the paper. Proposition 1 ([12]). CFL–Reach is in P. Proof. (Sketch) The proof is a dynamic programming algorithm. The algorithm maintains for each pair of vertices u and v a table entry Y[u,v] such that Y[u,v] is the set of all non- terminals V in the grammar such that there is a path from u to v with yield that can be derived from V. The algorithm can be modified to output the derivation for x where x L ∈ is the yield of a path from s to t. Note that this implies that for all “yes” instances there exists a string with length of the derivation at most polynomial in the size of the graph. Sudborough [14] studied the class of languages logspace reducible to a CFL. This class is called LogCFL. Sudborough [14] also showed that LogCFL can be characterized as the set of all languages accepted by an AuxPDA(poly). An AuxPDA(poly) is an NTM with a read-only input tape and a logspace read-write work tape. It also has a pushdown stack available for auxiliary storage. The machine is allowed to run only for a polynomial number (in the input length) of steps. It is also known that the language NBC(D ) (Nondeterministic block choice 2 Dyck ) is complete for the class LogCFL. The language NBC(D ) consists of all strings of the 2 2 form x [x #x ][x #x ]...[x #x ] where each x is a string of two types of parentheses. 1 2 3 4 5 k k+1 i The string between “[” and “]” is called a block and the symbol # separates choices in a block. A string is in the language NBC(D ) if and only if there is a choice of x ’s from each 2 i block such that the final string (after all choices have been made) is in D . 2 3 Formal Language Class restricted Reachability We know that REG–Reach is in NL [16]. The algorithm works by constructing the product automataoftheinputgraphandtheDFAfortheregularlanguage. Theproblemthenreduces to the reachability problem on the product automata. One problem with this approach is that even if the input graph is an undirected graph, the product automata will be a directed graph. Weknowthatreachabilityindirectedgraphsisharderthanreachabilityinundirected graphs. The following theorem shows that for regular languages, restricted directed and undirected reachability are equivalent. Theorem 4. If L is the regular language L((ab) ) over the alphabet a,b then L–UReach ∗ { } is NL-complete. Proof. To show that L–UReach is NL-hard, we give a logspace reduction from REACH. Given an instance (G,s,t) of REACH we construct an instance (G,s,t) of L–UReach where (cid:48) G is a labelled undirected graph where each edge is labelled either a or b. The vertex set (cid:48) of G is given by V(G) = V(G) m : (u,v) E(G) . For each edge (u,v) E(G), we (cid:48) (cid:48) uv ∪{ ∈ } ∈ add two undirected edges u,m labelled a and m ,v labelled b to E(G). It is easy to uv uv (cid:48) { } { } 6 see that any directed path from s to t corresponds to a path from s to t in G labelled by a (cid:48) string in L and vice versa. So we know that REG–Reach is NL-complete and CFL–Reach is at least as hard as LogCFL. So it is interesting to consider the complexity of LIN–Reach. We know that REG LIN CFL in the formal language theory setting. The following theorem shows that LIN–R⊆each⊆is equivalent to REG–Reach. Theorem 5. LIN–TreeReach, LIN–DagReach, LIN–UReach and LIN–Reach are all NL-complete. Proof. ThereisanNL-completelanguageinLIN[13]. Thehardnessfollowsfromthisfactand Observation 1. Now we show that all these problems are in NL. The Dynamic Programming algorithm for CFL–Reach from Proposition 1 runs in poly-time and produces a polynomial length derivation for the output string (string yielded by the path). For any language in LIN, a polynomial length derivation can only produce a polynomial length string (and hence polynomial length path). Let us say that the length of the path is bounded by nk where n is the size of the graph and k is a constant. Then our algorithm will search for a path of length at most nk by nondeterministically guessing the next vertex at each step and simultaneously parsing the string at each step (using a 1-turn PDA.). This can be implemented by a 1-turn AuxPDA that runs in time nk and takes log(n) space. Sudborough [13] proved that this class is exactly the same as NL. The following theorem shows that for solving reachability for DCFLs (which are nonde- terministic), some nondeterminism is unavoidable. Theorem 6. DCFL–DagReach is LogCFL-complete. Proof. LetL DCFL. WewilldescribeanAuxPDA(poly)thatdecidesthelanguageL–DagReach. ∈ The machine starts with the source vertex s as the current vertex. At each step it nonde- terministically moves to an out-neighbor of the current vertex. When the machine takes the edge (u,v) it executes one step of the DPDA for L, using the stack and finite control, with the label on (u,v) as the current input symbol. The machine accepts iff it reaches t and the DPDA accepts. For hardness, we reduce NBC(D ) to DCFL–DagReach. The reduction results in a 2 series-parallel graph as shown in Figure 1. In the figure, a dashed arrow represents a simple path labelled by the given string. Note that the language D is in DCFL. 2 Proposition 2. CFL–TreeReach and CFL–DagReach are LogCFL-complete. Proof. Sudborough[13]defines acontext-free languagethatiscompleteforthe classLogCFL. This shows the hardness. To show membership in LogCFL consider an AuxPDA(poly) that starts with s as the current vertex and at each step guesses the next vertex while simul- taneously using the stack to simulate the parsing of the CFL. This machine accepts iff the current vertex is t at some point and the PDA is in an accepting state at the same time. It is easy to see that this AuxPDA(poly) decides these languages. 7 x [x #x ][x #x ] 1 2 3 4 5 x x 2 4 x s 1 t x x 3 5 Figure 1: Reducing NBC(D ) to DCFL–DagReach 2 We now give a simplified presentation of a known result that says that CFL–Reach is P-complete. Also observe that Theorem 7 ([15]). Let D ((cid:15)-free Dyck ) be the CFL given by the grammar 2 2 S (S) [S] SS ( ) [ ]. → | | | | D –Reach is P-complete. 2 Proof. This theorem has been proved in [15] using a different terminology. Here we give a simplified presentation of the proof using our terminology for the hardness of this language. We show the P hardness for D by reducing a P-complete problem MCVP (Monotone Circuit 2 Value Problem where fan-out and fan-in of each gate is at most 2) to D –Reach. We may 2 assume without loss of generality that each gate in the input circuit has fan-out at most 2. The reduction works by replacing each gate by a gadget as shown in Figure 2. Each gadget in the construction has an input vertex and an output vertex. The gadgets for input gates are straightforward. For an AND gate we add 3 new vertices and connect them to the gadgets for two gates feeding input to the AND gate. Suppose that the left input to the AND gate comes from the 2nd (1st) output wire of the left input gate. Then the first and second edges are labelled by “[” (“(” resp.) and “]” (“)” resp.) respectively. We use proof by induction on the level of the output gate of the circuit to prove the correctness of this reduction. The inductive hypothesis is that there is a valid path from the input vertex to the output vertex of a gadget iff the output of the gate is 1 and any path that enters a gadget through its input gate and leaves it from some vertex other than its output vertex will be invalid. This holds trivially for gadgets for the input gates. Now any valid path from the input vertex to the output vertex of the AND gadget must consist of valid subpaths within the gadgets for the gates feeding input to this AND gate. The only exception is when some path leaves this gadget for the AND gate from some vertex other than its output vertex. Note that by the induction hypothesis such a path can only leave from vertex w or z of the gadget. But the vertex w (also z) has out-degree at most 2 and the other edge will be labelled by a closing bracket that does not match the type of bracket on the edge (u,v). This mismatch invalidates the path. A similar argument holds for OR gates. This completes the induction. Now we prove a theorem similar in spirit to Theorem 4 for CFLs. The proof uses the same idea to make the undirected version as hard as the directed one. 8 Inputgatewithvalue1 Inputgatewithvalue0 input output input output ( ) Gadgetforleftinput Gadgetforrightinput ANDgate input w z output (or[ )or] (or[ )or] Gadgetforleftinput ORgate (or[ )or] input Gadgetforrightinput output (or[ )or] Figure 2: Reducing MCVP to D –Reach 2 Theorem 8. Let DD be the CFL given by the grammar 2 S (aSb) [cSd] SS (a b) [c d]. → | | | | DD –UReach is P-complete. 2 Proof. CFL–UReach is in P by [15]. We prove hardness by reducing from D –Reach. 2 The reduction works by replacing each edge of the D –Reach instance by an undirected 2 path of length two. If for two vertices a,b, the directed edge from a to b is labelled “(” (respectively “)”,“[” and “]”) then replace it by an undirected path of length two with yield “(a”(respectively “b)”,“[c” and “d]”) when read from vertex a to vertex b. The correctness of the reduction is easy to see. We state the following proposition, which follows from Theorem 9. Proposition 3. CSL–TreeReach and CSL–DagReach are PSPACE-complete. 4 Complexity Class restricted Reachability Now we consider the complexity of L–Reach and its variants when L is chosen from com- plexity classes. Barrett et. al. [2] has shown that even for languages in L(cid:32) , the languages L–Reach and L–UReach are undecidable. But note that for any decidable L, the language L–DagReach is decidable. So we restrict our study only to L–DagReach in this section. WehaveseenthatmovingupintheChomskyhierarchyincreasesthecomplexityofreach- ability. It is natural to ask whether such an observation also holds with respect to the com- plexityclasses, i.e., increasingthecomplexityofLincreasesthecomplexityofL–DagReach. More concretely, does A L(cid:32) B imply A–DagReach L(cid:32) B–DagReach. The following the- ≤m ≤m orem (which we restate from the introduction) shows that this is very unlikely. Theorem 2: There is an A TC0 for which A–DagReach is NP-complete. ∈ 9 Proof. The language A can be thought of as an encoding of vertex cover. Each string w in A consists of 3 parts, say w ,w and w . w is a string of the form 1k0n k and encodes 1 2 3 1 − (cid:0) (cid:1) k, the size of vertex cover, in unary. w consists n bits which is the adjacency matrix 2 2 representation of the input graph. w consists n bits which encodes the vertex cover by the 3 characteristic vector. The strings w ,w and w are separated by a # and each of the n bits 1 2 3 in w is separated by a #. 3 Let n (x) be the number of 1’s in the string x. A string w is in the language A iff the 1 following conditions hold. 1. The size of the vertex cover must be at most the size given in the first part of w. ie., n (w ) n (w ), and 1 3 1 1 ≤ 2. If the edge i,j is present in the graph, then either the ith or the jth vertex must be { } present in the vertex cover. ie., (w (i,j) = 1) = ((w (i) = 1) (w (j) = 1). 2 3 3 ⇒ ∨ Any string w A can be expressed as ∈ ( (w (i,j) = 1) = (w (i) = 1 w (j) = 1)) i,j 2 3 3 ∀ ⇒ ∨ ∧ k n,((n (w ) = k) (n (w ) k)) 1 1 1 3 ∃ ≤ ∧ ≤ An AC0 circuit is enough to check the conditions ( (w (i,j) = 1) = (w (i) = i,j 2 3 ∀ ⇒ 1 w (j) = 1)) and k n,(n (w ) = k) but a TC0 circuit is necessary to check whether 3 1 1 ∨ ∃ ≤ n (w ) k. 1 3 ≤ A sketch of the structure of the circuit is given in Fig 3. ∨ ∧ ··· ∧ ∨ ··· n1(w1)=1? ··· n1(w1)=n? n1(w3)≤1? n1(w3)≤n? (i,j)=0? ∨ i=1? j=1? Figure 3: Circuit for A To show NP-hardness, we reduce VERTEX–COVER to A–DagReach. The language A–DagReach is in NP as the non-deterministic Turing machine guesses the path and verifies whether the yield of the path is in A. The reduction is given in Fig 4. The DAG contains three parts. The first part, path from s to t encodes the size of the vertex cover and the second part, from t to t encodes 1 1 2 the graph while the third part, from t to t represents the actual vertex cover. 2 For every w A we construct a valid path in DAG as follows. Take the edges labelled ∈ by 1, corresponding to the 1s in the third part of w (it is same as the vertices in the vertex (cid:48) cover). For the remaining vertices, the edges labelled 0 will be taken in the path. 10