Cell Probe Model Research Articles

Dynamic Parameterized Problems and Algorithms

Fixed-parameter algorithms and kernelization are two powerful methods to solve NP-hard problems. Yet so far those algorithms have been largely restricted to static inputs. In this article, we provide fixed-parameter algorithms and kernelizations for fundamental NP-hard problems with dynamic inputs. We consider a variety of parameterized graph and hitting set problems that are known to have f ( k ) n 1+o(1) time algorithms on inputs of size n , and we consider the question of whether there is a data structure that supports small updates (such as edge/vertex/set/element insertions and deletions) with an update time of g ( k ) n o(1) ; such an update time would be essentially optimal. Update and query times independent of n are particularly desirable. Among many other results, we show that F EEDBACK V ERTEX S ET and k -P ATH admit dynamic algorithms with f ( k )log O(1) update and query times for some function f depending on the solution size k only. We complement our positive results by several conditional and unconditional lower bounds. For example, we show that unlike their undirected counterparts, D IRECTED F EEDBACK V ERTEX S ET and D IRECTED k -P ATH do not admit dynamic algorithms with n o(1) update and query times even for constant solution sizes k ≤ 3 , assuming popular hardness hypotheses. We also show that unconditionally, in the cell probe model, D IRECTED F EEDBACK V ERTEX S ET cannot be solved with update time that is purely a function of k .

New amortized cell-probe lower bounds for dynamic problems

We build upon the recent papers by Weinstein and Yu [11], Larsen [7], and Clifford et al. [3] to present a general framework that gives amortized lower bounds on the update and query times of dynamic data structures. Using our framework, we present two concrete results.1.For the dynamic polynomial evaluation problem, where the polynomial is defined over a finite field of size n1+Ω(1) and has degree n, any dynamic data structure must either have an amortized update time of Ω((lg⁡n/lg⁡lg⁡n)2) or an amortized query time of Ω((lg⁡n/lg⁡lg⁡n)2).2.For the dynamic online matrix vector multiplication problem, where we get an n×n matrix whose entires are drawn from a finite field of size nΘ(1), any dynamic data structure must either have an amortized update time of Ω((lg⁡n/lg⁡lg⁡n)2) or an amortized query time of Ω(n⋅(lg⁡n/lg⁡lg⁡n)2). For these two problems, the previous works by Larsen [7] and Clifford et al. [3] gave the same lower bounds, but only for worst case update and query times. Our bounds match the highest unconditional lower bounds known till date for any dynamic problem in the cell-probe model.

Time Bounds for Streaming Problems

We give tight cell-probe bounds for the time to compute convolution, multiplication and Hamming distance in a stream. The cell probe model is a particularly strong computational model and subsumes, for example, the popular word RAM model. • We first consider online convolution where the task is to output the inner product between a fixed n-dimensional vector and a vector of the n most recent values from a stream. One symbol of the stream arrives at a time and the each output must be computed before the next symbols arrives. • Next we show bounds for online multiplication where the stream consists of pairs of digits, one from each of two n digit numbers that are to be multiplied. One pair arrives at a time and the task is to output a single new digit from the product before the next pair of digits arrives. • Finally we look at the online Hamming distance problem where the Hamming distance is outputted instead of the inner product. For each of these three problems, we give a lower bound of Ω ( δ w log n ) time on average per output, where δ is the number of bits needed to represent an input symbol and w is the cell or word size. We argue that these bound are in fact tight within the cell probe model.

Randomized Approximate Nearest Neighbor Search with Limited Adaptivity

We study the complexity of parallel data structures for approximate nearest neighbor search in d -dimensional Hamming space {0,1} d . A classic model for static data structures is the cell-probe model [27]. We consider a cell-probe model with limited adaptivity , where given a k ≥1, a query is resolved by making at most k rounds of parallel memory accesses to the data structure. We give two randomized algorithms that solve the approximate nearest neighbor search using k rounds of parallel memory accesses: —a simple algorithm with O ( k (log d ) 1/ k ) total number of memory accesses for all k ≥1; —an algorithm with O ( k +(1/ k log d ) O (1/ k ) ) total number of memory accesses for all sufficiently large k . Both algorithms use data structures of polynomial size. We prove an Ω(1/ k (log d ) 1/ k ) lower bound for the total number of memory accesses for any randomized algorithm solving the approximate nearest neighbor search within k ≤log log d /2log log log d rounds of parallel memory accesses on any data structures of polynomial size. This lower bound shows that our first algorithm is asymptotically optimal when k = O (1). And our second algorithm achieves the asymptotically optimal tradeoff between number of rounds and total number of memory accesses. In the extremal case, when k = O (log log d /log log log d ) is big enough, our second algorithm matches the Θ(log log d /log log log d ) tight bound for fully adaptive algorithms for approximate nearest neighbor search in [11].

