On the Complexity of L-reachability

TL;DR

This paper explores the computational complexity of language-based graph reachability problems (L-REACH), analyzing how the complexity varies with different formal language classes and graph structures, revealing deep links to classical complexity questions.

Contribution

It provides a comprehensive complexity classification of L-REACH variants across formal language classes and graph types, connecting these problems to major open questions in complexity theory.

Findings

L-REACH complexity increases with language class power

Existence of regular languages with NL-complete L-REACH

P vs NP is equivalent to P vs DAGREACH-1(P)

Abstract

We initiate a complexity theoretic study of the language based graph reachability problem (L-REACH) : Fix a language L. Given a graph whose edges are labeled with alphabet symbols of the language L and two special vertices s and t, test if there is path P from s to t in the graph such that the concatenation of the symbols seen from s to t 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 characterizations for all of them. Our main results are the following: 1.Restricting the language using formal language theory we show that the complexity 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 undirected graphs. In the case of linear languages, the complexity of L-REACH does not go beyond the complexity of L itself. Further, there is a deterministic 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 we show that there is a language A in TC0 for which A-DAGREACH is NP-complete. Using this we show that P vs NP question is equivalent to P vs DAGREACH-1(P) question. This leads to the intriguing possibility that by proving DAGREACH-1(P) is contained in some subclass of P, we can prove an upward translation of separation of complexity classes. Note that we do not know a way to upward translate the separation of complexity classes.

Tables

Table 1. Table 1: Formal language class restricted reachability

Language Class	Tree-Reach	DAG-Reach	UReach/Reach
Regular	Ł-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	\classLogCFL-complete	\classLogCFL-complete	¶-complete
	(Prop. 2)	(Prop. 2)	(Theorem 7/[15])
Context-sensitive	\PSPACE-complete	\PSPACE-complete	Undecidable
	(Prop. 3)	(Prop. 3)	([2])

Equations

$$\text{mbox}{\text{sc}DagReach}^{-1}(\text{class}\text{class}C)=\{⟨L:⟨\mathrm{L}--⟨\text{mbox}\text{sc}\mathrm{DagReach}\in \text{class}C\}$$

$$S\to (S)|[S]|SS|()|[].$$

$$S\to (aSb)|[cSd]|SS|(ab)|[cd].$$

