Results 1 
8 of
8
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
Lower bounds for dynamic connectivity
 STOC
, 2004
"... We prove an Ω(lg n) cellprobe lower bound on maintaining connectivity in dynamic graphs, as well as a more general tradeoff between updates and queries. Our bound holds even if the graph is formed by disjoint paths, and thus also applies to trees and plane graphs. The bound is known to be tight fo ..."
Abstract

Cited by 15 (0 self)
 Add to MetaCart
We prove an Ω(lg n) cellprobe lower bound on maintaining connectivity in dynamic graphs, as well as a more general tradeoff between updates and queries. Our bound holds even if the graph is formed by disjoint paths, and thus also applies to trees and plane graphs. The bound is known to be tight for these restricted cases, proving optimality of these data structures (e.g., Sleator and Tarjan’s dynamic trees). Our tradeoff is known to be tight for trees, and the best two data structures for dynamic connectivity in general graphs are points on our tradeoff curve. In this sense these two data structures are optimal, and this tightness serves as strong evidence that our lower bounds are the best possible. From a more theoretical perspective, our result is the first logarithmic cellprobe lower bound for any problem in the natural class of dynamic language membership problems, breaking the long standing record of Ω(lg n / lg lg n). In this sense, our result is the first datastructure lower bound that is “truly ” logarithmic, i.e., logarithmic in the problem size counted in bits. Obtaining such a bound is listed as one of three major challenges for future research by Miltersen [13] (the other two challenges remain unsolved). Our techniques form a general framework for proving cellprobe lower bounds on dynamic data structures. We show how our framework also applies to the partialsums problem to obtain a nearly complete understanding of the problem in cellprobe and algebraic models, solving several previously posed open problems.
Lower Bound Techniques for Data Structures
, 2008
"... We describe new techniques for proving lower bounds on datastructure problems, with the following broad consequences:
â¢ the first Î©(lgn) lower bound for any dynamic problem, improving on a bound that had been standing since 1989;
â¢ for static data structures, the first separation between linea ..."
Abstract

Cited by 1 (0 self)
 Add to MetaCart
We describe new techniques for proving lower bounds on datastructure problems, with the following broad consequences:
â¢ the first Î©(lgn) lower bound for any dynamic problem, improving on a bound that had been standing since 1989;
â¢ for static data structures, the first separation between linear and polynomial space. Specifically, for some problems that have constant query time when polynomial space is allowed, we can show Î©(lg n/ lg lg n) bounds when the space is O(n Â· polylog n).
Using these techniques, we analyze a variety of central datastructure problems, and obtain improved lower bounds for the following:
â¢ the partialsums problem (a fundamental application of augmented binary search trees);
â¢ the predecessor problem (which is equivalent to IP lookup in Internet routers);
â¢ dynamic trees and dynamic connectivity;
â¢ orthogonal range stabbing;
â¢ orthogonal range counting, and orthogonal range reporting;
â¢ the partial match problem (searching with wildcards);
â¢ (1 + Îµ)approximate near neighbor on the hypercube;
â¢ approximate nearest neighbor in the lâ metric.
Our new techniques lead to surprisingly nontechnical proofs. For several problems, we obtain simpler proofs for bounds that were already known.
Synonyms: dynamic trees
"... The dynamic connectivity problem asks to maintain a graph G subject to the following operations: insert(u, v): insert an undirected edge (u, v) into the graph. delete(u, v): delete the edge (u, v) from the graph. connected(u, v): test whether u and v lie in the same connected component. Let m be an ..."
Abstract
 Add to MetaCart
The dynamic connectivity problem asks to maintain a graph G subject to the following operations: insert(u, v): insert an undirected edge (u, v) into the graph. delete(u, v): delete the edge (u, v) from the graph. connected(u, v): test whether u and v lie in the same connected component. Let m be an upper bound on the number of edges in the graph. This entry discusses cellprobe lower bounds for this problem. Let tu be the complexity of insert and delete, and tq be the complexity of query. The partialsums problem. Lower bounds for dynamic connectivity are intimately related to lower bounds for another classic problem: maintaining partial sums. Formally, the problem asks to maintain an array A[1.. n] subject to the following operations: update(k, ∆): let A[k] ← ∆. sum(k): returns the partial sum ∑k i=1 A[i]. testsum(k, σ): returns a boolean value indicating whether sum(k) = σ. To specify the problem completely, let elements A[i] come from an arbitrary group G, containing at least 2δ elements. In the cellprobe model with bbit cells, let tΣ u be the complexity of update, and tΣ q be the complexity of testsum (which is also a lower bound on sum). The tradeoffs between tΣ u and tΣ q are well understood for all values of b and δ. However, this entry only considers lower bounds under the standard assumptions that b = Ω(lg n) and tu ≥ tq. Assuming b = Ω(lg n) is standard for upper bounds in the RAM model, and also means that the lower bound applies to the pointer machine. Then, Pǎtra¸scu and Demaine [6] prove: Theorem 1. The complexity of the partialsums problems satisfies: tΣ q · lg(tΣ u/tΣ q) = Ω ( δ b · lg n). Observe that this matches the textbook upper bound using augmented trees. One can build a balanced binary tree over A[1],..., A[n], and store in every internal node the sum of its subtree. Then, updates and queries touch O(lg n) nodes (and spend O(⌈δ/b⌉) time in each one, due to the size of the group). To decrease the query time, one can use a Btree. 1 n
Lower Bounds for Dynamic Connectivity (2004; Pǎtra¸scu, Demaine) Mihai Pǎtra¸scu, MIT, web.mit.edu/∼mip/www/
"... The dynamic connectivity problem asks to maintain a graph G subject to the following operations: insert(u, v): insert an undirected edge (u, v) into the graph. delete(u, v): delete the edge (u, v) from the graph. connected(u, v): test whether u and v lie in the same connected component. Let m be an ..."
Abstract
 Add to MetaCart