Tight lower bounds for the longest common extension problem

The longest common extension problem is to preprocess a given string of length n into a data structure that uses S(n) bits on top of the input and answers in T(n) time the queries LCE(i,j) computing the length of the longest string that occurs at both positions i and j in the input. We prove that the trade-off S(n)T(n)=Ω(nlog⁡n) holds in the non-uniform cell-probe model provided that the input string is read-only, each letter occupies a separate memory cell, S(n)=Ω(n), and the size of the input alphabet is at least 28⌈S(n)/n⌉. It is known that this trade-off is tight.

Upper and Lower Bounds on the Power of Advice

Proving superpolylogarithmic lower bounds for dynamic data structures has remained an open problem despite years of research. Pǎtraşcu proposed an exciting approach for breaking this barrier via a two-player communication model in which one player gets private advice at the beginning of the protocol. He gave reductions from the problem of solving an asymmetric version of set-disjointness in his model to a diverse collection of natural dynamic data structure problems in the cell probe model. He also conjectured that, for any hard problem in the standard two-party communication model, the asymmetric version of the problem is hard in his model, provided not too much advice is given. In this paper, we prove several surprising results about his model. We show that there exist Boolean functions requiring linear randomized communication complexity in the two-party model, for which the asymmetric versions in his model have deterministic protocols with exponentially smaller complexity. For set-disjointness, which also requires linear randomized communication complexity in the two-party model, we give a deterministic protocol for the asymmetric version in his model with a quadratic improvement in complexity. These results demonstrate that Pǎtraşcu's conjecture, as stated, is false. In addition, we show that the randomized and deterministic communication complexities of problems in his model differ by no more than a logarithmic multiplicative factor. We also prove lower bounds in some restricted versions of this model for natural functions such as set-disjointness and inner product. All of our upper bounds conform to these restrictions. Moreover, a special case of one of these lower bounds implies a new proof of a strong lower bound on the tradeoff between the query time and the amortized update time of dynamic data structures with nonadaptive query algorithms.

Adapt or Die: Polynomial Lower Bounds for Non-Adaptive Dynamic Data Structures

In this paper, we study the role non-adaptivity plays in maintaining dynamic data structures. Roughly speaking, a data structure is non-adaptive if the memory locations it reads and/or writes when processing a query or update depend only on the query or update and not on the contents of previously read cells. We study such non-adaptive data structures in the cell probe model. The cell probe model is one of the least restrictive lower bound models and in particular, cell probe lower bounds apply to data structures developed in the popular word-RAM model. Unfortunately, this generality comes at a high cost: the highest lower bound proved for any data structure problem is only polylogarithmic (if allowed adaptivity). Our main result is to demonstrate that one can in fact obtain polynomial cell probe lower bounds for non-adaptive data structures. To shed more light on the seemingly inherent polylogarithmic lower bound barrier, we study several different notions of non-adaptivity and identify key properties that must be dealt with if we are to prove polynomial lower bounds without restrictions on the data structures. Finally, our results also unveil an interesting connection between data structures and depth-2 circuits. This allows us to translate conjectured hard data structure problems into good candidates for high circuit lower bounds; in particular, in the area of linear circuits for linear operators. Building on lower bound proofs for data structures in slightly more restrictive models, we also present a number of properties of linear operators which we believe are worth investigating in the realm of circuit lower bounds.

Succinct encoding of arbitrary graphs

We consider the problem of encoding graphs with n vertices and m edges compactly supporting adjacency, neighborhood and degree queries in constant time in the Θ(logn)-bit word RAM model. The adjacency query asks whether there is an edge between two vertices, the neighborhood query reports the neighbors of a given vertex in constant time per neighbor, and the degree query reports the number of incident edges to a given vertex.We study the problem in the context of succinctness, where the goal is to achieve the optimal space requirement as a function of n and m, to within lower order terms. We prove a lower bound in the cell probe model indicating it is impossible to achieve the information-theory lower bound up to lower order terms unless the graph is either too sparse (namely, m=o(nδ) for any constant δ>0) or too dense (namely m=ω(n2−δ) for any constant δ>0).Furthermore, we present a succinct encoding of graphs supporting aforementioned queries in constant time. The space requirement of the encoding is within a multiplicative 1+ϵ factor of the information-theory lower bound for any arbitrarily small constant ϵ>0. This is the best achievable space bound according to our lower bound where it applies. The space requirement of the representation achieves the information-theory lower bound tightly within lower order terms where the graph is very sparse (m=o(nδ) for any constant δ>0), or very dense (m>n2/lg1−δn for an arbitrarily small constant δ>0).

