Randomized Time Space Tradeoffs for Directed Graph Connectivity

Transcription

1 Randomized Time Space Tradeoffs for Directed Graph Connectivity Parikshit Gopalan, Richard Lipton, and Aranyak Mehta College of Computing, Georgia Institute of Technology, Atlanta GA 30309, USA. Abstract. We present a spectrum of randomized time-space tradeoffs for solving directed graph connectivity or STCONN in small space. We use a strategy parameterized by a parameter k that uses k pebbles and performs short random walks of length n k 1 using a probabilistic counter. We use this to get a family of algorithms that ranges between and log n in space and 2 log2 n and n n in running time. Our approach allows us to look at Savitch s algorithm and the random walk algorithm as two extremes of the same basic divide and conquer strategy. 1 Introduction The Graph Reachability problem is central to the study of algorithms that run in small space. Characterizing the complexities of the directed and undirected versions of this problem is an important problem that has received much attention. Undirected graph connectivity or USTCONN is in NL. It can also be decided in RL by taking a random walk on the graph [1]. Nisan [9] derandomizes the random walk using a pseudorandom generator for small space to prove that it lies in SC. Savitch s algorithm [13] is a deterministic algorithm which works in space. However it is also known to be in DSPACE(log 4 3 n) [2]. Feige [7] shows a family of randomized polynomial time algorithms that range between breadth first search and the RL random walk algorithm. Directed graph connectivity or STCONN is complete for NL under logspace reductions. It seems to have higher complexity than USTCONN for deterministic and randomized complexity classes. It is in DSPACE() by Savitch s theorem [13]. Savitch s algorithm is not a polynomial time algorithm, it runs in time 2 log2 n. There has been little success iesigning algorithms that simultaneously run in small space and time. STCONN is not known to lie in SC. The best tradeoff known currently [3] does give polynomial time for o(n) space, but not for space n 1 ε for any constant ε. It is also not known whether we can use Research supported in part by NSF CCR Also with Telcordia

2 randomness to reduce the space required. A simple random walk with restarts [8] works in space log n but the running time is doubly exponential in the space. Lower bounds for STCONN have been proved in several restricted models. See [12], [15] for a survey of some known results. In particular a lower bound of is known in the JAG model of Cook and Rackoff [5] and some of its extensions. For the RJAG model Berman and Simon [4] show that this bound holds for any algorithm running in time 2 logo(1) n. Poon [11] generalizes this result log to show a space lower bound of 2 n +log log T for an algorithm that runs in expected time T on a randomized NNJAG which generalizes the RJAG model. Our Results We present a spectrum of randomized time-space tradeoffs for solving directed graph connectivity or STCONN in small space. The spectrum ranges from Savitch s algorithm to the random walk with restarts algorithm of [8]. We use a strategy parameterized by a parameter k that uses k pebbles and performs short random walks of length d = n 1 k. Our main theorem is Theorem 1: There is a randomized algorithm that solves directed graph connectivity in RT ISP (2 d log2 n In particular, ) for 2 d n. When k = 1 and d = n this reduces to the random walk algorithm of [8] which solves STCONN in space log n and expected time n n. When k = log n and d = 2, we get a randomized analog of Savitch s algorithm [13] which takes space and time 2 log2 n. Intermediate values of k give an algorithm with parameters in between. If k = log n and time 2 log3 n. and d = log n, we get an algorithm that runs in space log 2 n Our algorithms can be made to run on the probabilistic NNJAG model defined by Poon in [11]. For space S log2 n, our algorithms exactly match the lower bounds shown by Poon. This shows that these lower bounds are optimal for a large range of parameters. Previously the only lower bounds known to be optimal in any JAG related model were for space Ω() due to Edmonds, Poon and Achlioptas [6]. Our algorithms use a divide and conquer strategy on the random walk. We divide a single random walk into a number of random walks of smaller size. This requires more space but speeds up the algorithm. It has been noted previously (e.g. [15]) that if we can solve s-t connectivity in log-space for any distance which is ω(1), then we can beat the space bound. That the random walk with restarts works in small space for any distance is also a classical result, as is the idea of small space probabilistic clocks [8], [14]. The main contribution of this

