TOWARDS MAKING SPACE-BOUNDED

NON-DETERMINISM UNAMBIGUOUS

A THESIS

submitted by

ANANT DHAYAL

for the award of the degree

of

MASTER OF SCIENCE

(by Research)

DEPARTMENT OF COMPUTER SCIENCE AND ENGINEERING

INDIAN INSTITUTE OF TECHNOLOGY, MADRAS.

MAY 2015

THESIS CERTIFICATE

This is to certify that the thesis titled TOWARDS MAKING SPACE-BOUNDED NON-

DETERMINISM UNAMBIGUOUS, submitted by Anant Dhayal, to the Indian Institute of

Technology, Madras, for the award of the degree of Master of Science (by Research), is a

bonafide record of the research work done by him under my supervision. The contents of this

thesis, in full or in parts, have not been submitted to any other Institute or University for the

award of any degree or diploma.

Jayalal SarmaResearch GuideAssistant ProfessorDept. of Computer Science and EngineeringIIT-Madras, 600 036

Place: Chennai

Date: May, 2015

ACKNOWLEDGEMENTS

The work presented in the thesis was done under the guidance of Jayalal Sarma. I would like

to thank him for his guidance and constant motivation throughout the course of my research.

He supported me in different roles. He was my guide, mentor, motivator and a friend. He was

a source of optimism at times when I would find a concept almost incomprehensible, and at

the times when I was frustrated by constant failures in my attempts. At such times, he chose to

spend a great deal of his valuable time, despite having important appointments, to encourage me

and to help me learn. While working with him, I developed a lot of qualities which are essential

part of a true researcher. As a researcher, I doubt that I would have reached such a destination

without his help. I would like to thank my mother, father and brother for their constant support

and encouragement. It would never have been possible for me to achieve anything in my life

without their constant hard work. I am very thankful to N.S. Narayanaswamy and Raghvendra

Rao B.V. who have been of great help throughout my research. Also, the concepts I learned by

doing courses with them were of a great help in my research. I would like to thank my friend

Saurabh Sawlani for playing a wonderful role of a research partner. He has been of great help,

and without him my research journey wouldn’t have been so smooth. I am very greatful to

my friends Akshay Degwekar, Dinesh Krishnamoorthy, Sajin Koroth, William Moses and all

the members of ACT lab who helped me by taking part in long fruitful discussions in the lab.

I would also like to thank my friends Anand Aiyer, Gaurav Singh, Ashish Srivastava, Aman

Nougrahiya, Nitin Gupta, Swapnil Gupta, Ankit Chauhan and Amit Rawat for making my stay

at IIT Madras such wonderful and memorable one.

Anant Dhayal

i

ABSTRACT

KEYWORDS: Weighting Scheme, Unambiguous, Non-determinism, Graph

Reachability, Inductive Counting, Min-unique, Min-poly, Graph

Isomorphism

For a graph G(V,E) and a vertex s ∈ V , a weighting scheme (w : E → N) is called a

min-unique weighting scheme, if for any vertex v of the graph G, there is a unique path of

minimum weight from s to v. Instead, if the number of paths of minimum weight is bounded

by nc (n = |V |) for some constant c, then the weighting scheme is called a min-poly weighting

scheme. Weight of a path p is the sum of the weights of the edges appearing in p.

In this work, we propose an unambiguous non-deterministic log-space (UL) algorithm for

the problem of testing reachability in graphs augmented with a min-poly weighting scheme.

This improves the result due to Allender and Reinhardt [25] where a UL algorithm was given

for the case when the weighting scheme is min-unique.

Our main technique is a triple inductive counting, which generalizes the techniques of [17,

29] and [25], combined with a hashing technique due to Fredman, Komlos and Szemeredi [13].

We combine this with a complementary unambiguous verification method, to give the desired

UL algorithm. Our result implies that it suffices to design UL-computable min-poly weighting

schemes for directed graphs in order to make space bounded non-determinism unambiguous.

On a different frontier, while reachability for planar graphs was shown to be in UL [6] using

the min-unique weighting scheme technique, the task of designing a deterministic log-space

ii

algorithm for the problem is still elusive. In the second part of the thesis, we present a different

approach towards the problem. The approach involves “planarizing" a known reduction [30]

from the graph reachability problem to the graph isomorphism problem, noting that the planar

graph isomorphism problem was shown recently to be in log-space [8]. We observe that the

approach, if implemented, implies more than what we intend it to, namely that NL = L. We

also present some negative results about the approach.

iii

TABLE OF CONTENTS

ACKNOWLEDGEMENTS i

ABSTRACT ii

LIST OF TABLES vi

LIST OF FIGURES vii

ABBREVIATIONS viii

NOTATIONS ix

1 INTRODUCTION 1

1.1 Overview and Motivation . . . . . . . . . . . . . . . . . . . . . . . . . . . 1

1.1.1 Weighting Schemes and NL vs UL Problem . . . . . . . . . . . . . 2

1.1.2 Planar Version of Reduction to Graph Isomorphism . . . . . . . . . 3

1.2 Preliminaries . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4

1.2.1 Graph Theoretic Preliminaries . . . . . . . . . . . . . . . . . . . . 4

1.2.2 Some Space Complexity Classes . . . . . . . . . . . . . . . . . . . 6

1.3 Contribution of the Thesis . . . . . . . . . . . . . . . . . . . . . . . . . . 7

1.4 Organization of the Thesis . . . . . . . . . . . . . . . . . . . . . . . . . . 8

2 LITERATURE SURVEY 10

2.1 REACH and Different Graph Classes . . . . . . . . . . . . . . . . . . . . . 10

2.2 UL Algorithm for MIN-UNIQUE REACH . . . . . . . . . . . . . . . . . . . 13

2.3 Weighting Scheme Design for Grid Graphs . . . . . . . . . . . . . . . . . 20

2.4 GI and Different Graph Classes . . . . . . . . . . . . . . . . . . . . . . . 21

2.5 Reduction from REACH to GI . . . . . . . . . . . . . . . . . . . . . . . . 22

iv

3 MIN-CONST AND MIN-POLY GRAPHS 26

3.1 UL Algorithm for MIN-CONST REACH . . . . . . . . . . . . . . . . . . . 26

3.2 FewUL Algorithm for MIN-POLY REACH . . . . . . . . . . . . . . . . . . 33

3.3 UL Algorithm for MIN-POLY REACH . . . . . . . . . . . . . . . . . . . . 40

4 AN ATTEMPT TO SHOW PLANAR-REACH IS IN L 47

4.1 The Approach . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47

4.2 Implication to L vs NL problem . . . . . . . . . . . . . . . . . . . . . . . . 48

4.3 K3,3 and K5 Minors after the Gadget Replacement . . . . . . . . . . . . . 51

5 CONCLUSION AND FUTURE WORK 55

LIST OF TABLES

2.1 Complexity of Reachability for Restricted Graph Classes . . . . . . . . . . 13

vi

LIST OF FIGURES

1.1 Class Hierarchy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7

2.1 Toran’s Gadget . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25

4.1 Planarizing MOD-k Circuit . . . . . . . . . . . . . . . . . . . . . . . . . . 50

4.2 Gadget for MOD-2 Gate . . . . . . . . . . . . . . . . . . . . . . . . . . . 52

4.3 K3,4 Minor Introduced by MOD-2 Gate’s Gadget . . . . . . . . . . . . . . 53

4.4 K5 Minor Introduced by MOD-2 Gate’s Gadget . . . . . . . . . . . . . . . 54

vii

ABBREVIATIONS

TM Turing Machine

Reach Reachability problem

GI Graph Isomorphism problem

GA Graph Automorphism problem

DAG Directed Acyclic Graph

L Deterministic Log-space

NL Non-deterministic Log-space

UL Unambiguous Non-deterministic Log-space

P Deterministic Polynomial-time

NP Non-deterministic Polynomial-time

viii

NOTATIONS

V (G) Vertex set of graph GE(G) Edge set of graph GN Set of natural numbersK3,3 Complete bipartite graph with 3 nodes in both the partitionsK5 Complete graph on 5 nodes

ix

CHAPTER 1

INTRODUCTION

This thesis presents a study on space complexity of the graph reachability problem, also known

as REACH. It focuses on two potential approaches for bringing down the space complex-

ity of REACH for different graph classes. In this chapter, we will give an overview of both

the approaches. Also, we will present some preliminaries and basic definitions that are used

throughout this thesis.

Below we give the formal definition of REACH.

REACH

Input A graph G = (V,E) and two vertices s and t, where |V | = n. Also, s and t

are denoted as starting-node and terminal-node respectively.

Output Yes, if there is a path from s to t in G

No, otherwise

1.1 Overview and Motivation

REACH faithfully abstracts the notion of space complexity in computation. This connection be-

comes explicit if we consider the set of all configurations that a space bounded Turing machine

can be in while solving a problem. Indeed, the configurations, which are represented by vertices

are connected by a direct edge if the Turing machine under consideration makes the move in one

step. Checking whether the Turing machine accepts an input is exactly solving the reachability

problem in the configuration graph from the start configuration to the accepting configuration.

In the case of directed graphs, the problem exactly captures the non-deterministic logarithmic

space computation, making REACH NL-complete under log-space reductions 1, as the config-

uration graph can be constructed using log-space (in the size of the input). Hence establishing

an deterministic log-space algorithm to solve this problem is, arguably, one of the central prob-

lems in space complexity theory. An intermediate step to establishing log-space algorithm for

reachability is that of establishing an unambiguous non-deterministic log-space algorithm for

the problem.

In this section, we will give a brief overview of the two potential approaches to bring down

the space complexity of REACH and the motivation behind, us choosing these particular direc-

tions.

1.1.1 Weighting Schemes and NL vs UL Problem

A weighting scheme w : E → N, is a map from the edge set of a graph to natural numbers. If a

weighting scheme for a graph class A, transforms the graphs such that they satisfy a particular

property B, then we call such a weighting scheme, a B weighting scheme for A graphs.

Some important weighting schemes which will be used in the thesis are defined below :

• A weighting scheme that maps the edges of a graph G such that there is a uniqueminimum-weight path from s to any vertex v, is said to be min-unique weighting schemefor G w.r.t vertex s. Here, the property B is, "min-unique w.r.t. s".

• A weighting scheme that maps the edges of a graph G such that there are at most c(where c is a known constant) minimum-weight paths from s to any vertex v, is said tobe min-const weighting scheme for G w.r.t vertex s.

• A weighting scheme that maps the edges of a graph G such that there are at most nc

(where c is a known constant) minimum-weight paths from s to any vertex v, is said tobe min-poly weighting scheme for G w.r.t vertex s.

1All the reductions that we will mention in the thesis will be log-space reductions, and all the completenessresults we will mention will be of class NL, unless stated otherwise.

2

From here onwards, we will use the terms, min-unique, min-const and min-poly for the

weighting schemes which are min-unique, min-const and min-poly w.r.t. the starting-node s,

respectively.

Allender and Reindhart [25] gave a UL algorithm for testing reachability in graphs which

are augmented with min-unique weighting schemes. This implies that if we construct a UL-

computable min-unique weighting scheme for any graph class, then the REACH problem for

that graph class will be in the complexity class UL. Till date no such weighting scheme has

been designed for directed graphs.

A potential approach towards putting REACH for directed or any other graph class in the

complexity class UL is, ease the "unique" factor in the weighting scheme to "const" or "poly",

as designing a min-const or a min-poly weighting scheme seems to be an easier task.

1.1.2 Planar Version of Reduction to Graph Isomorphism

