Results 1  10
of
21
Timespace tradeoffs for predecessor search
 In Proc. 38th ACM Sympos. Theory Comput
, 2006
"... We develop a new technique for proving cellprobe lower bounds for static data structures. Previous lower bounds used a reduction to communication games, which was known not to be tight by counting arguments. We give the first lower bound for an explicit problem which breaks this communication compl ..."
Abstract

Cited by 36 (4 self)
 Add to MetaCart
We develop a new technique for proving cellprobe lower bounds for static data structures. Previous lower bounds used a reduction to communication games, which was known not to be tight by counting arguments. We give the first lower bound for an explicit problem which breaks this communication complexity barrier. In addition, our bounds give the first separation between polynomial and near linear space. Such a separation is inherently impossible by communication complexity. Using our lower bound technique and new upper bound constructions, we obtain tight bounds for searching predecessors among a static set of integers. Given a set Y of n integers of ℓ bits each, the goal is to efficiently find predecessor(x) = max {y ∈ Y  y ≤ x}. For this purpose, we represent Y on a RAM with word length w using S words of space. Defining a = lg S n +lg w, we show that the optimal search time is, up to constant factors: logw n lg min ℓ−lg n
Logarithmic lower bounds in the cellprobe model
 SIAM Journal on Computing
"... Abstract. We develop a new technique for proving cellprobe lower bounds on dynamic data structures. This enables us to prove Ω(lg n) bounds, breaking a longstanding barrier of Ω(lg n/lg lg n). We can also prove the first Ω(lgB n) lower bound in the external memory model, without assumptions on the ..."
Abstract

Cited by 34 (4 self)
 Add to MetaCart
