Cell-probe Lower Bounds for Dynamic Problems via a New Communication Model
aa r X i v : . [ c s . D S ] D ec Cell-probe Lower Bounds for Dynamic Problems via a NewCommunication Model
Huacheng YuStanford University
Abstract
In this paper, we develop a new communication model to prove a data structure lower bound for thedynamic interval union problem. The problem is to maintain a multiset of intervals I over [0 , n ] withinteger coordinates, supporting the following operations: • insert(a, b) : add an interval [ a, b ] to I , provided that a and b are integers in [0 , n ] ; • delete(a, b) : delete a (previously inserted) interval [ a, b ] from I ; • query() : return the total length of the union of all intervals in I .It is related to the two-dimensional case of Klee’s measure problem. We prove that there is a dis-tribution over sequences of operations with O ( n ) insertions and deletions, and O ( n . ) queries, forwhich any data structure with any constant error probability requires Ω( n log n ) time in expectation.Interestingly, we use the sparse set disjointness protocol of H˚astad and Wigderson [ToC’07] to speedup a reduction from a new kind of nondeterministic communication games, for which we prove lowerbounds.For applications, we prove lower bounds for several dynamic graph problems by reducing them fromdynamic interval union. Introduction
In computational geometry, Klee’s measure problem [11, 3, 4] is the following: given N rectangular ranges(axis-parallel hyperrectangles) in d -dimensional space, compute the volume of their union.A classic sweep-line algorithm by Bentley [3] solves the d = 2 case in O ( N log N ) time: consider theline x = x with x continuously increasing from −∞ to ∞ ; the length of the intersection of this line andthe union may change only when it reaches the left or right border of a rectangle. Bentley’s algorithm usesa segment tree to dynamically maintain the length of the intersection efficiently. Surprisingly, this is thebest known algorithm even for an intriguing special case: all coordinates are integers within a polynomiallybounded range [0 , n ] . In this case, the segment tree in Bentley’s algorithm is essentially used to solve thefollowing dynamic problem, which we call the dynamic interval union problem :Maintain a multiset I of intervals with integer coordinates in [0 , n ] , supporting the following operations: • insert(a, b) : add an interval [ a, b ] to I , provided that a and b are integers in [0 , n ] ; • delete(a, b) : delete a (previously inserted) interval [ a, b ] from I ; • query() : return the total length of the union of all intervals in I .The segment tree data structure solves this dynamic problem with O (log n ) insertion and deletion time,and O (1) query time. For the application to 2D Klee’s measure problem, there are N insertions, N deletionsand N queries to the data structure. A natural question to ask here is whether we can improve the insertionand deletion time. However, there is a very simple reduction from the partial sum problem showing thatthe slowest operation among insertion, deletion and query needs to take Ω(log n ) time (see Appendix A).Moreover, Pˇatras¸cu and Demaine [18, 20] showed an optimal trade-off between update and query time forpartial sum, which can be carried over via the reduction to show that if both insertion and deletion need tobe done in O ( ǫ log n ) time, then query has to take Ω(2 /ǫ log n ) time.This seems to be the end of the story. However, in fact, there is no o ( N log N ) time algorithm knowneven for n = N . . When we apply the above dynamic problem to this case, there will be N insertions, N deletions, and only n = N . queries! There will be far fewer queries than insertions and deletions.The argument above does not rule out the possibility of having a dynamic interval union data structure with o (log n ) update time, and O ( n . ) query time. It is even possible to have a data structure with O (1) insertionand deletion time, and O ( n . ) query time. Having such a data structure would give a linear time algorithmfor the above special case of Klee’s measure problem, making a breakthrough on this 40-year-old problem.Unfortunately, we show that such data structure does not exist, even if we allow randomization, amorti-zation and constant error probability. Theorem 1.
For any ǫ > and integer n ≥ , there is a distribution over operation sequences to thedynamic interval union problem over [0 , n ] , with O ( n − ǫ ) insertions and deletions, and O ( n ǫ ) queries, forwhich any data structure that correctly answers all queries simultaneously with probability ≥ mustspend Ω( ǫ n − ǫ log n ) probes in expectation, in the cell-probe model with word size Θ(log n ) . We define the cell-probe model in Section 1.1.It is an easy exercise to show that we can use the hard distribution from the theorem to obtain a new harddistribution with Θ( n / . ) = Θ( N ) insertions and deletions and n queries, such that any data structurerequires Ω( N log N ) time on it. This lower bound rules out the possibility of using the plain-vanilla sweep-line algorithm with a sophisticated data structure to solve 2D Klee’s measure problem faster than the classicalgorithm. As a corollary, the theorem also implies that o (log n ) insertion and deletion time leads to analmost linear lower bound on query time. There is a simple linear time algorithm for the n ≤ √ N case. t ( n ) usually means that the first k operations take at most k · t ( n ) time for every k , buthere, even if we fix the number of operations in advance, and the data structure is allowed to use heavypreprocessing in order to optimize the total running time, there is still no way to break the lower bound.This notion of running time is usually what we care about, when applying a data structure to solve somecomputational problem. The only catch is that the data structure is online: it must output an answer beforeseeing the next operation, which makes it different from an offline computational problem. Moreover, weclaim without proof the following theorem that using the same hard distribution, the same lower bound holdsfor data structures that correctly answer any constant fraction of the queries in expectation. Theorem 1 ′ . For any ǫ > and integer n ≥ , there is a distribution over operation sequences to thedynamic interval union problem over [0 , n ] , with O ( n − ǫ ) insertions and deletions, and O ( n ǫ ) queries, forwhich any data structure with expected fraction of correct answers at least δ must spend Ω δ ( ǫ n − ǫ log n ) probes in expectation for any δ ∈ (0 , , in the cell-probe model with word size Θ(log n ) . We prove Theorem 1 via a reduction from a more accessible intermediate problem called batch par-tial sum , for which we prove a lower bound directly. The batch partial sum problem asks to maintain K sequences ( A i,j ) i ∈ [ K ] ,j ∈ [ B ] of length B over a finite field F p , supporting the following operations to thesequences: • update( j , v ) : for all i ∈ [ K ] , set A i,j i to value v i ; • query( j ) : return P i ∈ [ K ] P l ≤ j i A i,l ,provided that j and v are vectors of length K , and j i ∈ [ B ] , v i ∈ F p . Basically, we need to maintain K independent copies of the partial sum problem, except that when answering queries, instead of returning K individual prefix sums, we only need to return the sum of these K numbers. Theorem 2.
For large enough integers
K, B, p with p ≥ B , there is a distribution over operation sequencesto the batch partial sum problem with O ( B ) updates and O ( B ) queries, for which any data structurethat correctly answers all queries simultaneously with probability ≥ must spend Ω( KB log B/ ( w +log B )) probes in expectation, in the cell-probe model with word size w . Note that when
K, B, p are all polynomials in n and w = Θ(log n ) for some n , the lower boundbecomes Ω( K log n ) per operation. Therefore, in this case, the best thing to do is just to use K partial sumdata structures to maintain the K sequences independently. However, the techniques we use in the proofare very different from the proof of the lower bound for partial sum by Pˇatras¸cu and Demaine [19]. SeeSection 1.3 for an overview.Moreover, we also apply our main theorem to prove lower bounds for three dynamic graph problems:dynamic o (log n ) update time, then queries must take n − o (1) time. Note that a previous result by Pˇatras¸cu andThorup [21] also implies the same trade-off for the first two problems under zero error. Corollary 2.
For the following three dynamic graph problems:(a) dynamic In this paper, [ K ] stands for the set of positive integers { , , . . . , K } . c) dynamic weight s-t shortest path,any data structure with amortized expected update time o (log n ) , and error probability ≤ under poly-nomially many operations must have amortized expected query time n − o (1) . The cell-probe model of Yao [26] is a strong non-uniform computational model for data structures. A datastructure in the cell-probe model has access to a set of memory cells. Each cell can store w bits. The set ofcells is indexed by w -bit integers, i.e., the address is in [2 w ] . w is usually set to be Ω(log n ) , where n is theamount of information the data structure needs to handle. To access the memory, the data structure can probe a cell, which means that it can look at the contentof the cell, and then optionally overwrite it with a new value. During an operation, the data structure basedon the parameters of the operation decides which cell to probe the first, then based on the parameters andthe information from the first probe, decides the cell to probe next, etc. Each cell-probe (including both theaddress and the new value) the data structure performs may be an arbitrary function of the parameters of theoperation and the contents in the cells previously probed during this operation. If the operation is a query,in the end, the data structure returns an answer based on the parameters and the contents in all cells probedduring this operation. The update (query resp.) time is defined to be the number of cells probed during a(n)update (query resp.) operation.The cell-probe model only counts the number of memory accesses during each operation, making itselfa strong model, e.g., it subsumes the word-RAM model. Thus, data structure lower bounds proved in thismodel will hold in various other settings as well.
In 1989, Fredman and Saks introduced the chronogram method to prove an
Ω(log n/ log log n ) lower boundfor partial sum in their seminal paper [9]. The lower bound is tight for maintaining a sequence of { , } s. Ω(log n/ log log n ) was also the highest lower bound proved for any explicit data structure problem for along time.In 2004, Pˇatras¸cu and Demaine [19] broke this log n/ log log n barrier using a new approach: the in-formation transfer tree technique. They proved an Ω(log n ) lower bound for the partial sum problem withnumbers in [ n ] . Moreover, using this new technique, one can prove an update-query time trade-off of t q log t u t q = Ω(log n ) , where t u is the update time and t q is the query time, while earlier approaches can onlyprove t q log t u = Ω(log n ) . Later on, the information transfer tree technique has been used to prove severalother data structure lower bounds [18, 8, 6, 7].In 2012, there was a breakthrough by Larsen [13] on dynamic data structure lower bounds. Larsencombined the chronogram method with the cell sampling technique of Panigraphy, Talwar and Wieder [15],and proved an Ω((log n/ log log n ) ) lower bound for the 2D orthogonal range counting problem. Thislower bound is also the highest lower bound proved for any explicit dynamic data structure problem so far.Similar approaches were also applied later [14, 5].All above techniques can only be used to prove a relatively smooth trade-off between update and querytime. However, Pˇatras¸cu and Thorup [21] used a new idea to prove a sharp trade-off for the dynamic con-nectivity problem in undirected graphs. They proved that if one insists on o (log n ) insertion and deletiontime, query has to take n − o (1) time. Besides the sharp trade-off, they also introduced the simulation bycommunication games of the data structure. They first decomposed the entire execution of the data struc-ture on a sequence of operations into several communication games. For each communication game, they n is usually a polynomial in the number of operations. Although the batch partial sum problem looks similar to the partial sum problem, it seems hopeless to applythe information transfer technique directly to solve our problem. It is due to a critical difference between thetwo problems: in partial sum, the lower bound proved roughly equals to the number of bits in the answer toa query; while in batch partial sum, the lower bound we aim at is much larger than the size of an answer. Theproof in [19] heavily relies on the fact that in partial sum problem, after fixing the values in a lot of entriesin the sequence, as long as there is still one summand in the prefix sum left uniformly at random, the sumwill also be uniformly at random. Therefore, we will need to learn a certain amount of information fromthe memory to figure out the answer. If we apply the same technique in batch partial sum, as an answer stillcontains only log n bits of information, we will again get a lower bound of Ω(log n ) per operation, while weaim at Ω( K log n ) . The cell sampling technique has a similar issue. It can only be applied when the numberof bits used to describe a query is comparable with the number of bits used in an answer.The main idea of our proof is to use the simulation by communication games technique mentioned inSection 1.2. After decomposing into communication games, there are two things to prove: a “fast” datastructure implies an efficient communication protocol, and no efficient communication protocol exists. Thechoice of communication model for the game is crucial. If we use a too weak communication model, itwould be hard to take advantage of the model to design an efficient protocol given fast data structure. If thecommunication model we use is too strong, it would be difficult or even impossible to prove a communica-tion lower bound, especially when small chance of error is allowed. Pˇatras¸cu and Thorup gave two differentsimulations: one in the deterministic setting, the other in the nondeterministic setting. The deterministicsimulation itself (transforming a data structure into a communication protocol) is not efficient enough toachieve our lower bound. The nondeterministic model, in our case of allowing error, would correspond tothe distributional MA cc ∩ co- MA cc model. It is particularly difficult to prove a lower bound in this model.In our application, the communication problem we want to prove a lower bound for is closely related to theinner product problem. Namely, Alice and Bob get n -dimensional binary vectors x and y respectively andthe goal is to compute the inner product h x, y i over F . There is a clever MA cc ∩ co- MA cc protocol byAaronson and Wigderson [1] which solves the inner product problem with only ˜ O ( √ n ) bits of communica-tion. It has much less cost than expected, which suggests that it might even be impossible to prove a desiredlower bound for our problem in this strong model.To overcome this obstacle, we define a new communication model (see Section 3), which is weakerthan MA cc ∩ co- MA cc , so that we are capable of proving a desired communication lower bound. Moreover,we will be able to achieve the same performance of transforming data structure into protocol as in thenondeterministic model. Interestingly, in order to have less requirement on the power of communicationmodel, we use an elegant protocol for computing sparse set disjointness by H˚astad and Wigderson [10] as asubroutine: Theorem 3 (H˚astad and Wigderson) . In the model of common randomness, R (DISJ nk ) = O ( k ) for in-stances of disjoint sets and R (DISJ nk ) = O ( k + log n ) for non-disjoint sets. DISJ nk is the following problem: Alice and Bob get sets X and Y of size k over a universe [ n ] re-spectively, their goal is to compute whether the two sets are disjoint. R (DISJ nk ) stands for the minimumexpected communication cost by any zero-error protocol which computes DISJ nk .As we will see later, this new communication model has the power of nondeterminism. Also it isrestricted enough so that we can apply the classic techniques for proving randomized communication lower5ounds. Using this model, we prove the first sharp update-query trade-off under constant probability oferror. The remainder of this paper is organized as follows. In Section 3, we present the reduction from batchpartial sum to dynamic interval union, and define the new communication model and the new simulation.In Section 4, we prove a communication lower bound in this new model, which completes the proof ofour main result. In Section 5, we apply the main theorem to several dynamic graph problems. Finally, weconclude with some remarks in Section 6.
In the classic deterministic communication complexity setting [25], two players Alice and Bob receive inputs x ∈ X and y ∈ Y respectively. Their goal is to collaboratively evaluate a function f on their joint input ( x, y ) . The players send bits to each other according to some predefined protocol. At each step, the protocolmust specify which player sends the next bit based on the transcript (the bits sent so far). The sender decidesto send a bit 0 or 1 based on the transcript and his/her input. It the end, the answer f ( x, y ) can only dependon the entire transcript. In the setting with public randomness, the players have access to a common randombinary string of infinite length. Besides the sender’s input and the transcript, each message may also dependon these random bits. The players have infinite computational power. The cost of a protocol is the numberof bits communicated, i.e., the length of the transcript. Definition 1.
For function f with domain X × Y , the matrix M ( f ) is a |X | × |Y| matrix, with rows indexedby X and columns indexed by Y . The entry in row x and column y is the function value f ( x, y ) . Definition 2. A combinatorial rectangle or simply a rectangle in M ( f ) is a set X × Y for X ⊆ X and Y ⊆ Y . Definition 3. A monochromatic rectangle in M ( f ) is a combinatorial rectangle in which the function valuedoes not vary. Definition 4.
Let µ be a distribution over X × Y . A α - monochromatic rectangle under µ is a combinatorialrectangle X × Y such that there is a function value v , αµ ( X × Y ) ≤ µ (( X × Y ) ∩ f − ( v )) , i.e., acombinatorial rectangle with at least α -fraction of the input pairs having the same function value. A classic result [12] in communication complexity is that every protocol in the deterministic setting withworst-case communication cost C induces a partitioning of M ( f ) into C monochromatic rectangles. Eachrectangle corresponds to one possible transcript, i.e., when the players are given an input pair in this rectan-gle, the corresponding transcript will be transmitted. A similar result shows that every randomized protocolwith low error probability induces a partitioning into rectangles, such that most of the rectangles are nearlymonochromatic ( α -monochromatic with α close to ). Proving there is no large monochromatic rectangleor nearly monochromatic rectangle in M ( f ) would imply communication lower bounds in deterministic orrandomized setting respectively. In this session, we will prove our main result, a lower bound for the dynamic interval union problem, via areduction from the batch partial sum problem. 6 heorem 1.
For any ǫ > and integer n ≥ , there is a distribution over operation sequences to thedynamic interval union problem over [0 , n ] , with O ( n − ǫ ) insertions and deletions, and O ( n ǫ ) queries, forwhich any data structure that correctly answers all queries simultaneously with probability ≥ mustspend Ω( ǫ n − ǫ log n ) probes in expectation, in the cell-probe model with word size Θ(log n ) . Theorem 2.
For large enough integers
K, B, p with p ≥ B , there is a distribution over operation sequencesto the batch partial sum problem with O ( B ) updates and O ( B ) queries, for which any data structurethat correctly answers all queries simultaneously with probability ≥ must spend Ω( KB log B/ ( w +log B )) probes in expectation, in the cell-probe model with word size w . The idea of this reduction is similar to the proof of Proposition 1 in Appendix A.
Proof of Theorem 1.
Take prime p = Θ( n ǫ ) , B = Θ( n ǫ ) with B ≤ p , and K = n/Bp = Θ( n − ǫ ) . Weare going to show that we can solve the batch partial sum problem with this setting of the parameters givena dynamic interval union data structure over [0 , n ] . We first concatenate the K sequences into one longsequence of length KB , such that A i,j will be (( i − · B + j ) -th number in the long sequence, and tryto maintain the whole sequence using one dynamic interval union data structure. Then we associate eachnumber in the long sequence with a segment of length p in [0 , n ] such that the k -th number in the longsequence is associated with [( k − · p, k · p ] . We use the length of interval in the associated segment toindicate the value of the number. That is, we always maintain the invariant that for k -th number in the longsequence with non-zero value v , we have exactly one interval [( k − · p, ( k − · p + v ] intersecting itsassociated segment.To set k -th number to a new value v ′ , if before the operation it had value v = 0 , we first call delete (( k − p, ( k − p + v ) to reset the number. Then if v ′ = 0 , we call insert (( k − p, ( k − p + v ′ ) to updateits new value to v ′ . Therefore, as an update of the batch partial sum problem is just setting K numbersto new values, it can be implemented using O ( K ) insertions and deletions of the dynamic interval unionproblem, with O ( K ) extra probes to determine what the old value was and to record the new value.To answer query ( j ) , we first insert intervals that correspond to associated segments of the ( j i + 1) -thnumber to the last number in sequence i for i ∈ [ K ] , to set everything we are not querying to be “in theunion”, no matter how much they were covered by intervals before. That is, we insert [(( i − B + j i ) · p, iB · p ] for each sequence i . Then we do one query, which will return the sum of all numbers as if each number notin the query was set to p (or modulo p ). This number modulo p is exactly the answer we want. At last, wedo K deletions to remove the temporary intervals we inserted earlier for this query, and return the answer.Therefore, every query of batch partial sum can be implemented using O ( K ) insertions and deletions, andone query of the dynamic interval union.Thus, any sequence of O ( B ) updates and O ( B ) queries of batch partial sum can be implemented using O ( KB ) = O ( n − ǫ ) insertions and deletions, O ( B ) = O ( n ǫ ) queries of dynamic interval union, and extra O ( K ) = O ( n − ǫ ) probes. However, by Theorem 2, there is a hard distribution consisting of O ( B ) updatesand O ( B ) queries, which requires Ω( KB log B/ ( w + log B )) = Ω( ǫ n − ǫ log n ) probes in expectationin the cell-probe model with word size w = Θ(log n ) . By the above reduction, this hard distribution alsoinduces a distribution over operation sequences for dynamic interval union with desired number of updates,queries and lower bound on the number of probes. This proves the theorem.By setting ǫ = p t u / log n in Theorem 1, we get the following corollary. Corollary 1.
Any dynamic interval union data structure that answers all queries correctly in a sequence of O ( n ) operations with probability ≥ with expected amortized insertion and deletion time t u and querytime t q must have t q ≥ t u n − √ t u / log n . n particular, t u = o (log n ) implies that t q = n − o (1) . In the following, we are going to prove a lower bound for the batch partial sum problem. We will firstspecify a hard distribution over operation sequences. Then by Yao’s Minimax Principle [24], it suffices toshow that any deterministic data structure that answers all queries correctly with high probability under thisinput distribution must be inefficient. To show this, we will consider a collection of communication gamescorresponding to different parts of the operation sequence (different time periods). For each communicationgame, if the data structure is fast within the corresponding time period under certain measure of efficiency,then the game can be solved with low communication cost . On the other hand, we will prove communicationlower bounds for all these games. Summing these lower bounds up, we will be able to prove that the entireexecution cannot be efficient.
Hard distribution D : Without loss of generality, assume B is a power of , and B = 2 b . The operationsequence will always have B updates and B queries occurring alternatively: U , Q , . . . , U B − , Q B − ,where the U t ’s are updates, and the Q t ’s are queries. The operations are indexed by integers between and B − , or they can be viewed as being indexed by b -bit binary strings (which corresponds to the binaryrepresentation of the integer). We may use either of these two views in the rest of the paper without furthermention. Let t be a binary string, rev( t ) be the string with t ’s bits reversed. For each U t , we set it to update( j , v ) with j i = rev( t ) and v i independently uniformly chosen from F p for every i . For each Q t , we set it to query( j ) with j i independently and uniformly chosen from [ B ] . Different operations aresampled independently. Indicate this distribution by D . Communication game:
The hard distribution D has a fixed pattern of updates and queries. Let us fix two consecutive intervals I A , I B of operations (with I A before I B ) in the sequence. Define the communicationgame G ( I A , I B ) between two players Alice and Bob to be the following: sample a sequence from D , Aliceis given all operations except for those in I B , Bob is given all operations except for those in I A , their goal isto cooperatively compute the answers to all queries in I B by sending messages to each other alternatively.Given a deterministic batch partial sum data structure, a nature way to solve this game is to let Bob firstsimulate the data structure up to the beginning of I A , then skip all the operations in I A and try to continuesimulating on I B . Every time Bob needs to probe a cell, if it was probed in I A , he sends a message toAlice asking for the new value, otherwise he knows exactly what is in the cell from his own simulation. Thechallenge for Bob is to figure out which cells were probed. Our main idea is to introduce a prover Merlin,who knows both Alice and Bob’s inputs. Merlin will tell them this information in a unique and succinct way. Moreover, the players will be able to verify whether the message from Merlin is exactly what theyexpect, and will be able to solve the task efficiently if it is. This motivates the following definition of a newcommunication model. Communication model M : Draw an input pair ( x, y ) from a known distribution. Alice is given x , Bobis given y and Merlin is given both x and y . Their goal is to compute some function f ( x, y ) . As part ofthe communication protocol, the players must specify a unique string Z ( x, y ) for every possible input pair,which is the message Merlin is supposed to send. A communication procedure shall consist of the followingfour stages:1. Merlin sends a message z to Alice and Bob based on his input pair ( x, y ) ;2. Alice and Bob communicate based on ( x, z ) and ( y, z ) as in the classic communication setting withpublic randomness. Merlin does not see the random bits when sending the message z ;3. Alice and Bob decide to accept or reject; 8. if the players accept in Stage 3, they return a value v .In this model, we say a protocol computes function f with error ε and communication cost C , if1. Alice and Bob accept in Stage 3 if and only if Merlin sends what he is supposed to send, i.e., z = Z ( x, y ) (with probability 1),2. given z = Z ( x, y ) , the value v they return equals to f ( x, y ) with probability ≥ − ε over the inputdistribution and public randomness,3. given z = Z ( x, y ) , the expected number of bits communicated between the three players in Stage 1and 2 is no more than C over the input distribution and public randomness. Remark.
The public randomness used in Stage 2 does not help the players in general. Nevertheless, westill keep it in the definition for the sake of neatness of our proof. Z ( x, y ) can be viewed as a question that the players want to ask Merlin about their joint input. Onecan potentially design more efficient protocols in this model than in the classic communication model ifverifying the answer to this question is easier than computing it.With respect to this communication model, on one hand, we can show that given a “good” batch partialsum data structure, we can solve the communication game efficiently (Lemma 1). On the other hand, weprove a communication lower bound for it (Lemma 2). Combining these two lemmas, we conclude that no“good” data structure exists. Lemma 1.
Given a deterministic batch partial sum data structure for the cell-probe model with word size w that is correct on all queries in a random operation sequence drawn from D with probability ≥ , wecan solve the communication game G ( I A , I B ) with error . and cost O (cid:18) E D [ | P A | + | P B | + | P A ∩ P B | · w ] (cid:19) in model M , where P A ( P B resp.) is the (random) set of cells probed in time period I A ( I B resp.) by thedata structure.Proof. We prove the lemma by showing the following protocol is efficient in terms of P A and P B . Communication protocol:
Step 1: (Merlin sends the key information)Merlin first simulates the data structure up to the beginning of I B , which is also the end of I A ,and records the set P A , all the cells that were probed in time period I A . Then Merlin continuessimulating the operations in I B . At the meanwhile, every time he probes a memory cell, he checksif this cell has been probed in I B before and checks if it was probed in I A (in set P A ). If this is thefirst time probing this cell since the beginning of I B , Merlin will send one bit to Alice and Bob. Hesends “1” if the cell was probed in I A , and sends “0” otherwise.Step 2: (Alice and Bob simulate the data structure to accomplish the task)Alice simulates the data structure up to the beginning of I B , and records P A . Since Bob does nothave any information about operations in I A , he instead simulates up to the beginning of I A , thentries to skip I A and simulate the operations in I B directly. Of course, the memory state Bob holds9ight be very different from what it should look like at the beginning of I B . But with the help ofMerlin’s message, Bob will be able to figure out the difference.As Bob simulates the data structure, every he needs to probe a cell, he first checks if this is the firsttime probing this cell since the beginning of I B . If it is not, Bob knows its content from the lastprobe. Otherwise, he looks at the next bit of Merlin’s message. If it is a “0”, Merlin is claimingthat this cell was not probed in I A . Thus, its content has not been changed since the beginning of I A . Bob has the information in his own copy of memory. If it is a “1”, Bob sends the address ofthis cell to Alice, Alice will send back its content. At the same time, Alice checks if the cell wasactually probed in I A . If the check fails, they report “Merlin is cheating” (they reject), and abortthe protocol. At last, Bob updates this cell in his own copy of memory, and records that it has beenprobed in I B .If there are no more bits left in Merlin’s message when Bob needs to look at the next bit, or thereare still unread bits when Bob has finished the simulation, the players reject.Step 3: (Players verify that Merlin is truthful)According to the simulation in Step 2, Alice takes the set P A . Bob generates the set of cells thatwere probed in I B but Merlin claims that they were not in P A (and thus did not ask Alice for thecontents). They check if these two sets of cells are disjoint (all cells that Merlin claims not probedin I A are actually not) using the zero-error sparse set disjointness protocol in Theorem 3 of H˚astadand Wigderson. If the two sets intersect, they report “Merlin is cheating” (reject), otherwise theyreport “Merlin is truthful” (accept) and Bob returns the answers he has computed for all queries in I B .Step 1 above describes what Merlin is supposed to do, and thus defines Z ( x, y ) . The following showsthat the above protocol is a valid protocol in model M , and solves the communication game efficiently.1. If Merlin tells the truth ( z = Z ( x, y ) ), it is not hard to see that the players will always accept. If z is a prefix of Z ( x, y ) or Z ( x, y ) is a prefix of z , Bob will detect it in Step 2 and reject. Otherwiselet the i -th bit be the first bit that z and Z ( x, y ) differ. As the first i − bits are the same in z and Z ( x, y ) , Bob will correctly simulate the data structure up to that point, right before a probe that causesBob to read the i -th bit of z . Thus the cell probed by the data structure corresponding to the i -th bitwill be the same in Bob’s simulation and in the actual execution. If Z i ( x, y ) = 0 , z i = 1 , the cell isnot probed in I A but Merlin claims it is. The players can detect the mistake and will reject in Step2. If Z i ( x, y ) = 1 , z i = 0 , Merlin claims the cell is not probed in I A but it is. In this case, the cellwill belong to both Alice’s and Bob’s sets in Step 3. Therefore, the sparse set disjointness protocolwill return “intersect”. The players will reject. This proves that Alice and Bob accept if and only if z = Z ( x, y ) .2. Given z = Z ( x, y ) , Bob will successfully simulate the data structure on all operations in I B . As thedata structure correctly answers all queries simultaneously with ≥ probability, in particular, itanswers all queries in I B correctly with ≥ probability. Thus, the error probability is no morethan . .3. Given z = Z ( x, y ) , Merlin sends exactly one bit for each cell in P B , | z | = | P B | . In Step 2, the playerssend O ( w ) bits for every “1” in z , which is O ( | P A ∩ P B | · w ) in total. In Step 3, by Theorem 3, theplayers send O ( | P A | + | P B | ) bits in expectation to compute sparse set disjointness. in expectationover the randomness of the protocol and the input distribution D , the protocol uses O (cid:18) E D [ | P A | + | P B | + | P A ∩ P B | · w ] (cid:19) s be a binary string of length less than b = log B . Define I s to be the interval consisting operations { U t , Q t : s is a prefix of t } . Let G ( s ) = G ( I s , I s ) be the communication game defined by I s and I s ,e.g., in game G ( ∅ ) , Alice receives all operations in the first half of the sequence as her input, and Bobreceives the second half, in game G (0) , Alice receives the first quarter and the second half, Bob receives thesecond quarter and the second half. Lemma 2.
For p ≥ B large enough, the communication game G ( s ) requires communication cost at least Ω(2 −| s | KB ( b − | s | )) for any protocol with error . in model M , where | s | is the length of string s . We will defer the proof of Lemma 2 to Section 4. Using these two lemmas, we are ready to prove ourdata structure lower bound.
Proof of Theorem 2.
Fix a (randomized) data structure for batch partial sum problem, which errors withprobability no more than . , and in expectation, probes T cells on an operation sequence drawn from D .By Markov’s inequality and union bound, there is a way to fix the random bits used by the data structure,such that the error probability is no more than . , and probes at most T cells in expectation. In thefollowing, we show that for such deterministic data structure, T must be large.For binary string s of length no more than log B , define P s to be the (random) set of cells probed by thedata structure in I s . For every s , Lemma 1 and Lemma 2 together implies that E D [ | P s | + | P s | + | P s ∩ P s | · w ] ≥ Ω (cid:16) −| s | KB ( b − | s | ) (cid:17) . Now sum up the two sides over all binary strings s of length at most b − . For the left-hand-side, fix anoperation sequence. In the sum P s ( | P s | + | P s | ) , every probe will be counted at most log B times, becausethe probes during U t or Q t will be counted only when s is a prefix of t . In the sum P s | P s ∩ P s | , for eachcell in | P s ∩ P s | , we refer it to its first probe in I s . Every probed will be referred to at most once: considera probe during U t or Q t , assume the last probe to this cell happened during U t ′ or Q t ′ for some t ′ < t , thisprobe will be referred only when s is a prefix of t ′ and s is a prefix t , i.e., s is the longest common prefixof t ′ and t . Therefore, the left-hand-side sums up to at most T · ( w + log B ) . The right-hand-side sums upto X s : | s |
For large enough p and L , solving the multi-index problem in model M with error . requirescommunication cost Ω (min { LK log p, LK log L } ) under input distribution µ . Before proving this lemma, we first show that it implies Lemma 2.
Proof of Lemma 2.
Fix a protocol P for G ( s ) with error . and cost C . We are going to use it to solvemulti-index. Let us first assume that there is a sequence of public random bits that all three parties cansee. We will first design a protocol in this setting, then try to get rid of this extra requirement by fixing therandom bits.For an input pair ( x, y ) ∼ µ for the multi-index problem, consider the following protocol: Preprocessing:
Use the public randomness to sample an operation sequence from D conditioned on that F maps it to ( x, y ) . It is easy to verify that all operations outside I B does not dependent on y and alloperations outside I A does not depend on x . Therefore, with no communication, all three parties get theirinputs for G ( s ) . 12 imulate P : Alice and Bob run protocol P to compute all answers to queries in I B . Postprocessing:
Bob knows all updates outside I A , and from the value returned by the communicationgame, he gets to know the answers to all queries. Therefore, Bob can compute for i -th query in I B , thesum of all entries updated in I A that are summands of the query, which is exactly h x, y i i , by subtracting allother summands from the answer. With no further communication, Bob can figure out the solution to themulti-index problem.After Preprocessing, the inputs the players get for G ( s ) will be distributed as D . Therefore, in Simulate P , the communication cost will be C in expectation, and error probability will be . over the randomnessof P , input ( x, y ) and random bits r used in Preprocessing. By Markov’s inequality and union bound, thereis a way to fix r , such that the communication cost is at most C in expectation and error probability is atmost . over the randomness of P and ( x, y ) . To show that the protocol can be implemented in model M ,we hardwire r and define for each input pair ( x, y ) , Z ( x, y ) to be the message Merlin is supposed to send inSimulate P when Preprocessing uses random bits r . Alice and Bob accept if and only if they were to acceptin P .It is easy to verify that the above protocol solves the multi-index problem under input distribution µ witherror . and cost C . However, by Lemma 3, we have a lower bound of Ω(min { LK log p, LK log L } ) onthe communication cost. Together with p ≥ B ≥ L , we have C ≥ Ω( LK log L ) = Ω(2 −| s | KB ( b − | s | )) .This proves the lemma.To prove a communication lower bound in model M , the main idea is to use the uniqueness of thecertificate ( Z ( x, y ) ) and the perfect completeness and soundness. To start with, let us first consider the casewhere the protocol is deterministic, and the communication cost C is defined in worst case instead of inexpectation.In this case, fix one Merlin’s possible message z , it defines a communication problem between Aliceand Bob in the classic model: check whether Z ( x, y ) = z . By definition, the players can solve this task withzero error. By the classic monochromatic rectangle argument, we can partition the matrix M ( f ) (definedin Section 2) into exponentially in C many combinatorial rectangles, such that in each rectangle, either Z ( x, y ) = z for every pair or Z ( x, y ) = z for every pair. In particular, it partitions the set Z − ( z ) intocombinatorial rectangles. Moreover, for each rectangle with Z ( x, y ) = z , the protocol associates it with avalue, which is the value returned in Stage 4. Now we go over all possible z ’s, which is again exponentiallyin C many. Every input pair belongs to exactly one of the Z − ( z ) ’s. By cutting all Z − ( z ) , along with theirpartitioning into rectangles, and pasting into one single matrix, it induces a partitioning of the whole matrix M ( f ) into O ( C ) rectangles. The values associated with the rectangles should match the actual functionvalues with high probability. Therefore, there must be large nearly monochromatic rectangles in M ( f ) .A nature final step of the proof, as in many communication complexity lower bound proofs, would beto show that all nearly monochromatic rectangles are small. However, in the multi-index problem, there doexist large monochromatic rectangles.Fix a set S ⊆ [ LK ] of coordinates, such that it has L/ log L coordinates in each block. Let X = { x : ∀ j ∈ S, x j = 0 } , Y = { ( y , . . . , y L ) : ∀ j / ∈ S, i ∈ [ L ] , y i,j = 0 } . X × Y is a monochromatic rectanglewith value (0 , . . . , , and µ ( X × Y ) = Θ( p − LK/ log L · (log L ) − LK ) = Θ(2 − LK (log p/ log L +log log L ) ) .In particular, for p = O ( L ) , we can only prove lower bounds no better than Ω( LK log log L ) using thisapproach only.However, these y ’s are not what a “typical” Bob’s input should look like. Since the ones in { y , . . . , y L } only appear in (1 / log L ) -fraction of the coordinates, while a random input with very high probability shouldhave ones appearing in a constant fraction of the coordinates. This motivates the following definition of evenly-spreading : 13 efinition 5. Define Bob’s input to be evenly-spreading , if for any set of coordinates of size at most . LK ,the number of ones in all L vectors in Bob’s input in these coordinates is no more than . LK . Lemma 4.
For L · K large enough, with probability ≥ , Bob’s input is evenly-spreading.Proof. Draw a random input ( x, y ) from µ , and try to upper-bound the probability that it is not evenly-spreading. Fix a set of coordinates S = S ∪ S ∪ · · · ∪ S K of size at most . LK , where S k is a subsetof coordinates in block k . Let ξ ki be the random variable h S k , y i i , which is the number of ones in y i thatis in S k . By the properties of µ , in k -th block of y i , each of the L + 1 possibilities occurs with probabilityno more than /L , and is independent of all other blocks and vectors. Thus, we have that E [ ξ ki ] ≤ | S k | /L , ξ ki ∈ [0 , , and ξ ki ’s are independent. Let ξ = P Kk =1 P Li =1 ξ ki , be the number of ones in all L vectors in S . We have E [ ξ ] ≤ . LK . Thus, by Hoeffding’s inequality, Pr[ ξ > . LK ] ≤ Pr[ ξ − E [ ξ ] > . LK ] ≤ e − LK/ . However, the number of possible set S ’s is no more than LK . By union bound, the probability thatthere exists an S violating the constraint is at most e − LK/ · LK < . , for large enough L · K .Instead of upper-bounding how many input pairs a nearly monochromatic rectangle can contain, we aregoing to upper-bound the measure of evenly-spreading inputs in it. Define set E to be the all input pairs ( x, y ) that y is not evenly-spreading. By Lemma 4, µ ( E ) ≤ . . The following lemma shows that thereare no large nearly monochromatic rectangles if we ignore all elements in E . Lemma 5.
For large enough p, L , every . -monochromatic rectangle R , which is disjoint from E , musthave µ ( R ) ≤ max { − Ω( LK log L ) , − Ω( LK log p ) } . Proof.
Fix a combinatorial rectangle R = X × Y , such that there is a value v = ( v , . . . , v L ) that µ ( R ∩ f − ( v )) ≥ . µ ( R ) . We want to prove that µ ( R ) must be small. First, without loss of generality, we canassume that for every y ∈ Y , µ (( X × { y } ) ∩ f − ( v )) ≥ . µ ( X × { y } ) , i.e., every column in R is . -monochromatic. Since in general, by Markov’s inequality, at least / (with respect to µ y ) of the columnsin R are . -monochromatic, we can just apply the following argument to the subrectangle induced by X and these columns, and only lose a factor of .Let | Y | = q, Y = { y , y , . . . , y q } , y i = ( y i , . . . , y iL ) . Let r i be the dimension of subspace in F LKp spanned by vectors in first i L -tuples: { y jl : 1 ≤ j ≤ i, l ∈ [ L ] } , and r = 0 . Let r = r q be the dimensionof the subspace spanned by all vectors in Y . Define ν to be the probability distribution over Y such that ν ( y i ) = ( r i − r i − ) /r . ν ( y i ) is proportional to “the number of new dimensions y i introduces”. Thus, ν issupported on no more than r elements in Y .Since every column in Y is 0.6-monochromatic under µ x , R will also be 0.6-monochromatic under µ x × ν . By Markov’s inequality again, at least 1/5 of the rows are 0.5-monochromatic in R under µ x × ν .However, when r is large, there cannot be too many such rows, even in the whole matrix. For some 0.5-monochromatic row x , let S ⊆ Y be the set of columns with value v in that row. By definition, we have ν ( S ) ≥ . . By the way we set up the distribution ν , the linear space spanned by all vectors in S musthave dimension at least r/ . This adds at least r/ independent linear constraints on x . There can be atmost p − r/ -fraction of x ’s satisfying all linear constraints in the whole matrix. By taking a union bound onall possible S ’s, we obtain an upper bound on the measure of 0.5-monochromatic rows in R under µ x × ν .More formally, we have 14 µ x ( X ) ≤ µ x ( { x : ν ( { y : f ( x, y ) = v } ) ≥ . } )= Pr x ∼ µ x (cid:20) Pr y =( y ,...,y L ) ∼ ν [ ∀ l ∈ [ L ] , h x, y l i = v l ] ≥ . (cid:21) = Pr x ∼ µ x [ ∃ S ⊆ supp( ν ) , ν ( S ) ≥ . , ∀ y ∈ S, ∀ l ∈ [ L ] , h x, y l i = v l ] ≤ X S ⊆ supp( ν ) ν ( S ) ≥ . Pr x ∼ µ x [ ∀ y ∈ S, ∀ l ∈ L, h x, y l i = v l ] ≤ X S ⊆ supp( ν ) ν ( S ) ≥ . p − r/ ≤ r p − r/ ≤ − Ω( r log p ) . Therefore, if r ≥ . LK , we have µ ( R ) ≤ µ x ( X ) ≤ − Ω( r log p ) ≤ − Ω( LK log p ) .Otherwise, r ≤ . LK . In this case, we are going to show that, it is impossible to pack too manyvectors the the form of Bob’s inputs into any subspace of small dimension. In particular, we will upperbound µ y ( Y ) , the measure of Bob’s evenly-spreading inputs, when their span has dimension r . Fix a basisof the span of vectors in Y , consisting of r vectors in F LKp . Without loss of generality, we can assumethat for each basis vector, there is a coordinate in which this vector has value 1, and all other basis vectorshave value 0, because we can always run a standard Gaussian elimination to transform the basis into thisform. Let T be this set of r coordinates. As each vector in the subspace is a linear combination of thebasis, fixing the values in coordinates in T uniquely determines a vector in the subspace. By definition ofevenly-spreading, and | T | = r ≤ . LK , each L -tuple y i ∈ Y can have at most . LK T . For all LK blocks in the L vectors, there are (cid:0) LK ≤ . LK (cid:1) choices for the set of blocks with ones. Moreover, each y i can have at most one 1 in each block. If a vector has a 1 in a block, there will be at most L different choicesto place the 1. Otherwise, we must set all coordinates in T in that block to be . After fixing values allcoordinates in T , there can be at most one such vector in the subspace with matching values. Thus, we have µ y ( Y ) ≤ (cid:18) LK ≤ . LK (cid:19) · L . LK · L − LK ≤ L − . LK · LK ≤ − Ω( LK log L ) . Therefore, in this case, we have µ ( R ) ≤ µ y ( Y ) ≤ − Ω( LK log L ) . Combining both cases, we concludethat µ ( R ) ≤ max { − Ω( LK log L ) , − Ω( LK log p ) } .Using the above lemma, we can prove communication lower bound for multi-index. Proof of Lemma 3.
Fix a protocol that solves the multi-index problem with error 0.15 and cost C in model M . As we are working with a fixed input distribution, randomness in the protocol shall not help. Inparticular, by Markov’s inequality and union bound, there is a way to fix the internal (public) randomnessof the protocol, such that the success probability is at least and communication cost no more than C .From now on, let us assume the protocol is deterministic, and success probability is at least .For some message z sent by Merlin, let T z = Z − ( z ) be set of the input pairs ( x, y ) such that z ismessage Merlin is supposed to send when the players get these input pairs. As Alice and Bob are always ableto decide whether z = Z ( x, y ) , the classical combinatorial rectangle argument induces a way to partitioneach T z into rectangles based on the transcript between Alice and Bob. Moreover, the set { T z } z ∈{ , } ∗ These vectors do not have to be from Bob’s inputs. γ ( x, y ) , which includes both Merlin’s message and the transcript between Alice and Bob, inducesa partition of the matrix M ( f ) into combinatorial rectangles { R i } . For each R i with transcript γ i , theplayers will return a fixed answer v i for every pair of inputs in the rectangle.By the definition of communication cost, we have E ( x,y ) ∼ µ [ | γ ( x, y ) | ] ≤ C . Thus, by Markov’s in-equality X R i : | γ i |≤ C µ ( R i \ E ) ≥ X R i : | γ i |≤ C µ ( R i ) − µ ( E ) > . − .
05 = 0 . (1)By the definition of probability of computing f correctly, X R i µ ( R i ∩ f − ( v i )) ≥ . . By Markov’s inequality, X R i : µ (( R i \ E ) ∩ f − ( v i )) < . µ ( R i \ E ) µ ( R i \ E )= X R i : µ ( R i \ E \ f − ( v i )) > . µ ( R i \ E ) µ ( R i \ E ) ≤ . X R i : µ ( R i \ E \ f − ( v i )) > . µ ( R i \ E ) µ ( R i \ E \ f − ( v i )) ≤ . X R i µ ( R i \ f − ( v i ))= 10 . − X R i µ ( R i ∩ f − ( v i )) ≤ / Thus, we have X R i : µ (( R i \ E ) ∩ f − ( v i )) ≥ . µ ( R i \ E ) µ ( R i \ E ) ≥ − µ ( E ) − / > . (2)Let R be the (disjoint) union of all R i with value v i and transcript γ i , such that µ (( R i \ E ) ∩ f − ( v i )) ≥ . µ ( R i \ E ) and | γ i | ≤ C . By (1) and (2), we have µ ( R \ E ) ≥ . . However, there can be only O ( C ) differentsuch γ i ’s, and thus O ( C ) such rectangles. There must be some transcript γ i such that µ ( R i \ E ) ≥ − O ( C ) and R i \ E is . -monochromatic rectangle under distribution µ . Therefore, by Lemma 5, we have C ≥ Ω(min { LK log L, LK log p } ) , which proves the lemma. In this section, we present three applications of our main theorem to dynamic graph problems. See Ap-pendix B for formal definitions of the problems.
Corollary 2.
For the following three dynamic graph problems: n Figure 1: dynamic (a) dynamic o (log n ) , and error probability ≤ under poly-nomially many operations must have amortized expected query time n − o (1) .Proof. (sketch) To prove the lower bounds, we are going to give three reductions from dynamic intervalunion. The corollary follows from Corollary 1.(a) To solve dynamic interval union, we maintain the following graph G : G has a Hamiltonian path → → · · · → n ; for every [ a, b ] ∈ I , G has an edge b → a . It is not hard to see that the graph can bemaintained efficiently given a dynamic I isexactly n + 1 minus the number of strongly connected components in G . See Figure 1.(b) The underlying graph is shown as Figure 2. The edges connecting vertices i and i + 1 have infinitecapacities and zero cost. The edges connect i and i ′ have capacities 1 and cost -1. The edges connecting i ′ and i + 1 have capacities 1 and cost 0. All edges connecting to s or t have cost 0. The only valuesthat may change are the capacities of edges connecting to s or t . More specifically, we maintain thegraph such that the capacity from s to vertex i always equals to the number of intervals in I with leftendpoint i , the capacity from i to t always equals to the number of intervals with right endpoint i . It iseasy to verify that given a dynamic planar s-t min-cost flow data structure, we can efficiently maintainthese invariants. To query the total length of the union of I , we query the min-cost flow in G with flowvalue |I| . For each i , the amount of flow from i to i + 1 (also counting flow going through i ′ ) is exactlythe number of intervals containing [ i, i + 1] . As i → i ′ → i + 1 has a smaller cost than going to i + 1 directly from i , min-cost flow will prefer to use the former path. Each [ i, i + 1] contained in any intervalsin I adds a cost of − to the flow. Therefore, the negate of the cost is exactly the length of the union.(c) We maintain a graph G such that there is an edge from s to with weight 0, an edge from n to t withweight , edges from i to i + 1 with weight 1, and edges from i + 1 to i with weight . Moreover, foreach interval [ a, b ] ∈ I , the graph has an edge a → b with weight 0. The shortest path from s to t isexactly the length of the union, because for [ i, i + 1] contained in any interval in I , we can go from i to i + 1 with zero cost: go to the left endpoint of the interval, then go to the right endpoint using one edge,and go to i + 1 . See Figure 3. In [5], Clifford, Grønlund and Larsen mentioned a log m log n barrier for dynamic data structure lowerbounds, where m is the number of different queries (including parameters), and n is the number operationsin the sequence we analyse. In some sense, our main result can also be viewed as a “ (log m log n ) -type”lower bound, as the query takes only O (1) bits to describe. The way we prove this type of lower bound is17 ns t ′ ′ ′ ( ∞ ,
0) ( ∞ ,
0) ( ∞ , (1 , −
1) (1 ,
0) (1 , −
1) (1 ,
0) (1 , −
1) (1 ,
0) ( ∗ , ∗ , Figure 2: dynamic planar s-t min-cost flow ns t
Figure 3: dynamic weight s-t shortest path18ery different from [13, 14, 5]. We obtain this kind of the lower bound via reduction. Assume we want toprove a lower bound for problem A . We first prove a lower bound for some other problem B with large m , and get a high lower bound. Then we find a way to implement updates of B using updates of A , andqueries of B using updates and queries of A , and thus derive a lower bound for A . Note that it is importantthat we implement queries in problem B using both updates and queries in the original problem. Becauseif we only use queries to implement queries, in order to keep all the information in the query of B , it hasto be decomposed into many queries of A . A simple calculation shows that in this case, we cannot breakthe barrier for problem A unless we have already broken it for problem B . However, if we use both updatesand queries of A , it is possible to “hide” information in the updates. A good example is the reduction inProposition 1 in Appendix A. However, using this approach, we still cannot beat log m ′ log n , where m ′ isthe number of different updates (including parameters). Nevertheless, it gives us a potential way to breakthe log m log n barrier for problems with m ′ > m if we can combine it with the previous techniques.Pˇatras¸cu has used the communication lower bound for lopsided set disjointness, set disjointness problemof a special form, to prove a collection of (static) data structure lower bounds [16, 17]. In this paper, weapplied communication protocol (upper bound) for sparse set disjointness, set disjointness of a different spe-cial form, to prove a dynamic data structure lower bound . In some sense, this can be viewed as an analogueof the recent development in duality between algorithm and complexity [22, 23, 2] in the communicationcomplexity and data structure world. It would be interesting to see examples where both communicationlower bound and upper bound for the exact same problem can be used to prove data structure lower bounds.On Klee’s measure problem, our result is an unconditional lower bound for one certain type of algo-rithms. From Theorem 1, we can generate a hard input distribution for the sweep-line algorithm, such that ifthe algorithm only sorts the rectangles, goes through the entire area row by row and computes the number ofgrids in the union only based on the rectangles intersecting the current row or previous rows, then it cannotbeat Bentley’s algorithm. However, our hard distribution is not very robust, in the sense that if we do thesweep-line from a different direct, the distribution over inputs becomes really easy. At least, it still showsus what an o ( N log N ) time algorithm for computing 2D Klee’s measure problem on [0 , N / ] × [0 , N / ] should not look like, if exists. Acknowledgement.
The author would like to thank Yuqing Ai and Jian Li for introducing Klee’s measureproblem to me during a discussion, and would like to thank Timothy Chan for telling me the state-of-the-art.The author also wishes to thank Ryan Williams for helpful discussions on applications to dynamic graphproblems and in paper-writing.
References [1] Scott Aaronson and Avi Wigderson. Algebrization: a new barrier in complexity theory. In
Proceedingsof the 40th Annual ACM Symposium on Theory of Computing , pages 731–740, 2008.[2] Amir Abboud, Ryan Williams, and Huacheng Yu. More applications of the polynomial method toalgorithm design. In
Proceedings of the Twenty-Sixth Annual ACM-SIAM Symposium on DiscreteAlgorithms, SODA 2015 , pages 218–230, 2015.[3] Jon L. Bentley. Algorithms for Klee’s rectangle problems.
Unpublished manuscript , 1977.[4] Timothy M. Chan. Klee’s measure problem made easy. In , pages 410–419, 2013.195] Rapha¨el Clifford, Allan Grønlund, and Kasper Green Larsen. New unconditional hardness results fordynamic and online problems. In , 2015.[6] Rapha¨el Clifford and Markus Jalsenius. Lower bounds for online integer multiplication and con-volution in the cell-probe model. In
Automata, Languages and Programming - 38th InternationalColloquium, ICALP 2011 , pages 593–604, 2011.[7] Rapha¨el Clifford, Markus Jalsenius, and Benjamin Sach. Tight cell-probe bounds for online ham-ming distance computation. In
Proceedings of the Twenty-Fourth Annual ACM-SIAM Symposium onDiscrete Algorithms, SODA 2013 , pages 664–674, 2013.[8] Rapha¨el Clifford, Markus Jalsenius, and Benjamin Sach. Cell-probe bounds for online edit distanceand other pattern matching problems. In
Proceedings of the Twenty-Sixth Annual ACM-SIAM Sympo-sium on Discrete Algorithms, SODA 2015 , pages 552–561, 2015.[9] Michael L. Fredman and Michael E. Saks. The cell probe complexity of dynamic data structures. In
Proceedings of the 21st Annual ACM Symposium on Theory of Computing , pages 345–354, 1989.[10] Johan H˚astad and Avi Wigderson. The randomized communication complexity of set disjointness.
Theory of Computing , 3(1):211–219, 2007.[11] Victor Klee. Can the measure of ∪ n [ a i , b i ] be computed in less than O ( n log n ) steps? The AmericanMathematical Monthly , 84(4):284–285, 1977.[12] Eyal Kushilevitz and Noam Nisan.
Communication Complexity . Cambridge University Press, 1997.[13] Kasper Green Larsen. The cell probe complexity of dynamic range counting. In
Proceedings of the44th Symposium on Theory of Computing Conference, STOC 2012 , pages 85–94, 2012.[14] Kasper Green Larsen. Higher cell probe lower bounds for evaluating polynomials. In , pages 293–301, 2012.[15] Rina Panigrahy, Kunal Talwar, and Udi Wieder. Lower bounds on near neighbor search via metricexpansion. In , pages805–814, 2010.[16] Mihai Pˇatras¸cu. (Data) STRUCTURES. In , pages 434–443, 2008.[17] Mihai Pˇatras¸cu. Unifying the landscape of cell-probe lower bounds.
SIAM J. Comput. , 40(3):827–847,2011.[18] Mihai Pˇatras¸cu and Erik D. Demaine. Lower bounds for dynamic connectivity. In
Proceedings of the36th Annual ACM Symposium on Theory of Computing , pages 546–553, 2004.[19] Mihai Pˇatras¸cu and Erik D. Demaine. Tight bounds for the partial-sums problem. In
Proceedings ofthe Fifteenth Annual ACM-SIAM Symposium on Discrete Algorithms, SODA 2004 , pages 20–29, 2004.[20] Mihai Pˇatras¸cu and Erik D. Demaine. Logarithmic lower bounds in the cell-probe model.
SIAM J.Comput. , 35(4):932–963, 2006.[21] Mihai Pˇatras¸cu and Mikkel Thorup. Don’t rush into a union: take time to find your roots. In
Proceed-ings of the 43rd ACM Symposium on Theory of Computing, STOC 2011 , pages 559–568, 2011.2022] Ryan Williams. Improving exhaustive search implies superpolynomial lower bounds.
SIAM J. Com-put. , 42(3):1218–1244, 2013.[23] Ryan Williams. Faster all-pairs shortest paths via circuit complexity. In
Symposium on Theory ofComputing, STOC 2014 , pages 664–673, 2014.[24] Andrew Chi-Chih Yao. Probabilistic computations: Toward a unified measure of complexity. In , pages 222–227, 1977.[25] Andrew Chi-Chih Yao. Some complexity questions related to distributive computing. In
Proceedingsof the 11h Annual ACM Symposium on Theory of Computing , pages 209–213, 1979.[26] Andrew Chi-Chih Yao. Should tables be sorted?
J. ACM , 28(3):615–628, 1981.
A Reduction from Partial Sum
The partial sum problem is to maintain a sequence of n numbers ( A i ) over [ n ] , supporting the followingoperations: • update(i, v) : set A i to value v ; • query(l) : return P i ≤ l A i .Pˇatras¸cu and Demaine [19] showed that at least one of the operations needs to take Ω(log n ) time in thecell-probe model with word size w = Θ(log n ) . Proposition 1.
Any data structure for the dynamic interval union problem with insertion time t i , deletiontime t d and query time t q must have max { t i , t d , t q } ≥ Ω(log n ) in the cell-probe model with word size w = Θ(log n ) .Proof. Consider the partial sum problem with √ n numbers over [ √ n ] . Any data structure will take Ω(log n ) time to update or query. Fix a dynamic interval union data structure over [0 , n ] , we will use it to solve thepartial sum problem. First partition [0 , n ] into √ n blocks of length √ n each. The i -th block will correspondto number A i . We maintain the invariant that for each number A i , there is an interval in the correspondingblock of length equal to the value of A i .More specifically, every time we need to update A i from value v ′ to v , we delete the previous interval [( i − √ n, ( i − √ n + v ′ ] , then insert a new interval [( i − √ n, ( i − √ n + v ] . When we need to querythe sum of first l numbers, we first insert an interval [ l √ n, n ] , which covers all blocks from the ( l + 1) -th tothe last, then query the length of the union, delete the interval inserted earlier. We know that the temporarilyinserted interval has length ( √ n − l ) √ n . Subtracting it from the answer returned, we get the total length ofintervals in the first l blocks, which is exactly the sum of first l numbers.Every update of partial sum can be implemented using an insertion and a deletion of dynamic intervalunion, every query can be implemented using an insertion, a deletion and a query. Therefore, at least one ofthe operations has to take Ω(log n ) time. B Catalogue of Dynamic Graph Problems in Our Application
The dynamic problem is to maintain a directed graph G , supporting: • insert(u, v) : insert an edge ( u, v ) ; 21 delete(u, v) : delete an (existing) edge ( u, v ) ; • query() : return the number of strongly connected components in G .The dynamic planar s-t min-cost flow problem is to maintain an undirected planar flow network G withedge cost, supporting: • update(u, v, cap) : update the capacity of (an existing) edge ( u, v ) to cap ; • query(f) : return the min-cost flow from a fixed source s to a fixed sink t with flow value f .The dynamic weighted s-t shortest path problem is to maintain a weighted directed graph G , supporting: • insert(u, v, w) : insert an edge ( u, v ) with weight w ; • delete(u, v) : delete an (existing) edge ( u, v ) ; • query() : return the shortest path from a fixed source s to a fixed target tt