Two graphs G(V,E) and H(V ′, E ′) are isomorphic to each other if there exists a bijective

mapping f : V → V ′ such that, (u, v) ∈ E ⇐⇒ (f(u), f(v)) ∈ E ′. A graph G(V,E) is said

to possess a automorphism if there exists a non-trivial bijective mapping f : V → V such that,

(u, v) ∈ E ⇐⇒ (f(u), f(v)) ∈ E.

The problem of finding out, whether or not two given graphs are isomorphic to each other, is

known as Graph Isomorphism or GI. The problem of finding out, whether or not a given graph

possesses a non-trivial automorphism, is known as Graph Automorphism or GA. One other

variation of GA is COLOR-GA, where along with the input, a non-trivial bijective mapping

from a proper subset X of V to itself is given, and the input is a yes instance if and only if

there exists a automorphism which abides by input mapping, i.e. vertices of set X are mapped

in accordance with the input mapping. Note, that if such an automorphism exists, it will be

3

non-trivial, as the input mapping is non-trivial.

There is a simple reduction from COLOR-GA to GI. For a input (G,f ), output (G′, G′′)

such that G′ and G′′ are two modifications of G. Start with G′ = G′′ = G, and for each ith

mapping entry (x, y) in f , add one cycle of size n + i on x in G′ and one on y in G′′. Now,

it is easy to see that for each entry (x, y) in f , x ∈ G′ is forced to map with y ∈ G′′ (because

of the unique sized cycles attached to them) in any isomorphism. Any such isomorphism is

equivalent to some automorphism of G which abides by f , and vice-versa.

Toran gave a reduction from REACH to COLOR-GA [30], proving the NL-hardness of GI

(as we have seen that COLOR-GA reduces to GI). NL-completeness of GI is still unknown.

But, the problem of GI for planar graphs, also known as PLANAR-GI, is in the class L [8]. One

obvious way to construct a log-space algorithm for REACH for planar graphs, also known as

PLANAR-REACH, is to try planarizing the reduction given by Toran. This planarization will

make sure that PLANAR-REACH reduces to PLANAR-GI (as we can be see that, the reduction

from COLOR-GA to GI also preserves planarity), and will be in the class L.

1.2 Preliminaries

1.2.1 Graph Theoretic Preliminaries

A graph is defined as an ordered 2-tuple (V,E), where V is a non-empty set. The elements of

V are known as the vertices or nodes of G and elements of E are known as the edges of G.

An edge e is a 2-tuple (u, v), where u and v both belong to the set V . u and v are called the

endpoints of e and e is said to be incident on u and v. Both these vertices are said to be adjacent

to each other.

In case of undirected graphs, each edge is an unordered pair of vertices, whereas in case of

4

directed graphs, each edge is an ordered pair of vertices. In an edge e = (u, v) of a directed

graph, u is known as the source vertex of e and v is known as the destination vertex of e. e is

denoted as an incoming edge for vertex v and an outgoing edge for vertex u. u is denoted as an

in-neighbour of v and v is denoted as an out-neighbour of u.

The degree of a vertex in an undirected graph, is the number of edges that are incident on it.

In case of a directed graph, there are two types of degrees associated to a vertex. The first one

is called the indegree, which is the number of edges for which the vertex acts as a destination

vertex. The second one is called the outdegree, which is the number of edges for which the

vertex acts as a source vertex.

A path in a graph is a sequence of vertices, such that there exists an edge from each veretx

to its succeeding vertex in the sequence. In case of directed graphs, the edges should be in the

direction of the succeeding vertex, i.e. the succeeding vertex should be the destination vertex.

A vertex v is reachable from a vertex u if there exists a path from u to v.

A cycle is a path where the sequence starts and ends at the same vertex. The paths and

cycles are called simple, if no two vertices in the sequence are same, exception being the first

and last vertices of a cycle. A graph is said to be acyclic if it contains no cycles. A directed

graph with no cycles is called directed acyclic graph or DAG.

A graph is called layered, if there exists a partitioning of the vertices and an ordering of the

parts, such that any edge with its source vertex in some part X must have its destination vertex

in the part which is the successor of X in the ordering. Each part in the partition is called a

layer.

In a weighted graph, each edge is given a numeric value, which is known as its weight. A

graph which is not weighted is called unweighted. In a weighted graph, weight of a path (or

cycle) is the sum of the weights of the edges in the path (or cycle). In an unweighted graph,

5

length of a path (or cycle) is the number of edges in the path (or cycle).

A graph is said to be planar, if there exists an embedding of its vertices and edges on a plane

such that no two edges cross each other. A graph is called 2-D grid graph or simply grid graph,

if its vertices lie on a 2-dimensional grid, and all the edges are of the type ((a, b), (a ± 1, b))

or ((a, b), (a, b ± 1)). One can see that a grid graph is a planar graph with a special type of

embedding. In a 3-D grid graph, the vertices lie on a 3-dimensional grid, and all the edges

are of the type ((a, b, c), (a ± 1, b, c)), ((a, b, c), (a, b ± 1, c1)) or ((a, b, c), (a, b, c ± 1)). A

3-D grid graph is called monotone, if none of the edges are of the type ((a, b, c), (a-1, b, c)),

((a, b, c), (a, b-1, c)) or ((a, b, c), (a, b, c-1)).

For a graph G(V,E) with |V | = n, graph adjacency matrix is a n×n matrix, with columns

and rows numbered from 0 to n − 1. The entry (i, j) is 1, if there is an edge from vertex i to

vertex j, else it is 0. In all the problems in this thesis the input graph will be given in the form

of its adjacency matrix. The label of a vertex is the column-number (or row-number) of the

graph adjacency matrix represented by it.

1.2.2 Some Space Complexity Classes

We introduce the basic complexity classes and related notations that the rest of this thesis will

use.

• L: It is the class of decision problems solvable by a deterministic TM, which takesO(log n) space on its work tape, where n is the size of the input. We call such a ma-chine, deterministic log-space TM.

• NL: It is the class of decision problems solvable by a non-deterministic TM, which takesO(log n) space on its work tape. We call such a machine, a non-deterministic log-spaceTM.

• UL: It is the class of decision problems solvable by a non-deterministic TM, which takesO(log n) space on its work tape and for every input, has at most one computational pathwhich accepts the input. We call such a machine, an unambiguous log-space TM.

6

• FewUL: It is the class of decision problems solvable by a non-deterministic TM, whichtakesO(log n) space on its work tape and for every input, has at most one computationalpath to any of the accept configurations. Note, that in any log-space TM, the total numberof configurations is polynomially many (in the size of the input).

• FewL: It is the class of decision problems solvable by a non-deterministic TM, whichtakes O(log n) space on its work tape, and for every input, has at most polynomial many(in the size of the input) computational paths which accepts the input. Note, that in anon-deterministic log-space TM, there can be exponentially many computational pathswhich accept the input.

Figure 1.1: Class Hierarchy

The following can be drawn from the definitions.

L ⊆ UL ⊆ FewUL ⊆ FewL ⊆ NL (See figure 1.1).

1.3 Contribution of the Thesis

In this thesis, we explore two potential approaches to reduce the complexity of REACH for

directed graphs and some other important graph classes.

We improve the UL algorithm by Allender and Reindhart [25], to make it work for REACH

in graphs augmented with min-const weighting schemes. As our main contribution, we further

make progress on this algorithmic front by relaxing the restriction on the number of minimum-

7

weight paths from constant to polynomially many, i.e. relaxing the weighting scheme require-

ment to min-poly. The main technique that is used in this context is a triple inductive counting

technique (generalizing [25]) and a hashing technique given by Fredman, Komlós and Sze-

merédi [13]. (which was also used in [14]).

An important comparison of our results is with that of [14]. In [14], it is shown that REACH

for graphs such that, for any vertex v, there are at most polynomially many paths from s to v,

log-space many-one reduces to REACH for graphs such that, for every vertex v, there is at most

1 path from s to any vertex v. Note that the weighting scheme that assigns 1 to every edge is

min-poly for these classes of graphs. However, notice that this is only a very special case of

min-poly weighting schemes. Indeed, in a graph augmented with a min-poly weighting scheme,

in general, there can be a vertex v such that there are exponentially many paths from s to v, but

still only polynomially many minimum-weight paths from s to v.

We will discuss a possible attempt for designing a log-space algorithm for PLANAR-REACH,

which uses Toran’s reduction [30]. Then we will prove that, using this reduction (or similar re-

ductions) to give an L algorithm for PLANAR-REACH will imply that L = NL. We will also

prove that this reduction introduces both K3,3 and K5 as minors in the resultant graph, and

thus makes it non-planar. So, an alternate planar reduction is required for the attempt to be a

success.

1.4 Organization of the Thesis

This thesis is organized into 5 chapters. Current chapter is an introduction to the thesis. It

contains the overview of the two potential approaches to reducing the complexity of REACH

for different graph classes. Here, we also defined some graph theoretic preliminaries and some

important space complexity classes, which will be used throughout this thesis.

8

In Chapter 2, we will present a survey of the previous important works done towards these

approaches. Also, we will give details of some very important proofs. This chapter will be very

important because it will form the basis for the next two chapters, where we will present our

results in full detail. In Chapter 3, we will give the details of the improvements we made in the

direction of the first approach. Each section will be a buildup on the previous one, improving

the result of the preceding section. In Chapter 4, we will give the details of the second approach

and will prove negative results for the same.

Finally, Chapter 5 will conclude the thesis and will list some interesting open problems in

both the directions.

9

CHAPTER 2

LITERATURE SURVEY

In this chapter, we will present a survey of all the results from past, which will help in proper

understanding of the two approaches. Our work is a buildup on some of these results. First,

we will give a status of REACH for different graph classes. Then, we will describe the UL

algorithm given by Allender and Reinhardt [25] for REACH in graphs augmented with min-

unique weighting schemes. Then, before moving to the second attempt, we will talk about

the status of GI for some important graph classes. Finally, we will give the details of Toran’s

reduction of REACH to GI [30].

2.1 REACH and Different Graph Classes

In this section, we briefly survey the research that has been done on the reachability problem.

The problem is known to be complete for NL in the case of directed graphs. By Savitch’s theo-

rem [26], the problem is known to be solvable in O(log2 n) space deterministically. However,

this algorithm does not run in polynomial time. It is long-standing open question whether there

is a polynomial time and poly-logarithmic space deterministic algorithm for solving reachabil-

ity problem.

REACH for directed graphs reduces to REACH for DAGs, making the latter NL-complete.

This reduction is easy to see. For each vertex v in the input graph G, introduce n new vertices

(v, 1), (v, 2), . . . (v, n) (each labeled using two coordinates) in the output graph G′. For each

edge (x, y) in G, for (i = 1 to n-1) introduce an edge ((x, i), (y, i+1)) in G′. Its easy to see that,

for any x and y, if there is a l-length path from x to y in G, then there will be a l-length path

from (x, 1) to (x, l+1) in G′, and vice-versa. So, if y is reachable from x in G, then (y, i) for

some i will be reachable from (x, 0) in G′, and vice-versa. For each vertex x in G, add edges

to create a path ((x, 0), (x, 1), . . . (x, n)). These new paths are just connecting all the vertices

with the same first coordinate, and not introducing any new paths between vertices with distinct

first coordinate. These new paths will make sure that if y is reachable from x in G, then (y, n)

will be reachable from (x, 0) in G′, and vice-versa. So, make the vertex (s, 0) the new starting

vertex, and the vertex (t, n) the new terminal vertex. G′ has no cycles because all edges have

