the cell probe complexity of dynamic data structures dynamic data structure problems involve the representation of data in memory in such a way as to permit certain types of modifications of the data (updates) and certain types of questions about the data (queries). this paradigm encompasses many fundamental problems in computer science. the purpose of this paper is to prove new lower and upper bounds on the time per operation to implement solutions to some familiar dynamic data structure problems including list representation, subset ranking, partial sums, and the set union problem. the main features of our lower bounds are: they hold in the cell probe model of computation (a. yao [18]) in which the time complexity of a sequential computation is defined to be the number of words of memory that are accessed. (the number of bits b in a single word of memory is a parameter of the model). all other computations are free. this model is at least as powerful as a random access machine and allows for unusual representation of data, indirect addressing etc. this contrasts with most previous lower bounds which are proved in models (e.g., algebraic, comparison, pointer manipulation) which require restrictions on the way data is represented and manipulated. the lower bound method presented here can be used to derive amortized complexities, worst case per operation complexities, and randomized complexities. the results occasionally provide (nearly tight) tradeoffs between the number r of words of memory that are read per operation, the number w of memory words rewritten per operation and the size b of each word. for the problems considered here there is a parameter n that represents the size of the data set being manipulated and for these problems b = logn is a natural register size to consider. by letting b vary, our results illustrate the effect of register size on time complexity. for instance, one consequence of the results is that for some of the problems considered here, increasing the register size from logn to polylog(n) only reduces the time complexity by a constant factor. on the other hand, decreasing the register size from logn to 1 increases time complexity by a logn factor for one of the problems we consider and only a loglogn factor for some other problems. the first two specific data structure problems for which we obtain bounds are: list representation. this problem concerns the representation of an ordered list of at most n (not necessarily distinct) elements from the universe u = {1, 2,&hellip;, n}. the operations to be supported are report(k), which returns the kth element of the list, insert(k, u) which inserts element u into the list between the elements in positions k - 1 and k, delete(k), which deletes the kth item. subset rank. this problem concerns the representation of a subset s of u = {1, 2,&hellip;, n}. the operations that must be supported are the updates &ldquo;insert item j into the set&rdquo; and &ldquo;delete item j from the set&rdquo; and the queries rank(j), which returns the number of elements in s that are less than or equal to j. the natural word size for these problems is b = logn, which allows an item of u or an index into the list to be stored in one register. one simple solution to the list representation problem is to maintain a vector v, whose kth entry contains the kth item of the list. the report operation can be done in constant time, but the insert and delete operations may take time linear in the length of the list. alternatively, one could store the items of the list with each element having a pointer to its predecessor and successor in the list. this allows for constant time updates (given a pointer to the appropriate location), but requires linear cost for queries. this problem can be solved must more efficiently by use of balanced trees (such as avl trees). when b = logn, the worst case cost per operation using avl trees is o(logn). if instead b = 1, so that each bit access costs 1, then the avl three solution requires o(log2n) per operation. it is not hard to find similar upper bounds for the subset rank problem (the algorithms for this problem are actually simpler than avl trees). the question is: are these upper bounds bet possible? our results show that the upper bounds for the case of logn bit registers are within a loglogn factor of optimal. on the other hand, somewhat surprisingly, for the case of single bit registers there are implementations for both of these problems that run in time significantly faster than o(log2n) per operation. let cprobe(b) denote the cell probe computational model with register size b. theorem 1. if b &le; (logn)t for some t, then any cprobe(b) implementation of either list representation or the subset rank requires &ohgr;(logn/loglogn) amortized time per operation. theorem 2. subset rank and list representation have cprobe(1) implementations with respective complexities o((logn)(loglogn)) and o((logn)(loglogn)2) per operation. paul dietz (personal communication) has found an implementation of list representation with logn bit registers that requires only o(logn/loglogn) time per operation, and thus the result of theorem 1 is best possible. the lower bounds of theorem 1 are derived from lower bounds for a third problem: partial sum mode k. an array a[1],&hellip;, a[n] of integers mod k is to be represented. updates are add(i, &dgr;) which implements a[i] &larr; a[i] + &dgr;; and queries are sum(j) which returns &sgr;i&le;ja[i] (mod k). this problem is demoted ps(n, k). our main lower bound theorems provide tradeoffs between the number of register rewrites and register reads as a function of n, k, and b. two corollaries of these results are: theorem 3. any cprobe(b) implementation of ps(n, 2) (partial sums mod 2) requires &ohgr;(logn/(loglogn + logb)) amortized time per operation, and for b &ge; logn, there is an implementation that achieves this. in particular, if b = &thgr;((logn)c) for some constant c, then the optimal time complexity of ps(n, 2) is &thgr;(logn/loglogn). theorem 4. any cprobe(1) implementation of ps(n, n) with single bit registers requires &ohgr;((logn/loglogn)2) amortized time per operation, and there is an implementation that achieves o(log2n) time per operation. it can be shown that a lower bound of ps(n, 2) is also a lower bound for both list representation and subset rank (the details, which are not difficult, are omitted from this report), and thus theorem 1 follows from theorem 3. the results of theorem 4 make an interesting contrast with those of theorem 2. for the three problems, list representation, subset rank and ps(n, k), there are standard algorithms that can be implemented on a cprobe(logn) that use time o(logn per operation, and their implementations on cprobe(1) require o(log2n) time. theorem 4 says that for the problem ps(n, n) this algorithm is essentially best possible, while theorem 2 says that for list representation and rank, the algorithm can be significantly improved. in fact, the rank problem an be viewed as a special case of ps(n, n) where the variables take on values on {0, 1}, and apparently this specialization is enough to reduce the complexity on a cprobe(1) by a factor of logn/loglogn, even though on a cprobe(logn) the complexities of the two problems differ by no more than a loglogn factor. the third problem we consider is the set union problem. this problem concerns the design of a data structure for the on-line manipulation of sets in the following setting. initially, there are n singleton sets {1}, {2},&hellip;, {n} with i chosen as the name of the set {i}. our data structure is required to implement two operations, find(j), and union(a, b, c). the operation find(j) returns the name of the set containing j. the operation union(a, b, c) combines the sets with names a and b. the names of the existing sets at any moment must be unique and chosen to be integers in the range from 1 to 2n. the sets existing at any time are disjoint and define a partition of the elements into equivalence classes. a well known data structure for the set union problem represents the sets as trees and stores the name of a set in the root of its corresponding tree. a union operation is performed by attaching the root of the smaller set as a child of the root of the larger set (weight rule). a find operation is implemented by following the path from the appropriate node to the root of the tree containing it, and then redirecting to the root the parent pointers of the nodes encountered along this path (path compression). from now on we consider sequences of union and find operations consisting of n-1 union operations and m find operations with m &ge; n. tarjan [14] demonstrated that the above algorithm requires time &thgr;(m&agr;(m, n)), where &agr;(m, n) is an inverse to ackermann's function, to execute n-1 union and m find operations. in particular, if m = &thgr;(n), then the running time is almost, but not quite, linear. tarjan conjectured [14] that no linear time algorithm exists for the set union problem, and provided significant evidence in favor of this conjecture (which we discuss in the following section). we affirm tarjan's conjecture in the cprobe(logn) model. theorem 5. any cprobe(logn) implementation of the set union problem requires &ohgr;(m&agr;(m, n)) time to execute m find's and n-1 union's, beginning with n singleton sets. n. blum [2] has given a logn/loglogn algorithm (worst case time per operation) for the set union problem. this algorithm is also optimal in the cprobe(polylogn) model. the following section provides further discussion of these results, section 3 outlines our lower bound method, and section 4 contains some proofs.