3 paper is to put these ideas together to yield an interesting trade-off result. The main lemmas involve a careful analysis of the time, randomness, space and error probability of our hierarchical random walks. Our approach allows us to look at Savitch s algorithm and the random walk algorithm as variants of the same basic divide and conquer strategy. In the next section we outline the idea behind the algorithm and analyze clocks that run in small space. The algorithm and its analysis are presented in full detail in Section 4. 2 Outline of the Algorithm Suppose we are given a directed graph G on n nodes and are asked to find a path of length d from u to v or report that no such path exists. One way to do this is by performing random walks of length d with restarts: Starting from u randomly choose the next step for d steps. If we reach v then we are done, else we restart at u. If indeed there is path between u and v of length d, we expect to find it in expected time. If we run for much longer (say time n 3d ) and do not find a path then we report that no such path exists and we will be correct with high probability. In [8] it is shown how this procedure can work in space log n. Our algorithm uses the above procedure of random walks with restarts. We use a divide and conquer strategy which is analogous to the recursive doubling strategy of Savitch s algorithm. Let us denote by G l the graph whose edges are paths in G of length l. If there is an s-t path in G, there is an s-t path of length at most n l in G l. Suppose we have k pebbles. Set d = n 1 k. We number our pebbles 1,..., k and use them in a hierarchical fashion. We try to discover an s-t path in G of length d. This we achieve by performing random walks of length d with restarts on G using pebble 1. However, we do not have G described explicitly, so we work recursively. We use pebble 2 to answer the queries is (x, y) an edge in G? ; and, in general, pebble i to answer edge queries about G n d i 1. The recursion bottoms out at pebble k, which we use to answer queries of the form is x connected to y by a path of length d in G?. Each level answers the queries asked by the previous level by performing random walks with restarts on the corresponding graph. A crucial requirement for performing all the random walks with restarts is a counter that keeps track of time up to n 3d so that we know when to stop the random walk and report that there is no u-v path. However, this is not possible in logspace. So we use a probabilistic counter (as in [8], [14]), which waits for a successive run of heads. We show that this counter works accurately enough to keep the errors small. An alternative way to represent this recursive pebbling strategy is to imagine that pebble 1 is performing a random walk on G, and that it queries an oracle for the edges of G. This oracle is implemented by pebbles 2 to k in a recursive manner.

4 Small Space Clocks Consider a sequence of unbiased coin tosses (0 or 1). Consider a counter which counts the lengths of a successive runs of 1s and stops at the first time it encounter a run of length l. We call this probabilistic counter Clock(2 l ). Lemma 1. Clock(2 l ) is a probabilistic procedure that runs in space log l for time T such that P r[t > t] < e t l2 l+1 and P r[t < t] < t 2 l Proof. Let T denote the time when a run of 1s of length l first appears. We first bound the probability that T is very large compared to 2 l. Divide the sequence into segments of length l. Let X i denote the random variable which is 1 if the i th segment contains all 1s, and is 0 otherwise. It is clear that the X i s are independent Bernoulli random variables each with expected value 2 l. Also, if T > t then X i = 0 for i = 1,..., t l. Therefore P r[t > t] P r[ t l i=1 X i = 0]. Hence, by the Chernoff bound, we get P r[t > t] < e t l2 l+1 (1) Next, a simple union bound shows that T is unlikely to be very small compared to 2 l. At any time, the probability that the next l coin tosses are all 1s is 2 l. Hence P r[t < t] < t 2 l (2) Note that the probability that the clock runs for a long time is much smaller than the probability that the clock runs out very quickly. However, this suffices for our purposes. 3 The Algorithm We describe a family of algorithms parameterized by a parameter k which takes values between 1 and log n. The input is a graph G on n vertices, and two vertices s and t. We set d = n 1 k. The algorithm is recursive. Each call is given input vertices u, v and a distance parameter d which is an upper bound on the distance from u to v. Thus the first call is with vertices s, t and d = n, and calls at the lowest level work with d = d. Each call performs a random walk with restarts on the appropriate graph and is clocked by Clock(n 3d ). As mentioned earlier, the first call is to RWALK(s, t, n). We first show that the algorithm indeed terminates with high probability. The main technical difficulty here is the following. The running time of the algorithm is essentially the sum of the running times of all the random walks performed. Each random walk runs for as long as the associated Clock runs. If this clock runs too long, so does the random walk. Each step of the random walk invokes a new random walk at the lower level (i.e. for a smaller distance). Hence