greater second coordinate in the destination vertex than that in the source vertex. Edges never

come back to vertices with lower second coordinate.

REACH for DAGs further reduces to REACH for special kind of DAGs, where indegree of

all the vertices is at most 2. We will denote such a DAG by 2in-DAG. This makes REACH

for 2in-DAGs also NL-complete. For this reduction, replace any node of the input DAG with

indegree k > 2, by two new nodes with a new edge between them. The new node which is

source for the new edge will act as the source for the first k − 1 incoming edges of the original

node. The second new node which is the destination of the new edge, will also act as the

destination for the kth incoming edge of the original node, and will act as the source for all

the outgoing edges of the original node. So, we have created two new nodes with indegrees

2 and k-1, without introducing any cycles and without affecting the reachability between any

two nodes in the original DAG. So, keep repeating this procedure until the indegree for all the

nodes in the final graph becomes at most 2.

We survey the problem for restricted graph families. The reachability problems for directed

forests, undirected forests, directed trees and graphs where all vertices have out-degree at most

one are L-complete [7]. REACH for undirected graphs was proved to be in L [24], and is thus L-

complete. If the width of a layered graph is constant (width is the maximum number of vertices

11

in any layer), and even five, and even when the out-degree is 1, the reachability problem on

such problems are known to be complete for the class NC1 [4].

Planar Graphs: When we restrict to directed planar graphs, the problem is hard for L under

projections. This has been an important version of the reachability problem studied by several

authors [16, 12, 15]. It is an open problem in the area to design a deterministic log-space

algorithm for this problem. Recently there has been several works (see [31] for a detailed

survey) on designing simultaneous sub-linear space and polynomial time algorithm for planar

reachability problem.

Many restricted versions of directed planar graphs have been shown to be in L. Reacha-

bility on series-parallel graphs which forms an important subclass of planar graphs is known

to be L-complete [18]. When the planar DAG is restricted to have only one sink-vertex (or

symmetrically only one source-vertex), the problem is known to be in L [2]. This result was

extended to two sources. Later, Stolee et al [28] extended this toO(log n) sources (also known

as few-sources). The case of multiple sinks and multiple sources, which indeed is same as the

class of general planar graphs, is open.

To attack a simpler questions first, it is natural to ask if we can design better non-deterministic

algorithms for the reachability problem on directed planar graphs (or even planar DAGs) 1.

In this context, the unambiguous non-deterministic algorithm is studied. The main question

in this direction was - can we design an unambiguous non-deterministic log-space algorithm

for solving reachability on directed acyclic planar graphs? The question was answered posi-

tively through a sequence of two results. Allender and Reiheart [25] designed a UL-algorithm

for graphs augmented with min-unique weighting schemes. Complementing this, a log-space

1It is not known whether directed planar reachability problem log-space reduces to directed planar DAG reach-ability problem. The reduction from general reachability to DAG reachability described above does not preserveplanarity.

12

computable min-unique weighting scheme was designed for grid graphs in [6], proving both

PLANAR-REACH and REACH for grid graphs to be in UL.

It is known that generalizing this to the three dimensional grid graphs itself will show that

NL = UL. Indeed, REACH for directed graphs reduces to REACH for 3-D monotone grid graphs

[6], making it NL-complete.

To end the section, we list down the restrictions on reachability and their corresponding

complexity bounds.

Graph Class Complexity Bound Remark and ReferencesUndirected L-complete [24]Directed Forest L-complete [7]Directed Acyclic Graphs NL-complete Folklore.Grid Graphs in UL [6]Planar Graphs in UL [2] [6]Single(Double)-Source Planar DAGs L-complete [2]Few-Source Planar DAGs L-complete [28]Series Parallel graphs L-complete [18]

Table 2.1: Complexity of Reachability for Restricted Graph Classes

2.2 UL Algorithm for MIN-UNIQUE REACH

In this section we will describe the UL algorithm given by Allender and Reinhardt[25] to

solve REACH for graphs augmented with min-unique weighting schemes. We can also apply

a weighting scheme on a graph in log-space (provided the weights assigned by the weighting

scheme are not more than polynomial in their value). Replace each edge e by a simple path of

length equal to the weight w(e) of the edge, given by the weighting scheme. The path should be

in the same direction as the edge. Now, its easy to see that for this resultant graph the weighting

scheme which gives weight 1 to all the edges is an min-unique weighting scheme, if and only

if the initial weighting scheme was min-unique for the input graph. We call such a graph a

13

MIN-UNIQUE GRAPH. Similarly, we can also apply a min-constant or a min-poly weighting

scheme on a graph in log-space, making it a MIN-CONSTANT GRAPH or a MIN-POLY GRAPH,

respectively.

So, from now onwards our input will be a MIN-UNIQUE GRAPH and not a graph augmented

with a min-unique weighting scheme.

Before we describe the algorithm we will define some terms and terminologies :

• d(v) : Length of a shortest s v path

• Node(s) within level-k : Node(s) with d(v) ≤ k

• Node(s) in level-k : Node(s) with d(v) = k

• ck : Number of nodes within level-k

• Σk : Sum of d(v)s of nodes within level-k

• A Graph is min-unique upto level-k : All nodes with d(v) ≤ k has exactly one minimumlength path

• Similarly, we can define graphs which are min-constant or min-poly upto level-k.

Idea:

First, we design an unambiguous log-space routine TEST-UNIQUE which returns d(v) ≤ k

(in at most one non-deterministic path), assuming that the correct values of ck and Σk are given

and that the input graph is min-unique upto level-k.

Using TEST-UNIQUE as a subroutine, the routine UPDATE-UNIQUE computes inductively

the values of ck+1 and Σk+1, given that the input graph is min-unique upto level-k and the

correct values of ck and Σk are known. Here, we also check if the input graph is min-unique

upto level-(k+1) or not. If it is not, then we reject.

We know that the input graph is min-unique upto level-0 and we also know the correct

values of c0 and Σ0. So, in MAIN-UNIQUE we will use the above routines to compute cn−1

14

and Σn−1 and verify that the graph is min-unique upto level-(n-1), i.e. it is a MIN-UNIQUE

GRAPH. Once, this is done we will check whether t is reachable from s or not. If reachable,

we will accept.

Algorithm:

Here we give a UL algorithm for :

MIN-UNIQUE REACH = { (G(V,E), s, t) | G is min-unique and ∃s t path}

Algorithm 1 MAIN-UNIQUE: Main UL routine for MIN-UNIQUE REACH

1: Input: (G, s, t)

2: k := 1

3: c0 := 1; Σ0 := 0

4: (c1,Σ1) = UPDATE-UNIQUE(G, s, 0, c0,Σ0)

5: while k < n− 1 and (ck−1,Σk−1) 6= (ck,Σk) do

6: (ck+1,Σk+1) = UPDATE-UNIQUE(G, s, k, ck,Σk)

7: k := k + 1

8: end while

9: if TEST-UNIQUE(G, s, t, k, ck,Σk) then

10: ACCEPT

11: else

12: REJECT

13: end if

15

Algorithm 2 UPDATE-UNIQUE: Deterministic (barring TEST-UNIQUE calls) routine for com-puting ck+1 and Σk+1

1: Input: (G, s, k, ck,Σk)

2: Output: ck+1,Σk+1

3: ck+1 := ck; Σk+1 := Σk

4: num := 0;

5: for v ∈ V do

6: if ¬(TEST-UNIQUE(G, s, v, k, ck,Σk)) then

7: for x such that (x, v) ∈ E do

8: if TEST-MIN(G, s, x, k, ck,Σk) then

9: num := num+ 1

10: end if

11: if num > 1 then

12: REJECT

13: end if

14: end for

15: if num = 1 then

16: ck+1 := ck+1 + 1; Σk+1 := Σk+1 + k + 1

17: end if

18: end if

19: end for

16

Algorithm 3 TEST-UNIQUE: UL routine to check if d(v) ≤ k

1: Input: (G, s, v, k, ck,Σk)

2: count := 0; sum := 0; path.to.v := false;

3: for x ∈ V do

4: Nondeterministically guess whether d(x) ≤ k

5: if the guess in Line 4 is that d(x) ≤ k then

6: Nondeterministically guess 0 ≤ ` ≤ k

7: Nondeterministically guess a path of length ` from s to x

8: if (the path is not valid) then

9: REJECT

10: end if

11: count := count+ 1; sum := sum+ `

12: if x = v then

13: path.to.v := true;

14: end if

15: end if

16: end for

17: if count = ck and sum = Σk then

18: Return path.to.v

19: else

20: REJECT

21: end if

Proof of correctness:

Here we present the proof of correctness of the above algorithm in full detail. The proof

structure is different than that of [25], and will motivate the proof structure used in the next

17

chapter.

Claim 1 If G is min-unique upto level-k and correct values of ck and Σk are given, the al-

gorithm TEST-UNIQUE has exactly one non-rejecting path, and it returns the correct boolean

value of “d(v) ≤ k?”.

Proof We argue that ∀x ∈ V , there is a unique way to guess the answer to “d(x) ≤ k?”

and the value of `, such that the equalities count = ck and sum = Σk are satisfied. It can be

analyzed by cases :

• If the algorithm, in a non-deterministic path, guesses d(x) ≤ k for some vertex x forwhich d(x) > k, then it will not be able to guess any path of length ≤ k, and hencewill end up rejecting in that non-deterministic path. If it guesses d(x) > k for somevertex x for which d(x) ≤ k, it will not increment count. But then, to compensate thisloss, for count to reach ck, the algorithm, in this non-deterministic path, will have toguess d(y) ≤ k for some vertex y for which d(y) > k, and hence will reject in thisnon-deterministic path.

• If the algorithm, in a non-deterministic path, guesses ` < d(x) for any vertex x, thenit will not be able to find a path of such length and hence will end up rejecting in thatnon-deterministic path. If it guesses ` > d(x), then to compensate, it will have to guess` < d(y) for some other vertex y, and hence will reject in that non-deterministic path.

Hence, only the path in which, for each vertex x, the correct answer to “d(x) ≤ k?” is

guessed and the guessed value of ` is equal to d(x) (if d(x) ≤ k), will be a non-rejecting path

and will return the correct answer of “d(v) ≤ k?”.

Claim 2 If G is min-unique upto level-k and correct values of ck and Σk are given, the algo-

rithm UPDATE-UNIQUE runs deterministically barring the calls to the routine TEST-UNIQUE,

and computes the correct values of ck+1 and Σk+1. It also rejects if G is not min-unique upto

level-(k+1).

18

Proof The algorithm first assigns ck+1 := ck and Σk+1 := Σk. Now, to update these values

we need the exact set of vertices with d(v) = k + 1, i.e. the vetices in level-(k + 1). The

algorithm, for each v, checks if d(v) > k. If the check is passed, then for each of v’s neighbour

x, the algorithm checks if d(x) ≤ k. For the neighbours passing this test, we know that

d(x) = k. If more than one neighbours pass the test, the algorithm rejects as G is not min-

unique upto level-(k+1). If any of the neighbour passes the test and num = 1 (line 15),

d(v) = k+ 1. Hence, ck+1 is incremented by 1 and Σk+1 is incremented by k+ 1. Hence, both

the parameters get updated correctly and hence the proof.

Observation 1 Observe that, since G is min-unique upto level-0 and we begin with the correct

values of c0 and Σ0, by induction, Claims 1 and 2 imply that the values of ck and Σk calculated

after every iteration of while-loop (lines 5 to 8) in the MAIN-UNIQUE algorithm are always

correct. Also, the iteration ends without rejecting, if and only if the graphG is min-unique upto

