A time-space tradeoff is established in the branching program model for the problem of computing the product of two n x n matrices over the semiring ((0, l}, V, A). It is a.ssumed that ea.ch element of each nxn input matrix is chosen independently to be 1 with probability n-ll2 and to be 0 with probability 1- n-1/2. Letting S and T denote expected space and time of a deterministic algorithm, the tradeoff is ST = R(n3.5) for T < cln2.5 and ST = R(n3) for T> where c1, c2> 0. The lower bounds are matched to within a logarithmic factor by upper bounds in the branching program model. Thus, the tradeoff possesses a sharp break a.t T = O(n2.5). These expected case lower bounds are also the best known lower bounds for the worst case.

Directed and undirected st-connectivity are important problems in computing. There are algorithms for the undirected case that use O (n) time and algorithms that use O (log n) space. The first result of this thesis proves that, in a very natural structured model, the JAG (Jumping Automata for Graphs), these upper bounds are not simultaneously achievable. This uses new entropy techniques to prove tight bounds on a game involving a helper and a player that models a computation having precomputed information about the input stored in its bounded space. The second result proves that a JAG requires a time-space tradeoff of T \Theta S 1 2 2\Omega i mn 1 2 j to compute directed st-connectivity. The third result proves a time-space tradeoff of T \Theta S 1 3 2\Omega i m 2 3 n 2 3 j on a version of the...

We consider the problem of clock synchronization with uncertain message delays and bounded clock drifts. To analyze this classical problem we introduce a characterization theorem for the tightest achievable estimate of the readings of a remote clock in any given execution of the system. Using this theorem, we obtain the first optimal on-line distributed algorithms for clock synchronization. The algorithms are optimal for all executions, rather than only worst cases. The general algorithm for systems with drifting clocks has high space overhead, which is unavoidable, as we show. For systems with drift-free clocks (i.e., clocks that run at the rate of real time), we present a remarkably simple and efficient algorithm. The discussion focuses on the variant where one of the clocks shows real time, but we present results also for the case where real time...

The string matching problem is one of the most studied problems in computer science. While it is very easily stated and many of the simple algorithms perform very well in practice, numerous works have been published on the subject and research is still very active. In this paper we survey recent results on parallel algorithms for the string matching problem.

We establish the first nontrivial lower bounds on timespace tradeoffs for the selection problem. We prove that any comparison-based randomized algorithm for finding the median requires Ω(n log logS n) expected time in the RAM model (or more generally in the comparison branching program model), if we have S bits of extra space besides the read-only input array. This bound is tight for all S ≫ log n, and remains true even if the array is given in a random order. Our result thus answers a 16-year-old question of Munro and Raman, and also complements recent lower bounds that are restricted to sequential access, as in the multi-pass streaming model [Chakrabarti et al., SODA 2008]. We also prove that any comparison-based, deterministic, multi-pass streaming algorithm for finding the median requires Ω(n log ∗ (n/s) + n log s n) worst-case time (in scanning plus comparisons), if we have s cells of space. This bound is also tight for all s ≫ log 2 n. We get deterministic lower bounds for I/O-efficient algorithms as well. All proofs in this paper involve “elementary ” techniques only. 1

The following is a second proof of (basically) the same undirected st-connectivity result using recursive flyswatters as given in my thesis and in STOC-93 [Ed93a, Ed-PHD]. The input graph and the reduction techniques in the two proofs are similar. The main difference is that JAG result is reduced to a different game. In this paper, the game consists of a pebble walking on a line. The movements of the pebble are directed by a player and a random input. The conjecture is that the player cannot get the pebble across the line much faster than that done by a random walk. Likely, however, this is hard to prove. What can be proven is that this game becomes equivalent to the game in the original paper, if the player who is directing the pebble always knows where in the line pebble is. Therefore, the lower bound for the original game applies to this new game. Hence, the JAG lower bound proved in this paper is the same as that proven before. Two advantages of this new proof are that it is a litt...

We prove that Ω(n log n) comparisons are necessary for any quantum algorithm that sorts n numbers with high success probability and uses only comparisons. If no error is allowed, at least 0.110n log2 n − 0.067n + O(1) comparisons must be made. The previous known lower bound is Ω(n). Key words: sorting, quantum computation, decision tree complexity, lower bound.