The dynamic connectivity problem asks to maintain a graph G subject to the following operations: insert(u, v): insert an undirected edge (u, v) into the graph. delete(u, v): delete the edge (u, v) from the graph. connected(u, v): test whether u and v lie in the same connected component. Let m be an upper bound on the number of edges in the graph. We are interested in cellprobe lower bounds for this problem. We write tu for the complexity of insert and delete, and tq for the complexity of query. The partialsums problem. Lower bounds for dynamic connectivity are intimately related to lower bounds for another classic problem: maintaining partial sums. Formally, the problem asks to maintain an array A[1.. n] subject to the following operations: update(k, ∆): let A[k] ← ∆. sum(k): returns the partial sum �k i=1 A[i]. testsum(k, σ): returns a boolean value indicating whether sum(k) = σ. To specify the problem completely, we will say elements A[i] come from an arbitrary group G, containing at least 2 δ elements. In the cellprobe model with bbit cells, let t Σ u be the complexity of update, and t Σ q be the complexity of testsum (which is also a lower bound on sum). The tradeoffs between t Σ u and t Σ q are well understood for all values of b and δ. However, in this survey we only look at lower bounds under the standard assumptions that b = Ω(lg n) and tu ≥ tq. Assuming b = Ω(lg n) is standard for upper bounds in the RAM model, and also means that the lower bound applies to the pointer machine. Then, Pǎtra¸scu and Demaine [6] prove: Theorem 1. The complexity of the partialsums problems satisfies: tΣ q · lg(tΣ u/tΣ q) = Ω ( δ b · lg n). Observe that this matches the textbook upper bound using augmented trees. We can build a balanced binary tree over A[1],..., A[n], and store in every internal node the sum of its subtree. Then, updates and queries touch O(lg n) nodes (and spend O(⌈δ/b⌉) time in each one, due to the size of the group). To decrease the query time, we can use a Btree.
Abstract
, 2004
"... We consider the problem of maintaining a string of n brackets ‘( ’ or ‘) ’ under the operation reverse(i) that changes the ith bracket from ‘(’ to ‘) ’ or vice versa, and returns ‘yes ’ if and only if the resulting string is properly balanced. We show that this problem can be solved on the RAM in ti ..."
Abstract
 Add to MetaCart
We consider the problem of maintaining a string of n brackets ‘( ’ or ‘) ’ under the operation reverse(i) that changes the ith bracket from ‘(’ to ‘) ’ or vice versa, and returns ‘yes ’ if and only if the resulting string is properly balanced. We show that this problem can be solved on the RAM in time O(log n / log log n) per operation using linear space and preprocessing. Moreover, we show that this is optimal in the sense that every data structure supporting reverse (no matter its space and preprocessing complexity) needs time Ω(log n / log log n) per operation in the cell probe model. 1
LOGARITHMIC LOWER BOUNDS IN THE CELLPROBE MODEL ∗
"... Abstract. We develop a new technique for proving cellprobe lower bounds on dynamic data structures. This technique enables us to prove an amortized randomized Ω(lg n) lower bound per operation for several data structural problems on n elements, including partial sums, dynamic connectivity among dis ..."
Abstract
 Add to MetaCart
Abstract. We develop a new technique for proving cellprobe lower bounds on dynamic data structures. This technique enables us to prove an amortized randomized Ω(lg n) lower bound per operation for several data structural problems on n elements, including partial sums, dynamic connectivity among disjoint paths (or a forest or a graph), and several other dynamic graph problems (by simple reductions). Such a lower bound breaks a longstanding barrier of Ω(lg n / lg lg n) for any dynamic language membership problem. It also establishes the optimality of several existing data structures, such as Sleator and Tarjan’s dynamic trees. We also prove the first Ω(log B n) lower bound in the externalmemory model without assumptions on the data structure (such as the comparison model). Our lower bounds also give a queryupdate tradeoff curve matched, e.g., by several data structures for dynamic connectivity in graphs. We also prove matching upper and lower bounds for partial sums when parameterized by the word size and the maximum additive change in an update. Key words. Cellprobe complexity, lower bounds, data structures, dynamic graph problems, partialsums problem AMS subject classification. 68Q17 1. Introduction. The