level-k.

Theorem 1 The algorithm MAIN-UNIQUE has at most one path to ACCEPT state. It has

exactly one path to ACCEPT state if and only ifG is a MIN-UNIQUE GRAPH and t is reachable

from s.

Proof Using Observation 1 and Claim 1, we know that there is exactly one non-rejecting

path in each call to TEST-UNIQUE. Thus, there is exactly one non-rejecting path in each call

to UPDATE-UNIQUE, as UPDATE-UNIQUE is deterministic barring the calls to TEST-UNIQUE.

Similarly, there is exactly one non-rejecting path in MAIN-UNIQUE, as MAIN-UNIQUE is de-

terministic barring the calls to UPDATE-UNIQUE. If G is not min-unique, one of the calls to

UPDATE-UNIQUE (line 6) will lead in rejection. If G is min-unique, the while-loop (lines 5 to

8) will terminate without rejecting. If t is indeed reachable from s, this non-rejecting path goes

to the state ACCEPT (line 10). If t is not reachable from s, this path rejects (line 12).

19

Remark:

By making two small changes, we can also make this algorithm to work for

MIN-UNIQUE REACH [25].

• Instead of rejecting, accept at the point where you find that G is not min-unique (line 12in UPDATE-UNIQUE algorithm). It can be easily seen that if G is not min-unique, we areaccepting unambiguously (when the while-loop in MAIN-UNIQUE reaches the first levelupto which G is not min-unique, at lexiographically first vertex in that level with morethan one minimum-length paths the algorithm UPDATE-UNIQUE will accept).

• Also, we will accept in MAIN-UNIQUE when t is not reachable from s (line 12), andwill reject if t is reachable from s (line 10). This change will make sure that the algo-rithm rejects the MIN-UNIQUE GRAPHS having s t paths. So, it will only accept(unambiguously) if the input graph is min-unique, and t is not reachable from s.

Now, MIN-UNIQUE REACH is also in the complexity class coUL as a consequence of the

above algorithm. This proves, MIN-UNIQUE REACH ∈ UL ∩ coUL.

2.3 Weighting Scheme Design for Grid Graphs

There are two important consequences of the UL upper bound for MIN-UNIQUE REACH de-

scribed in the previous section. Reinhardt and Allender used their result to prove that NL and UL

are equal in non-uniform setting, i.e. NL/poly = UL/poly [25]. Strengthening the result, Pavan

et al [23] showed that NL = UL if and only if there is a polynomially-bounded UL-computable

MIN-UNIQUE weighting scheme for DAGs.

More importantly, Allender et al [2] proved that reachability for planar graphs reduces to

reachability for grid graphs. Later Bourke, Tewari and Vinodchandran [6] came up with a log-

space computable min-unique weighting scheme for Grid Graphs. This shows that reachability

for planar graphs is in UL. We will briefly describe this scheme below.

Weighting Scheme : The graph that are considered here are n× n grid graphs. The edges are

20

given weights according to the following scheme:

n4 to edges going in east and west direction.

i+ n4 to upward edges in column i.

−i+ n4 to downward edges in column i.

It is easy to see that this weighting scheme is log-space computable. To show the property

of min-uniqueness : the main observation used in [6] is that the scheme ensures that any simple

directed cycle in the input graph will have a weight equal to the number of squares of the grid

it encloses. Using this, they show that the existence of two or more minimum-weight paths

between any two vertices in the graph will contradict the minimality of the weight of the paths,

thus proving that the minimum-length path between any two vertices in the graph is unique.

Notice that the weighting scheme is very specific to 2-dimensional grids. The above weight-

ing scheme can be shown to be not min-unique, even on 3-D grid graphs. However, it does not

rule out the possibility of a different weighting scheme working in the case of 3-D Grid graphs.

As observed in [6], if we extend it even to a special case of 3-D grid graphs (called three

dimensional monotone grid graphs), even then NL = UL.

2.4 GI and Different Graph Classes

In this subsection, we review the literature related to our approach to reachability problem

based on the graph isomorphism problem. As mentioned in the introduction, an intriguing

situation arises in the setting of planar graphs - namely that the seemingly harder problem of

graph isomorphism is in L for planar graphs and the the reachability problem for the same class

of graphs is not known to be in L. As we mentioned, there is a reduction from GI to REACH,

in the case of general graphs. In this section, we will be reviewing the same.

21

P is the class of decision problems solvable by deterministic TMs that run in time poly-

nomial in the size of the input. NP is the class of decision problems solvable by a non-

deterministic TM that run in time polynomial in the size of the input. It is known that,

NL ⊆ P ⊆ NP. The first containment follows by the fact that REACH can be solved in polyno-

mial time by using Depth First Search (considering s as the root). The second containment can

be drawn form the definitions.

It is easy to see that the graph isomorphism problem (GI) for general graphs is NP. Cur-

rently, no deterministic polynomial time algorithm for this problem is known. Also it is known

that, if GI is NP-complete under polynomial time many-one reductions, then the polynomial

hierarchy PH will collapse down to the second level Σp2 (c.f.[19]). It is conceivable that GI is a

problem which is neither NP-complete nor does it has a P algorithm. Ladner proved that such

languages exist if P 6= NP[20].

In a recent development in the area, the PLANAR-GI problem is proved to be in L [8]. Soon

after this, GI for K3,3-minor free graphs and K5-minor free graphs is also proved to be in L

[10]. This is a very intriguing situation, that the problem (GI) which, in the case of general

graphs, seems to have relatively higher computational complexity than REACH - but in the case

of planar graphs, GI is in L where as REACH is not known to be.

2.5 Reduction from REACH to GI

As a consequence to the well known result NL = coNL [17, 29], REACH many-one reduces, in

log-space, to REACH. We have seen that REACH for general graphs can be reduced to REACH

for 2in-DAGs. The same reduction will reduce REACH for general graphs to REACH for 2in-

DAGs. We have also seen (Page 4) that COLOR-GA reduces to GI. So, for showing that REACH

reduces to GI, it is enough to give a reduction from REACH for 2in-DAGs to COLOR-GA. We

22

describe this reduction in the rest of this section.

In the input of REACH or REACH, we can always assume s to be a source vertex (vertex

with indegree 0), because in case it is not, then we can add a new vertex s′, add an edge from

s′ to s, and replace s with s′ in the input. We can without loss of generality assume that s is of

outdegree 1. Observe that if we replace each vertex of a 2in-DAG by a MOD-k gate except s and

the wire which starts at s is assigned the constant 1, 0 as the input to the input wires of all the

gates corresponding to source nodes other than s, then the output wire of the gate corresponding

to the vertex t will output 1 if the number of paths form s to t MOD-k (also known as output

of the circuit) is non-zero and 0 otherwise. We will call any gate corresponding to a vertex x as

gate x, and any gate corresponding to a source vertex as source gate.

Note that to check whether the input is in REACH or not, it suffices to check whether the

number of s t paths is 0 or not. We know that the number of s t paths is bounded by

2n. Using Chinese Remainder Theorem we can divide this check (x mod 2n ≡ 0) into n2

different checks, namely i = 1 to n2 : x mod i ≡ 0. So, make n2 copies of the input graph

and replace each gate in the ith copy by a MOD-i gate.

Now, the remaining task is to convert all of these n2 checks into the problem of membership

testing, in the set COLOR-GA. Toran introduced a gadget for MOD-i gate [30]. Replacing each

MOD-i gate (in all the n2 copies) with this gadget is the next step of the reduction. Before we

move further in the reduction, we will give the construction of the gadget.

Construction : Each MOD-i gate u with input wires x and y (input is bounded by 2), is re-

placed by i2 + 3i nodes, labeled by :

23

(x, 0), (x, 1), . . . (x, i-1) (corresponding to wire x);

(y, 0), (y, 1), . . . (y, i-1) (corresponding to wire y);

(z, 0), (z, 1), . . . (z, i-1) (corresponding to all the output wires);⋃j∈[0,i−1]{

⋃k∈[0,i−1](u, j, k)}

We will denote the set⋃k∈[0,i−1](u, j, k)} by packet-j).

Edges go from :

∀ j - (x, j) to each node in packet-j (call it the 1st set of edges);

∀ k − (y, k) to the nodes⋃k∈[0,i−1](u, i, k) (call it the 2nd set of edges);

∀ j, k − (u, j, k) to (z, (j + k) mod i) (call it the 3rd set of edges).

Applying the gadget : After replacing each MOD-i gate, do the following :

• For any wire going from gate u to gate v, if the wire is the first input wire of the gate v,connect the nodes corresponding to the output wire of u to the nodes corresponding tothe first input wire of the gate v (i.e. ∀k add a edge from the node (z,k) of u’s gadget tothe node (x,k) of v’s gadget).

• For any wire going from gate u to gate v, if the wire is the second input wire of the gatev, connect the nodes corresponding to the output wire of u to the nodes corresponding tothe second input wire of the gate v (i.e. ∀k, add a edge from node (z,k) of u’s gadget tonode (y,k) of v’s gadget).

Taking the union of the resultant graphs will complete the reduction from REACH for 2in-

DAGs to COLOR-GA. What remains is the output map of the COLOR-GA instance. Below we

describe the output map.

Output Map : The output map will be the union of the following maps -

• Map the nodes corresponding to the first input wire of the gate s, in a manner such thatthey are rotated by a factor 1.

• Map the nodes corresponding to the second input wire of the gate s, in a manner suchthat they are rotated by a factor 0.

24

Figure 2.1: Toran’s Gadget

• Map all the nodes corresponding to the first and second input wires of the other sourcegates, in a manner such that they are rotated by a factor 0.

• Map all the nodes corresponding to the second input wire of any gate which correspondsnodes with indegree 1, in a manner such that they are rotated by a factor 0.

• Map the nodes corresponding to the output wire of the gate t, in a manner such that theyare rotated by a factor 0.

This union is non-trivial as the nodes corresponding to the first input wire of the gate s are

rotated by a factor 1.

Theorem 2 ([30]) The union graph and the output map (described in the above reduction)

forms a valid instance of COLOR-GA if and only if the input graph of the reduction was a valid

instance of REACH for 2in-DAGs.

25

CHAPTER 3

MIN-CONST AND MIN-POLY GRAPHS

In this chapter, we will give an unambiguous non-deterministic log-space (UL) algorithm for

the problem of testing reachability in graphs augmented with a min-const weighting scheme.

Our main technique is a triple inductive counting, which generalizes the techniques of [17, 29]

and [25].

After this, we will give an improved version of this algorithm which also works for graphs

augmented with a min-poly weighting scheme. But, the complexity of this algorithm goes up to

FewUL. Here, we use a hashing technique due to [13] (also used in [14]). Further, combining

the above techniques with a complementary unambiguous verification method, we give a UL

algorithm for min-poly case.

3.1 UL Algorithm for MIN-CONST REACH

In this section, we introduce a modification of Allender and Reinhardt’s [25] algorithm, which

also works for MIN-CONST GRAPHS. To handle constant many minimum-length paths, we

introduce a new inductive parameter pk which stores the sum of the number of minimum length

paths from s to every vertex v which is within level-k. We denote by p(x), the number of

minimum-length paths from s to x. This means, pk =∑

d(x)≤k p(x).

Idea: In this algorithm we will also have to calculate the parameter pk inductively. This is

required because, now for each vertex x we have p(x) minimum-length paths, and unlike in

the case of MIN-UNIQUE GRAPHS now p(x) can be more than 1. So, while guessing the

minimum-length path to any vertex x, we can have more than one non-deterministic paths in

