Proofs: Fredman-Saks lower bound
These are the human proofs of Fredman-Saks lower bound, at full length.
The chronogram bound for dynamic partial sums full
This proof shows: statement.
We prove Theorem 1. Fix a deterministic structure for partial sums over on positions in the cell-probe model with -bit cells and at most cells, , whose updates each probe at most cells. Let be the least power of 2 with ; then , because . Let . The memory starts in a fixed state. A query sum(x) is a decision tree: the next cell it reads depends on the contents read so far.
The random input. The updates come in epochs, in the time order epoch , epoch , ..., epoch 1. Epoch has updates, at the positions for , in increasing order of , with values . All values of all epochs are independent and uniform in . After epoch 1, one query sum(x) is made, with uniform in and independent of the values.
For a cell read by the query, its epoch is the epoch of the last update that wrote it, or none if no update wrote it. Let be the event that the query reads at least one cell whose epoch is .
Lemma. For each , .
Proof. Write with and , with . For uniform, and are independent and uniform. It is enough to prove conditioned on any fixed and any fixed values of all epochs other than ; then average. So fix and . The only randomness left is , uniform over values, and .
For let . The epoch- positions that are at most are exactly , because when , and for , , and then the positions are . In both cases the answer to sum(x_j) is , where is the sum of the values of the other epochs at positions at most , which depends only on , and with or , an index fixed by . As runs over , the index runs over a set of consecutive integers that contains all of and one of or .
Call good if sum(x_j), run after all updates, reads no cell of epoch , and bad otherwise. Let be the set of good , a function of .
The message. Given (and the fixed , ), the encoder writes:
- the mask of , bits;
- the number of cells written by the updates of epochs , in bits, and then, for each such cell, its address and its contents after the last update, bits each;
- for each bad , in increasing order, the value , bits each;
- if (the case ), also is covered; if , the value is not an answer, and the encoder adds it, bits.
Each update probes at most cells, so , because . A cell address fits in bits, because the model has at most cells, and so does . So part 2 has at most bits.
The message is prefix-free. The decoder reads the mask, which has a fixed length; then ; then bits; then bits for each bad , a number it knows from the mask; then more bits or none, which it knows from . So no message is a proper prefix of another one.
Decoding. The decoder knows and . It runs the structure on the updates of epochs , which it knows, and gets the memory just before epoch . For a good , it simulates sum(x_j): when the query reads a cell, it takes the contents from part 2 if the cell is listed there, and from otherwise. Let us check that this gives the true contents of every cell that the true query reads. A cell listed in part 2 was last written in epochs , and part 2 gives its final contents. A cell not listed was not written after epoch ; since is good, the cell was not last written in epoch either; so its contents are those of . By induction over the reads of the decision tree, the simulation follows the true query and returns the true answer . The decoder knows , so it gets . For bad , part 3 gives . With part 4, the decoder knows and , so it knows for all , which is .
The decoder does not know which simulations would be correct without the mask; that is why the mask is sent.
Counting. The map from to the message is injective and prefix-free, and is uniform over values. By the source coding theorem (Kraft's inequality), the expected length of the message is at least . Let be the number of bad . Then
Divide by :
Now . Next by the choice of . And . So .
For fixed , the event happens exactly when is bad, and is uniform over and independent of , so . Averaging over and proves the lemma.
The theorem. Each cell that the query reads has at most one epoch, so the number of cells it reads is at least the number of for which happens. By linearity of expectation and the lemma, the expected number of cells read is at least . The expectation is over the values and over . So some fixed choice of the values gives a sequence of updates after which the average over of the cost of sum(x) is at least . Finally , so .