Time–space trade-offs for longest common extensions

We revisit the longest common extension (LCE) problem, that is, preprocess a string T into a compact data structure that supports fast LCE queries. An LCE query takes a pair (i,j) of indices in T and returns the length of the longest common prefix of the suffixes of T starting at positions i and j. We study the time–space trade-offs for the problem, that is, the space used for the data structure vs. the worst-case time for answering an LCE query. Let n be the length of T. Given a parameter τ, 1⩽τ⩽n, we show how to achieve either O(n/τ) space and O(τ) query time, or O(n/τ) space and O(τlog(|LCE(i,j)|/τ)) query time, where |LCE(i,j)| denotes the length of the LCE returned by the query. These bounds provide the first smooth trade-offs for the LCE problem and almost match the previously known bounds at the extremes when τ=1 or τ=n. We apply the result to obtain improved bounds for several applications where the LCE problem is the computational bottleneck, including approximate string matching and computing palindromes. We also present an efficient technique to reduce LCE queries on two strings to one string. Finally, we give a lower bound on the time–space product for LCE data structures in the non-uniform cell probe model showing that our second trade-off is nearly optimal.

Cell-Probe Proofs

We study the nondeterministic cell-probe complexity of static data structures. We introduce cell-probe proofs (CPP), a proof system for the cell-probe model, which describes verification instead of computation in the cell-probe model. We present a combinatorial characterization of CPP. With this novel tool, we prove the following lower bounds for the nondeterministic cell-probe complexity of static data structures. –There exists a data structure problem with high nondeterministic cell-probe complexity. –For the exact nearest neighbor search (NNS) problem or the partial match problem in high dimensional Hamming space, for any data structure with Poly( n ) cells, each of which contains O ( n C ) bits where C < 1, the nondeterministic cell-probe complexity is at least Ω(log( d /log n )), where d is the dimension and n is the number of points in the data set. –For the polynomial evaluation problem of d -degree polynomial over finite field of size 2 k where d ≤ 2 k , for any data structure with s cells, each of which contains b bits, the nondeterministic cell-probe complexity is at least min (( k / b ( d − 1)), ( k −log( d −1)/log s )).

Towards optimal range medians

We consider the following problem: Given an unsorted array of n elements, and a sequence of intervals in the array, compute the median in each of the subarrays defined by the intervals. We describe a simple algorithm which needs O ( n log k + k log n ) time to answer k such median queries. This improves previous algorithms by a logarithmic factor and matches a comparison lower bound for k = O ( n ) . The space complexity of our simple algorithm is O ( n log n ) in the pointer machine model, and O ( n ) in the RAM model. In the latter model, a more involved O ( n ) space data structure can be constructed in O ( n log n ) time where the time per query is reduced to O ( log n / log log n ) . We also give efficient dynamic variants of both data structures, achieving O ( log 2 n ) query time using O ( n log n ) space in the comparison model and O ( ( log n / log log n ) 2 ) query time using O ( n log n / log log n ) space in the RAM model, and show that in the cell-probe model, any data structure which supports updates in O ( log O ( 1 ) n ) time must have Ω ( log n / log log n ) query time. Our approach naturally generalizes to higher-dimensional range median problems, where element positions and query ranges are multidimensional—it reduces a range median query to a logarithmic number of range counting queries.

Succinct indexable dictionaries with applications to encoding k -ary trees, prefix sums and multisets

We consider the indexable dictionary problem, which consists of storing a set S ⊆ {0,…, m − 1} for some integer m while supporting the operations of rank( x ), which returns the number of elements in S that are less than x if x ∈ S , and −1 otherwise; and select( i ), which returns the i th smallest element in S . We give a data structure that supports both operations in O (1) time on the RAM model and requires B( n, m ) + o ( n ) + O (lg lg m ) bits to store a set of size n , where B( n, m ) = ⌊lg ( m / n )⌋ is the minimum number of bits required to store any n -element subset from a universe of size m . Previous dictionaries taking this space only supported (yes/no) membership queries in O (1) time. In the cell probe model we can remove the O (lg lg m ) additive term in the space bound, answering a question raised by Fich and Miltersen [1995] and Pagh [2001]. We present extensions and applications of our indexable dictionary data structure, including: —an information-theoretically optimal representation of a k -ary cardinal tree that supports standard operations in constant time; —a representation of a multiset of size n from {0,…, m − 1} in B( n, m + n ) + o ( n ) bits that supports (appropriate generalizations of) rank and select operations in constant time; and + O (lg lg m ) —a representation of a sequence of n nonnegative integers summing up to m in B( n, m + n ) + o ( n ) bits that supports prefix sum queries in constant time.