the algorithm TEST-UNIQUE which come up with valid minimum-length s x paths in G.

So, now in the new algorithm TEST-CONST, every time when we have to guess a minimum-

length path to some vertex x, we will guess p(x) and then guess p(x) many minimum-length

paths. Also in this new algorithm, we will return the value p(v) if v is within level-k, and 0 if

v is not within level-k. Note, that in the previous algorithm, we were just returning a boolean

value. We will maintain a order while guessing p(x) paths, so that the guessing procedure is

unambiguous. Finally, we will verify that for each vertex x, the guessed value of p(x) is indeed

correct.

Guessing Constant Paths Unambiguously in Log-space:

Here, we will guess q s x paths of length `.

• A ` length path π is lexiographically greater than another `-length path π′ if at the firstvertex where both the paths differ (starting from the start vertex s), π has vertex withhigher label than π′.

• Take q log n+ log `+ q − 1 bits (all initialized to 0) from the empty part of the tape.

• The first q slices of log n bits will contain the current nodes of the q paths (all initializedto log n zeros, i.e. node s).

• The next log ` bits contain the counter of the current path length for all the q paths beingguessed.

• The ith bit of the last q − 1 bits will indicate, whether or not ith path is lexiographicallygreater than i+ 1st path (according to the guessing done so far).

• Non-deterministically keep guessing next nodes for all the q paths. Each time replace thecurrent q nodes by the next q nodes, in the q slices. After every such guess increase thecounter contained in the log ` bits by 1.

• Update the last q − 1 bits, every time you guess a next node for some path. Make ith bit1 at the very first time when the next node in ith path is lexiographically greater than thatof i+1st path. Once ith bit is made 1, the next nodes guessed in ith and i+1st paths neednot follow any order. But, before the iteration where ith bit is made 1, same next nodeshave to be guessed for both the paths.

• Before all the ` + 1 nodes have been guessed for all the paths, all the q − 1 bits shouldbecome 1 (as we are guessing q distinct paths of length `). ` + 1st node for all the pathsshould be x.

27

Algorithm: Here we give a UL algorithm for :

MIN-CONST REACH = { (G(V,E), s, t) | ∃s t path and ∀v ∈ V, p(v) ≤ c}.

Algorithm 4 MAIN-CONST: Main UL routine for MIN-CONST REACH

1: Input: (G, s, t)

2: k := 1

3: c0 := 1; Σ0 := 0; p0 := 1

4: (c1,Σ1, p1) = UPDATE-CONST(G, s, 0, c0,Σ0, p0)

5: while k < n− 1 and (ck−1,Σk−1, pk−1) 6= (ck,Σk, pk) do

6: (ck+1,Σk+1, pk+1) = UPDATE-CONST(G, s, k, ck,Σk, pk)

7: k := k + 1

8: end while

9: if TEST-CONST(G, s, t, k, ck,Σk, pk) > 0 then

10: ACCEPT

11: else

12: REJECT

13: end if

28

Algorithm 5 UPDATE-CONST: Deterministic (barring TEST-CONST calls) routine for com-puting ck+1, Σk+1 and pk+1

1: Input: (G, s, k, ck,Σk, pk)

2: Output: ck+1,Σk+1, pk+1

3: ck+1 := ck; Σk+1 := Σk; pk+1 := pk;

4: num := 0;

5: for v ∈ V do

6: if TEST-CONST(G, s, v, k, ck,Σk, pk) = 0 then

7: for x such that (x, v) ∈ E do

8: num := num+ TEST-CONST(G, s, x, k, ck,Σk, pk);

9: if num > c then

10: REJECT

11: end if

12: end for

13: if num > 0 then

14: ck+1 := ck+1 + 1; Σk+1 := Σk+1 + k + 1; pk+1 := pk+1 + num;

15: end if

16: end if

17: end for

29

Algorithm 6 TEST-CONST: UL routine to compute the number of paths to v1: Input: (G, s, v, k, ck,Σk, pk)

2: count := 0; sum := 0; paths := 0; paths.to.v := 0;

3: for x ∈ V do

4: Nondeterministically guess 0 ≤ q ≤ c

5: if q 6= 0 then

6: Nondeterministically guess 0 ≤ ` ≤ k

7: Nondeterministically guess q paths p1, p2, . . . pq of length exactly ` each from s to x.

8: if (the paths are not valid) then

9: REJECT

10: end if

11: count := count+ 1; sum := sum+ `; paths := paths+ q;

12: if x = v then

13: paths.to.v := q;

14: end if

15: end if

16: end for

17: if count = ck, sum = Σk and paths = pk then

18: Return the value of paths.to.v

19: else

20: REJECT

21: end if

Proof of Correctness:

Claim 3 If G is min-const upto level-k and correct values of ck,Σk and pk are given, the

algorithm TEST-CONST has exactly one non-rejecting path, and it returns the correct value of

30

p(v) if d(v) ≤ k and 0 if d(v) > k.

Proof We argue that ∀x ∈ V , there is a unique way to guess the values of q and `, such that

the equalities count = ck, sum = Σk and paths = pk are satisfied. We analyze this by cases :

• If the algorithm, in a non-deterministic path, guesses q 6= 0 (i.e. d(x) ≤ k) for somevertex x for which q = 0 (i.e. d(x) > k), then it will not be able to guess any path oflength ≤ k, and hence will end up rejecting in that non-deterministic path. If it guessesq = 0 (i.e. d(x) > k) for some vertex x for which q 6= 0 (i.e. d(x) ≤ k), it will have toguess q 6= 0 (i.e. d(y) ≤ k) for some vertex y for which q = 0 (i.e. d(y) > k), and hencewill reject in that non-deterministic path.

• Now, for the non-deterministic paths where q 6= 0, i.e. x is within level-k :– If the algorithm, in a non-deterministic path, guesses ` < d(x) for any vertex x,

then it will not be able to find a path of such length and hence will end up rejectingin that non-deterministic path. If it guesses ` > d(x), then to compensate, it willhave to guess ` < d(y) for some other vertex y, and hence will reject in that non-deterministic path.

– If the algorithm, in a non-deterministic path, guesses q > p(x) for any vertex x, thenit will not be able to guess q many paths, and hence will end up rejecting in that non-deterministic path. If it guesses q < p(x), then to compensate, it will have to guessq > p(y) for some other vertex y, and hence will reject in that non-deterministicpath.

Hence, only the path in which, for each vertex x, “q = 0?” (i.e. “d(x) ≤ k?”) is guessed

correctly, and the guessed value of q is equal to p(x) and ` is equal to d(x) (if q 6= 0), will be a

non-rejecting path and will return the correct value of p(v) if d(v) ≤ k and 0 if d(v) > k (as in

this case the if-condition at line 5 will not be satisfied).

Claim 4 If G is min-const upto level-k and correct values of ck,Σk and pk are given, the al-

gorithm UPADTE-CONST runs deterministically barring the calls to the routine TEST-CONST,

and computes the correct values of ck+1,Σk+1 and pk+1. It also rejects if G is not min-const

upto level-(k+1).

31

Proof The algorithm first assigns ck+1 := ck,Σk+1 := Σk and pk+1 = pk. Now, to update

these values we need the exact set of vertices with d(v) = k + 1, i.e. the vertices in level-

(k + 1). The algorithm, for each v, checks if d(v) > k and for each of its neighbour x, calls

TEST-CONST. If all the calls return 0, i.e. no neighbour is within level-k, we do not do anything

and move on to the next vertex. If the sum of the values returned by all the calls (which is being

stored in the variable num in line 8) is in the range 1 to c, pk+1 is incremented by this value,

ck+1 is incremented by 1 and Σk+1 is incremented by k + 1 (line 14). If at any point on line 8,

the variable num exceeds c we reject (line 10), as the input graphG is not MIN-CONST. Hence,

all the three parameters get updated correctly and hence the proof.

Observation 2 Observe that, since G is min-const upto level-0 and we begin with the correct

values of c0,Σ0 and p0 (we assume that there is 1 zero length path from s to s), by induction,

Claims 3 and 4 imply that the values of ck,Σk and pk calculated after every iteration of while-

loop (lines 5 to 8) in the MAIN-CONST algorithm are correct. Also , the iteration ends without

rejecting, if and only if the graph G is min-const upto level-k.

Theorem 3 The algorithm MAIN-CONST has at most one path to ACCEPT state. Additionally,

the algorithm has exactly one path to ACCEPT state if and only if G is a MIN-CONST GRAPH

and t is reachable from s.

Proof Using Observation 2 and Claim 3, we know that there is exactly one non-rejecting

path in each call to TEST-CONST. Thus, there is exactly one non-rejecting path in each call

to UPDATE-CONST, as UPDATE-CONST is deterministic barring the calls to TEST-CONST.

Similarly, there is exactly one non-rejecting path in MAIN-CONST, as MAIN-CONST is de-

terministic barring the calls to UPDATE-CONST. If G is not min-const, one of the calls to

UPDATE-CONST (line 6) will lead in rejection. If G is min-const, the while-loop (lines 5 to 8)

32

will terminate without rejecting. If t is indeed reachable from s, this non-rejecting path goes to

the state ACCEPT (line 10). It t is not reachable from s, this path rejects (line 12).

Remark: By making similar changes as in the case of MIN-UNIQUE REACH, we can also

make this algorithm to work for MIN-CONST REACH. Change the line 10 in UPDATE-CONST

algorithm to ACCEPT, and interchange the lines 10 and 12 in MAIN-CONST algorithm. This

new algorithm is a UL algorithm for MIN-CONST REACH. Thus, MIN-UNIQUE REACH ∈

UL ∩ coUL.

3.2 FewUL Algorithm for MIN-POLY REACH

In this section, we introduce a modification of the previous algorithm to work for MIN-POLY

GRAPHS. To handle polynomially many minimum-length paths we can’t guess them simulta-

neously, as we only have O(log n) space. So, to guess them in an unique order, we have to

assign each path a unique value, and then guess them one by one in some order corresponding

to the assigned values.

Ordering of Paths: For any `-length path π : s v, we define π(i) as the label of the ith

vertex of the path, and φ(π) =∑`

i=02ni+π(i). The bit representation of φ(π) is n × (` + 1)-