5 RWALK(u,v,d ) Start Clock(n 3d ) While (Clock(n 3d ) is ticking) v 0 = u; v cur = u; [RESTART] for i = 1 to d v prev = v cur R v cur [n] if d > d //(recursive call) if RWALK(v prev, v cur, d ) = 0 then goto [RESTART] d else //(bottom of recursion) if (v prev, v cur) / E(G) then goto [RESTART] end for if v cur = v then Return 1 else goto [RESTART] end while Return 0 //(Clock terminated) Fig. 1. RWALK(u,v,d ) there is no a priori bound even on the total number of random walks performed, it depends on the length of each random walk. We prove our bound through induction. By level j of the algorithm we will mean the jth level of recursion in the algorithm. Random walks at level j are performed using pebble j. There are k levels in all. Lemma 2. The algorithm terminates in time n O(dk) with very high probability. Proof. We use induction on the level j to prove the following: With probability at least 1 n7dj, for all l j, there are no more than n 7d(l 1) random walks e performed at the nd lth level of the recursion, and each of these random walks runs for time less than n 7d. The base case of the induction is true since only one random walk is performed at the first level and by Lemma 1 with probability at least 1 e nd it does not run for time greater than n 7d. Assume that the inductive hypothesis is true for level j. The number of random walks at level j + 1 is equal to the total number of steps performed in all the random walks at level j. Thus with probability at least 1 n7dj no more than n 7d(j 1) n 7d = n 7dj walks run at level j + 1. Given e nd this, the probability that any of these walks runs for more than n 7d is bounded by n7dj e nd. Hence the statement is true for j + 1 and this concludes the induction. Since there are k levels, with probability 1 n7dk e nd is bounded by k, the total number of walks i=1 n7d(i 1) n 7dk and none of them runs for more than n 7d. This implies that the algorithm runs in time n 7d(k+1) = n O(dk). We now argue that with good probability the algorithm does indeed find an s-t path if one exists.

6 Notice first that the algorithm only errs in one direction: if there is no s-t path the algorithm will certainly return 0. Now a call to RWALK (say RWALK(u, v, d )) at any level of the recursion essentially consists of two parts: while the clock runs it randomly chooses d vertices to perform the random walk between u and v; and it asks edge queries to the level below. Call a sequence of vertices x 0 = u, x 1, x 2,..., x d = v a valid sequence if in the graph G there is a path of length d /d from x i to x i+1 for all i = 0,..., d 1. We prove first that at any call RWALK(u, v, d ) finds a valid sequence with high probability if there is a path of length d from u to v in G. Lemma 3. If there is a u-v path of length d in G, RWALK(u, v, d ) finds a valid sequence with probability at least 1 2. Proof. By Lemma 1, we know that Clock(n 3d ) runs for time at least n 2d with probability at least 1 1. The probability that RWALK(u, v, d ) does not find a particular d length sequence in this time is at most 1. So the error probability is at most 2. Having RWALK(u, v, d ) choose a valid sequence with high probability is not enough. We also need the calls at all lower levels to return correct answers. Here the main issue is that we are running about k number of random walks, and the probability of error of each random walk is about n d. Hence clearly many of the walks will return incorrect answers. But the key is that for most instances, we do not care. We only require those queries which actually pertain to the s-t path to be answered correctly. For this we argue in a bottom up manner. For convenience, we define a notion of height of a pebble which is the inverse of the level. The pebble at level k is at height 1 whereas the pebble at level 1 is at height k. Lemma 4. If there is a s-t path in G, RWALK(s, t, n) will find it with probability at least Proof. By induction on h, we prove that the pebble at height h answers any single query incorrectly with probability at most h 1 i=0 2di. If h = 1, then this follows from Lemma 3 since finding a path between u and v is equivalent to finding a valid sequence (since at height 1 we have direct access to G, and do not need to make any edge queries). Assume that the statement holds for height h 1. Consider the pebble at height h which is asked if u is adjacent to v. If a u-v path exists, then by Lemma 3, it guesses a valid sequence with probability at least 1 2. It now makes d queries to the pebble at level h 1. That pebble returns correct answers to all these d queries with probability at least 1 d h 2 i=0 2di. Hence the probability that pebble at height h answers the query incorrectly is at most d h 2 i=0 2di + 2 = h 1 i=0 2di. The overall failure probability of RWALK(s, t, n) is the probability that the pebble at height k answers the question is there a path from s to t? incorrectly. By the induction above, this is at most 2dk = 2n which goes to 0 asymptotically.