Lower bounds for predecessor searching in the cell probe model

We consider a fundamental problem in data structures, static predecessor searching: Given a subset S of size n from the universe [ m ] , store S so that queries of the form “What is the predecessor of x in S?” can be answered efficiently. We study this problem in the cell probe model introduced by Yao [A.C.-C. Yao, Should tables be sorted, J. Assoc. Comput. Mach. 28 (3) (1981) 615–628]. Recently, Beame and Fich [P. Beame, F. Fich, Optimal bounds for the predecessor problem and related problems, J. Comput. System Sci. 65 (1) (2002) 38–72] obtained optimal bounds as functions of either m or n only on the number of probes needed by any deterministic query scheme if the associated storage scheme uses only n O ( 1 ) cells of word size ( log m ) O ( 1 ) bits. We give a new lower bound proof for this problem that matches the bounds of Beame and Fich. Our lower bound proof has the following advantages: it works for randomised query schemes too, while Beame and Fich's proof works for deterministic query schemes only. In addition, it is simpler than Beame and Fich's proof. In fact, our lower bound for predecessor searching extends to the ‘quantum address-only’ query schemes that we define in this paper. In these query schemes, quantum parallelism is allowed only over the ‘address lines’ of the queries. These query schemes subsume classical randomised query schemes, and include many quantum query algorithms like Grover's algorithm [L. Grover, A fast quantum mechanical algorithm for database search, in: Proceedings of the 28th Annual ACM Symposium on Theory of Computing, 1996, pp. 212–219]. We prove our lower bound using the round elimination approach of Miltersen, Nisan, Safra and Wigderson [P. Bro Miltersen, Noam Nisan, S. Safra, A. Wigderson, On data structures and asymmetric communication complexity, J. Comput. System Sci. 57 (1) (1998) 37–49]. Using tools from information theory, we prove a strong round elimination lemma for communication complexity that enables us to obtain a tight lower bound for the predecessor problem. Our strong round elimination lemma also extends to quantum communication complexity. We also use our round elimination lemma to obtain a rounds versus communication tradeoff for the ‘greater-than’ problem, improving on the tradeoff in [P. Bro Miltersen, Noam Nisan, S. Safra, A. Wigderson, On data structures and asymmetric communication complexity, J. Comput. System Sci. 57 (1) (1998) 37–49]. We believe that our round elimination lemma is of independent interest and should have other applications.

On dynamic bit-probe complexity

This work present several advances in the understanding of dynamic data structures in the bit-probe model: • We improve the lower bound record for dynamic language membership problems to Ω ( ( lg n lg lg n ) 2 ) . Surpassing Ω ( lg n ) was listed as the first open problem in a survey by Miltersen. • We prove a bound of Ω ( lg n lg lg lg n ) for maintaining partial sums in Z / 2 Z . Previously, the known bounds were Ω ( lg n lg lg n ) and O ( lg n ) . • We prove a surprising and tight upper bound of O ( lg n lg lg n ) for the greater-than problem, and several predecessor-type problems. We use this to obtain the same upper bound for dynamic word and prefix problems in group-free monoids. We also obtain new lower bounds for the partial-sums problem in the cell-probe and external-memory models. Our lower bounds are based on a surprising improvement of the classic chronogram technique of Fredman and Saks [Michael L. Fredman, Michael E. Saks, The cell probe complexity of dynamic data structures, in: Proc. 21st ACM Symposium on Theory of Computing STOC, 1989, pp. 345–354], which makes it possible to prove logarithmic lower bounds by this approach. Before the work of M. Paˇtraşcu and Demaine [Mihai Paˇtraşcu, Erik D. Demaine, Logarithmic lower bounds in the cell-probe model, SIAM Journal on Computing 35 (4) (2006) 932–963. See also SODA’04 and STOC’04], this was the only known technique for dynamic lower bounds, and surpassing Ω ( lg n lg lg n ) was a central open problem in cell-probe complexity.

The cell probe complexity of succinct data structures