bits long and if we divide it into (` + 1) packets of n-bits each, ith packet has only the bit

corresponding to the position π(i) set to 1 and rest all the bits set to 0. Its easy to see that φ(π)

is unique for π.

Now, φ(π) is unique for π, but it takes polynomially many bits for representation. So, we

need a O(log n)-bit integer, i.e. an integer which is polynomial in n, and which for each of the

vertex v ∈ V , hashes perfectly, the φ(π) values of all the minimum-length s v paths.

We define another term, φm(π) = φ(π) mod-m. We say that any integer m is good for a

33

vertex v ∈ V , if no two minimum-length s v paths p1 and p2 satisfy φm(p1) = φm(p2). We

say that m is good for the graph G, if it is good for all v ∈ V . We say that m is k-good for G, if

it is good for all the vertices which are within level-k. The following proposition ensures that

there is always a polynomial sized good m.

Proposition 1 [13] For every constant c there is a constant c′ so that for every set S of n2-

bit integers with |S| ≤ nc there is a c′ log n-bit prime number m so that for all x, y ∈ S,

x 6= y =⇒ x 6≡ y mod m.

Guessing Paths in Lexicographic Order:

Our algorithm will require guessing paths to a vertex v and checking if the guessed paths

are in lexicographic order w.r.t. φm. Here, we outline a method of doing this in log-space.

Keep a counter c of log ` bits to keep track of how far we have traversed along a path. Ini-

tialize this to 0. Keep log n bits to store the current vertex ρ of the current path π. Let π′ be

the previous path. Keep two variables, δπ and δπ′ , of logm bits each. to store the interme-

diate value of φm(π) and previously calculated final value of φm(π′) respectively. Repeat the

following two steps until c reaches `. (1) δπ = (δπ + 2ρ) mod m (the factor 2ρ mod m can

be calculated in log-space by multiplying 2, ρ times and simultaneously performing mod m

every time). (2) Increment c and choose one of the ρ’s neighbour vertices non-deterministically

and replace ρ by this neighbour.

Setting δπ′ to δπ and setting δπ, ρ and c to 0, repeat the steps in the previous paragraph till

we have guessed all the q paths. Each time, before updating δπ′ , check if δπ is strictly less than

δπ′ . If not, reject there itself.

Idea: Here, if we have a good m, the algorithm goes as that in the case of MIN-CONST

GRAPHS, except a slight change in the step, where we are guessing the minimum-length paths

34

for any x. But, we are still faced with the problem of obtaining a good m. In the following

set of routines, we will guess the value of m and use it while simultaneously detecting if it is

good. Note that this routine will not be unambiguous any more, because there could be several

choices of m which are good for the given graph. However, each choice of m will lead to

exactly one accept state. Hence, we can label these accept configurations with their respective

choices of m, thus making it a FewUL routine.

Algorithm: Here we give a FewUL algorithm for :

MIN-POLY REACHc = { (G(V,E), s, t) | ∃s t path and ∀v ∈ V, p(v) ≤ nc}.

Algorithm 7 MAIN-POLY-FEW: Main FewUL routine for MIN-POLY REACH

1: Input: (G, s, t)

2: Non-deterministically guess 2 ≤ m < nc′

3: k := 1

4: c0 := 1; Σ0 := 0; p0 := 1

5: (c1,Σ1, p1) = UPDATE-POLY(G, s, 0, c0,Σ0, p0,m)

6: while k < n− 1 and (ck−1,Σk−1, pk−1) 6= (ck,Σk, pk) do

7: (ck+1,Σk+1, pk+1) = UPDATE-POLY(G, s, k, ck,Σk, pk,m)

8: k := k + 1

9: end while

10: if TEST-POLY(G, s, t, k, ck,Σk, pk,m) > 0 then

11: Go to ACCEPT-m

12: else

13: REJECT

14: end if

35

Algorithm 8 UPDATE-POLY: Deterministic (barring TEST-POLY calls) routine computingck+1, Σk+1 and pk+1

1: Input: (G, s, k, ck,Σk, pk,m)

2: Output: ck+1,Σk+1, pk+1

3: ck+1 := ck; Σk+1 := Σk; pk+1 := pk;

4: num := 0;

5: for v ∈ V do

6: if TEST-POLY(G, s, v, k, ck,Σk, pk,m) = 0 then

7: for x such that (x, v) ∈ E do

8: num := num+ TEST-POLY(G, s, x, k, ck,Σk, pk,m);

9: if num > nc then

10: REJECT

11: end if

12: end for

13: if num > 0 then

14: ck+1 := ck+1 + 1; Σk+1 := Σk+1 + k + 1; pk+1 := pk+1 + num;

15: end if

16: end if

17: end for

36

Algorithm 9 TEST-POLY: UL routine to compute p(v), if d(v) ≤ k (returns 0 if d(v) > k)1: Input: (G, s, v, k, ck,Σk, pk,m)

2: count := 0; sum := 0; paths := 0; paths.to.v := 0;

3: for x ∈ V do

4: Nondeterministically guess 0 ≤ q ≤ nc

5: if q 6= 0 then

6: Nondeterministically guess 0 ≤ ` ≤ k

7: Nondeterministically guess q paths p1, p2, . . . pq of length exactly ` each from s to x.

8: if ( (∃i < j, φm(pi) ≤ φm(pj)) OR (paths are not valid) ) then

9: REJECT

10: end if

11: count := count+ 1; sum := sum+ `; paths := paths+ q;

12: if x = v then

13: paths.to.v := q;

14: end if

15: end if

16: end for

17: if count = ck, sum = Σk and paths = pk then

18: Return the value of paths.to.v

19: else

20: REJECT

21: end if

Proof of Correctness:

Claim 5 If m is k-good for G, and G is min-poly upto level-k, given the correct values of ck,

Σk and pk, the algorithm TEST-POLY has exactly one non-rejecting path, and it returns the

37

correct value of p(v) if d(v) ≤ k and 0 if d(v) > k.

Proof We argue that, since m is k-good for G, ∀x ∈ V , there is a unique way to guess

the values of q and `, such that the equalities count = ck, sum = Σk and paths = pk are

satisfied. The only difference between the routines TEST-CONST and TEST-POLY is, the way

of guessing q many paths of length `. But, we have seen above that, if m is k-good for G,

the guessing procedure in TEST-POLY will also be unambiguous, as all the vertices for which

minimum-length paths are being guessed are within level-k. So, the same proof of Claim 3 will

work for this claim also.

Claim 6 If m is k-good for G, G is min-poly upto level-k and correct values of ck,Σk and pk

are given, the algorithm UPDATE-POLY runs deterministically barring the calls to the routine

TEST-POLY, and computes the correct values of ck+1,Σk+1 and pk+1. It also rejects if G is not

min-poly upto level-(k+1) (as now the check at line 10 is changed to num > nc).

Proof The routine UPDATE-POLY runs similar to UPDATE-CONST. The only difference is

that, it makes calls to TEST-POLY instead to TEST-CONST. In Claim 5, we have seen that if m

is k-good for G, TEST-POLY works same as TEST-CONST, and is correct. Hence, by the same

proof as that of Claim 4, this claim too is correct.

Observation 3 Observe that, since G is min-poly upto level-0 and we begin with the correct

values of c0,Σ0 and p0, by induction, Claims 5 and 6 imply that the values of ck,Σk and pk

calculated after every iteration of while-loop (lines 6 to 9) in the MAIN-POLY-FEW algorithm

are correct, if m is good for G. Also, the iteration ends without rejecting, if and only if the

graph G is min-poly upto level-k.

38

Claim 7 If m is good for G, the algorithm MAIN-POLY-FEW has at most one path to the state

ACCEPT-m.

Proof Using Observation 3 and Claim 5, we know that there is exactly one non-rejecting

path in each call to TEST-POLY. Thus, there is exactly one non-rejecting path in each call to

UPDATE-POLY, as UPDATE-POLY is deterministic barring the calls to TEST-POLY. Similarly,

there is exactly one non-rejecting path in MAIN-POLY-FEW, as MAIN-POLY-FEW for a partic-

ular choice of m, is deterministic barring the calls to UPDATE-POLY. If t is indeed reachable

from s, this non-rejecting path goes to ACCEPT-m, as m is guessed initially and is not changed

thereafter.

Claim 8 If m is not good for G, irrespective of whether G is min-poly or not, MAIN-POLY-

FEW will always reject.

Proof Let k be the smallest integer such that m is not k-good for G (i.e. it is (k-1)-good for

G), and let v be the lexiographically first vertex, such that there exist atleast two minimum-

length s v paths p1 and p2 satisfying φm(p1) = φm(p2).

If G is min-poly, the first k calls to UPDATE-POLY runs unambiguously to give correct

output. In the (k + 1)st call to UPDATE-POLY (we are having the correct values of ck,Σk and

pk and the fourth parameter passed to any TEST-POLY call will be k), consider the first call to

TEST-POLY. For x = v, if we guess q = p(v), then the paths cannot be in strictly decreasing

order w.r.t. φm and the algorithm will reject. If we guess q > p(v) , then the algorithm will fail

to find q paths and reject. If we guess q < p(v) , then paths will never be equal to pk, as the

q for some other vertex u will then need to be greater than p(u) (for paths to become equal to

pk), which is not possible.

39

If G is not min-poly, then there is a smallest integer k′ such that G is min-poly upto level-

(k′ − 1) and is not min-poly upto level-k′. If k′ ≤ k then by Claim 6 first k′ − 1 calls to

UPDATE-POLY runs to give correct output and the k′th call to UPDATE-POLY rejects. The case

k′ > k has the same proof as the case when G is min-poly.

Theorem 4 The algorithm MAIN-POLY-FEW is correct and FewUL.

Proof If m is not good for G, then the algorithm MAIN-POLY-FEW will reject according

to the Claim 8. If m is good for G, then there is at most one path which reaches ACCEPT-

m (Claim 7). As there are polynomially many possible values of m, MAIN-POLY-FEW is

FewUL. After covering all the reachable vertices, the while loop (lines 6 to 9) in MAIN-POLY-

FEW terminates with correct values of ck, Σk and pk, if m is good for G and G is min-poly

(Observation 3). Before reaching ACCEPT-m we do a final check to see whether or not vertex

t has been covered. As this case occurs only when m is good for G and G is min-poly (Claims

7 and 8), the correct value of p(t) will be returned (Claim 5) and thus the final decision will be

correct.

3.3 UL Algorithm for MIN-POLY REACH

The algorithm presented in the previous section is not unambiguous because there can be more

than one good m. To address this, we modify the MAIN-POLY-FEW routine in such a way that

we always use the least goodm (let us call this integer f ). The TEST-POLY and UPDATE-POLY

routines are already unambiguous and need no change.

Idea: The main idea is to non-deterministically guess f , and to verify that f is the smallest

good integer for the graph G. This is done using an unambiguous algorithm FAULT-POLY,

40

which checks if any integer is not good. This routine is run over all the values less than f .

Finally when we reach f , we run same as in the algorithm MAIN-POLY-FEW and accept if and

only if it is good and there is a path from s to t.

If an integer m < f is not good, then there must be a least integer k1(m) such that m is

not k1(m)-good. The algorithm FAULT-POLY guesses k1 and tries to check if k1 = k1(m).

Till one level before k1, it keeps calling the algorithm UPDATE-POLY to update ck,Σk and pk

values. Then, it stops updating these values and tries to find a vertex v with d(v) = k1 in order

to certify that m is not k1-good. For any such vertex v, there must exist a, b ∈ V such that a, b

are in-neighbours of v at distance k1 − 1 from s and there must be two paths, pa through a and

pb through b such that φm(pa) = φm(pb). A UL routine FIND-MATCH((G, s, k, a, b, α, β,m),

which guesses α (respectively β) number of s a (s b) paths and pairwise checks for

collision w.r.t. the function φm between s a and s b paths.

Algorithm: Here we give a UL algorithm for :

MIN-POLY REACH = { (G(V,E), s, t) | ∃s t path and ∀v ∈ V, p(v) ≤ nc}.

41

Algorithm 10 MAIN-POLY: Main UL routine for MIN-POLY GRAPHS

1: Input: (G, s, t)

2: Non-deterministically guess 2 ≤ f < nc′

3: m := 2

4: while m < f do

5: FAULT-POLY(G, s,m)

6: m := m+ 1

7: end while

8: k := 1

9: c0 := 1; Σ0 := 0; p0 := 1

10: (c1,Σ1, p1) = UPDATE-POLY(G, s, 0, c0,Σ0, p0,m)

11: while k < n− 1 and (ck−1,Σk−1, pk−1) 6= (ck,Σk, pk) do

12: (ck+1,Σk+1, pk+1) := UPDATE-POLY(G, s, k, ck,Σk, pk,m)

13: k := k + 1

14: end while

15: if TEST-POLY(G, s, t, k, ck,Σk, pk,m) > 0 then

16: ACCEPT

17: else

18: REJECT

19: end if

42

Algorithm 11 FAULT-POLY: UL routine to check if m is not good for G1: Input: (G, s,m)

2: non-deterministically guess 1 < k1 < n

3: c0 := 1; Σ0 := 0; p0 := 1; k := 1

4: while k < k1 do

5: (ck,Σk, pk) = UPDATE-POLY(G, s, k, ck−1,Σk−1, pk−1,m)

6: k := k + 1

7: end while

8: for v ∈ V do

9: if TEST-POLY(G, s, v, k − 1, ck−1,Σk−1, pk−1,m) = 0 then

10: valid := false

11: for x such that (x, v) ∈ E do

12: if TEST-POLY(G, s, x, k − 1, ck−1,Σk−1, pk−1,m) > 0 then

13: valid := true

14: end if

15: end for

16: if valid then

17: for (a, b)|(a, v) and (b, v) ∈ E do

18: α := TEST-POLY(G, s, a, k − 1, ck−1,Σk−1, pk−1,m)

19: β := TEST-POLY(G, s, b, k − 1, ck−1,Σk−1, pk−1,m)

20: if (α > 0) ∧ (β > 0)∧ FIND-MATCH(G, s, k, a, b, α, β,m) then

21: RETURN

22: end if

23: end for

24: end if

25: end if

26: end for

27: REJECT 43

Algorithm 12 (FIND-MATCH): UL routine to find paths with matching φm values.1: Input: (G, s, k, a, b, α, β,m)

2: collision_found := false

3: for i = 1 to α do

4: Guess a path π of length k − 1 from s to a

5: if (i ≥ 2) ∧ (φm(π) ≥ X) then

6: REJECT

7: end if

8: X := φm(π)

9: for j = 1 to β do

10: Guess a path π′ of length k − 1 from s to b

11: if (j ≥ 2) ∧ (φm(π′) ≥ Y ) then

12: REJECT

13: end if

14: Y := φm(π)

15: if X = Y then

16: collision_found := true

17: end if

18: end for

19: end for

20: if collision_found then

21: Return true

22: else

23: Return false

24: end if

44

Proof of Correctness: Let f ′ be the smallest good value for the graph G.

Claim 9 If m is not good and G is min-poly then there exists exactly one non-reject path in

UPDATE-FAULT-MIN.

Proof We prove this by considering the following cases :

• If k1 > k1(m)+1, then in the while loop (lines 4-7), when k = k1(m)+1, UPDATE-POLY

will reject (in the proof of Claim 8 see the case when G is min-poly).

• If k1 = k1(m) + 1, then in the last iteration of while loop (lines 4-7) when k = k1 − 1 =k1(m), correct values will be computed by UPDATE-POLY as m is (k−1)-good and G ismin-poly (Claim 6). But, after the loop termination, in line 9 when TEST-POLY is calledfor the first time with fourth parameter as k − 1 = k1(m), it will reject since m is notk1(m)-good (in the proof of Claim 8 see the case when G is min-poly).

• If k1 < k1(m), then FIND-MATCH will never find two paths p1 and p2 satisfying φm(p1) =φm(p2), and the if condition on line 15 will never be satisfied (as X will never be equalto Y ). So, it will always return false and thus, FAULT-POLY will reject at line 27.

• If k1 = k1(m), the values ck,Σk and pk will be updated by UPDATE-POLY calls inthe while loop (lines 4-7), until k becomes equal to k1 (or k1(m)). Let u be the lex-icographically first vertex such that there exist two s u paths p1 and p2 satisfyingφm(p1) = φm(p2). When v = u, in the call to FIND-MATCH at line 20, the if conditionon line 15 will be satisfied when X = φm(p1) and Y = φm(p2), setting the variablecollision_found to be true, and in line 21 true will be returned as a final boolean value.So, in line 21 FAULT-POLY will return to MAIN-POLY, and this is the only non-rejectpath.

Claim 10 If m is good and G is min-poly, then FAULT-POLY rejects.

Proof Notice that, irrespective of the value of k1 guessed, FIND-MATCH will not be able

to find two paths p1 and p2 such that φm(p1) = φm(p2) as m is good. Hence, in line 21,

FAULT-POLY algorithm will never return and thus will reject in line 27.

45

Theorem 5 The algorithm MAIN-POLY is correct and UL.

Proof If G is not min-poly, MAIN-POLY will always reject irrespective of what happens in

the while loop (line 4-7), because from line 8 onwards it runs similar to MAIN-POLY-FEW

with m = f . So, as irrespective of m MAIN-POLY-FEW rejects when the input graph is not

min-poly (Theorem 4), MAIN-POLY will also reject.

Now, consider the case when G is min-poly. We argue that if f = f ′, MAIN-POLY accepts

in at most one path, and if f 6= f ′, MAIN-POLY rejects. Consider the case f = f ′. In each

iteration of the first while loop (lines 4-7) in MAIN-POLY, m is not good and thus by claim 9,

the while loop terminates in exactly one path. The rest of the algorithm (lines 8-19) is identical

to MAIN-POLY-FEW. So, by the proof of Theorem 4 there is at most one accept path. Note,

that here unlike in MAIN-POLY-FEW, we will reach a unique accept state corresponding to

m = f = f ′.

Now consider f 6= f ′. If f < f ′, then at line 7, when the first while loop terminates,

m = f < f ′, the rest of the algorithm will reject as f is not good for G (Claim 8). If f > f ′,

then when in first while loop m = f ′, FAULT-POLY will reject, as m is good (Claim 10).

Now we argue correctness. As argued, line 15 in MAIN-POLY will be reached only when

f = f ′. At this point, ck,Σk and pk are calculated correctly, as Observation 3 still holds. Thus,

by Claim 5, TEST-POLY outputs the correct value of p(t) as m = f ′ is good and thus the final

result is correct.

46

CHAPTER 4

AN ATTEMPT TO SHOW PLANAR-REACH IS IN L

In this chapter, we will discuss a potential approach to improve the known space complexity

upper bounds for PLANAR-REACH. We first describe the outline of the approach in the next

section. In the section that follows, we describe that for the approach to be working out through

the outline we describe, it must imply a stronger statement, namely NL = L. In the end,

we describe specific negative results about the specific approach itself. However, we remark

that the results in this chapter do not rule out some variants of the gadgets being useful for

completing the proof.

4.1 The Approach

Recently, a deterministic log-space algorithms were given for GI for planar graphs [8], K3,3

minor free graphs and K5 minor free graphs [10].

Using this as a starting point, a natural approach to prove that REACH for these classes of

graphs is in L, is to give log-space computable reduction from REACH to GI (for these classes

of graphs). Consider the case of REACH for planar graphs. Following Toran’s reduction [30],

this can be done in three steps,

1. Reduce REACH for DAGs to REACH for 2in-DAGs.

2. Reduce REACH for 2in-DAGs to COLOR-GA.

3. Reduce COLOR-GA to GI.

We would like to implement the above three steps preserving planarity (or K3,3 minor free

property, K5 minor free property respectively). Notice that showing REACH for any of these

three sub-classes of DAGs is in L, will also imply that REACH for that sub-class of DAGs in L,

as L is closed under complementation.

To begin with, we observe that steps (1) and (3) preserves the structural restriction that we

are aiming at. That is, the reduction from REACH for DAGs to REACH for 2in-DAGs (Section

2.1), and the reduction from COLOR-GA to GI (Section 1.1.2), both preserve planarity, i.e.

they do not introduce K3,3 and K5 as minors.

Thus, the only remaining step is step (2) - namely, a reduction from REACH for 2in-DAGs to

COLOR-GA which preserves planarity. It suffices to show that the reduction does not introduce

K3,3 minor (or K5 minor) in the resultant graph.

Toran [30] gave a reduction from REACH for 2in-DAGs to COLOR-GA (Section 2.5). We

will analyze this reduction in the following two sections.

4.2 Implication to L vs NL problem

In this subsection we show that the aimed gadget construction achieves more than what we

originally targeted. That is, if we design the gadget for step (2) described in the previous

section, then it will imply that NL = L.

To substantiate this, we first recall that in Toran’s reduction (which we reviewed in Sec-

tion 2.5), an intermediate step was to convert the input graph G into n2 circuits. The ith circuit

was formed by replacing each node in G, by a MOD-i gate. Then, each node in this circuit was

replaced by the Toran’s gadget for MOD-i gate.

This intermediate step dissolves the difference between planar and general graphs. More

48

formally, we argue that any circuit which uses only MOD-i gates can be transformed into a

planar circuit (that is a circuit whose underlying undirected graph is planar) without changing

the output function computed by the circuit.

We first state the following theorem from [9] which is already a first step in this direction,

although it was not studied there with this motivation.

Theorem 6 ([9]) Any Boolean circuit which uses only MOD-2 gates can be transformed into a

planar circuit without changing the output function computed by the circuit.

Note, that this transformation does preserve the 2in-DAG property. This is needed for

application of Toran’s gadget because the output at any gate which is part of some cycle, cannot

be defined, and Toran’s gadget will not work for gates with in-degrees more than two. An easy

generalization of planarization technique for MOD-2 case, gives the same result for MOD-k

gates as well. This generalization was also observed in [22]. We include the detailed proof for

completeness.

Theorem 7 Any Boolean circuit which uses only MOD-k gates can be transformed into a pla-

nar circuit without changing the output function computed by the circuit. And in addition the

transformation also preserves the 2in-DAG property.

Proof We replace each pair of edges ((a, b),(x, y)), which are crossing in the planar em-

bedding of the MOD-k circuit, by a planarizing gadget (shown in figure 4.1(b)). Observe that

that the number of paths between the nodes a and b, and the nodes x and y, is exactly 1. The

number of paths between, the nodes x and b, and the nodes a and y is k, which is equivalent to

0 mod k. Also, no cycles have been introduced, and the in-degrees of the nodes a, b, x and y

remains the same, and the in-degrees of all the new nodes that have been introduced is at most

2. This means, that the output at these gates is unchanged and the 2in-DAG property of the

circuit has been retained.

49

Figure 4.1: Planarizing MOD-k Circuit

Thus, the task of designing a gadget for step (2) - generalizing Toran’s gadget such that

it does not introduce K3,3 (or K5) minors in the resultant graph - is equivalent to giving a

reduction from REACH for 2in-DAGs to COLOR-GA forK3,3 (orK5) minors free graphs. Since

the gadget described above does not introduce K3,3 (or K5) minors, this, in turn is equivalent

to, designing a reduction from REACH for DAGs to GI for K3,3 (or K5) minors free graphs.

This will show that REACH for DAGs in L and hence REACH for DAGs will be is in L implying

that NL = L.

We conclude that using Toran’s gadget (or any other gadget which performs the same task)

to design an L algorithm for REACH or REACH for planar DAGs is as difficult as proving

50

NL = L.

4.3 K3,3 and K5 Minors after the Gadget Replacement

Notice that for the approach described in the first section, if we are aiming for showing that

planar DAG reachability is in L, we can assume that we are starting with an instance of the

REACH problem on planar 2in-DAGs. Hence, it suffices to argue that the gadget replacement

does not introduce non-planarity.

Thus, the natural question is to check whether the resulting graph is planar. We first observe

that Toran’s gadget itself has a planar embedding in the case of MOD-2 gate (figure 4.2 (b)).

However, for k > 2 the gadget for MOD-k gate is not even planar. But since the gadgets are

tripartite they cannot contain K5 directly. Notice that for our purpose in the previous section,

it suffices to argue that the resulting graph does not contain K5 as a minor. This is because,

isomorphism testing of even K5-free graphs is in L [10].

Thus, the next natural question is if the interconnection of these gadgets produces a K5. We

now present a negative observation about our approach, that it introduces both K3,3 and K5 as

minors in the resultant graph (figures 4.3 and 4.4), thus closing down this attempt to complete

the proof with the same gadget. However, it is conceivable that a different gadget can be made

to work.

51

Figure 4.2: Gadget for MOD-2 Gate

52

Figure 4.3: K3,4 Minor Introduced by MOD-2 Gate’s Gadget

53

Figure 4.4: K5 Minor Introduced by MOD-2 Gate’s Gadget

54

CHAPTER 5

CONCLUSION AND FUTURE WORK

The main contribution of this thesis is a UL algorithms for REACH in directed graphs augmented

with min-const or min-poly weighting schemes. This is an improvement of the previous result

by Allender and Reindthart [25], where they designed a UL algorithm for REACH in directed

graphs augmented with min-unique weighting schemes.

In the later part of the thesis, we explored the possibility of improving the space bound

for testing reachability in planar graphs. We first argued that using Toran’s reduction [30] for

designing an L algorithm for REACH or REACH for planar DAGs leads to a proof that NL = L.

We also showed that Toran’s gadget for MOD-2 gate introduces both K3,3 and K5 as minors, in

the resultant graph. So, for the approach to work one has to design an alternate gadget which

keeps the resultant graph either K3,3-minor free or K5-minor free.

We end this chapter and the thesis by listing down some of the open problems that the work

presented in thesis leads to.

Open Problem 1: (Min-poly Weighting Scheme Design) Are min-const or min-poly log-

space computable weighing schemes easier to design than min-unique log-space computable

weighing schemes? In the former case, the restrictions on the number of minimum weight

s v paths is less stringent. Hence it is conceivable that such a weighting scheme is easier to

design. Designing such a weighting scheme would immediately imply that NL = UL. Indeed,

it may be simpler to design such weighting schemes for restricted graph classes? We know a

min-unique weighting scheme for grid graphs [6]. If we are able to extend this scheme to make

it work for “Monotone 3D Grid Graphs", then NL = UL [6].

Open Problem 2: (Reduction between weighting schemes) In a related work [27] (see also

the paper [11]), we have shown that testing reachability in MAX-POLY GRAPHS1 can be done

in UL. It would be interesting to know if these problems are inter-reducible in log-space. In

particular, is there a deterministic log-space algorithm, which given a log-space computable,

polynomially bounded, min-unique (resp. min-poly) weighting scheme for a graphG, produces

a max-unique (resp. max-poly) weighting scheme for G.

Open Problem 3: (MOD-k Gadget design) Can we come up with an alternate gadget which

does not introduce K3,3 or K5 minors in the resultant graph? As we observed, although the

original approach was proposed to give an L algorithm for testing reachability in planar DAGs,

if we are able to construct one such gadget, then NL = L.

1Weighting schemes where for every vertex v the number of s to v paths of maximum weight is unique(bounded by a polynomial) are called max-unique (max-poly). Graphs augmented with max-unique (max-poly)weighting schemes are called MAX-UNIQUE GRAPHS (MAX-UNIQUE GRAPHS).

56

LIST OF PAPERS BASED ON THESIS

1. Anant Dhayal, Jayalal Sarma and Saurabh Sawlani "Polynomial Min/Max-weightedReachability is in Unambiguous Logspace", In 34th International Conference on Foun-dation of Software Technology and Theoretical Computer Science, FSTTCS 2014, De-cember 15-17, 2014, New Delhi, India, pages 597–609, 2014.

57

CURRICULUM VITAE

• Name: Anant Dhayal

• Roll: CS12S018

• Date Of Birth: 29th December 1989

• Citizenship: Indian

• Educational Background:– B.Tech. CSE, Then LNM Institute Of Information Technology, Jaipur (2008-2012)

– M.S. (By Research), Theoretical Computer Science∗ Date Of Registration: July 2012∗ Adviser: Dr. Jayalal Sarma M.N.∗ Institute: Indian Institute Of Technology, Madras∗ CGPA: 10

• Permanent Address: Q-2/1, Govt. Women’s Polytechnic Campus, Residency Road,Jodhpur, Rajasthan-342005, India

58

GENERAL TEST COMITTEE

• Dr. Jayalal Sarma M.N. (Guide)

– Designation: Assistant Professor

– Email: jayalal@cse.iitm.ac.in

– Department: Computer Science And Engg.

• Prof. Sukhendu Das (Chairman)

– Designation: Professor

– Email: sdas@cse.iitm.ac.in

– Department: Computer Science And Engg.

• Dr. C. Pandu Rangan (Internal Member)

– Designation: Professor

– Email: cpr@cse.iitm.ac.in

– Department: Computer Science And Engg.

• Dr. Arindama Singh (External Member)

– Designation: Professor

– Email: asingh@ee.iitm.ac.in

– Department: Mathematics

59

REFERENCES

[1] Eric Allender. Reachability problems: An update. In Proceedings of Computability in Europe,pages 25–27, 2007.

[2] Eric Allender, David A. Mix Barrington, Tanmoy Chakraborty, Samir Datta, and Sambuddha Roy.Planar and grid graph reachability problems. Theory of Computing Systems, 45(4):675–723, July2009.

[3] Sanjeev Arora and Boaz Barak. Computational Complexity: A Modern Approach. CambridgeUniversity Press, New York, NY, USA, 1st edition, 2009.

[4] David A. Mix Barrington. Bounded-width polynomial-size branching programs recognize exactlythose languages in NC1. Journal of Computer and System Sciences, 38(1):150–164, 1989.

[5] Manuel Blum and Dexter Kozen. On the power of the compass (or, why mazes are easier tosearch than graphs). In 19th Annual Symposium on Foundations of Computer Science, Ann Arbor,Michigan, USA, 16-18 October 1978, pages 132–142, 1978.

[6] Chris Bourke, Raghunath Tewari, and N. V. Vinodchandran. Directed planar reachability is inunambiguous log-space. ACM Transations on Computation Theory, 1(1):4:1–4:17, February 2009.

[7] Stephen A. Cook and Pierre McKenzie. Problems complete for deterministic logarithmic space.Journal of Algorithms, 8(3):385–394, 1987.

[8] S. Datta, N. Limaye, P. Nimbhorkar, T. Thierauf, and F. Wagner. Planar graph isomorphism is inlog-space. In Computational Complexity, 2009. CCC ’09. 24th Annual IEEE Conference on, pages203–214, July 2009.

[9] Samir Datta, Raghav Kulkarni, Nutan Limaye, and Meena Mahajan. Planarity, determinants, per-manents, and (unique) matchings. ACM Transactions on Computation Theory, Volume 1, Issue1, Number 3, March, 2010. A preliminary version appeared in Computer Science - Theory andApplications, volume 4649 of Lecture Notes in Computer Science, pages 115–126. Springer BerlinHeidelberg, 2007.

[10] Samir Datta, Prajakta Nimbhorkar, Thomas Thierauf, and Fabian Wagner. Graph Isomorphismfor K3,3-free and K5-free graphs is in Log-space. In IARCS Annual Conference on Foundationsof Software Technology and Theoretical Computer Science, volume 4 of Leibniz InternationalProceedings in Informatics (LIPIcs), pages 145–156, Dagstuhl, Germany, 2009. Schloss Dagstuhl–Leibniz-Zentrum fuer Informatik.

[11] Anant Dhayal, Jayalal Sarma, and Saurabh Sawlani. Polynomial min/max-weighted reachability isin unambiguous log-space. In 34th International Conference on Foundation of Software Technol-ogy and Theoretical Computer Science, FSTTCS 2014, December 15-17, 2014, New Delhi, India,pages 597–609, 2014.

[12] David Eppstein, Giuseppe F. Italiano, Roberto Tamassia, Robert Endre Tarjan, Jeffery Westbrook,and Moti Yung. Maintenance of a minimum spanning forest in a dynamic plane graph. Journal ofAlgorithms, 13(1):33–54, 1992.

60

[13] Michael L. Fredman, János Komlós, and Endre Szemerédi. Storing a sparse table with 0(1) worstcase access time. Journal of the ACM, 31(3):538–544, June 1984.

[14] Brady Garvin, Derrick Stolee, Raghunath Tewari, and N.V. Vinodchandran. ReachFewL =ReachUL. Computational Complexity, 23(1):85–98, 2014.

[15] Monika Rauch Henzinger, Philip N. Klein, Satish Rao, and Sairam Subramanian. Faster shortest-path algorithms for planar graphs. Journal of Computer and System Sciences, 55(1):3–23, 1997.

[16] Thore Husfeldt. Fully dynamic transitive closure in plane dags with one source and one sink. InAlgorithms - ESA ’95, Third Annual European Symposium, Corfu, Greece, September 25-27, 1995,Proceedings, pages 199–212, 1995.

[17] Neil Immerman. Nondeterministic space is closed under complementation. SIAM Journal ofComputing, 17(5):935–938, October 1988.

[18] Andreas Jakoby, Maciej Liskiewicz, and Rüdiger Reischuk. Space efficient algorithms for directedseries-parallel graphs. Journal of Algorithms, 60(2):85–114, 2006.

[19] J. Kobler, U. Schöning, and J. Toran. The Graph Isomorphism Problem: Its Structural Complexity.Progress in Theoretical Computer Science. Birkhäuser Boston, 2012.

[20] Richard E. Ladner. On the structure of polynomial time reducibility. Journal of the ACM,22(1):155–171, 1975.

[21] Nutan Limaye, Meena Mahajan, and Prajakta Nimbhorkar. Longest paths in planar dags in un-ambiguous logspace. Chicago Journal of Theoretical Computer Science, Volume 2010, Number8, 2010. A preliminary version appeared in Proceedings of Computing: The Australasian TheorySymposium (CATS), pages 101–108, 2009.

[22] Princy Lunawat. Reachability in directed planar graphs. M.Tech. thesis, Indian Institute of Tech-nology Madras, 2013.

[23] Aduri Pavan, Raghunath Tewari, and N. V. Vinodchandran. On the power of unambiguity in log-space. Computational Complexity, 21(4):643–670, 2012.

[24] Omer Reingold. Undirected st-connectivity in log-space. In Proceedings of Symposium of Theoryof Computing 2005, pages 376–385, 2005.

[25] Klaus Reinhardt and Eric Allender. Making nondeterminism unambiguous. SIAM Journal ofComputing, 29(4):1118–1131, 2000.

[26] Walter J. Savitch. Relationships between nondeterministic and deterministic tape complexities.Journal of Computer and System Sciences, 4(2):177–192, April 1970.

[27] Saurabh Sawlani. Longest path, reachability and max-poly weighting schemes. M.S. thesis, IndianInstitute of Technology Madras, 2015.

[28] Derrick Stolee, Chris Bourke, and N. V. Vinodchandran. A log-space algorithm for reachability inplanar acyclic digraphs with few sources. Computational Complexity, 25:131–138, 2010.

[29] R. Szelepcsényi. The method of forced enumeration for nondeterministic automata. Acta Infor-matica, 26(3):279–284, November 1988.

[30] Jacobo Torán. On the hardness of graph isomorphism. SIAM Journal of Computing, 33(5):1093–1108, May 2004.

61

[31] N.V. Vinodchandran. Space complexity of the directed reachability problem over surface-embedded graphs. Progress in Computer Science and Applied Logic: The Somenath Biswas An-niversary Volume, 26(1):37–49, 2014.

62