Abstract. We develop a new technique for proving cellprobe lower bounds on dynamic data structures. This enables us to prove Ω(lg n) bounds, breaking a longstanding barrier of Ω(lg n/lg lg n). We can also prove the first Ω(lgB n) lower bound in the external memory model, without assumptions on the data structure. We use our technique to prove better bounds for the partialsums problem, dynamic connectivity and (by reductions) other dynamic graph problems. Our proofs are surprisingly simple and clean. The bounds we obtain are often optimal, and lead to a nearly complete understanding of the problems. We also present new matching upper bounds for the partialsums problem. Key words. cellprobe complexity, lower bounds, data structures, dynamic graph problems, partialsums problem AMS subject classification. 68Q17
Robust lower bounds for communication and stream computation
 in Proceedings of the 40th Annual ACM Symposium on Theory of Computing (British
, 2008
"... We study the communication complexity of evaluating functions when the input data is randomly allocated (according to some known distribution) amongst two or more players, possibly with information overlap. This naturally extends previously studied variable partition models such as the bestcase and ..."
Abstract

Cited by 21 (6 self)
 Add to MetaCart
We study the communication complexity of evaluating functions when the input data is randomly allocated (according to some known distribution) amongst two or more players, possibly with information overlap. This naturally extends previously studied variable partition models such as the bestcase and worstcase partition models [32, 29]. We aim to understand whether the hardness of a communication problem holds for almost every allocation of the input, as opposed to holding for perhaps just a few atypical partitions. A key application is to the heavily studied data stream model. There is a strong connection between our communication lower bounds and lower bounds in the data stream model that are “robust” to the ordering of the data. That is, we prove lower bounds for when the order of the items in the stream is chosen not adversarially but rather uniformly (or nearuniformly) from the set of all permuations. This randomorder data stream model has attracted recent interest, since lower bounds here give stronger evidence for the inherent hardness of streaming problems. Our results include the first randompartition communication lower bounds for problems including multiparty set disjointness and gapHammingdistance. Both are tight. We also extend and improve previous results [19, 7] for a form of pointer jumping that is relevant to the problem of selection (in particular, median finding). Collectively, these results yield lower bounds for a variety of problems in the randomorder data stream model, including estimating the number of distinct elements, approximating frequency moments, and quantile estimation.
UNIFYING THE LANDSCAPE OF CELLPROBE LOWER BOUNDS
, 2008
"... We show that a large fraction of the datastructure lower bounds known today in fact follow by reduction from the communication complexity of lopsided (asymmetric) set disjointness. This includes lower bounds for: • highdimensional problems, where the goal is to show large space lower bounds. • co ..."
Abstract

Cited by 11 (0 self)
 Add to MetaCart
We show that a large fraction of the datastructure lower bounds known today in fact follow by reduction from the communication complexity of lopsided (asymmetric) set disjointness. This includes lower bounds for: • highdimensional problems, where the goal is to show large space lower bounds. • constantdimensional geometric problems, where the goal is to bound the query time for space O(n·polylogn). • dynamic problems, where we are looking for a tradeoff between query and update time. (In this case, our bounds are slightly weaker than the originals, losing a lglgn factor.) Our reductions also imply the following new results: • an Ω(lgn/lglgn) bound for 4dimensional range reporting, given space O(n · polylogn). This is quite timely, since a recent result [39] solved 3D reporting in O(lg 2 lgn) time, raising the prospect that higher dimensions could also be easy. • a tight space lower bound for the partial match problem, for constant query time. • the first lower bound for reachability oracles. In the process, we prove optimal randomized lower bounds for lopsided set disjointness.
Cell Probe Lower Bounds For Succinct Data Structures
"... In this paper, we consider several static data structure problems in the deterministic cell probe model. We develop a new technique for proving lower bounds for succinct data structures, where the redundancy in the storage can be small compared to the informationtheoretic minimum. In fact, we succee ..."
Abstract

Cited by 8 (0 self)
 Add to MetaCart
In this paper, we consider several static data structure problems in the deterministic cell probe model. We develop a new technique for proving lower bounds for succinct data structures, where the redundancy in the storage can be small compared to the informationtheoretic minimum. In fact, we succeed in matching (up to constant factors) the lower order terms of the existing data structures with the lower order terms provided by our lower bound. Using this technique, we obtain (i) the first lower bound for the problem of searching and retrieval of a substring in text; (ii) a cell probe lower bound for the problem of representing permutation π with queries π(i) and π−1 (i) thatmatchesthelower order term of the existing data structures, and (iii) a lower bound for representing binary matrices that is also matches upper bounds for some set of parameters. The nature of all these problems is that we are to implement two operations that are in a reciprocal relation to each other (search and retrieval, computing forward and inverse element, operations on rows and columns of a matrix). As far as we know, this paper is the first to provide an insight into such problems. 1
On Rounds in Quantum Communication
 IEEE Transactions on Information Theory
, 2000
"... We investigate the power of interaction in two player quantum communication protocols. Our main result is a roundscommunication hierarchy for the pointer jumping function f k . We show that f k needs quantum communication n) if Bob starts the communication and the number of rounds is limited to k ( ..."
Abstract

Cited by 8 (2 self)
 Add to MetaCart
We investigate the power of interaction in two player quantum communication protocols. Our main result is a roundscommunication hierarchy for the pointer jumping function f k . We show that f k needs quantum communication n) if Bob starts the communication and the number of rounds is limited to k (for any constant k). Trivially, if Alice starts, O(k log n) communication in k rounds suces. The lower bound employs a result relating the relative von Neumann entropy between density matrices to their trace distance and uses a new measure of information.
Mikkel Thorup: Randomization does not help searching predecessors
 Symposium on Discreat Algorithms
"... At STOC’06, we presented a new technique for proving cellprobe lower bounds for static data structures with deterministic queries. This was the first technique which could prove a bound higher than communication complexity, and it gave the first separation between data structures with linear and po ..."
Abstract

Cited by 7 (0 self)
 Add to MetaCart