We consider time-space tradeoffs for static data structure problems in the cell probe model with word size 1 (the bit probe model). In this model, the goal is to represent n -bit data with s = n + r bits such that queries (of a certain type) about the data can be answered by reading at most t bits of the representation. Ideally, we would like to keep both s and t small, but there are tradeoffs between the values of s and t that limit the possibilities of keeping both parameters small. In this paper, we consider the case of succinct representations, where s = n + r for some redundancy r ≪ n . For a Boolean version of the problem of polynomial evaluation with preprocessing of coefficients, we show a lower bound on the redundancy–query time tradeoff of the form ( r + 1 ) t ≥ Ω ( n / log n ) . In particular, for very small redundancies r , we get an almost optimal lower bound stating that the query algorithm has to inspect almost the entire data structure (up to a logarithmic factor). We show similar lower bounds for problems satisfying a certain combinatorial properties of a coding theoretic flavor, and obtain ( r + 1 ) t ≥ Ω ( n ) for certain problems. Previously, no ω ( m ) lower bounds were known on t in the general model for explicit Boolean problems, even for very small redundancies. By restricting our attention to systematic or index structures ϕ satisfying ϕ ( x ) = x ⋅ ϕ ∗ ( x ) for some map ϕ ∗ (where ⋅ denotes concatenation), we show similar lower bounds on the redundancy–query time tradeoff for the natural data structuring problems of Prefix Sum and Substring Search.

Logarithmic Lower Bounds in the Cell-Probe Model

We develop a new technique for proving cell-probe lower bounds on dynamic data structures. This technique enables us to prove an amortized randomized $\Omega(\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 long-standing barrier of $\Omega(\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 $\Omega(\log_B n)$ lower bound in the external-memory model without assumptions on the data structure (such as the comparison model). Our lower bounds also give a query-update trade-off 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.

A strong lower bound for approximate nearest neighbor searching

We prove a lower bound of d 1−o(1) on the query time for any deterministic algorithms that solve approximate nearest neighbor searching in Yao's cell probe model. Our result greatly improves the best previous lower bound for this problem, which is Ω( loglogd logloglogd ) [A. Chakrabarti et al., in: Proc. 31st Ann. ACM Symp. Theory of Computing, 1999, pp. 305–311]. Our proof is also much simpler than the proof of A. Chakrabarti et al.

Dynamic nested brackets

We consider the problem of maintaining a string of n brackets `('or `)' under the operation reverse ( i ) that changes the i th 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.

Cell-probe lower bounds for the partial match problem

Given a database of n points in {0,1} d , the partial match problem is: In response to a query x in {0,1,∗} d , is there a database point y such that for every i whenever x i≠∗ , we have x i = y i . In this paper we show randomized lower bounds in the cell–probe model for this well-studied problem (Analysis of associative retrieval algorithms, Ph.D. Thesis, Stanford University, 1974; The Art of Computer Programming; Sorting and Searching, Addison-Wesley, Reading, MA, 1973; SIAM J. Comput. 5(1) (1976) 19; J. Comput. System Sci. 57(1) (1998) 37; Proceedings of the 31st Annual ACM Symposium on Theory of Computing, 1999; Proceedings of the 29th International Colloquium on Algorithms, Logic, and Programming, 1999). Our lower bounds follow from a near-optimal asymmetric communication complexity lower bound for this problem. Specifically, we show that either Alice has to send Ω(d/ log n) bits or Bob has to send Ω(n 1−o(1)) bits. When applied to the cell–probe model, it means that if the number of cells is restricted to be poly( n, d) where each cell is of size poly( log n,d) , then Ω(d/ log 2 n) probes are needed. This is an exponential improvement over the previously known lower bounds for this problem obtained by Miltersen et al. (1998) and Borodin et al. (1999). Our lower bound also leads to new and improved lower bounds for related problems including a lower bound for the ℓ ∞ c-nearest neighbor problem for c<3 and an improved communication complexity lower bound for the exact nearest neighbor problem.

New Lower Bound Techniques for Dynamic Partial Sums and Related Problems

We study the complexity of the dynamic partial sum problem in the cell-probe model. We give the model access to nondeterministic queries and prove that the problem remains hard. We give the model access to the right answer $\pm 1$ as an oracle and prove that the problem remains hard. This suggests which kind of information is hard to maintain. From these results, we derive a number of lower bounds for dynamic algorithms and data structures: We prove lower bounds for dynamic algorithms for existential range queries, reachability in directed graphs, planarity testing, planar point location, incremental parsing, and fundamental data structure problems like maintaining the majority of the prefixes of a string of bits. We prove a lower bound for reachability in grid graphs in terms of the graph's width. We characterize the complexity of maintaining the value of any symmetric function on the prefixes of a bit string.