Reachability in High Treewidth Graphs

TL;DR

This paper presents a space-efficient polynomial-time algorithm for reachability in directed graphs with bounded treewidth, using the graph's tree decomposition to achieve significantly reduced space complexity.

Contribution

It introduces a novel algorithm that decides reachability in polynomial time with space complexity proportional to the treewidth times log n, improving over previous methods.

Findings

Algorithm runs in polynomial time.

Space complexity is O(w log n).

Applicable to graphs with bounded treewidth.

Abstract

Reachability is the problem of deciding whether there is a path from one vertex to the other in the graph. Standard graph traversal algorithms such as DFS and BFS take linear time to decide reachability however their space complexity is also linear. On the other hand, Savitch's algorithm takes quasipolynomial time although the space bound is $O(\log^2 n)$. Here, we study space efficient algorithms for deciding reachability that runs simultaneously in polynomial time. In this paper, we show that given an $n$ vertex directed graph of treewidth $w$ along with its tree decomposition, there exists an algorithm running in polynomial time and $O(w\log n)$ space, that solves reachability in the graph.

Equations

$$\hat{B}(⟨Z,r⟩):=Z\cup ((\text{sep}(V(G_{⟨Z,r⟩}))\cup \text{sep}(Z))\cap V(G_{⟨Z,r⟩})).$$

