Results 1  10
of
10
A geometric approach to lower bounds for approximate nearneighbor search and partial match
 In Proc. 49th IEEE Symposium on Foundations of Computer Science (FOCS
, 2008
"... This work investigates a geometric approach to proving cell probe lower bounds for data structure problems. We consider the approximate nearest neighbor search problem on the Boolean hypercube ({0, 1} d, ‖ · ‖1) with d = Θ(log n). We show that any (randomized) data structure for the problem that a ..."
Abstract

Cited by 15 (2 self)
 Add to MetaCart
(Show Context)
This work investigates a geometric approach to proving cell probe lower bounds for data structure problems. We consider the approximate nearest neighbor search problem on the Boolean hypercube ({0, 1} d, ‖ · ‖1) with d = Θ(log n). We show that any (randomized) data structure for the problem that answers capproximate nearest neighbor search queries using t probes must use space at least n1+Ω(1/ct). In particular, our bound implies that any data structure that uses space Õ(n) with polylogarithmic word size, and with constant probability gives a constant approximation to nearest neighbor search queries must be probed Ω(log n / log log n) times. This improves on the lower bound of Ω(log log d / log log log d) probes shown by Chakrabarti and Regev [8] for any polynomial space data structure, and the Ω(log log d) lower bound in Pătras¸cu and Thorup [26] for linear space data structures. Our lower bound holds for the near neighbor problem, where the algorithm knows in advance a good approximation to the distance to the nearest neighbor. Additionally, it is an average case lower bound for the natural distribution for the problem. Our approach also gives the same bound for (2 − 1)approximation to the farthest neighbor problem. c For the case of nonadaptive algorithms we can improve the bound slightly and show a Ω(log n) lower bound on the time complexity of data structures with O(n) space and logarithmic word size. We also show similar lower bounds for the partial match problem: any randomized tprobe data structure that solves the partial match problem on {0, 1, ⋆} d for d = Θ(log n) must use space n1+Ω(1/t). This implies an Ω(log n / log log n) lower bound for time complexity of near linear space data structures, slightly improving the Ω(log n/(log log n) 2) lower bound from [25],[16] for this range of d. Recently and independently Pătras¸cu achieved similar bounds [24]. Our results also generalize to approximate partial match, improving on the bounds of [4, 25]. 1 1
Fast Prefix Search in Little Space, with Applications
"... Abstract. It has been shown in the indexing literature that there is an essential difference between prefix/range searches on the one hand, and predecessor/rank searches on the other hand, in that the former provably allows faster query resolution. Traditionally, prefix search is solved by data stru ..."
Abstract

Cited by 8 (4 self)
 Add to MetaCart
(Show Context)
Abstract. It has been shown in the indexing literature that there is an essential difference between prefix/range searches on the one hand, and predecessor/rank searches on the other hand, in that the former provably allows faster query resolution. Traditionally, prefix search is solved by data structures that are also dictionaries—they actually contain the strings in S. For very large collections stored in slowaccess memory, we propose much more compact data structures that support weak prefix searches—they return the ranks of matching strings provided that some string in S starts with the given prefix. In fact, we show that our most spaceefficient data structure is asymptotically spaceoptimal. Previously, data structures such as String Btrees (and more complicated cacheoblivious string data structures) have implicitly supported weak prefix queries, but they all have query time that grows logarithmically with the size of the string collection. In contrast, our data structures are simple, naturally cacheefficient, and have query time that depends only on the length of the prefix, all the way down to constant query time for strings that fit in one machine word. We give several applications of weak prefix searches, including exact prefix counting and approximate counting of tuples matching conjunctive prefix conditions. 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 7 (2 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
Predecessor search with distancesensitive query time. arXiv:1209.5441
, 2012
"... ar ..."
(Show Context)
6.851: Advanced Data Structures Spring 2007
, 2007
"... The topic of this lecture is the fusion tree, another data structure to solve the predecessor/successor problem. Given a static set S ⊆ {0, 1, 2,..., 2 w − 1}, fusion trees can answer predecessor/successor queries in O(log w n). Essentially, fusion trees are Btrees with a branching factor of k = Θ( ..."
Abstract
 Add to MetaCart
(Show Context)
The topic of this lecture is the fusion tree, another data structure to solve the predecessor/successor problem. Given a static set S ⊆ {0, 1, 2,..., 2 w − 1}, fusion trees can answer predecessor/successor queries in O(log w n). Essentially, fusion trees are Btrees with a branching factor of k = Θ(w1/5). Tree height is
ABSTRACT
"... Proving lower bounds for range queries has been an active topic of research since the late 70s, but so far nearly all results have been limited to the (rather restrictive) semigroup model. We consider one of the most basic range problem, orthogonal range counting in two dimensions, and show almost o ..."
Abstract
 Add to MetaCart
(Show Context)
Proving lower bounds for range queries has been an active topic of research since the late 70s, but so far nearly all results have been limited to the (rather restrictive) semigroup model. We consider one of the most basic range problem, orthogonal range counting in two dimensions, and show almost optimal bounds in the group model and the (holy grail) cellprobe model. Specifically, we show the following bounds, which were known in the semigroup model, but are major improvements in the more general models: • In the group and cellprobe models, a static data structure of size n lg O(1) n requires Ω(lg n / lg lg n) time per query. This is an exponential improvement over previous bounds, and matches known upper bounds. • In the group model, a dynamic data structure takes time Ω ` lg n ( lg lg n)2 ´ per operation. This is close to the O(lg 2 n) upper bound, whereas the previous lower bound was Ω(lg n). Proving such (static and dynamic) bounds in the group model has been regarded as an important challenge at least
unknown title
, 2012
"... In the last two lectures, we discussed several data structures for solving predecessor and successor queries in the word RAM model: van Emde Boas trees, yfast trees, and fusion trees. This establishes an upper bound on the predecessor problem. In this lecture we discuss lower bounds on the cellpro ..."
Abstract
 Add to MetaCart
In the last two lectures, we discussed several data structures for solving predecessor and successor queries in the word RAM model: van Emde Boas trees, yfast trees, and fusion trees. This establishes an upper bound on the predecessor problem. In this lecture we discuss lower bounds on the cellprobe complexity of the static predecessor problem with constrained space. In particular, if we are constrained to polynomial space, then we obtain a lower bound of Ω ( { lg w min lg lg n, log}) w n using the round elimination technique in a communication model. This shows that the minimum of van Emde Boas trees and fusion trees solves the static predecessor problem optimally, up to a lg lg factor. The lower bound is particularly elegant because it only relies only on information theory. On the