At STOC’06, we presented a new technique for proving cellprobe lower bounds for static data structures with deterministic queries. This was the first technique which could prove a bound higher than communication complexity, and it gave the first separation between data structures with linear and polynomial space. The new technique was, however, heavily tuned for the deterministic worstcase, demonstrating long query times only for an exponentially small fraction of the input. In this paper, we extend the technique to give lower bounds for randomized query algorithms with constant error probability. Our main application is the problem of searching predecessors in a static set of n integers, each contained in a ℓbit word. Our tradeoff lower bounds are tight for any combination of parameters. For small space, i.e. n 1+o(1) , proving such lower bounds was inherently impossible through known techniques. An interesting new consequence is that for near linear space, the classic van Emde Boas search time of O(lg ℓ) cannot be improved, even if we allow randomization. This is a separation from polynomial space, since Beame and Fich [STOC’02] give a predecessor search time of O(lg ℓ / lg lg ℓ) using quadratic space. We also show a tight Ω(lg lg n) lower bound for 2dimensional range queries, via a new reduction. This holds even in rank space, where no superconstant lower bound was known, neither randomized nor worstcase. We also slightly improve the best lower bound for the approximate nearest neighbor problem, when small space is available. 1
Tight Lower Bounds for MultiPass Stream Computation via Pass Elimination
, 2008
"... There is a natural relationship between lower bounds in the multipass stream model and lower bounds in multiround communication. However, this connection is less understood than the connection between singlepass stream computation and oneway communication. In this paper, we consider datastream ..."
Abstract

Cited by 5 (3 self)
 Add to MetaCart
There is a natural relationship between lower bounds in the multipass stream model and lower bounds in multiround communication. However, this connection is less understood than the connection between singlepass stream computation and oneway communication. In this paper, we consider datastream problems for which reductions from natural multiround communication problems do not yield tight bounds or do not apply. While lower bounds are known for some of these datastream problems, many of these only apply to deterministic or comparisonbased algorithms, whereas the lower bounds we present apply to any (possibly randomized) algorithms. Our results are particularly relevant to evaluating functions that are dependent on the ordering of the stream, such as the longest increasing subsequence and a variant of tree pointer jumping in which pointers are revealed according to a postorder traversal. Our approach is based on establishing “passelimination” type results that are analogous to the roundelimination results of Miltersen et al. [23] and Sen [29]. We demonstrate our approach by proving tight bounds for a range of datastream problems including finding the longest increasing sequences (a problem that has recently become very
Lower Bounds for Asymmetric Communication Channels and Distributed Source Coding
"... 1 Introduction Many network systems have an inherent asymmetry between two (or more) classes of devices that leads to ..."
Abstract

Cited by 4 (0 self)
 Add to MetaCart
1 Introduction Many network systems have an inherent asymmetry between two (or more) classes of devices that leads to
The limits of buffering: A tight lower bound for dynamic membership in the external memory model
 In Proc. ACM Symposium on Theory of Computing
, 2010
"... We study the dynamic membership (or dynamic dictionary) problem, which is one of the most fundamental problems in data structures. We study the problem in the external memory model with cell size b bits and cache size m bits. We prove that if the amortized cost of updates is at most 0.999 (or any ot ..."
Abstract

Cited by 4 (2 self)
 Add to MetaCart
We study the dynamic membership (or dynamic dictionary) problem, which is one of the most fundamental problems in data structures. We study the problem in the external memory model with cell size b bits and cache size m bits. We prove that if the amortized cost of updates is at most 0.999 (or any other constant < 1), then the query cost must be Ω(logb log n (n/m)), where n is the number of elements in the dictionary. In contrast, when the update time is allowed to be 1 + o(1), then a bit vector or hash table give query time O(1). Thus, this is a threshold phenomenon for data structures. This lower bound answers a folklore conjecture of the external memory community. Since almost any data structure task can solve membership, our lower bound implies a dichotomy between two alternatives: (i) make the amortized update time at least 1 (so the data structure does not buffer, and we lose one of the main potential advantages of the cache), or (ii) make the query time at least roughly logarithmic in n. Our result holds even when the updates and queries are chosen uniformly at random and there are no deletions; it holds for randomized data structures, holds when the universe size is O(n), and does not make any restrictive assumptions such as indivisibility. All of the lower bounds we prove hold regardless of the space consumption of the data structure, while the upper bounds only need linear space. The lower bound has some striking implications for external memory data structures. It shows that the query complexities of many problems such as 1Drange counting, predecessor, rankselect, and many others, are all the same