$${\sigma }_s=\{\begin{array}{ll}⟨1⟩& s=0\\ {\sigma }_{s-1}\diamond ⟨2^s⟩\diamond {\sigma }_{s-1}& s>0\end{array}$$

$${\text{SEQ}}_{t,d}={\text{SEQ}}_{\text{left}(t),c_1}\diamond {\text{SEQ}}_{\text{right}(t),c_1}\diamond {\text{SEQ}}_{\text{left}(t),c_2}\diamond {\text{SEQ}}_{\text{right}(t),c_2}\diamond \cdots \diamond {\text{SEQ}}_{\text{right}(t),c_{2d-1}}$$

$$2^{h}d\left(\genfrac{}{}{0ex}{}{h+\log d}{\log d}\right)$$

$$L(h,d)=\{\begin{array}{ll}2{\sum }_{c\in {\sigma }_{\log d}}L(h-1,c)& h>0\\ d& h=0\end{array}$$

$$L(h,d)=\{\begin{array}{ll}{\sum }_{i=0}^{\log d}\frac{d}{2^{i-1}}L(h-1,c)& h>0\\ d& h=0\end{array}$$

$$2^{h}d\left(\genfrac{}{}{0ex}{}{h+\log d}{\log d}\right)$$

$$=d$$

$$L(h,d)$$

Full text

In this paper, we show that given an $n$ vertex directed graph of treewidth $w$ along with its tree decomposition, there exists an algorithm running in polynomial time and $O(w\log n)$ space, that solves reachability in the graph.

1 Introduction

Given a graph $G$ and two vertices $u$ and $v$ in $G$, the reachability problem is to decide if there exists a path from $u$ to $v$ in $G$. This problem is $\NL$-complete for directed graphs and $\L$-complete for undirected graphs [16]. Hence its study gives important insight into space bounded computations. We will henceforth refer to the problem of directed graph reachability as \Reach. The famous open question $\L\stackrel{{\scriptstyle?}}{{=}}\NL$ essentially asks if there is a deterministic logspace algorithm for \Reach or not. \Reach can be solved in $\Theta(n\log n)$ space and optimal time using standard graph traversal algorithms such as DFS and BFS. We also know, due to Savitch, that it can be solved in $\Theta(\log^{2}n)$ space [17]. However, Savitch’s algorithm requires $n^{\Theta(\log n)}$ time. Wigderson surveyed reachability problems in which he asked if there is an algorithm for \Reach that runs simultaneously in $O(n^{1-\epsilon})$ space (for any $\epsilon>0$) and polynomial time [18]. Here, we make some partial progress towards answering this question.

In 1998 Barnes et al. made progress in answering Wigderson’s question for general graph by presenting an algorithm for \Reach that runs simultaneously in $n/2^{\Theta(\sqrt{\log n})}$ space and polynomial time [7]. Using this result, Asano et al. improved the space bound of DFS and showed that it could be performed using $O(n)$ bits of space and $O(m\log n)$ time [5]. For several other topologically restricted classes of graphs, there has been significant progress in giving polynomial time algorithms for \Reach that run simultaneously in sublinear space. For grid graphs a space bound of $O(n^{1/2+\epsilon})$ was first achieved [4]. The same space bound was then extended to all planar graphs by Imai et al. [14]. Later for planar graphs, the space bound was improved to $\tilde{O}(n^{1/2})$ space by Asano et al. [6]. For graphs of higher genus, Chakraborty et al. gave an $\tilde{O}(n^{2/3}g^{1/3})$ space algorithm which additionally requires, as an input, an embedding of the graph on a surface of genus $g$ [9]. They also gave an $\tilde{O}(n^{2/3})$ space algorithm for $H$ minor-free graphs which requires tree decomposition of the graph as an input and $O(n^{1/2+\epsilon})$ space algorithm for $K_{3,3}$-free and $K_{5}$-free graphs. For layered planar graphs, Chakraborty and Tewari showed that for every $\epsilon>0$ there is an $O(n^{\epsilon})$ space algorithm [10].

Treewidth is a well-studied property of graphs. The value of treewidth can range from $1$ (for a tree) to $n-1$ (for a complete graph on $n$ vertices). The computational complexity of many difficult problems become easy for bounded treewidth graphs. The weighted independent set problem can be solved in $O(2^{w}n)$ time [8]. Similarly, we can solve other classic problems such as the Hamiltonian circuit, vertex cover, Steiner tree, and vertex coloring in linear time for bounded treewidth [3]. It is $\NP$-complete to find on given input $\langle G,k\rangle$, if $G$ has treewidth $k$ [2]. However, an $O(\sqrt{\log n})$-factor approximation algorithm is known [13]. Series-parallel graphs are equivalent to graphs of treewidth $2$. For them, Jackoby and Tantau showed a logspace algorithm for \Reach. Das et al. extended the logspace bound to bounded treewidth graphs when the input contains the tree decomposition [11]. Elberfeld et al. showed a logspace algorithm for any monadic second order property of a logical structure of bounded treewidth [12].

Our Result

In this paper, we present a polynomial time algorithm with improved space bound for deciding reachability in graphs of treewidth $w$. In particular, we show the following result.

Theorem 1**.**

Given a graph $G$, a tree decomposition $T$ of $G$ of treewidth $w$, and two vertices $u$ and $v$ in $G$, there is an $O(w\log n)$ space and polynomial time algorithm that decides if there is a path from $u$ to $v$ in $G$.

To prove this, we first give an algorithm to compute a more balanced tree decomposition from the given tree decomposition that has similar treewidth. Our idea to compute this new tree decomposition is based on the idea of computing a balanced binary tree decomposition from Elberfeld et al. [12]. However, in their paper, they construct a graph called descriptor decomposition of size $\Omega(n^{w})$ as an intermediate. They then use this graph to construct a tree decomposition. They bound the depth of tree decomposition by $O(w\log n)$. As a result, their algorithm requires $\Omega(n^{w})$ time and the bound on depth is dependent on $w$. We, on the other hand, construct a tree decomposition using only $\poly(n)$ time and of depth $O(\log n)$. It is important to note here that the depth of our tree decomposition is independent of $w$. Next, we give an algorithm to decide reachability in $G$, which uses the newly constructed balanced binary tree decomposition. We use the idea of universal sequences from the work of Asano et al. [6], to bound the time complexity of our algorithm by a polynomial.

For graphs of treewidth $n^{1-\epsilon}$, for any $\epsilon>0$, our algorithm gives an $O(n^{1-\delta})$ space and polynomial time algorithm (for some $\delta$), thus giving an affirmative answer to Wigderson’s question for such class of graphs. For graphs of polylog treewidth, we show that reachability is in polynomial time and polylog space. Graphs which have genus $g$ have treewidth $O((gn)^{1/2})$, hence our algorithm gives a $O((gn)^{1/2}\log n)$ space and polynomial time algorithm for it. For planar graphs, our approach gives $O(n^{1/2}\log n)$ space and polynomial time algorithm.

Let $H$ be a graph on $h$ vertices. An $H$ minor-free graph is also, by definition, $K_{h}$ minor free where $K_{h}$ is a complete graph on $h$ vertices. Graphs which exclude a fixed minor $K_{h}$, have a treewidth of $h{n}^{1/2}$ [1][15]. Hence, for constant $h$, our approach results in $O(n^{1/2}\log n)$ space and polynomial time algorithm for $H$ minor-free graphs.

In Section 2 we give the definitions, notations and previously known results that we use in this paper. In Section 3 we show how to efficiently compute a logarithmic depth, binary tree decomposition of $G$ having a similar width from the input tree decomposition. In Section 4 we give the reachability algorithm and prove its correctness and complexity bounds.

2 Preliminaries

For a graph $G$ on $n$ vertices, we denote its vertex and edge sets as $V(G)$ and $E(G)$ respectively. Let $W$ be a subset of $V(G)$. We denote the subgraph of $G$ induced by the vertices in $W$ by $G[W]$. Let $[n]$ denote the set $\{1,2,\ldots,n\}$ for $n\geq 1$ .

We next define the necessary terminology and notations related to tree decomposition that we use in this paper. For tree decomposition, we will treat the graph as an undirected graph by ignoring the direction of its edges.

For a graph $G$, a tree decomposition is a labeled tree $T$ where the labeling function $B:V(T)\rightarrow\{X\mid X\subseteq V(G)\}$ has the following property: (i) $\bigcup_{t\in V(T)}B(t)=V(G)$, (ii) for every edge $\{v,w\}$ in $E(G)$, there exists $t$ in $V(T)$ such that $v$ and $w$ are in $B(t)$, and (iii) if $t_{3}$ is on the path from $t_{1}$ to $t_{2}$ in $T$, then $B(t_{1})\cap B(t_{2})\subseteq B(t_{3})$. The treewidth of a tree decomposition $T$ is $\max_{t\in V(T)}(B(t)-1)$. Finally the treewidth of a graph $G$ is the minimum treewidth over all tree decompositions of $G$. We refer to a node $t$ in $V(T)$ as a treenode and the set $B(t)$ to be the bag corresponding to $t$.

The next tool that we would be using is that of separators in graphs. For a subset $W$ of $V(G)$, a vertex separator of $W$ in $G$, denoted as $\textsf{sep}(W)$, is a subset $S$ of $V(G)$ such that every component of the graph $G[V(G)\setminus S]$ has at most $\lvert W\rvert/2$ vertices of $W$.

We state here the following commonly known result about vertex separators in the form that we would be using it. We also give a proof of the result for the sake of completeness.

Lemma 1**.**

Let $G$ be a graph and $T$ be a tree decomposition of $G$. For every subset $U$ of $V(G)$, there exists a vertex $t$ in $V(T)$ such that the bag $B(t)$ is the vertex separator of $U$ in $G$.

Proof.

We root the tree arbitrarily. For a treenode $t$ in $V(T)$, we denote its parent by $\textsf{parent}(t)$. Let $C(t)=B(t)\cap U$. We define weights on the vertices of $T$, such that each vertex of $U$ is counted in only one of the weights. $\alpha(t)=\lvert C(t)\setminus C(\textsf{parent}(t))\rvert$. Thus, $\sum_{t\in V(T)}\alpha(t)=\lvert U\rvert$. In a weighted tree, there exists a vertex whose removal divides the tree into components whose weights are at most half the total weight of the tree. Let this vertex be $t^{*}$ for the weight function $\alpha$. We claim that $B(t^{*})$ is the vertex separator for $U$ in $G$. To prove this, we will prove that for a connected component $H$ of $G[V(G)\setminus B(t^{*})]$, $H$ is a subset of $(\cup_{t\in T_{i}}B(t))$ for some subtree $T_{i}$ of $T\setminus\{t^{*}\}$. Since the total weight of this subtree is at most half the total weight on $T$, it would follow that the number of vertices of $U$ contained in this set would be at most half, thus proving the lemma.

We will now prove that $H\subseteq(\cup_{t\in T_{i}}B(t))$. We first observe that a vertex $v\in V(G)\setminus B(t^{*})$ can be in the bag of only one of the subtree, since otherwise, it would belong to $B(t^{*})$ as well, due to the third property of tree decomposition. Now, let us assume that there are two vertices of $H$ which belong to the bags of two different subtrees, say $T_{i}$ and $T_{j}$. Since they are in connected component, there will exist a path between them. In this path, there will exist an edge, whose endpoints $v_{1}$ and $v_{2}$ would belong to different subtrees. We thus get a contradiction to the second property of tree decomposition. ∎

3 Finding a Tree Decomposition of Small Depth

In this section, we show how to compute a binary tree decomposition (say $T^{\prime}$) with logarithmic depth and treewidth $O(w)$. We require the tree decomposition to have logarithmic depth because our main algorithm for reachability (Algorithm 4) might potentially store reachability information for all vertices corresponding to the bags of treenodes in a path from the root to a leaf. Once the depth is reduced to $O(\log n)$ with bag size being $O(w)$, the algorithm will only need to store reachability information of $O(w\log n)$ vertices. Thus, we prove the following theorem.

Theorem 2**.**

Given as input $\langle G,T\rangle$ where $G$ is a graph and $T$ is a tree decomposition of $G$ with treewidth $w$, there exists an algorithm working simultaneously in $O(w\log n)$ space and polynomial time which outputs a binary tree decomposition $T^{\prime}$ of $G$ which has treewidth $6w+6$ and depth $O(\log n)$.

We will now develop the framework that will help us to prove Theorem 2.

First, we show how to compute a vertex separator of a given set $U$ in $G$ in polynomial time and $O(w\log n)$ space. We cycle through every node in the tree $T$ and store the set of vertices in $B(t)$. Doing this requires $O(w\log n)$ space. Then using Reingold’s undirected reachability algorithm [16], we count the number of vertices of $U$ in each of the components of $G[V(G)\setminus B(t)]$. By Lemma 1, at least one of these sets $B(t)$ would be a separator of $U$ in $G$. Its size will be the size of $B(t)$ for some treenode $t$. Hence it can be at most $w+1$. We summarise this procedure in Lemma 2.

Lemma 2**.**

Given as input $\langle G,T,U\rangle$ where $G$ is a graph, $T$ is a tree decomposition of $G$ with treewidth $w$, and $U$ is a subset of $V(G)$, there exists an $O(w\log n)$ space and polynomial time algorithm that computes $\textsf{sep}(U)$ and $|\textsf{sep}(U)|$ is at most $w+1$.

3.1 Constructing a Recursive Decomposition

As an intermediate step, we first construct a recursive decomposition of the graph which is a tree whose nodes represents a subgraph of $G$. The root node represents the entire $G$. We then remove a separator from it. We assume inductively that each of the connected components has their recursive decomposition and connect the root node to the roots of these recursive decompositions of connected components. We select a separator such that a small number of bits can encode each node. This recursive decomposition acts as an intermediate to our tree decomposition. Once we have a recursive decomposition of the graph, we add labels to each node such that it satisfies the properties of tree decomposition.

Definition 1**.**

Let $Z\subseteq V(G)$ and a vertex $r\in(V(G)\setminus Z)$. Define $G_{\langle Z,r\rangle}$ to be the subgraph of $G$ induced by the set of vertices in the connected component of $G[V(G)\setminus Z]$ which contains $r$. Define the tree $\textsf{rdtree}(Z,r)$ which we call recursive decomposition as follows:

• •

The root of $\textsf{rdtree}(Z,r)$ is $\langle Z,r\rangle$.

• •

Let $Z^{\prime}=Z\cup\textsf{sep}(Z)\cup\textsf{sep}(V(G_{\langle Z,r\rangle})$ and let $r_{1},\ldots,r_{k}$ be the lowest indexed vertices in each of the connected components of $G[(V(G_{\langle Z,r\rangle})\setminus Z^{\prime}]$. The children of the root are roots of the recursive decompositions $\textsf{rdtree}(Z^{\prime}_{i},r_{i})$ for each $i\in\{1,\ldots,k\}$, where $Z^{\prime}_{i}$ is the set of vertices in $Z^{\prime}$ that are adjacent to at least one vertex of $V(G_{\langle Z^{\prime},r_{i}\rangle})$ in $G$.

We now show that for the graph $G$ the recursive decomposition tree structure has logarithmic depth, and every node in the tree can be encoded by a few bits.

Lemma 3**.**

Let $v_{0}$ be a vertex in $G$. Then the depth of the recursive decomposition $\textsf{rdtree}(\phi,v_{0})$ is at most $\log n$. Moreover, for a node $\langle Z,r\rangle$ in $\textsf{rdtree}(\phi,v_{0})$, we have $|Z|\leq 4w+4$.

Proof.

We prove a more general result that for any set of vertices $Z\subseteq V(G)$ and a vertex $r\in(V(G)\setminus Z)$, the depth of $\textsf{rdtree}(Z,r)$ is at most $\log n$. By Definition 1, we have that the set $\textsf{sep}(V(G_{\langle Z,r\rangle}))$ is a subset of $Z^{\prime}$. Hence removal of $Z^{\prime}$ divides the graph $G_{\langle Z,r\rangle}$ into components each of which is of size at most half that of the size of $G_{\langle Z,r\rangle}$. Since $r_{1},\ldots,r_{k}$ are chosen from these components, it follows that the size of $G_{\langle Z^{\prime},r_{i}\rangle}$ is at most half of $G_{\langle Z,r\rangle}$. Additionally, in Definition 1 the sets $Z^{\prime}_{i}$ are chosen in such a manner that the graphs $G_{\langle Z^{\prime}_{i},r_{i}\rangle}$ and $G_{\langle Z^{\prime},r_{i}\rangle}$ are equivalent. This proves that the size of the graph $G_{\langle Z,r\rangle}$ halves at each level of the recursive decomposition. Hence $\textsf{rdtree}(\phi,v_{0})$ would have at most $\log n$ depth.

We prove the second part of the lemma by induction on the depth of $\textsf{rdtree}(\phi,v_{0})$. This is trivially true for the root. Now let $\langle Z^{\prime}_{i},r_{i}\rangle$ be a child of $\langle Z,r\rangle$. Let $Z_{i}$ be the set of vertices of $Z\setminus\textsf{sep}(Z)$ which are adjacent to at least one of the vertices of $V(G_{\langle Z^{\prime},r_{i}\rangle})$ in $G$, and let $C_{i}$ be the unique connected component of $G[V(G)\setminus\textsf{sep}(Z)]$ whose intersection with $G_{\langle Z^{\prime},r_{i}\rangle}$ is not empty. Since $\textsf{sep}(Z)$ is a separator of $Z$ in $G$, $C_{i}$ will contain at most $\lvert Z\rvert/2$ vertices of $Z$ in it. This shows that $\lvert Z_{i}\rvert\leq\lvert Z\rvert/2$. By Definition 1, we know that $\lvert Z^{\prime}_{i}\rvert\leq\lvert Z_{i}\rvert+\lvert\textsf{sep}(Z)\rvert+\lvert\textsf{sep}(V(G_{\langle Z,r\rangle}))\rvert$. The size of $\textsf{sep}(V(G_{\langle Z,r\rangle}))\leq w+1$ and $\textsf{sep}(Z)\leq w+1$ by Lemma 2. Lastly by induction $\lvert Z\rvert/2\leq(4w+4)/2$. Hence it follows that $|Z^{\prime}_{i}|\leq 4w+4$. ∎

We now show that the recursive decomposition tree corresponding to $G$ can be computed efficiently as well. To prove this, we give procedures that, given a node in the recursive decomposition tree, can compute its parent and children efficiently.

Algorithm 1 outputs the children of $\langle Z,r\rangle$ in $\textsf{rdtree}(\phi,v_{0})$. Note that we don’t explicitly store $G_{\langle Z,r\rangle}$ but compute it whenever required. The separators in line $1$ and $2$ both have cardinality at most $w+1$ and can be computed in $O(w\log n)$ space and polynomial time by Lemma 2. The cardinality of $Z$ is at most $4w+4$ by Lemma 3. Therefore $|Z^{\prime}|$ is at most $6w+6$. The size of $\widehat{Z}$ computed would again be $4w+4$ by Lemma 3. Thus the space required by Algorithm 1 is $O(w\log n)$.

Algorithm 2 outputs the parent of $\langle Z,r\rangle$ in $\textsf{rdtree}(\phi,v_{0})$. It uses Algorithm 1 as a subroutine to get the children of a node in $\textsf{rdtree}(\phi,v_{0})$. Hence we can traverse the tree $\textsf{rdtree}(\phi,v_{0})$ in $O(w\log n)$ space and polynomial time. We summarize the above in Lemma 4.

Lemma 4**.**

Let $G$ be a graph, $T$ be a tree decomposition of $G$ with treewidth $w$ and $v_{0}$ be a vertex in $G$. Given $\langle G,T,v_{0}\rangle$ and the node $\langle Z,r\rangle$ in $\textsf{rdtree}(\phi,v_{0})$, there exist algorithms that use $O(w\log n)$ space and polynomial time, and output the children and parent of $\langle Z,r\rangle$ respectively. As a consequence $\textsf{rdtree}(\phi,v_{0})$ can be traversed in $O(w\log n)$ space and polynomial time as well.

3.2 Constructing a New Tree Decomposition

We now construct a new tree decomposition of $G$ from the recursive decomposition defined earlier. The new tree decomposition will have the same tree structure as that of the recursive decomposition. However, we will assign it a labeling function. The subgraph that a node of the recursive decomposition represents is a connected component obtained after removing a set of separators from $G$. The corresponding label for this node in the new tree decomposition is simply the set of separator vertices in the boundary of this subgraph together with the separator required to subdivide this subgraph further. We formalize this in Definition 2.

Definition 2**.**

Let $\widehat{T}$ be the tree corresponding to the recursive decomposition $\textsf{rdtree}(\phi,v_{0})$. For a node $\langle Z,r\rangle$ in $\textsf{rdtree}(\phi,v_{0})$, we define the function $\widehat{B}(\langle Z,r\rangle)$ as follows:

[TABLE]

We first show that $\widehat{T}$ is a tree decomposition of $G$ as well, with labeling function $\widehat{B}$.

Lemma 5**.**

The tree $\widehat{T}$ defined in Definition 2 along with the labeling function $\widehat{B}$, is a tree decomposition of $G$ of width $6w+6$. Moreover, the depth of $\widehat{T}$ is at most $\log n$.

Proof.

We claim that for a vertex $v$ in $G_{\langle Z,r\rangle}$, there exists a vertex $\langle Z^{\prime},r^{\prime}\rangle$ in $\textsf{rdtree}(Z,r)$ such that $\widehat{B}(\langle Z^{\prime},r^{\prime}\rangle)$ contains $v$. We prove this by induction on the height of the recursive decomposition $\textsf{rdtree}(Z,r)$. If $\textsf{rdtree}(Z,r)$ is just a single node, then $v$ is in $\textsf{sep}(V(G_{\langle Z,r\rangle}))$ by construction. Otherwise $v$ is either in $(\textsf{sep}(Z)\cup\textsf{sep}(V(G_{\langle Z,r\rangle})))$ or in one of the connected components of $G[V(G_{\langle Z,r\rangle})\setminus(\textsf{sep}(Z)\cup\textsf{sep}(V(G_{\langle Z,r\rangle})))]$. If $v$ is in $(\textsf{sep}(Z)\cup\textsf{sep}(V(G_{\langle Z,r\rangle})))$, then $v$ is in $\widehat{B}(\langle Z,r\rangle)$ and we are done. Otherwise one of the children of $\langle Z,r\rangle$ will be $\langle\tilde{Z},\tilde{r}\rangle$ such that $v$ is in $G_{\langle\tilde{Z},\tilde{r}\rangle}$. Now by induction hypothesis, there exists a vertex $\langle Z^{\prime},r^{\prime}\rangle$ in $\textsf{rdtree}(\tilde{Z},\tilde{r})$ such that $\widehat{B}(\langle Z^{\prime},r^{\prime}\rangle)$ contains $v$. It follows that every vertex $v$ of $V(G)$ is contained in the label of at least one of the vertices of $\widehat{T}$, satisfying the first property of tree decomposition.

We claim that for any edge $(u,v)$ in $G$ such that $\{u,v\}\subseteq V(G_{\langle Z,r\rangle})\cup Z$, either both $u$ and $v$ are in $\widehat{B}(\langle Z,r\rangle)$ or there exists a child $\langle Z^{\prime}_{i},r_{i}\rangle$ of $\langle Z,r\rangle$ such that $\{u,v\}\subseteq V(G_{\langle Z^{\prime}_{i},r_{i}\rangle})\cup Z^{\prime}_{i}$. Since $u$ and $v$ are connected by an edge, there cannot exist any set of vertices $\widehat{Z}$ such that $u$ and $v$ are in different connected components of $G[V(G)\setminus\widehat{Z}]$. Let $Z^{\prime}=Z\cup\textsf{sep}(Z)\cup\textsf{sep}(V(G_{\langle Z,r\rangle}))$. If both $u$ and $v$ are in $Z^{\prime}$, then they are in $\widehat{B}(\langle Z,r\rangle)$. Otherwise, let $r_{i}$ be the lowest indexed vertex in the connected component of $G[(V(G_{\langle Z,r\rangle})\setminus Z^{\prime}]$ which contains either of $u$ or $v$. Let $Z^{\prime}_{i}$ is the set of vertices in $Z^{\prime}$ that are adjacent to at least one of the vertices of $V(G_{\langle Z^{\prime},r_{i}\rangle})$ in $G$. Now, if both $u$ and $v$ are not in $V(G_{\langle Z^{\prime}_{i},r_{i}\rangle})$, then one of them have to be in $Z^{\prime}_{i}$. Hence in all cases, $u$ and $v$ are contained in $V(G_{\langle Z^{\prime}_{i},r_{i}\rangle})\cup Z^{\prime}_{i}$. Hence by induction on the height of the tree decomposition $\widehat{T}$ we have that there exists a treenode in $\widehat{T}$ whose bag contains both $u$ and $v$, satisfying the second property of tree decomposition.

To establish the third property of tree decomposition we first show that if $v$ is not in $Z\cup V(G_{\langle Z,r\rangle})$, then for no descendant $\langle\tilde{Z},\tilde{r}\rangle$ of $\langle Z,r\rangle$ will $\widehat{B}(\langle\tilde{Z},\tilde{r}\rangle)$ contain $v$. We show this by induction on the height of the recursive decomposition. If there is only one node in $\textsf{rdtree}(Z,r)$, then $\widehat{B}(\langle Z,r\rangle)$ does not contain $v$ by definition. Otherwise, no connected component of $G[V(G_{\langle Z,r\rangle})\setminus Z^{\prime}]$ contains $v$. Also $Z^{\prime}_{i}$ for any of its children will not contain $v$ as claimed.

Now let $\langle Z,r\rangle$ be a treenode in $\widehat{T}$. We claim that for any child $\langle Z^{\prime}_{i},r_{i}\rangle$ of $\langle Z,r\rangle$ if a vertex $v$ is in $\widehat{B}(\langle Z,r\rangle)$, then either $v$ is also in $\widehat{B}(\langle Z^{\prime}_{i},r_{i}\rangle)$ or no descendant of $\langle Z^{\prime}_{i},r_{i}\rangle$ has a bag corresponding to it which contains $v$. Let $\langle Z,r\rangle$ be a node in $\textsf{rdtree}(\phi,v_{0})$ such that $\widehat{B}(\langle Z,r\rangle)=X$. Since any connected component of $G[V(G_{\langle Z,r\rangle})\setminus\widehat{B}(\langle Z,r\rangle)]$ cannot contain $v$, $v$ is not in $V(G_{\langle Z^{\prime}_{i},r_{i}\rangle})$ for any child $\langle Z^{\prime}_{i},r_{i}\rangle$ of $\langle Z,r\rangle$. Now if $v$ is not in $\widehat{B}(\langle Z^{\prime}_{i},r_{i}\rangle)$, then it implies that $v$ is not in $Z^{\prime}_{i}\cup V(G_{\langle Z^{\prime}_{i},r_{i}\rangle})$ as well. Hence the third property of tree decomposition is satisfied as well.

For a vertex $\langle Z,r\rangle$ in $\textsf{rdtree}(\phi,v_{0})$, we have $\lvert Z\rvert\leq 4w+4$, $\textsf{sep}(Z)\leq w+1$ and $\textsf{sep}((V(G_{\langle Z,r\rangle}))\leq w+1$ as well. Hence $\widehat{B}(\langle Z,r\rangle)\leq 6w+6$.

Since the tree $\widehat{T}$ and $\textsf{rdtree}(\phi,v_{0})$ have the same structure, the bounds on their depths are the same. ∎

Next, we observe that given $\langle Z,r\rangle$, we can compute $\widehat{B}(\langle Z,r\rangle)$ in $O(w\log n)$ space and polynomial time. Hence we have the following Lemma.

Lemma 6**.**

Given a graph $G$ and a tree decomposition $T$ of $G$ with treewidth $w$, there is an algorithm that can compute a new tree decomposition $\widehat{T}$ of $G$ having treewidth at most $6w+6$ and depth at most $\log n$, using $O(w\log n)$ space and polynomial time. Moreover, the tree $\widehat{T}$ can be traversed in $O(w\log n)$ space and polynomial time as well.

Note that the tree $\widehat{T}$ might not be a binary tree since a separator might disconnect the graph into more than two components. However, to decide reachability in the later part of this paper, we require the tree decomposition to have bounded degree as well. We achieve this by using the following lemma from Elberfeld, Jakoby, and Tantau to get the required tree decomposition $T^{\prime}$.

Lemma 7**.**

[12*]**

There is a logspace algorithm that on the input of any logarithmic depth tree decomposition of a graph $G$ outputs a logarithmic depth, binary balanced tree decomposition of $G$ having the same treewidth.*

Now combining Lemma 6 and Lemma 7 we get the proof of Theorem 2.

We observe here that the input tree decomposition $T$ is used only to compute a vertex separator in $G$. For graphs where vertex separators can be computed efficiently, such as planar graphs [14] or constant treewidth graphs, the requirement of input tree decomposition can be waived.

4 Deciding Reachability using a Balanced Binary Tree Decomposition

In this section, we show that given a graph $G$ along with a binary, balanced tree decomposition $T$ whose depth is $O(\log n)$; there exists an efficient algorithm to decide reachability in $G$ in $O(w\log n)$ space and polynomial time. In particular, we show the following theorem.

Theorem 3**.**

Given $\langle G,T,u,v\rangle$ as input, where $G$ is a graph on $n$ vertices and $T$ is a binary balanced tree decomposition of $G$ having depth $h$ and treewidth $w$, there exists an $O(wh+\log n)$ space and polynomial time algorithm that solves reachability in $G$.

We first state the notation required to prove Theorem 3. This notation is commonly used to describe dynamic programming algorithms which use tree decomposition. Let $T$ be a rooted binary tree. We denote $\textsf{root}(T)$ to be the root of $T$ and for a node $t\in T$, we denote $\textsf{left}(t)$ and $\textsf{right}(t)$ to be the left and right child of $t$ respectively (the value is NULL if a child does not exist). For two nodes $t$ and $t^{\prime}$ in $T$, if $t^{\prime}$ lies in the path from $\textsf{root}(T)$ to $t$, then we say that $t^{\prime}$ is an ancestor of $t$ and $t$ is a descendent of $t^{\prime}$. For a treenode $t$, let $B_{e}(t)$ denote the set of edges of $G$ whose both endpoints are in $B(t)$. We define a subgraph of $G$ with respect to the treenode $t$ consisting of the ancestor vertices of $t$. Formally, the vertex set is $V^{\textsf{anc}}_{t}=\bigcup_{\{t^{\prime}\textrm{ is an ancestor of }t\}}B(t^{\prime})$, the edge set is $E^{\textsf{anc}}_{t}=\bigcup_{\{t^{\prime}\textrm{ is an ancestor of }t\}}B_{e}(t^{\prime})$ and the graph $G^{\textsf{anc}}_{t}=(V^{\textsf{anc}}_{t},E^{\textsf{anc}}_{t})$. Now, we define a subgraph of $G$ with respect to the treenode $t$ consisting of the ancestor as well as descendent vertices of $t$. Formally, the vertex set is $V_{t}=\bigcup_{\{t^{\prime}\textrm{ is an ancestor or descendent of }t\}}B(t^{\prime})$, the edge set is $E_{t}=\bigcup_{\{t^{\prime}\textrm{ is an ancestor or descendent of }t\}}B_{e}(t^{\prime})$ and the graph $G_{t}=(V_{t},E_{t})$.

We assume that the vertices $u$ and $v$ are in $\textsf{root}(T)$, for otherwise, we can add them in all of the bags of the given tree decomposition. Also, we assume that $n$ is a power of $2$.

We now explain our algorithm. Let $S_{1},S_{2},\ldots S_{m}$ be subsets of $V(G)$ which covers all the vertices. Given a sequence of these, say $\langle S_{i_{1}},S_{i_{2}},\ldots,S_{i_{k}}\rangle$ we can check if there is a path from $u$ to $v$ in $G$ corresponding to this sequence in the following way. Begin with a bit-vector where each bit corresponds to a vertex in $S_{1}$. For all vertices $w$ in $S_{1}$ we check if there exists an edge $(u,w)$ in $G$ and set the bit corresponding to $w$ to $1$ in the bit-vector. We set the bit corresponding to $u$ to $1$ too if it is present in $S_{1}$. The marked vertices of $S_{1}$ have a path from $u$ to them. Now, using this vector, we mark vertices in $S_{2}$ which are reachable from the marked vertices in $S_{1}$ using at most $1$ edge in the second bit-vector. In general, given a bit-vector with marked vertices corresponding to $j$’th element in the sequence, we use the other bit-vector to mark vertices in $S_{j+1}$. We iterate $k$ times to mark the vertices in $S_{i_{k}}$.

We say that a sequence $\langle S_{i_{1}},S_{i_{2}},\ldots,S_{i_{k}}\rangle$ is $good$ for a possible path $p$ from $u$ to $v$ when the existence of path $p$ in the graph implies that bit corresponding to $v$ is set to $1$ after the execution of the above discussed procedure. Our algorithm uses the tree decomposition to divide the vertices into sets and then finds a sequence that is $good$ for all the possible paths. The sets of vertices that our algorithm uses are $V_{t}$ for all the leaves $t$ of $T$. We can map a sequence of sets of vertices to a sequence of leaves of the graph. We thus need a sequence of leaves that is $good$ for all possible paths from $u$ to $v$. In Section 4.1, we show how to construct a $good$ sequence of leaves. Then, in Section 4.2, we show how to use this sequence to solve reachability.

4.1 Constructing a Good Sequence of Leaves

We will be using $universal$ $sequences$ and the following lemma about it from Asano et al. to construct the sequence of leaves.

For every integer $s\geq 0$, a universal sequence $\sigma_{s}$ of length $2^{s+1}-1$ is defined as follows:

[TABLE]

where $\diamond$ is the concatenation operation.

Lemma 8**.**

[6*]**

The universal sequence $\sigma_{s}$ satisfies the following properties:*

Let $\sigma_{s}=\langle c_{1},\ldots,c_{2^{s+1}-1}\rangle$. Then for any positive integer sequence $\langle d_{1},\ldots,d_{x}\rangle$ such that $\Sigma d_{i}\leq 2^{s}$, there exists a subsequence $\langle c_{i_{1}},\ldots,c_{i_{x}}\rangle$ such that $d_{j}\leq c_{i_{j}}$ for all $j\in[x]$.

• -

The sequence $\sigma_{s}$ contains exactly $2^{s-i}$ appearances of the integer $2^{i}$ and nothing else.

• -

The sequence $\sigma_{s}$ is computable in $O(2^{s})$ time and $O(s)$ space.

Definition 3**.**

Let $T$ be a balanced binary tree. Let $t$ be a node in $T$ and $d$ be a positive power of $2$. We define a sequence of leaves of $T$ in the following way.

[TABLE]

where $c_{i}$ is the $i$-th integer in $\sigma_{\log d}$. For the base case, if $t$ is a leaf, we have $\textsf{SEQ}_{t,d}$ is $\langle t\rangle$ concatenated with itself $d$ times. We also define $\textsf{SEQ}_{t,d}(r)$ to be the $r$th leaf in the sequence $\textsf{SEQ}_{t,d}$. The length of $\textsf{SEQ}_{t,d}$ is the number of leaves in $\textsf{SEQ}_{t,d}$.

We now wish to show that we can construct the sequence $\textsf{SEQ}_{\textsf{root}(T),d}$ in $O(h+\log d)$ space. We will first bound its length and then present a method to find its $r$th leaf.

Lemma 9**.**

Let $T$ be a balanced binary tree. Let $t$ be a node in $T$, $d$ be a positive power of $2$ and $h$ be the height of subtree of $T$ rooted at $t$. Then, the length of sequence $\textsf{SEQ}_{t,d}$ is

[TABLE]

Proof.

Let $L(h,d)$ be the length of the sequence $\textsf{SEQ}_{t,d}$. By definition of $\textsf{SEQ}_{t,d}$, we have

[TABLE]

From lemma 8, we get that $\sigma_{\log d}$ contains exactly $\frac{d}{2^{i}}$ occurrences of the integer $2^{i}$. Thus we have:

[TABLE]

We claim that $L(h,d)=2^{h}d\binom{h+\log d}{\log d}$ and we prove this through induction on $h$. For $h=0$, we see that

[TABLE]

Now, we assume the statement to be true for smaller values of ${h}$. We see that:

[TABLE]

using $\binom{a}{r}=\binom{a+1}{r}-\binom{a}{r-1}$

[TABLE]

∎

Lemma 10**.**

Let $T$ be a binary balanced tree of depth at most $h$. Let $t$ be a node of $T$ and $d$ be a power of $2$. The sequence $\textsf{SEQ}_{t,d}$ can be constructed in space $O(h+\log d)$.

Proof.

We see that $L(m,d)$ is atmost a polynomial in $m$ and $d$. For a given integer $r$, let $i^{*}$ be the smallest integer such that $r-2\sum_{i=1}^{i^{*}}L(m/2,c_{i})\leq 0$. By the definition, $\textsf{SEQ}_{t,d}(r)=\textsf{SEQ}_{\textsf{left}(t),c_{i^{*}}}(r-2\sum_{i=1}^{i^{*}-1}L(m/2,c_{i}))$ if $r-2\sum_{i=1}^{i^{*}-1}L(m/2,c_{i})-L(m/2,c_{i^{*}})\leq 0$ and $\textsf{SEQ}_{t,d}(r)=\textsf{SEQ}_{\textsf{right}(t),c_{i^{*}}}(r-2\sum_{i=1}^{i^{*}-1}L(m/2,c_{i})-L(m/2,c_{i^{*}}))$ otherwise.

The length of the sequence $\textsf{SEQ}_{t,d}$ is at most $2^{h}d\binom{h+\log d}{\log d}$. Hence the number of bits required to store any index of the sequence is at most $\log(2^{h}d\binom{h+\log d}{\log d})=O(h+\log d)$. This gives the space bound of Algorithm 3. ∎

4.2 Algorithm to Solve Reachability

For a leaf $t$ of $T$ and a vertex $v$ of $G$ we use $\textsf{index}_{t}(v)$ for the position of $v$ in an arbitrarily fixed ordering of the vertices of $G_{t}$.

Lemma 11**.**

Let $G$ be a graph and $T$ be a binary tree decomposition of $G$ of width $w$ and depth $h$. Let $t$ be a node of $T$ and $d$ be a power of $2$. For each vertex $y\in V^{\textsf{anc}}_{t}$, $y$ is marked after the execution of iterations in lines 4 to 4 of Algorithm 4 with values of $f$ in $\textsf{SEQ}_{t,d}$ if and only if there is a marked vertex $x$ in $V^{\textsf{anc}}_{t}$ and a path from $x$ to $y$ in $G_{t}$ of length at most $d$.

Proof.

We prove this by induction on the height of subtree rooted at $t$. The base case is trivial. Let $p$ be the path of length at most $d$ from $x$ to $y$ such that $x$ is marked and $x,y$ is in $V^{\textsf{anc}}_{t}$. We see that the edges of path $p$ will belong to either $E_{\textsf{left}(t)}$ or $E_{\textsf{right}(t)}$ (or both). We label an edge of $p$ as [math] if it belongs to $E_{\textsf{left}(t)}$, else label it as $1$. Break down $p$ into subpaths $p_{1},\ldots,p_{k}$ such that the edges in $p_{i}$ all have same label and label of edges in $p_{i+1}$ is different form label of $p_{i}$. The endpoints $y_{i}$ of these subpaths will belong to $V^{\textsf{anc}}_{t}$, for otherwise $y_{i}$ will not be in $B(t)$ but since $y_{i}$ has edges of both labels incident on it, it will be in bags of both subtrees rooted at $\textsf{left}(t)$ and $\textsf{right}(t)$ contradicting the third property of tree decomposition. Let $l_{i}$ be the length of path $p_{i}$. Since $l_{1}+l_{2}+\cdots+l_{k}\leq d$, by Lemma 8, there exists a subsequence $\langle c_{i_{1}},c_{i_{2}},\ldots,c_{i_{k}}\rangle$ of $\sigma_{\log d}$ such that $l_{j}\leq c_{i_{j}}$.

Consider the subsequence $\textsf{SEQ}_{\textsf{left}(t),c_{i_{1}}}\diamond\textsf{SEQ}_{\textsf{right}(t),c_{i_{1}}}\diamond\textsf{SEQ}_{\textsf{left}(t),c_{i_{2}}}\diamond\textsf{SEQ}_{\textsf{right}(t),c_{i_{2}}}\diamond\textsf{SEQ}_{\textsf{left}(t),c_{i_{3}}}\diamond\textsf{SEQ}_{\textsf{right}(t),c_{i_{3}}}\diamond\cdots\diamond\textsf{SEQ}_{\textsf{left}(t),c_{i_{k}}}\diamond\textsf{SEQ}_{\textsf{right}(t),c_{i_{k}}}$ of $\textsf{SEQ}_{t,d}$. We claim that $y_{j}$ is marked after the iterations with the value of $f$ in $\textsf{SEQ}_{\textsf{left}(t),c_{i_{j}}}\diamond\textsf{SEQ}_{\textsf{left}(t),c_{i_{j}}}$. Since $y_{j-1}$ is marked before the iterations and the path $p_{j}$ is either the subgraph $G_{\textsf{left}(t)}$ or $G_{\textsf{right}(t)}$ having length at most $c_{i_{j}}$, $y_{j}$ will be marked by induction hypothesis. ∎

Lemma 12**.**

On input of a graph $G$ with $n$ vertices and its tree decomposition $T$ with treewidth $w$ and depth $h$; Algorithm 4 solves reachability in $G$ and requires $O(wh+\log n)$ space and time polynomial in $2^{h},n$ and $w$.

Proof.

The proof of correctness of the algorithm follows from Lemma 11 and the fact that $u$ and $v$ are both present in $B(\textsf{root}(T))$ and $u$ is marked before the first iteration of the for-loop in line 4.

We first analyse the space required. The size of bit-vectors $R_{0}$ and $R_{1}$ is $wh$. $t_{0}$ and $t_{1}$ are indices of nodes of $T$. The space required to store index of a vertex of $T$ is $O(h)$. Space required to store a vertex of $G$ is $O(\log n)$, and $\textsf{index}_{t}(x)$ for a node $t$ and a vertex $x$ can be found in $O(\log n+h)$ space. Hence the total space required is $O(wh+\log n)$.

We now analyze the time bound. By Lemma 9, the size of $\textsf{SEQ}_{t,d}$ is polynomial in $2^{h}$ and $d$, the number of iterations in the for-loop of line 4 is thus a polynomial. The other lines do trivial stuff and hence the total running time of the algorithm is polynomial. ∎

Now, Theorem 3 follows from Lemma 12. Combining Theorem 3 and Theorem 2 we get the proof of Theorem 1.