$$({\forall }_{i,j}(w_2(i,j)=1)$$

Full text

• •

Restricting the language using formal language theory we show that the complexity of $\operatorname{\lang{\lang{L}}--\lang{\mbox{\sc Reach}}}$ increases with the power of the formal language class. We show that there is a regular language for which the $\operatorname{\lang{\lang{L}}--\lang{\mbox{\sc Reach}}}$ is $\NL$-complete even for undirected graphs. In the case of linear languages, the complexity of $\operatorname{\lang{\lang{L}}--\lang{\mbox{\sc Reach}}}$ does not go beyond the complexity of \langL itself. Further, there is a deterministic context-free language \langL for which $\operatorname{\lang{\lang{L}}--\lang{{\mbox{\sc DagReach}}}}$ is \classLogCFL-complete.

• •

We use $\operatorname{\lang{\lang{L}}--\lang{\mbox{\sc Reach}}}$ as a lens to study structural complexity. In this direction we show that there is a language $\lang{A}$ in \TC0 for which $\operatorname{\lang{A}--\lang{{\mbox{\sc DagReach}}}}$ is $\NP$-complete. Using this we show that $\P$ vs $\NP$ question is equivalent to $\P$ vs $\mbox{{\sc DagReach}}^{-1}(\class{\P})$222For any complexity class \classC, $\mbox{{\sc DagReach}}^{-1}(\class{\class{C}})=\{\lang{L}:\operatorname{\lang{L}--\lang{{\mbox{\sc DagReach}}}}\in\class{C}\}$. question. This leads to the intriguing possibility that by proving DagReach${}^{-1}(\class{\P})$ is contained in some subclass of ¶, we can prove an upward translation of separation of complexity classes. Note that we do not know a way to upward translate the separation of complexity classes.

1 Introduction

Reachability problems in mathematical structures are a well-studied problem in space complexity. An important example is the graph reachability problem where given a directed graph $G$ and two special vertices $s$ and $t$, is there a path333We follow the convention that a path can have repeated vertices and edges. from $s$ to $t$ in the graph $G$. This problem exactly captures the space complexity of problems solvable in nondeterministic logarithmic space. Various restrictions of the problem have been studied - reachability in undirected graphs characterizes deterministic logspace [10], reachability in constant width graphs (even undirected) characterizes $\NC^{1}$ [3], reachability in planar constant width directed graphs characterizes $\ACC^{0}$ [5] and the version in upward planar constant width directed graphs characterizes $\AC^{0}$ [4].

A natural extension of the problem using formal language theory is the $\operatorname{\lang{\lang{L}}--\lang{\mbox{\sc Reach}}}$ problem: Fix a language \langL defined over a finite alphabet $\Sigma$. 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 \langL. Indeed, if \langL is $\Sigma^{*}$, 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 $\operatorname{\lang{\lang{L}}--\lang{\mbox{\sc Reach}}}$ problem has not been studied from a space complexity theory perspective, a lot is known about its complexity [11, 12, 16, 8, 2]. An immediate observation is that the $\operatorname{\lang{\lang{L}}--\lang{\mbox{\sc Reach}}}$ problem is at least as hard as the membership problem of \langL. Indeed, given a string $x$, to check for membership in \langL it suffices to test $\operatorname{\lang{\lang{L}}--\lang{\mbox{\sc 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 $\operatorname{\lang{\class{CFL}}--\lang{\mbox{\sc 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 $\operatorname{\lang{\class{CFL}}--\lang{\mbox{\sc Reach}}}$ problem.

Our Results:

The results in this paper are in two flavors.

**Results based on Chomsky Hierarchy and Graph Classes: ** Firstly we study restrictions of $\operatorname{\lang{\lang{L}}--\lang{\mbox{\sc Reach}}}$ problem when $\lang{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**.**

$\operatorname{\class{DCFL}--\lang{{\mbox{\sc DagReach}}}}$* is $\class{LogCFL}$-complete.*

Results on the Structural Complexity front: Now we take a complexity theoretic view, where we study $\operatorname{\lang{\lang{L}}--\lang{\mbox{\sc Reach}}}$ as an operator on languages. It is shown in Barrett et. al. [2] that even for languages in logspace, the languages $\operatorname{\lang{L}--\lang{\mbox{\sc Reach}}}$ and $\operatorname{\lang{L}--\lang{\mbox{\sc UReach}}}$ are undecidable. Therefore in this section, we consider only DAGs. Note that for any language \langL, the language $\operatorname{\lang{L}--\lang{{\mbox{\sc DagReach}}}}$ is decidable.

It is natural to ask whether increasing the complexity of \langL increases the complexity of $\operatorname{\lang{L}--\lang{{\mbox{\sc DagReach}}}}$. More concretely, does $\lang{A}$ $\leq_{m}^{\L}$ $\lang{B}$ $\implies$ $\operatorname{\lang{A}--\lang{{\mbox{\sc DagReach}}}}$ $\leq_{m}^{\L}$ $\operatorname{\lang{B}--\lang{{\mbox{\sc DagReach}}}}$? The following theorem, along with the fact that there exists a language \langL (see Proposition 2) that is $\class{LogCFL}$-complete for which $\operatorname{\lang{L}--\lang{{\mbox{\sc DagReach}}}}$ remains $\class{LogCFL}$-complete shows that such a result is highly unlikely.

Theorem 2**.**

There exists a language $\lang{A}\in\TC^{0}$ for which $\operatorname{\lang{A}--\lang{{\mbox{\sc DagReach}}}}$ is \NP-complete.

For any complexity class $\class{C}$, we consider the class of languages defined as,

[TABLE]

Note that for any class $\class{C}$, we have $\mbox{{\sc DagReach}}^{-1}(\class{\class{C}})\subseteq\class{C}$. We have the following theorems for different choices of $\class{C}$.

*Theorem : *** We show the following structural theorems:

(Theorem 9) $\mbox{{\sc DagReach}}^{-1}(\class{\PSPACE})=\PSPACE$, $\mbox{{\sc DagReach}}^{-1}(\class{\NP})=\NP$. 2. 2.

(Theorem 10) $\P\neq\mbox{{\sc DagReach}}^{-1}(\class{\P})\iff\P\neq\NP$. 3. 3.

(Theorem 11) $\mbox{{\sc DagReach}}^{-1}(\class{\NL})\neq\NL\iff\NP\neq\NL$.

The above theorem shows that separating $\mbox{{\sc DagReach}}^{-1}(\class{\P})$ from $\P$ would separate $\P$ from $\NP$. This gives us an upward translation of lower bounds on complexity classes if we can prove that DagReach${}^{-1}(\class{\P})$ is contained in some subclass of ¶. Hence the question whether we can identify some “natural” complexity class containing $\mbox{{\sc DagReach}}^{-1}(\class{\P})$ becomes very interesting. It is clear that $\mbox{{\sc DagReach}}^{-1}(\class{\P})$ contains \classLogCFL-complete problems but is highly unlikely to contain some problems in $\L$. If DagReach${}^{-1}(\class{\P})$ contains some ¶-complete problem, then proving that DagReach${}^{-1}(\class{\P})$ is contained in some subclass of ¶ would be very hard. In this connection, we show the following:

Theorem 3**.**

If $\lang{L}$ is $\P$-complete under syntactic read-once logspace reductions, then $\operatorname{\lang{L}--\lang{{\mbox{\sc 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$, $\mbox{{\sc DagReach}}^{-1}(\class{\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}(\class{\P})$ may indeed be contained in some subclass of ¶.

We also remark that Theorem 10 holds with \NL instead of ¶. However, since DagReach${}^{-1}(\class{\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 $\operatorname{\lang{A}--\lang{{\mbox{\sc DagReach}}}}$ is $\NP$-complete. In this extended version, we improve this bound to $\TC^{0}$ (from logspace, see Theorem 2).

2 Preliminaries

In this section, we define language restricted reachability problems and make some observations 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 textbooks [1]. We use Ł and \NL to stand for the complexity classes deterministic logspace and nondeterministic logspace respectively. All reductions (even ones used for defining completeness) in this paper are in logspace unless mentioned otherwise.

Definition 1**.**

For any language $\lang{L}\subseteq\Sigma^{*}$, we consider graph $G$ where each edge in $G$ is labelled by an element from $\Sigma$. 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 $\operatorname{\lang{L}--\lang{\mbox{\sc Reach}}}$ as the set of all $(G,s,t)$ such that there exists a path from $s$ to $t$ in $G$ with yield in $\lang{L}$.

By restricting the graph in Definition 1, we obtain similar definitions for $\operatorname{\lang{L}--\lang{{\mbox{\sc DagReach}}}}$ (DAGs), $\operatorname{\lang{L}--\lang{\mbox{\sc UReach}}}$ (Undirected Graphs) and $\operatorname{\lang{L}--\lang{{\mbox{{\sc TreeReach}}}}}$ (Orientations of Undirected Trees).

Let $\Sigma$ and $\Gamma$ be finite alphabets. A function $f$ from $\Sigma^{*}$ to $\Gamma^{*}$ is called a projection if for all $x\in\Sigma^{*}$, the string $f(x)=y$ is such that for all $i\in[m]$, either $y_{i}=x_{j}$ for some $j\in[n]$ or $y_{i}=0$ or $y_{i}=1$, where $m=|y|$ and $n=|x|$. A language \langL over $\Sigma$ is said to be projection reducible to a language \langL’ over $\Gamma$ if there is a projection $f$ such that $x\in L\iff y=f(x)\in$ \langL’ and $|y|$ is polynomial in $|x|$.

Observation 1**.**

Any language \langL is projection reducible to $\operatorname{\lang{L}--\lang{{\mbox{{\sc TreeReach}}}}}$.

Clearly, the above observation holds for any reachability variant based on the graph. This is because $\operatorname{\lang{L}--\lang{{\mbox{{\sc TreeReach}}}}}$ is a restriction of the other reachability variants. In fact the following observation shows that $\operatorname{\lang{L}--\lang{{\mbox{{\sc TreeReach}}}}}$ is not much harder than \langL.

Observation 2**.**

For any language \langL, the language $\operatorname{\lang{L}--\lang{{\mbox{{\sc TreeReach}}}}}$ is logspace reducible to \langL.

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 \langL on the yield.

Next we define classes of languages based on language restricted reachability.

Definition 2**.**

For any class of languages $\class{C}$, we define the set of languages $\operatorname{\class{C}--\lang{{\mbox{{\sc Reach}}}}}$ as the class of all languages $\operatorname{\lang{L}--\lang{\mbox{\sc Reach}}}$ where $L$ is in $\class{C}$.

Again, by restricting graphs in Definition 2, we obtain similar definitions for $\operatorname{\class{C}--\lang{{\mbox{\sc DagReach}}}}$, $\operatorname{\class{C}--\lang{{\mbox{\sc UReach}}}}$ and $\operatorname{\class{C}--\lang{{\mbox{\sc TreeReach}}}}$.

Definition 3**.**

For a class of languages \classC and a complexity class \classD, we say that $\operatorname{\class{C}--\lang{{\mbox{{\sc Reach}}}}}$ is complete for \classD if the following conditions are satisfied.

• •

For all $\lang{L}\in\class{C}$, the language $\operatorname{\lang{L}--\lang{\mbox{\sc Reach}}}$ is in \classD.

• •

There exists a language \langL in \classC such that the language $\operatorname{\lang{L}--\lang{\mbox{\sc Reach}}}$ is hard for \classD.

Definition 4**.**

For any complexity class \classC, we define Reach${}^{-1}(\class{C})$ as the set of all languages \langL such that $\operatorname{\lang{L}--\lang{\mbox{\sc Reach}}}$ is in \classC.

Again, by restricting graphs in Definition 4, we obtain similar definitions for DagReach${}^{-1}(\class{C})$, UReach${}^{-1}(\class{C})$ and TreeReach${}^{-1}(\class{C})$.

Note that by Observation 1, for any class \classC the relations $\mbox{{\sc Reach}}^{-1}(\class{C})\subseteq$ $\mbox{{\sc DagReach}}^{-1}(\class{C})\subseteq$ $\mbox{{\sc TreeReach}}^{-1}(\class{C})\subseteq\class{C}$ holds. In this paper, we will be mainly studying DagReach${}^{-1}(\class{C})$ for many interesting complexity classes \classC.

Our motivation in studying DagReach${}^{-1}(\class{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\neq\EXP\implies\P\neq\NP$. The central question that we address is the following - For a class \classC, what is the complexity of DagReach${}^{-1}(\class{C})$? Clearly DagReach${}^{-1}(\class{C})$ is contained in \classC. But for many natural complexity classes \classC, \classD and \classE, if we can show that if DagReach${}^{-1}(\class{C})$ is contained in some subclass \classD of \classC, then separating \classC and \classD is equivalent to separating \classC from some complexity class \classE that contains \classC.

We use \classREG, \classCFL and \classCSL to stand for well-known formal language classes of regular, context-free and context-sensitive languages respectively[7]. The formal language class \classLIN, 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 \classLIN can also be characterized as \classCFLs 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]).**

$\operatorname{\class{CFL}--\lang{{\mbox{{\sc Reach}}}}}$* is in ¶.*

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\in\lang{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 \classCFL. This class is called $\class{LogCFL}$. Sudborough [14] also showed that $\class{LogCFL}$ can be characterized as the set of all languages accepted by an \classAuxPDA(poly). An \classAuxPDA(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 \langNBC(D_2) (Nondeterministic block choice Dyck2) is complete for the class $\class{LogCFL}$. The language \langNBC(D_2) consists of all strings of the form $x_{1}[x_{2}\#x_{3}][x_{4}\#x_{5}]\ldots[x_{k}\#x_{k+1}]$ where each $x_{i}$ is a string of two types of parentheses. The string between “[” and “]” is called a block and the symbol # separates choices in a block. A string is in the language \langNBC(D_2) if and only if there is a choice of $x_{i}$’s from each 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 $\operatorname{\class{REG}--\lang{{\mbox{{\sc Reach}}}}}$ is in \NL [16]. The algorithm works by constructing the product automata of the input graph and the DFA for the regular language. The problem then reduces 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. We know that reachability in directed graphs is harder than reachability in undirected graphs. The following theorem shows that for regular languages, restricted directed and undirected reachability are equivalent.

Theorem 4**.**

If \langL is the regular language \langL((ab)^) over the alphabet $\{a,b\}$ then $\operatorname{\lang{L}--\lang{\mbox{\sc UReach}}}$ is \NL-complete.*

Proof.

To show that $\operatorname{\lang{L}--\lang{\mbox{\sc UReach}}}$ is \NL-hard, we give a logspace reduction from \langREACH. Given an instance $(G,s,t)$ of \langREACH we construct an instance $(G^{\prime},s,t)$ of $\operatorname{\lang{L}--\lang{\mbox{\sc UReach}}}$ where $G^{\prime}$ is a labelled undirected graph where each edge is labelled either $a$ or $b$. The vertex set of $G^{\prime}$ is given by $V(G^{\prime})=V(G)\cup\{m_{uv}:(u,v)\in E(G)\}$. For each edge $(u,v)\in E(G)$, we add two undirected edges $\{u,m_{uv}\}$ labelled $a$ and $\{m_{uv},v\}$ labelled $b$ to $E(G^{\prime})$. It is easy to see that any directed path from $s$ to $t$ corresponds to a path from $s$ to $t$ in $G^{\prime}$ labelled by a string in \langL and vice versa. ∎

So we know that $\operatorname{\class{REG}--\lang{{\mbox{{\sc Reach}}}}}$ is \NL-complete and $\operatorname{\class{CFL}--\lang{{\mbox{{\sc Reach}}}}}$ is at least as hard as $\class{LogCFL}$. So it is interesting to consider the complexity of $\operatorname{\class{LIN}--\lang{{\mbox{{\sc Reach}}}}}$. We know that $\class{REG}\subseteq$ $\class{LIN}\subseteq\class{CFL}$ in the formal language theory setting. The following theorem shows that $\operatorname{\class{LIN}--\lang{{\mbox{{\sc Reach}}}}}$ is equivalent to $\operatorname{\class{REG}--\lang{{\mbox{{\sc Reach}}}}}$.

Theorem 5**.**

$\operatorname{\class{LIN}--\lang{{\mbox{\sc TreeReach}}}}$, $\operatorname{\class{LIN}--\lang{{\mbox{\sc DagReach}}}}$, $\operatorname{\class{LIN}--\lang{{\mbox{\sc UReach}}}}$ and $\operatorname{\class{LIN}--\lang{{\mbox{{\sc Reach}}}}}$ are all $\NL$-complete.

Proof.

There is an \NL-complete language in \classLIN [13]. The hardness follows from this fact and Observation 1. Now we show that all these problems are in \NL. The Dynamic Programming algorithm for $\operatorname{\class{CFL}--\lang{{\mbox{{\sc 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 \classLIN, 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 $n^{k}$ 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 $n^{k}$ by nondeterministically guessing the next vertex at each step and simultaneously parsing the string at each step (using a 1-turn \classPDA.). This can be implemented by a 1-turn \classAuxPDA that runs in time $n^{k}$ 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 \classDCFLs (which are nondeterministic), some nondeterminism is unavoidable.

Theorem 6**.**

$\operatorname{\class{DCFL}--\lang{{\mbox{\sc DagReach}}}}$* is $\class{LogCFL}$-complete.*

Proof.

Let $\lang{L}\in\class{DCFL}$. We will describe an \classAuxPDA(poly) that decides the language $\operatorname{\lang{L}--\lang{{\mbox{\sc DagReach}}}}$. The machine starts with the source vertex $s$ as the current vertex. At each step it nondeterministically 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 \langL, 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 \langNBC(D_2) to $\operatorname{\class{DCFL}--\lang{{\mbox{\sc DagReach}}}}$. The reduction results in a 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 \langD_2 is in \classDCFL. ∎

Proposition 2**.**

$\operatorname{\class{CFL}--\lang{{\mbox{\sc TreeReach}}}}$* and $\operatorname{\class{CFL}--\lang{{\mbox{\sc DagReach}}}}$ are $\class{LogCFL}$-complete.*

Proof.

Sudborough [13] defines a context-free language that is complete for the class $\class{LogCFL}$. This shows the hardness. To show membership in $\class{LogCFL}$ consider an \classAuxPDA(poly) that starts with $s$ as the current vertex and at each step guesses the next vertex while simultaneously 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 \classAuxPDA(poly) decides these languages. ∎

We now give a simplified presentation of a known result that says that $\operatorname{\class{CFL}--\lang{{\mbox{{\sc Reach}}}}}$ is ¶-complete. Also observe that

Theorem 7** ([15]).**

Let \langD_2 ($\epsilon$-free Dyck2) be the \classCFL given by the grammar

[TABLE]

$\operatorname{\lang{D_{2}}--\lang{\mbox{\sc Reach}}}$* is ¶-complete.*

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 ¶ hardness for \langD_2 by reducing a ¶-complete problem MCVP (Monotone Circuit Value Problem where fan-out and fan-in of each gate is at most 2) to $\operatorname{\lang{D_{2}}--\lang{\mbox{\sc Reach}}}$. We may 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 $2^{nd}$ ($1^{st}$) 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 \classCFLs. The proof uses the same idea to make the undirected version as hard as the directed one.

Theorem 8**.**

Let \langDD_2 be the CFL given by the grammar

[TABLE]

$\operatorname{\lang{DD_{2}}--\lang{\mbox{\sc UReach}}}$* is ¶-complete.*

Proof.

$\operatorname{\class{CFL}--\lang{{\mbox{\sc UReach}}}}$ is in ¶ by [15]. We prove hardness by reducing from $\operatorname{\lang{D_{2}}--\lang{\mbox{\sc Reach}}}$. The reduction works by replacing each edge of the $\operatorname{\lang{D_{2}}--\lang{\mbox{\sc Reach}}}$ instance by an undirected 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**.**

$\operatorname{\class{CSL}--\lang{{\mbox{\sc TreeReach}}}}$* and $\operatorname{\class{CSL}--\lang{{\mbox{\sc DagReach}}}}$ are \PSPACE-complete.*

4 Complexity Class restricted Reachability

Now we consider the complexity of $\operatorname{\lang{L}--\lang{\mbox{\sc Reach}}}$ and its variants when \langL is chosen from complexity classes. Barrett et. al. [2] has shown that even for languages in Ł, the languages $\operatorname{\lang{L}--\lang{\mbox{\sc Reach}}}$ and $\operatorname{\lang{L}--\lang{\mbox{\sc UReach}}}$ are undecidable. But note that for any decidable \langL, the language $\operatorname{\lang{L}--\lang{{\mbox{\sc DagReach}}}}$ is decidable. So we restrict our study only to $\operatorname{\lang{L}--\lang{{\mbox{\sc DagReach}}}}$ in this section.

We have seen that moving up in the Chomsky hierarchy increases the complexity of reachability. It is natural to ask whether such an observation also holds with respect to the complexity classes, i.e., increasing the complexity of \langL increases the complexity of $\operatorname{\lang{L}--\lang{{\mbox{\sc DagReach}}}}$. More concretely, does $\lang{A}\leq_{m}^{\L}\lang{B}$ imply $\operatorname{\lang{A}--\lang{{\mbox{\sc DagReach}}}}\leq_{m}^{\L}\operatorname{\lang{B}--\lang{{\mbox{\sc DagReach}}}}$. The following theorem (which we restate from the introduction) shows that this is very unlikely.

**Theorem 2: *** There is an $\lang{A}\in\TC^{0}$ for which $\operatorname{\lang{A}--\lang{{\mbox{\sc DagReach}}}}$ is \NP-complete. *

Proof.

The language \langA can be thought of as an encoding of vertex cover. Each string $w$ in \langA consists of 3 parts, say $w_{1},w_{2}$ and $w_{3}$. $w_{1}$ is a string of the form $1^{k}0^{n-k}$ and encodes $k$, the size of vertex cover, in unary. $w_{2}$ consists $n\choose 2$ bits which is the adjacency matrix representation of the input graph. $w_{3}$ consists $n$ bits which encodes the vertex cover by the characteristic vector. The strings $w_{1},w_{2}$ and $w_{3}$ are separated by a $\#$ and each of the $n$ bits in $w_{3}$ is separated by a $\#$.

Let $n_{1}(x)$ be the number of 1’s in the string $x$. A string $w$ is in the language \langA iff the following conditions hold.

The size of the vertex cover must be at most the size given in the first part of $w$.

ie., $n_{1}(w_{3})\leq n_{1}(w_{1})$, and 2. 2.

If the edge $\{i,j\}$ is present in the graph, then either the $i^{th}$ or the $j^{th}$ vertex must be present in the vertex cover.

ie., $(w_{2}(i,j)=1)\implies((w_{3}(i)=1)\lor(w_{3}(j)=1)$.

Any string $w\in\lang{A}$ can be expressed as

[TABLE]

An $\AC^{0}$ circuit is enough to check the conditions $(\forall_{i,j}(w_{2}(i,j)=1)\implies(w_{3}(i)=1\lor w_{3}(j)=1))$ and $\exists k\leq n,(n_{1}(w_{1})=k)$ but a $\TC^{0}$ circuit is necessary to check whether $n_{1}(w_{3})\leq k$.

A sketch of the structure of the circuit is given in Fig 3.

To show \NP-hardness, we reduce \langVERTEX–COVER to $\operatorname{\lang{A}--\lang{{\mbox{\sc DagReach}}}}$.

The language $\operatorname{\lang{A}--\lang{{\mbox{\sc DagReach}}}}$ is in $\NP$ as the non-deterministic Turing machine guesses the path and verifies whether the yield of the path is in \langA.

The reduction is given in Fig 4. The DAG contains three parts. The first part, path from $s$ to $t_{1}$ encodes the size of the vertex cover and the second part, from $t_{1}$ to $t_{2}$ encodes the graph while the third part, from $t_{2}$ to $t$ represents the actual vertex cover.

For every $w\in\lang{A}$ we construct a valid path in DAG as follows. Take the edges labelled by $1$, corresponding to the $1^{\prime}s$ in the third part of $w$ (it is same as the vertices in the vertex cover). For the remaining vertices, the edges labelled [math] will be taken in the path.

Every valid path in the DAG corresponds to a vertex cover in $G$. Let $w$ be the yield of the path and let $w_{3}$ be its third part. Then include $i$ in the vertex cover iff the $(2i-1)^{\hbox{th}}$ symbol of $w_{3}$ is 1. ∎

We are now going to see how the above result can be used for translating separations of complexity classes upwards (Theorem 10). For any complexity class $\class{C}$, we consider the class of languages defined as $\mbox{{\sc DagReach}}^{-1}(\class{C})=\{\lang{L}:\operatorname{\lang{L}--\lang{{\mbox{\sc DagReach}}}}\in\class{C}\}$. We have the following theorems for natural choices of $\class{C}$. Note that for any class $\class{C}$, we have $\mbox{{\sc DagReach}}^{-1}(\class{C})\subseteq\class{C}$.

Theorem 9**.**

$\mbox{{\sc DagReach}}^{-1}(\class{\PSPACE})=\PSPACE$* and $\mbox{{\sc DagReach}}^{-1}(\class{\NP})=\NP$.*

Proof.

Let $\lang{L}\in\PSPACE$, then given an instance of $\operatorname{\lang{L}--\lang{{\mbox{\sc DagReach}}}}$ we enumerate all paths from $s$ to $t$ and run the \PSPACE algorithm for $\lang{L}$ on the yield. This is a \PSPACE algorithm for $\operatorname{\lang{L}--\lang{{\mbox{\sc DagReach}}}}$. Similarly if $\lang{L}\in\NP$, then a path from $s$ to $t$ along with the certificate for the yield on that path is a poly-time verifiable certificate for the $\operatorname{\lang{L}--\lang{{\mbox{\sc DagReach}}}}$ problem. ∎

Theorem 10**.**

$\P\neq\mbox{{\sc DagReach}}^{-1}(\class{\P})\iff\P\neq\NP$.

Proof.

Suppose $\P\neq\mbox{{\sc DagReach}}^{-1}(\class{\P})$ and let $\lang{L}\in\P\setminus\mbox{{\sc DagReach}}^{-1}(\class{\P})$. Now $\operatorname{\lang{L}--\lang{{\mbox{\sc DagReach}}}}$ is in \NP by Theorem 9. By the choice of $\lang{L}$ we also have $\operatorname{\lang{L}--\lang{{\mbox{\sc DagReach}}}}$ is not in $\P$.

For the other direction: suppose $\mbox{{\sc DagReach}}^{-1}(\class{\P})=\P$. We know that there is a language $\lang{L}\in\P$ for which $\operatorname{\lang{L}--\lang{{\mbox{\sc DagReach}}}}$ is \NP-complete. Hence, $\P=\NP$. ∎

Theorem 10 shows that separating $\mbox{{\sc DagReach}}^{-1}(\class{\P})$ from $\P$ would separate $\P$ from $\NP$. This gives us an upward translation of lower bounds on complexity classes provided we can prove that DagReach${}^{-1}(\class{\P})$ is contained in some subclass of ¶. The interesting question is whether we can identify some “natural” complexity class containing $\mbox{{\sc DagReach}}^{-1}(\class{\P})$.

By using similar arguments, we also have

Theorem 11**.**

$\mbox{{\sc DagReach}}^{-1}(\class{\NL})\neq\NL\iff\NP\neq\NL$.

However DagReach${}^{-1}(\class{\NL})$ contains \NL-complete languages (See Theorem 5). So proving that DagReach${}^{-1}(\class{\NL})$ is separate from \NL could be very hard.

The following theorem can be viewed as an evidence that DagReach${}^{-1}(\class{P})$ could be separate from ¶. A language \langL is syntactic read-once logspace (this notion was considered by Hartmanis et. al. in [6]) reducible to another language \langL’ iff there is a logspace reduction from \langL to \langL’ and in the configuration graph for this reduction all paths from the start configuration to the accepting configuration reads each input variable at most once. It shows that if we restrict our attention to syntactic read-once logspace reductions, then $\operatorname{\lang{L}--\lang{{\mbox{\sc DagReach}}}}$ for a ¶-complete problem \langL is \NP-complete. Note that many natural ¶-complete problems such as \CVP (Circuit Value Problem) remains ¶-complete even under syntactic read-once logspace reductions.

**Theorem 3: *** If $\lang{L}$ is $\P$-complete under syntactic read-once logspace reductions, then $\operatorname{\lang{L}--\lang{{\mbox{\sc DagReach}}}}$ is $\NP$-complete. *

Proof.

Let $\lang{V}\in\NP$ via a poly-time verifier $\class{N}$. Let $\lang{W}$ be the witness language for $\lang{V}$. i.e., $\lang{W}=\{(x,w):N(x,w)=1\text{ and }|w|={|x|}^{k}\text{ for some }k\}$. Since \langL is ¶-complete $\lang{W}$ is read-once logspace reducible to $\lang{L}$ via $\class{M}$. We reduce $\lang{V}$ to $\operatorname{\lang{L}--\lang{{\mbox{\sc DagReach}}}}$. Let $x$ be our input. Take the configuration graph $G$ of $\class{M}$ on length $|x|+{|x|}^{k}$ inputs (after fixing the value of $x$) and label each edge by the symbol output by the machine $\class{M}$ in that step. This graph $H$ is considered as an input to the language $\operatorname{\lang{L}--\lang{{\mbox{\sc DagReach}}}}$. First we prove that $H\in\operatorname{\lang{L}--\lang{{\mbox{\sc DagReach}}}}$ implies that $x\in\lang{V}$. Consider a path from $s$ to $t$ in $H$ labelled by a string in \langL. This path corresponds to a witness string for $x$. Therefore there exists a string $w$ for which $(x,w)$ in $\lang{W}$ which implies $x\in\lang{V}$. For the other direction let $x\in\lang{V}$. Therefore there exists a string $w$ such that $(x,w)\in\lang{W}$. Now take the path in $G$ that corresponds to this $w$. The yield of this path is a member of the language \langL since \classM outputs this yield when given $(x,w)$ as input. ∎

5 Discussion and Open Problems

The main result of our work is the observation that if we can prove that the class DagReach${}^{-1}(\class{\P})$ is contained in some complexity class that is a subclass of ¶, then we can translate separation of complexity classes upwards. We propose the following open problem.

**Open Problem 1: ** Prove that $\mbox{{\sc DagReach}}^{-1}(\class{\P})\subseteq\NC$.

It would be interesting to study the behavior of DagReach${}^{-1}(\class{.})$ operator on complexity classes below \NL. $\AC^{0}$ is the class of all languages computable by poly-size, constant depth uniform Boolean circuits. Can we say anything about the set of languages DagReach${}^{-1}(\class{\AC^{0}})$? The only languages \langL for which we know that $\operatorname{\lang{L}--\lang{{\mbox{\sc DagReach}}}}$ is in $\AC^{0}$ are finite languages. Recall that \classDAGREACH is \NL-complete and we know that $\NL\neq\AC^{0}$. Therefore, for any language \langL such that $\operatorname{\lang{L}--\lang{{\mbox{\sc DagReach}}}}$ is in $\AC^{0}$, the $\operatorname{\lang{L}--\lang{{\mbox{\sc DagReach}}}}$ problem is strictly easier than \langDAGREACH. This leads us to our second open problem.

Open Problem 2: Prove that if $\operatorname{\lang{L}--\lang{{\mbox{\sc DagReach}}}}\in\AC^{0}$ then $\lang{L}\text{ is finite}$.