7 We finally prove: Lemma 5. The algorithm runs in space k log n = log2 n Proof. There are k levels of recursion. At each level there is only one random walk running at any given time. Each level keeps a clock, a start and end vertex and two current vertices. So each level takes O(log n) storage. Hence the total storage is k log n. We have proved our main Theorem: Theorem 1. There is an algorithm that solves directed graph connectivity in RT ISP (2 d log2 n, ) for 2 d n or equivalently in RT ISP 1 (2n k, k log n) for 1 k log n. It is interesting to note that by setting d = 2, we perform random walks of length 2. This is equivalent to guessing the midpoint v between s and t and then the midpoint of each of these paths and so on. If instead of guessing, we try all possible vertices, this is precisely Savitch s algorithm. Whe = n we get the logspace random walk with restarts of [8]. Intermediate values of d give an algorithm with parameters in between. In particular, if d = log n, we get an algorithm that runs in space log2 n and time n. 2log3 4 Implementation on a Probabilistic NNJAG The NNJAG model is a restricted model of computation for directed graph connectivity. It consists of an automaton with a set of internal states q, a set of pebbles k, and a transition function δ. A probabilistic NNJAG has access to random bits at each step and the transition function caepend on the bits read. At any time the NNJAG only knows the names of the nodes on which it has pebbles. It is allowed to move a pebble to an adjacent node, or to jump a pebble to a node on which there are already other pebbles. The space S is defined as k log n + log q. The time taken T is the number of moves made. We shall briefly give an informal description of how algorithm RWALK can be simulated on a probabilistic NNJAG [10]. The counter for the clock is maintained in the internal state of the NNJAG. Similarly at each step, the guess for the k vertices on the path is stored with the internal state. We then move pebbles along the edge and compare them with the nodes stored in the internal state to see if we have reached the target node. Theorem 2. [11] Any probabilistic NNJAG for STCONN on n node graphs that runs in expected time T and uses space S satisfies S log n +log log T. Theorem 3. For S, there exists a probabilistic NNJAG that meets the lower bound of Theorem 2.

8 Proof: Since the lower bound on S by Theorem 2 is less than or equal to, we can hope to show our algorithm is tight only when the space is less than log2 n or equivalently whe = Ω(log n). In Theorem 1, T = 2 d log2 n log log T = Θ( + ) = Θ() The bound implied by Theorem 2 for an NNJAG with this expected running time is ( log 2 ) n S = Ω + log log T ( log 2 ) n = Ω But this is exactly the space bound achieved by Theorem 1. Acknowledgments We thank C.K. Poon for discussions regarding the NNJAG model. We thank H. Venkateswaran for many helpful discussions. References 1. R. Aleliunas, R. Karp, R. Lipton, L. Lovasz, and C. Rakoff. Random walks, universal traversal sequences, and the complexity of maze problems. In 20th Annual Symposium on Foundations of Computer Science, pages , R. Armoni, A. Ta-Shma, A. Wigderson, and S. Zhou. An log(n) 4 3 space algorithm for s-t connectivity in undirected graphs. Journal of the ACM, 47: , G. Barnes, J. Buss, W. Ruzzo, and B. Schieber. A sublinear space, polynomial time algorithm for directed s-t connectivity. In 7th annual conference on Structure in Complexity Theory, pages 27 33, P. Berman and J. Simon. Lower bounds on graph threading by probabilistic machines. In 24th Annual Symposium on Foundations of Computer Science, pages , S. Cook and C. Rackoff. Space lower bounds for maze threadability on restricted machines. SIAM Journal on Computing, 9(3): , J. Edmonds, C. Poon, and D. Achlioptas. Tight lower bounds for st-connectivity on the NNJAG model. SIAM J. Comput., 28(6): , U. Feige. A spectrum of time-space tradeoffs for undirected s-t connectivity. Journal of Computer and System Sciences, 54(2): , J. Gill. Computational complexity of probabilistic turing machines. In Proc. 6th Annual ACM Symp. Theory of Computing, pages 91 95, N. Nisan. RL SC. Journal of Computational Complexity, 4, pages 1 11, C. Poon. Personal communication.

9 11. C. Poon. Space bounds for graph connectivity problems on node named jags and node ordered jags. In 34th Annual Symposium on Foundations of Computer Science, pages , C. Poon. On the complexity of the s-t connectivity problem. Ph.D Thesis, University of Toronto, W. Savitch. Relationships between nondeterministic and deterministic tape complexities. Journal of Computer and System Sciences, 4(2): , J. Simon. Space-bounded probabilistic turing machine complexity classes are closed under complement. In Proc. 13th Annual ACM Symp. Theory of Computing, pages , A. Wigderson. The complexity of graph connectivity. In Proceedings of the 17th Mathematical Foundations of Computer Science, pages , 1992.