New Amortized Cell-Probe Lower Bounds for Dynamic Problems

TL;DR

This paper introduces a general framework for deriving amortized cell-probe lower bounds for dynamic problems, providing the strongest known unconditional bounds for specific problems like polynomial evaluation and matrix-vector multiplication.

Contribution

It extends previous worst-case bounds to amortized bounds using a new framework, achieving the strongest unconditional lower bounds for dynamic data structures.

Findings

Dynamic polynomial evaluation requires either high update or query time.

Dynamic online matrix-vector multiplication requires either high update or query time.

The bounds match the best known unconditional lower bounds for these problems.

Abstract

We build upon the recent papers by Weinstein and Yu (FOCS'16), Larsen (FOCS'12), and Clifford et al. (FOCS'15) 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 $n^{1+\Omega(1)}$ and has degree $n$, any dynamic data structure must either have an amortized update time of $\Omega((\lg n/\lg \lg n)^2)$ or an amortized query time of $\Omega((\lg n/\lg \lg n)^2)$. (2) For the dynamic online matrix vector multiplication problem, where we get an $n \times n$ matrix whose entires are drawn from a finite field of size $n^{\Theta(1)}$, any dynamic data structure must either have an amortized update time of $\Omega((\lg n/\lg \lg n)^2)$ or an amortized query time of $\Omega(n \cdot (\lg n/\lg \lg n)^2)$. For these two problems, the previous works by Larsen (FOCS'12) and Clifford et al. (FOCS'15) 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.

Equations

$$F_j:=\{(I_A,I_B)\in {\mathcal{I}}_i:(I_A,I_B)\text{ violates condition j of Definition refdef:communicationLowerBound}\}.$$

$$\sum _{(I_A,I_B)\in {\mathcal{I}}_i}\mathbb{E}\left[|P(I_A)|\right]$$

$$\ge \sum _{(I_A,I_B)\in F_1}|I_A|\cdot {\lg }^{2}n$$

$$\ge \sum _{(I_A,I_B)\in F_1}|I_B|\cdot \gamma \cdot {\lg }^{2}n$$

$$=\mathrm{length}(F_1)\cdot \gamma \cdot {\log }^{2}n\ge \frac{|\mathcal{O}|\cdot {\lg }^{2}n}{6}.$$

$$\sum _{(I_A,I_B)\in {\mathcal{I}}_i}\mathbb{E}\left[|P(I_B)|\right]$$

$$\ge \sum _{(I_A,I_B)\in F_2}|I_B|\cdot {\lg }^{2}n$$

$$\ge \mathrm{length}(F_2)\cdot {\log }^{2}n$$

$$\ge \frac{|\mathcal{O}|\cdot {\lg }^{2}n}{6\gamma }.$$

$$\sum _{(I_A,I_B)\in {\mathcal{I}}_i}\mathbb{E}\left[C(I_A,I_B)\right]$$

$$\ge \sum _{(I_A,I_B)\in F_3}\frac{1}{200(c+1002)}\cdot |I_B|\cdot \frac{\lg n}{\lg \lg n}$$

$$\ge \frac{1}{1200(c+1002)}\cdot \frac{|\mathcal{O}|}{\gamma }\cdot \frac{\lg n}{\lg \lg n}.$$

$$\Gamma :=(1/{\log }_{\gamma }|\mathcal{O}|)\cdot \sum _{i=1}^{i_{max}}\sum _{(I_A,I_B)\in {\mathcal{I}}_i}|P(I_B)|.$$

$$\mathbb{E}\left[\Gamma \right]$$

$$\ge \frac{\lg \gamma }{\lg |\mathcal{O}|}\cdot \frac{i_{max}}{2}\cdot \frac{|\mathcal{O}|\cdot {\lg }^{2}n}{8\gamma }$$

$$\ge \Omega (|\mathcal{O}|\cdot {\lg }^{2}n).$$

$$\sum _i\sum _{(I_A,I_B)\in {\mathcal{I}}_i}C(I_A,I_B)\le \Gamma$$

$$\sum _{(I_A,I_B)\in {\mathcal{I}}_i}\mathbb{E}\left[C(I_A,I_B)\right]\ge \frac{1}{1200(c+1002)}\cdot \frac{|\mathcal{O}|}{\gamma }\cdot \frac{\lg n}{\lg \lg n}.$$

$$\mathbb{E}\left[\Gamma \right]$$

$$\ge \sum _{i\in K_3}\sum _{(I_A,I_B)\in {\mathcal{I}}_i}\mathbb{E}\left[C(I_A,I_B)\right]$$

$$=|K_3|\cdot \frac{1}{1200(c+1002)}\cdot \frac{|\mathcal{O}|}{\gamma }\cdot \frac{\lg n}{\lg \lg n}.$$

$$|K_3|$$

$$=1200(c+1002)\cdot \frac{o\left(|\mathcal{O}|\cdot {\left(\frac{\lg n}{\lg \lg n}\right)}^2\right)\cdot \gamma }{|\mathcal{O}|\cdot \left(\frac{\lg n}{\lg \lg n}\right)}$$

$$=o(1)\cdot \gamma \cdot \frac{\lg n}{\lg \lg n}$$

$$<i_{max}/2.$$

$$\alpha :=2,\beta :=2000,\gamma :={\lg }^{\beta }n={\lg }^{2000}n,\text{ and }\kappa :=2/3.$$

$$\mathbb{E}\left[C_j(X,Y)\right]\ge \frac{1}{100(c+1002)}\cdot n\cdot \left(\lg n/\lg \lg n\right)\text{ for all }1\le j\le q(Y).$$

$$\mathbb{E}\left[C(X,Y)\right]=\sum _{j=1}^{q(Y)}\mathbb{E}\left[C_j(X,Y)\right]\ge \frac{1}{200(c+1002)}\cdot q(Y)\cdot n\cdot \frac{\lg n}{\lg \lg n}.$$

$$\mathbb{E}\left[C(X,Y)\right]\ge \frac{1}{200(c+1002)}\cdot |Y|\cdot \frac{\lg n}{\lg \lg n}.$$

$$\mathbb{E}\left[|P(X)|\right]\le |X|\cdot {\lg }^{2}n\text{ and }\mathbb{E}\left[|P(Y)|\right]\le |Y|\cdot {\lg }^{2}n$$

$$\mathbb{E}\left[C_j(X,Y)\right]$$

$$\sum _{i=1}^n|T_i|\cdot \lg |\mathbb{F}|$$

$$=\sum _{i=1}^n|R_i|\cdot \lg |\mathbb{F}|-\sum _{i=1}^n\dim \left(\mathrm{span}\left(v_1^{|R_i},\dots ,v_k^{|R_i}\right)\right)\cdot \lg |\mathbb{F}|$$

$$=u(X)\cdot \lg |\mathbb{F}|-\mathcal{R}\mathcal{S}(v_1,\dots ,v_k)\cdot \lg |\mathbb{F}|\le (|X|-nk/32)\cdot \lg |\mathbb{F}|$$

$$=(|X|-(|X|-1)/32)\cdot \lg |\mathbb{F}|\le (31/32)\cdot |X|\cdot \lg |\mathbb{F}|$$

$${\ell }_2$$

$$\le 1+o(|X|)+(99/100)\cdot |X|\cdot \lg |\mathbb{F}|<(199/200)\cdot u(X)\cdot \lg |\mathbb{F}|.$$

$$p_v(X)$$

$$\alpha :=1,\beta :=2000,\gamma :={\lg }^{\beta }n={\lg }^{2000}n,\text{ and }\kappa :=1/2.$$

$$\mathbb{E}\left[C_j(X,Y)\right]\ge \frac{1}{200(c+1002)}\cdot \frac{\lg n}{\lg \lg n}\text{ for all }1\le j\le q(Y).$$

Full text

For the dynamic polynomial evaluation problem, where the polynomial is defined over a finite field of size $n^{1+\Omega(1)}$ and has degree $n$, any dynamic data structure must either have an amortized update time of $\Omega((\lg n/\lg\lg n)^{2})$ or an amortized query time of $\Omega((\lg n/\lg\lg n)^{2})$. 2. 2.

For the dynamic online matrix vector multiplication problem, where we get an $n\times n$ matrix whose entires are drawn from a finite field of size $n^{\Theta(1)}$, any dynamic data structure must either have an amortized update time of $\Omega((\lg n/\lg\lg n)^{2})$ or an amortized query time of $\Omega(n\cdot(\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.

Keywords: Dynamic Algorithms; Cell-Probe Lower Bounds; Polynomial Evaluation; Online Matrix Vector Multiplication

The research leading to these results has received funding from the European Research Council under the European Union’s Seventh Framework Programme (FP/2007-2013) / ERC Grant Agreement no. 340506. The third author gratefully acknowledges the financial support of the Doctoral Programme “Vienna Graduate School on Computational Optimization” which is funded by Austrian Science Fund (FWF, project no. W1260-N35).

1 Introduction

In an abstract dynamic problem, we want a data structure that supports two types of input operations: updates and queries. The time taken to handle an update (resp. query) operation is known as the update time (resp. query time). The main goal in this field is to design data structures with small update and query times for fundamental dynamic problems.

The Cell-Probe Model. The focus of this paper is on proving unconditional lower bounds on the update and query times of dynamic data structures.111In contrast, the recent papers [1, 5] prove conditional lower bounds assuming SETH and OMv conjectures. All such known lower bounds work in the cell-probe model of computation [12]. In this model, the memory is organized into a set of memory cells. Each cell stores $w=\Theta(\lg n)$ bits of information. For most dynamic problems, specifying an input to the data structure requires $\Theta(\lg n)$ bits because the number of inputs is polynomial in $n$. Moreover, usually the total number of cells in the memory of the data structure is polynomially bounded by $n$. Thus, it takes $w$ bits to specify the address of a cell. Whenever a cell is read or written, we say that it is probed. The data structure supports an input operation by probing cells in the memory. If the input operation is a query, then the data structure also outputs an answer to that query after probing cells. The time taken to handle an input operation is measured in terms of the number of cell-probes made by the data structure. Any other computation, such as computation inside the CPU, comes free of cost. Intuitively, this model captures the communication cost between the CPU and the memory, and is, thus, very suitable for information theoretic arguments.

Previous Work. Proving cell-probe lower bounds turns out to be technically very challenging. One of the first major papers in this area was by Fredman and Saks [4], who introduced the chronogram technique [2]. Here, we construct a random sequence of $\text{poly}(n)$ updates followed by one random query. Going backward in time, the sequence of updates are partitioned into $\Theta(\lg n/\lg\lg n)$ many epochs whose sizes keep increasing exponentially. To be more specific, for $i\geq 1$, epoch $i$ consists of $\delta^{i}$ consecutive updates, where $\delta:=\text{poly}\lg n$. We then mark each memory cell by the (unique) epoch in which it was last probed. Finally, we show that if the worst case update time is $\text{poly}\log n$, then the random query at the end must probe at least $\Omega(t)$ cells marked by each epoch, where $t$ is a parameter. Summing over all the epochs, this gives a lower bound of $\Omega(t\cdot\lg n/\lg\lg n)$ on the worst case query time. By interleaving queries and updates and the use of a counting argument, they show how their worst case lower bound implies an amortized lower bound.

An exciting development in this field has been the cell-sampling technique introduced by Panigrahy et al. [8] for static data structures. Larsen [6, 7] used this technique to provide new lower bounds for dynamic data structures. He showed how to prove a lower bound of $t=\Omega(\lg n/\lg\lg n)$ for a single epoch in the chronogram. Summing over all the epochs, this gives a lower bound of $\Omega((\lg n/\lg\lg n)^{2})$ on the worst case query time. At its core, the cell-sampling technique is an encoding argument. It says that if the query time were small, then there must exist a very small subset of memory cells (say, $\mathcal{C}^{*}$) from which one can infer the answers to a large number of queries. Next, it exploits the fact that for some dynamic problems, the answers to a sufficiently large number of queries completely determine the past updates.222Intuitively, these dynamic problems have the property that the vector of answers is $\approx n$-wise independent over a random sequence of updates. That is, any $n$ answers to queries (essentially) determine the input sequence. For such problems, therefore, if the query time were too small, then we could potentially give an encoding of the past updates by specifying the addresses and contents of the cells in $\mathcal{C}^{*}$. Since the size of $\mathcal{C}^{*}$ is very small, this encoding would use fewer bits than the entropy of the past updates. As this leads to a contradiction, we are left with no other choice but to conclude that the query time must be large.

For other major results, see  [9, 10, 13]. None of them, however, can give $\omega(\lg n)$ cell-probe lower bounds. For only three dynamic problems $\omega(\lg n)$ lower bounds are known, and they all follow from the cell-sampling technique: (1) 2d range counting, (2) polynomial evaluation and (3) OMv. Initially, all these lower bounds were for worst case update and query times.

Amortized lower bounds. For many problems there is a large gap between worst case and amortized lower bounds. Furthermore, from the perspective of a practitioner, amortized data structures are in many applications as useful as worst case data structures. Very recently, Weinstein and Yu [11] showed how to make Larsen’s lower bound for 2d range counting work in the amortized setting. Their lower bound also applies to data structures with very high error probability. But it remained open whether one can get such amortized lower bounds for the remaining two problems that are known to be solvable via the cell-sampling technique: (1) polynomial evaluation and (2) OMv. We resolve this question in the affirmative. In addition, we show a generic template for proving such amortized lower bounds. Specifically, in Definition 1, we introduce the notion of a well-behaved input sequence for a dynamic problem. We prove that if one can show the existence of a well-behaved input sequence, then the corresponding dynamic problem admits the desired amortized lower bound.

Remark. Fredman and Saks [4] mention an extension of the chronogram technique where the input sequence consists of multiple queries perfectly interleaved with the updates. It might be possible to get an alternate proof of our results using this approach. However, we believe that the framework we present is going to be useful for the cleaner exposition of future cell-probe lower bounds.

1.1 Our Results

Recall that an input means either an update or a query. Throughout this paper, we let $\mathcal{O}$ denote a (random) sequence of $\Theta(n^{\alpha})$ inputs for the dynamic problem under consideration, where $\alpha>0$ is some constant. Our goal is to give a lower bound of the expected number of cell-probes that any data structure has to make while processing the input sequence $\mathcal{O}$. By abusing the notation, we use the symbol $X\subseteq\mathcal{O}$ to denote a contiguous interval of inputs in $\mathcal{O}$. We let $|X|$ denote the size of the interval $X$, which refers to the number of inputs in $X$. We define $P(X)$ to be the set of cells probed by a data structure while processing the inputs in $X$. We say that two intervals $X,Y\subseteq\mathcal{O}$ are consecutive if the first input in $Y$ appears immediately after the last input in $X$. For any two consecutive intervals $X,Y\subseteq\mathcal{O}$, the counter $C(X,Y)$ denotes the number of times the following event occurs: While answering a query in $Y$, the data structure reads a cell that was updated in $X$, and is probed in $Y$, but the cell was not probed earlier in $Y$.333Note that the authors in [11] do not use this counter. Instead they consider the set of cells $P(X)\cap P(Y)$. In contrast, we only consider the cells probed in $Y$ for answering queries. The reason for this definition of $C(X,Y)$ is to avoid double counting cells that are written during $X$ and then probed multiple times during $Y$.

In Definition 1, we introduce the concept of a “well-behaved” input sequence, which implicitly captures the main idea behind the dynamic lower bounds obtained by the chronogram method.

Definition 1**.**

Let $\kappa\in(0,1)$ and $c,\alpha,\beta>0$ be constants, and define $\gamma:=\lg^{\beta}n$. Fix a dynamic problem $\mathcal{P}$, and consider a (random) input sequence $\mathcal{O}$ of size $\Theta(n^{\alpha})$ for this problem. Such an input sequence $\mathcal{O}$ is called “well-behaved” iff every dynamic data structure for problem $\mathcal{P}$ satisfies the following property while processing the updates and queries in $\mathcal{O}$.

• •

For every pair of consecutive intervals $X,Y\subseteq\mathcal{O}$ with $|X|\simeq\gamma\cdot|Y|$ and $|Y|\geq|\mathcal{O}|^{\kappa}$, at least one of these three conditions is violated:

$\mathbb{E}\left[|P(X)|\right]<|X|\cdot\lg^{2}n$, 2. 2.

$\mathbb{E}\left[|P(Y)|\right]<|Y|\cdot\lg^{2}n$, and 3. 3.

$\mathbb{E}\left[C(X,Y)\right]<\frac{1}{200(c+1002)}\cdot|Y|\cdot\frac{\lg n}{\lg\lg n}$.

We now explain this in a bit more details. Suppose that the input sequence $\mathcal{O}$ consists of a batch of random updates followed by one random query. Build a chronogram on top of this input sequence $\mathcal{O}$ and consider any sufficiently large epoch $i$ in this chronogram, ensuring that the number of inputs appearing after epoch $i$ is $\Omega(|\mathcal{O}|^{\kappa})$ for some small constant $\kappa\in(0,1)$. The total number of such large epochs is still $\Omega(\lg n/\lg\lg n)$. Hence, we do not incur any asymptotic loss in the derived lower bound if we focus only on these large epochs. Let $X$ denote the sequence of inputs in epoch $i$, and let $Y$ denote the sequence of all the inputs in $\mathcal{O}$ that appear after $X$. As we go back in time, the sizes of the epochs in a chronogram increase exponentially in some $\gamma:=\text{poly}\lg n$ factor. Thus, we have $|X|\simeq\gamma\cdot|Y|$ and $|Y|\geq|\mathcal{O}|^{\kappa}$. Intuitively, a chronogram based lower bound basically proves the following statement.

Claim 2** (Informal).**

If the update time of the data structure is some small $\text{poly}\lg n$, say $\lg^{2}n$, then to answer the random query at the end of the input sequence, the data structure must probe at least $\Omega(t)$ cells that were probed in $X$ but not probed before in $Y$, for some parameter $t$.

To notice the similarities between Claim 2 and Definiton 1, interpret Definition 1 as follows: A well-behaved input sequence $\mathcal{O}$ is such that if any data structure satisfies conditions (1) and (2), then it must violate condition (3). Seen in this light, conditions (1) and (2) in Definition 1 are analogous to the statement that the update time of the data structure is at most $\lg^{2}n$. Similarly, the assertion that condition (3) must be violated becomes analogous to the statement that while answering the random query at the end of the input sequence, the data structure must read many cells that were probed in $X$ but not probed before in $Y$.

Definition 1, however, is much more general than Claim 2. For example, typically a well-behaved sequence will intersperse the queries with the updates, instead of having only one query at the end of all the updates. Furthermore, as opposed to the classical chronogram method, the input sequence $\mathcal{O}$ need not end with the interval $Y$. These important distinctions between Definition 1 and Claim 2 help us derive amortized lower bounds using our framework.

Theorem 3 shows how the existence of a well-behaved input sequence implies a cell-probe lower bound for the dynamic problem under consideration. Its proof appears in Section 2. We use Theorem 3 to derive amortized cell-probe lower bounds for two concrete problems.

Theorem 3**.**

Let $\mathcal{O}$ be a well-behaved (random) input sequence for a dynamic problem $\mathcal{P}$ as per Definition 1. Then any dynamic data structure for problem $\mathcal{P}$ needs to probe at least $\Omega(|\mathcal{O}|\cdot(\lg n/\lg\lg n)^{2})$ cells in expectation while processing the input sequence $\mathcal{O}$.

We note that in the upcoming proofs of our lower bounds it is crucial that a well-behaved input sequence $\mathcal{O}$ additionally satisfies the following two properties: (1) $\mathcal{O}$ interleaves updates and queries. This is necessary because, for example, if we only had a single query at the end of $\mathcal{O}$, then an amortized data structure could just batch all updates together and solve the static version of the problem. The static version of the problem might, however, allow for faster algorithms than the dynamic version of the problem. (2) The updates and queries in $\mathcal{O}$ are independent operations. This is crucial for the chronogram argument and cell-sampling encoding proofs to go through.

Our Result on Dynamic Online Matrix Vector Multiplication (OMv).

Consider an $n\times n$ matrix $M$ over a finite field $\mathbb{F}$ of size $|\mathbb{F}|=n^{\Theta(1)}$. All the entries in this matrix are set to zero in the beginning. Subsequently, the data structure should be able to handle any sequence of two types of operations:

• •

Update $(i,j,x)\in\{1,\dots,n\}^{2}\times\mathbb{F}$: Set the entry $(i,j)$ of $M$, denoted as $M_{ij}$, to $x\in\mathbb{F}$.

• •

Query $v\in\mathbb{F}^{n}$: Return the matrix vector product $M\cdot v$.

Note that it requires $\Theta(\lg n)$ bits to specify an update, and $\Theta(n\cdot\lg n)$ bits to specify the answer to a query. Since each cell contains $w=\Theta(\lg n)$ bits, it is trivial to show a lower bound of $\Omega(1)$ on the update time, and a lower bound of $\Omega(n)$ on the query time. Our main result on the dynamic OMv problem is summarized in Theorem 4. To prove Theorem 4, we adapt the approach of Clifford et al. [3] into our setting. See Section 3 for the detailed proof.

Theorem 4**.**

For the dynamic OMv problem, there exists a well-behaved random input sequence $\mathcal{O}$ consisting of $n^{2}$ updates and $n$ queries.

Corollary 5**.**

A cell-probe data structure for the dynamic OMv problem must have a total update and query time of $\Omega(n^{2}(\lg n/\lg\lg n)^{2})$ over a sequence of $n^{2}$ updates and $n$ queries.

Proof.

The input sequence $\mathcal{O}$ as described in Theorem 4 consists of $n^{2}$ updates and $n$ queries. Since $\mathcal{O}$ is well-behaved, the total time taken to process the inputs in $\mathcal{O}$ is $\Omega(n^{2}\cdot(\lg n/\lg\lg n)^{2})$ in the cell-probe model (see Theorem 3). Hence, either $\Omega(n^{2}\cdot(\lg n/\lg\lg n)^{2})$ many cells are probed while processing the $n^{2}$ updates, or $\Omega(n^{2}\cdot(\lg n/\lg\lg n)^{2})$ many cells are probed while processing the $n$ queries. ∎

Our Result on Dynamic Polynomial Evaluation.

Here, the data structure gets a polynomial of degree $n$ over a finite field $\mathbb{F}$ of size $n^{1+\Omega(1)}$. It is specified as $(x-r_{1})\cdot(x-r_{2})\cdots(x-r_{n})$, where $r_{i}$ is the $i^{th}$ root. Subsequently, the data structure should be able to handle the following two types of operations:

• •

Update($i,z$): Set the $i^{th}$ root to $z\in\mathbb{F}$, that is, set $r_{i}:=z$.

• •

Query($x$): Evaluate the value of the polynomial at $x\in\mathbb{F}$.

Both an update and a query here can be specified using $\Theta(\lg n)$ bits. Since each cell contains $w=\Theta(\lg n)$ bits, it is trivial to show a lower bound of $\Omega(1)$ on the update or the query time. Our main result on the dynamic polynomial evaluation problem is summarized in Theorem 6, which we prove in Section 4.

Theorem 6**.**

For the dynamic polynomial evaluation problem, there exists a well-behaved random input sequence $\mathcal{O}$ consisting of $n$ updates and $n$ queries.

Corollary 7**.**

A cell-probe data structure for the dynamic polynomial evaluation problem must have a total update and query time of $\Omega(n(\lg n/\lg\lg n)^{2})$ over a sequence of $n$ updates and $n$ queries.

Proof.

(Sketch) Follows from Theorem 3 and Theorem 6. ∎

2 Proof of Theorem 3

For every interval $I\subseteq\mathcal{O}$ we define $\operatorname{DEC}(I):=(I_{A},I_{B})$, where $I_{B}\subseteq I$ are the last $\lfloor|I|/\gamma\rfloor$ inputs in the interval $I$, and $I_{A}$ are the first $|I|-\lfloor|I|/\gamma\rfloor$ inputs in the interval $I$. Note that $I_{A}$ and $I_{B}$ partition $I$, and we have $|I_{A}|\simeq\gamma\cdot|I_{B}|$.

Following the framework of Weinstein and Yu [11] we construct a “hierarchy” $\mathcal{I}$, which can be thought of as a rooted binary tree that is built on top of the input sequence $\mathcal{O}$. Every node in this tree corresponds to an interval $I\subseteq\mathcal{O}$, and the root corresponds to the entire sequence $\mathcal{O}$. Every non-leaf node $I\subseteq\mathcal{O}$ has two children $I_{A}$ and $I_{B}$ such that $\operatorname{DEC}(I)=(I_{A},I_{B})$. We ensure that every node $I\subseteq\mathcal{O}$ in this tree has size $|I|\geq|\mathcal{O}|^{\kappa}$. In other words, as we move down a path from the root, the intervals corresponding to the nodes on this path keep getting smaller and smaller in size. Consider the first (closest to the root) node $I^{\prime}\subseteq\mathcal{O}$ on this path whose size is less than $\gamma\cdot|\mathcal{O}|^{\kappa}$. If the node $I^{\prime}$ had two children $I^{\prime}_{A}$ and $I^{\prime}_{B}$ such that $\operatorname{DEC}(I^{\prime})=(I^{\prime}_{A},I^{\prime}_{B})$, then the size of $I^{\prime}_{B}$ would be less than $|\mathcal{O}|^{\kappa}$. In order to rule out this possibility, such a node $I^{\prime}$ becomes a leaf in the tree.

An interesting corollary of this construction is as follows. Consider any two nodes $I_{A},I_{B}\subseteq\mathcal{O}$ in this tree that are “siblings” of each other, meaning that they share the same parent node $\mathcal{I}\subseteq\mathcal{O}$ and $\operatorname{DEC}(I)=(I_{A},I_{B})$. Then the two intervals $I_{A},I_{B}$ are consecutive, $|I_{A}|\simeq\gamma\cdot|I_{B}|$, and $|I_{B}|\geq|\mathcal{O}|^{\kappa}$. Hence, the property of a well-behaved input sequence $\mathcal{O}$ as stated in Definition 1 will apply to these two intervals $I_{A}$ and $I_{B}$.

By convention, the root of this tree is at level [math], and the level of a child node is one more than that of its parent. With this convention in mind, for every integer $i\geq 1$ let $\mathcal{I}_{i}$ be the collection of ordered pairs of siblings $(I_{A},I_{B})$ that constitute the level $i$ of the hierarchy $\mathcal{I}$. We further define $i_{\max}:=0.1\gamma\lg|\mathcal{O}|/\lg\gamma$. Lemma 8 lower bounds the total size of the $I_{B}$ intervals at any level $i\leq i_{max}$ of this hierarchy. Theorem 3 follows from Lemma 9 and 10.

Lemma 8** ([11], Claim 4).**

For each level $i\leq i_{\max}$, we have $\sum_{(I_{A},I_{B})\in\mathcal{I}_{i}}|I_{B}|\geq|\mathcal{O}|/(2\gamma)$.

Lemma 9**.**

For every level $i\leq i_{\max}$, at least one of these three conditions is violated:

$\sum_{(I_{A},I_{B})\in\mathcal{I}_{i}}\mathbb{E}\left[|P(I_{A})|\right]<\frac{|\mathcal{O}|\cdot\lg^{2}n}{8}$. 2. 2.

$\sum_{(I_{A},I_{B})\in\mathcal{I}_{i}}\mathbb{E}\left[|P(I_{B})|\right]<\frac{|\mathcal{O}|\cdot\lg^{2}n}{8\gamma}$. 3. 3.

$\sum_{(I_{A},I_{B})\in\mathcal{I}_{i}}\mathbb{E}\left[C(I_{A},I_{B})\right]<\frac{1}{1200(c+1002)}\cdot\frac{|\mathcal{O}|}{\gamma}\cdot\frac{\lg n}{\lg\lg n}$.

Proof.

The input sequence $\mathcal{O}$ is well-behaved as per Definition 1. For $j\in\{1,2,3\}$, define

[TABLE]

We also define $\operatorname{length}(F_{j}):=\sum_{(I_{A},I_{B})\in F_{j}}|I_{B}|$. As per Definition 1, each ordered pair $(I_{A},I_{B})\in\mathcal{I}_{i}$ belongs to at least one of the $F_{j}$’s. Furthermore, by Lemma 8 we have $\sum_{(I_{A},I_{B})\in\mathcal{I}_{i}}|I_{B}|\geq\frac{|\mathcal{O}|}{2\gamma}$. Thus, we infer that $\sum_{j=1}^{3}\operatorname{length}(F_{j})\geq\frac{|\mathcal{O}|}{2\gamma}$, and hence there must be some $j\in\{1,2,3\}$ for which $\operatorname{length}(F_{j})\geq\frac{|\mathcal{O}|}{6\gamma}$. We now fork into three cases, and show that in each case one of the three conditions stated in Lemma 9 gets violated.

Case 1: $\operatorname{length}(F_{1})\geq\frac{|\mathcal{O}|}{6\gamma}$. In this case, we can derive that:

[TABLE]

The second inequality follows from the definition of the set $F_{1}$. The third inequality holds since $|I_{A}|\simeq|I_{B}|\cdot\gamma$. Hence, the first condition in Lemma 9 is violated.

Case 2: $\operatorname{length}(F_{2})\geq\frac{|\mathcal{O}|}{6\gamma}$. In this case, we can derive that:

[TABLE]

The second inequality follows from the definition of the set $F_{2}$. We conclude that in this case the second condition in Lemma 9 is violated.

Case 3: $\operatorname{length}(F_{3})\geq\frac{|\mathcal{O}|}{6\gamma}$. In this case, we can derive that:

[TABLE]

The inequalities follow from the definition of $F_{3}$. The computation shows that the third condition in Lemma 9 is violated. ∎

Lemma 10**.**

Suppose that a data structure probes $o(|\mathcal{O}|\cdot(\lg n/\lg\lg n)^{2})$ cells in expectation while processing the updates and queries in $\mathcal{O}$. Then there exists a level $i\leq i_{\max}$ such that all of the following conditions are satisfied:

$\sum_{(I_{A},I_{B})\in\mathcal{I}_{i}}\mathbb{E}\left[|P(I_{A})|\right]<\frac{|\mathcal{O}|\cdot\lg^{2}n}{8}$. 2. 2.

$\sum_{(I_{A},I_{B})\in\mathcal{I}_{i}}\mathbb{E}\left[|P(I_{B})|\right]<\frac{|\mathcal{O}|\cdot\lg^{2}n}{8\gamma}$. 3. 3.

$\sum_{(I_{A},I_{B})\in\mathcal{I}_{i}}\mathbb{E}\left[C(I_{A},I_{B})\right]<\frac{1}{1200(c+1002)}\cdot\frac{|\mathcal{O}|}{\gamma}\cdot\frac{\lg n}{\lg\lg n}$.

We devote the rest of this section to the proof of Lemma 10. For $j\in\{1,2,3\}$, say that a level $i\in\{1,\ldots,i_{max}\}$ in the hierarchy $\mathcal{I}$ is of “type $j$” iff it violates condition $j$ in Lemma 10. In Claim 11, we show that there is no level of type $1$ in $\{1,\ldots,i_{max}\}$. Claims 12, 13 state that for each $j\in\{2,3\}$, the number of levels in $\{1,\ldots,i_{max}\}$ that are of type $j$ is less than $i_{max}/2$. Hence, there exists some level $i\in\{1,\ldots,i_{max}\}$ that is not of type $1,2$ or $3$. By definition, such a level $i$ satisfies all the three conditions in Lemma 10.

Claim 11**.**

There is no level $i\in\{1,\ldots,i_{max}\}$ that is of type $1$.

Proof.

Let there be a level $i\leq i_{max}$ of type $1$, then $\sum_{(I_{A},I_{B})\in\mathcal{I}_{i}}\mathbb{E}\left[|P(I_{A})|\right]\geq\frac{|\mathcal{O}|\cdot\lg^{2}n}{8}$. The sum $\sum_{(I_{A},I_{B})\in\mathcal{I}_{i}}|P(I_{A})|$ is a lower bound on the total number of cells probed by the data structure while processing the updates and queries in $\mathcal{O}$. Hence, this inequality implies that the data structure probes at least $\Omega(|\mathcal{O}|\cdot\log^{2}n)$ cells in expectation while processing the input sequence $\mathcal{O}$. This contradicts the assumption specified in Lemma 10. ∎

Claim 12**.**

The number of type $2$ levels in $\{1,\ldots,i_{max}\}$ is strictly less than $i_{max}/2$.

Proof.

Consider any element $x$ in the sequence of updates and queries $\mathcal{O}$ and any level $i\in\{1,\ldots,i_{max}\}$. If there exists an ordered pair $(I_{A},I_{B})\in\mathcal{I}_{i}$ such that $x\in I_{B}$, then we say that $x$ “appears” in level $i$ and that the “window” of $x$ at level $i$ is equal to $|I_{B}|$.

Fix any element $x$ in $\mathcal{O}$ and scan through the levels $\{1,\ldots,i_{max}\}$ in the hierarchy $\mathcal{I}$ in increasing order. Clearly, the window of $x$ at any level it appears in is at most $|\mathcal{O}|$. Further, every time the element $x$ appears in a level during this scan, its window shrinks by at least a factor of $\gamma$. This property holds since $|I_{B}|\simeq(1/\gamma)\cdot|I|$ whenever we have $\operatorname{DEC}(I)=(I_{A},I_{B})$. Thus, any element in $\mathcal{O}$ can appear in at most $\log_{\gamma}|\mathcal{O}|$ levels. Accordingly, from a simple counting argument, it follows that the number of cell-probes made by the data structure while processing the input sequence $\mathcal{O}$ is at least

[TABLE]

If the number of type $2$ levels in $\{1,\ldots,i_{max}\}$ were at least $i_{max}/2$, then we would get:

[TABLE]

The second inequality holds since by definition every type $2$ level $i\in\{1,\ldots,i_{max}\}$ has $\mathbb{E}\left[|P(I_{B})|\right]\geq|\mathcal{O}|\cdot\lg^{2}n/(8\gamma)$. The third inequality holds since $i_{max}=\Omega(\gamma\cdot\lg|\mathcal{O}|/\lg\gamma)$. If other words, if Claim 12 were not true, then it would imply that the data structure makes $\Omega(|\mathcal{O}|\cdot\lg^{2}n)$ cell-probes in expectation while processing the input sequence $\mathcal{O}$. But this would contradict the working assumption specified in the statement of Lemma 10. ∎

Claim 13**.**

The number of type $3$ levels in $\{1,\ldots,i_{max}\}$ is strictly less than $i_{max}/2$.

Proof.

Let $\Gamma$ be a random variable that denotes the number of cell-probes made by the data structure while processing the (random) input sequence $\mathcal{O}$. Then we have:

[TABLE]

Equation 1 holds since each cell-write made by the data structure contributes at most once to its left hand side (LHS). To see why this is true, consider the scenario where the data structure writes a cell $c$ while processing an input $x$ (say) in the input sequence $\mathcal{O}$. Suppose that the same cell $c$ is read by the data structure while answering a subsequent query $y$ in $\mathcal{O}$, and, furthermore, the cell is not read by the data structure while processing any other input that appears in the interval between $x$ and $y$. Let $I_{x}$ and $I_{y}$ respectively denote the leaf-nodes in the hierarchy tree containing $x$ and $y$, and suppose that $I_{x}\neq I_{y}$. Let $I$ be the least common ancestor of $I_{x}$ and $I_{y}$ in the hierarchy tree, and let $\operatorname{DEC}(I)=(I_{A},I_{B})$. Then the cell-write of $c$ at $x$ contributes one towards the counter $C(I_{A},I_{B})$, and zero towards every other counter $C(I^{\prime}_{A},I^{\prime}_{B})$. Thus, the net contribution of the cell-write of $c$ at $x$ towards the LHS is one. In contrast, if it were the case that $I_{x}=I_{y}$, or if the cell $c$ was not read at all while processing any query that appears after $x$ in $\mathcal{O}$, then the net contribution of the cell-write at $x$ towards the LHS would have been zero. To summarize, we conclude that each cell-write made by the data structure contributes at most one towards the LHS.

By definition, every type $3$ level $i$ has

[TABLE]

Let $K_{3}\subseteq\{1,\ldots,i_{max}\}$ denote the set of type $3$ levels. Now, Equation 1 implies that:

[TABLE]

Rearranging the terms in the above inequality, we get:

[TABLE]

In the above derivation, the first equality holds since as per the statement of Lemma 10, the data structure probes $o(|\mathcal{O}|\cdot(\lg n/\lg\lg n)^{2})$ cells in expectation while processing the input sequence $\mathcal{O}$. The third equality holds since $\gamma=\lg^{\beta}n$ and $|\mathcal{O}|=n^{\alpha}$ for some constants $\alpha,\beta>0$. The last inequality holds since $i_{max}=0.1\gamma\log_{\gamma}|\mathcal{O}|$, $\gamma=\lg^{\beta}n$, $|\mathcal{O}|=\Theta(n^{\alpha})$ and $\alpha,\beta$ are constants. ∎

3 Proof of Theorem 4

Throughout this section, we will continue with the notations introduced in Section 1.1. Further, we will set the values of the parameters $\alpha,\beta,\gamma$ and $\kappa$ as follows.

[TABLE]

3.1 Defining the random input sequence $\mathcal{O}$

The (random) input sequence $\mathcal{O}$ consists of $n^{2}$ updates and $n$ queries. Such an input sequence is of size $\Theta(n^{\alpha})$ since we have set $\alpha=2$ (see Equation 2). The input sequence $\mathcal{O}$ is constructed as follows. First, we define a sequence of $n^{2}$ updates: For $1\leq k\leq n^{2}$, the $k^{th}$ update is denoted by $(i_{k},j_{k},x_{k})$, and it consists of a location $(i_{k},j_{k})\in[1,n]\times[1,n]$ and a value $x_{k}\in\mathbb{F}$. The $k^{th}$ update sets the matrix entry $M_{i_{k}j_{k}}$ to value $x_{k}\in\mathbb{F}$, where $x_{k}$ is picked uniformly at random from $\mathbb{F}$. However, the location of the $k^{th}$ update, given by $(i_{k},j_{k})$, is fixed deterministically. To finish the construction of the sequence $\mathcal{O}$, after each $n^{th}$ update we add a query chosen uniformly at random from $\mathbb{F}^{n}$. Formally, after each update $(i_{r\cdot n},j_{r\cdot n},x_{r\cdot n})$ for $1\leq r\leq n$, we insert a uniformly random query $v_{r}\in\mathbb{F}^{n}$. We ensure that the sequence of locations of the updates are well-spread, which means that they satisfy two properties.

All the pairs $(i_{k},j_{k})$ are mutually disjoint. 2. 2.

For every index $n^{4/3}\leq r\leq n^{2}$ and every set of $n/2$ row indices $S\subseteq\{1,\dots,n\}$, there exists a subset $S^{*}\subseteq S$ of size $|S^{*}|\leq 8n^{2}/r$ such that $|\bigcup_{k\leq r:i_{k}\in S^{*}}\{j_{k}\}|\geq n/4$.

Such a well-spread sequence of indices exists due to Lemma 2 in [3].

3.2 Proving that $\mathcal{O}$ is well-behaved

We begin by defining some additional notations. Let $u(X)$ and $q(X)$ respectively denote the number of updates and queries in an interval $X\subseteq\mathcal{O}$. It follows that $|X|=q(X)+u(X)$. For $1\leq j\leq q(X)$, let $X_{j}$ denote the sequence of inputs in $X$ preceding the $j^{th}$ query in $X$. Note that $X_{j}$ is always a prefix of $X$. Consider any two consecutive intervals $X,Y\subseteq\mathcal{O}$. The counter $C_{j}(X,Y)$ denotes the number of times the following event occurs: While answering the $j^{th}$ query in $Y$, the data structure probes a cell that was written in $X$ but was not previously probed in $Y_{j}$. Recall the definition of the counter $C(X,Y)$ from Section 1.1, and note that $C(X,Y)=\sum_{j=1}^{q(Y)}C_{j}(X,Y)$. Our main challenge will be to prove the lemma below. The proof of Lemma 14 appears in Section 3.3.

Lemma 14**.**

Every data structure for the dynamic OMv problem satisfies the following property while processing the random input sequence $\mathcal{O}$ described above. Consider any pair of consecutive intervals $X,Y\subseteq\mathcal{O}$ with $|X|\simeq\gamma\cdot|Y|$ and $|Y|\geq|\mathcal{O}|^{\kappa}$, such that $\mathbb{E}\left[|P(X)|\right]\leq|X|\cdot\lg^{2}n$ and $\mathbb{E}\left[|P(Y)|\right]\leq|Y|\cdot\lg^{2}n$. Then we must have:

[TABLE]

Proof of Theorem 4. Consider any data structure for the dynamic OMv problem, and any pair of consecutive intervals $X,Y\subseteq\mathcal{O}$ with $|X|\simeq\gamma\cdot|Y|$ and $|Y|\geq|\mathcal{O}|^{\kappa}$. If either condition (1) or condition (2) as stated in Definition 1 gets violated, then we have nothing more to prove. Henceforth, we assume that both the conditions (1) and (2) hold, so that we have $\mathbb{E}\left[|P(X)|\right]\leq|X|\cdot\lg^{2}n$ and $\mathbb{E}\left[|P(Y)|\right]\leq|Y|\cdot\lg^{2}n$. Now, applying Lemma 14, we get:

[TABLE]

Note that $|Y|\geq|\mathcal{O}|^{\kappa}=\Theta(n^{\alpha\kappa})=\Theta(n^{4/3})$. The last equality holds since $\alpha=2$ and $\kappa=2/3$ as per Equation 2, and because the sum only contains a finite number of summands. Recall that the input sequence $\mathcal{O}$ contains a query after every $n$ updates. Thus, the size of the interval $Y\subseteq\mathcal{O}$ is large enough for us to infer that $q(Y)\geq\frac{1}{2}|Y|/n$. Plugging this in Equation 3, we get:

[TABLE]

Thus, condition (3) as stated in Definition 1 gets violated whenever the conditions (1) and (2) hold. This implies that the input sequence $\mathcal{O}$ is well-behaved, and concludes the proof of Theorem 4.

3.3 Proof of Lemma 14.

Throughout the proof of Lemma 14, we fix the following quantities.

A data structure for the dynamic OMv problem. 2. 2.

Two consecutive intervals $X,Y\subseteq\mathcal{O}$ such that $|X|\simeq\gamma\cdot|Y|$ and $|Y|\geq|\mathcal{O}|^{\kappa}$. 3. 3.

An index $1\leq j\leq q(Y)$. 4. 4.

All the inputs in $\mathcal{O}$ that appear before the beginning of the interval $X$. 5. 5.

All the inputs in $\mathcal{O}$ that appear after the $j^{th}$ query in $Y$. 6. 6.

All the inputs in $Y_{j}$.

Thus, everything is fixed except the values of the updates and the queries in $X$ and the $j^{th}$ query in $Y$. Conditioned on these events, we next assume that:

[TABLE]

Finally, for the sake of contradiction, we assume that:

[TABLE]

We now show how to encode the sequence of values of the updates in $X$ using fewer than $u(X)\cdot\lg|\mathbb{F}|$ bits. This leads to a contradiction since the entropy of the object under consideration is exactly $u(X)\cdot\lg|\mathbb{F}|$ bits. This concludes the proof of Lemma 14.

Notations. We define some notations that will be used in the encoding proof. We let $M_{X}$ and $M_{Y_{j}}$ respectively denote the state of the matrix $M$ just after the interval $X$ and $Y_{j}$. For each row $1\leq i\leq n$, we let $m_{X,i}$ and $m_{Y_{j},i}$ respectively denote the vectors in $\mathbb{F}^{n}$ that correspond to the row $i$ of matrices $M_{X}$ and $M_{Y_{j}}$. Consider any set of indices $S\subseteq\{1,\dots,n\}$ and any vector $v\in\mathbb{F}^{n}$. We let $v^{|S}\in\mathbb{F}^{|S|}$ denote the vector with one entry $v(i)$ for each $i\in S$. In other words, this gives the restriction of the vector $v$ into the coordinates specified by the indices in $S$. For $1\leq i\leq n$, we let $R_{i}$ denote the set of column indices updated in the $i^{th}$ row of $M$ during to the interval $X\subseteq\mathcal{O}$. More formally, we have $R_{i}=\{j^{\prime}:(i^{\prime},j^{\prime},\cdot)\in X\}$.

Preliminaries. We introduce the concept of a rank sum in Definition 15. To get some intuition behind this definition, recall that the locations of the updates in $X$ are fixed and mutually disjoint. Only the values of the updates in $X$ can vary. Furthermore, since the updates preceding $X$ are fixed in advance, the values of the remaining entries in the matrix $M_{X}$ are known to the decoder. Thus, to encode the sequence of updates in $X$, it suffices to encode the vectors $m_{X,i}^{|R_{i}}$ for all $1\leq i\leq n$. Towards this end, the encoder will first find a suitable set of vectors $\{v_{1},\ldots,v_{k}\}\subseteq\mathbb{F}^{n}$, for some positive integer $k$ whose value will be determined later on. Next, as part of the procedure for encoding the vectors $m_{X,i}^{|R_{i}}$, she will convey (in an indirect manner to be specified later) to the decoder the results of the inner products $\left\langle m_{X,i}^{|R_{i}},v_{k^{\prime}}^{|R_{i}}\right\rangle$ for all $1\leq k^{\prime}\leq k$. For this encoding to be efficient, the decoder should be able to retrieve a lot of information about the vectors $m_{X,i}^{|R_{i}}$ by looking at the results of these inner products. This means that for most of the rows $i\in[1,n]$ we want most of the vectors $v_{1}^{|R_{i}},\ldots,v_{k}^{|R_{i}}$ to be linearly independent, or, equivalently, for most of the rows $i\in[1,n]$ we want $\dim\left(\operatorname{span}\left(v_{1}^{|R_{i}},\ldots,v_{k}^{|R_{i}}\right)\right)$ to be large. This intuition can be formalized by saying that we want the rank sum $\mathcal{RS}(v_{1},\ldots,v_{k})$, as defined below, to be large.

Definition 15**.**

The rank sum of a set of $k$ vectors $\{v_{1},\ldots,v_{k}\}\subseteq\mathbb{F}^{n}$ is given by $\mathcal{RS}(v_{1},\dots,v_{k})=\sum_{i=1}^{n}\dim\left(\operatorname{span}\left(v_{1}^{|R_{i}},\ldots,v_{k}^{|R_{i}}\right)\right)$.

Recall that the encoder will have to convey the results of the inner products $\left\langle m_{X,i}^{|R_{i}},v_{k^{\prime}}^{|R_{i}}\right\rangle$ to the decoder in an indirect manner. We now elaborate on this aspect of the encoding procedure in a bit more details. Basically, the encoder will identify a small set of cells $\mathcal{C}^{*}\subseteq P(X)$, and send their addresses and contents (at the end of the interval $X$) to the decoder. This set $\mathcal{C}^{*}$ will contain the necessary information about the inner products $\left\langle m_{X,i}^{|R_{i}},v_{k^{\prime}}^{|R_{i}}\right\rangle$. To see why this is possible, suppose that the decoder simulates the data structure from the beginning of $\mathcal{O}$ till just before the interval $X$, then skips the intervals $X$ and $Y_{j}$, and then tries to simulate a query $v\in\mathbb{F}^{n}$ at the $j^{th}$ position of $Y$. Furthermore, suppose that the decoder gets lucky, meaning that the query algorithm never has to read the content of a cell in $P(X)\setminus\mathcal{C}^{*}$. In such an event we say that the set $\mathcal{C}^{*}$ “resolves” the vector $v$. The key insight is that if $\mathcal{C}^{*}$ resolves $v$, then the decoder can recover the vector $M_{Y_{j}}\cdot v$ by looking at the contents of the cells in $\mathcal{C}^{*}$ (and a few other minor things that will be specified later on). Since the inputs in $Y_{j}$ are fixed in advance, from $M_{Y_{j}}\cdot v$ the decoder can infer the vector $M_{X}\cdot v$. Similarly, since the inputs preceding $X$ are fixed in advance, from $M_{X}\cdot v$ the decoder can infer the inner products $\left\langle m_{X,i}^{|R_{i}},v^{|R_{i}}\right\rangle$. To summarize, the encoder will convey to the decoder the inner products $\left\langle m_{X,i}^{|R_{i}},v^{|R_{i}}\right\rangle$ in an indirect manner, by sending her the addresses and contents of the cells in $\mathcal{C}^{*}$.

Now, recall the motivation behind Definition 15. It implies that ideally we would like to have a small set of cells $\mathcal{C}^{*}\subseteq P(X)$ that resolves a “nice” set of vectors in $\mathbb{F}^{n}$ with large rank sum. Furthermore, the decoder will also need to identify such a “nice” set of vectors. One way to do this is to require that there are a large number of subsets of $\mathbb{F}^{n}$ that are nice. If this is the case, then the encoder and the decoder can use shared randomness to sample some subsets of $\mathbb{F}^{n}$ uniformly at random, and with good enough probability, one of the sampled subsets will be nice. This intuition is formalized in Definition 16, where $\mathcal{M}(\mathcal{C})$ corresponds to the collection of all such nice subsets of query vectors $v\in\mathbb{F}^{n}$ for the set of cells $\mathcal{C}\subseteq P(X)$.

Definition 16**.**

Consider any subset of cells $\mathcal{C}\subseteq P(X)$ and any vector $v\in\mathbb{F}^{n}$. We say that $\mathcal{C}$ “resolves” $v$ iff the data structure does not probe any cell in $P(X)\setminus\mathcal{C}$ when it is asked to return the answer $Mv$ by the $j^{th}$ query in $Y$. We let $Q(\mathcal{C})\subseteq\mathbb{F}^{n}$ denote the set of vectors that are resolved by $\mathcal{C}$. Finally, we let $\mathcal{M}(\mathcal{C})\subseteq 2^{Q(\mathcal{C})}$ denote the collection of all subsets $\{v_{1},\ldots,v_{k}\}\subseteq Q(\mathcal{C})$ of size $k=(|X|-1)/n$ with rank sum $\mathcal{RS}(v_{1},\dots,v_{k})\geq nk/32$.

Lemma 17**.**

With probability at least $1/4$ over the randomness of $X$, there exists a subset of cells $\mathcal{C}^{*}\subseteq P(X)$ of size $|\mathcal{C}^{*}|=|X|\cdot\lg|\mathbb{F}|/(1024w)$ such that $|\mathcal{M}(\mathcal{C}^{*})|\geq|\mathbb{F}|^{0.999\cdot nk}$.

Proving Lemma 17 requires a standard application of the cell-sampling technique. We defer the proof of Lemma 17 to the end of the section (see Section 3.4). Instead we focus on showing that Lemma 17 leads to an encoding of the sequence of updates in $X$, and that the resulting encoding uses less than $u(X)\cdot\lg|\mathbb{F}|$ bits in expectation. This concludes the proof of Lemma 14.

Shared randomness between the encoder and the decoder.

We assume that both the encoder and the decoder have access to a joint source of random bits. They use this random source to sample $m=|\mathbb{F}|^{nk/512}$ sets $\Gamma_{1},\dots,\Gamma_{m}$. Each set $\Gamma_{i}$ consists of $k=(|X|-1)/n$ vectors that are picked uniformly at random from $\mathbb{F}^{n}$.

Encoding the sequence of updates in $X$.

Recall that the encoder and the decoder know the inputs preceding $X$ and the inputs in $Y_{j}$, and both of them know the sets $\Gamma_{1},\dots,\Gamma_{m}\subseteq\mathbb{F}^{n}$. The encoding procedure works as follows.

Step 1. We simulate the data structure until the end of $X$. If there exists a set of cells $\mathcal{C}^{*}\subseteq P(X)$ as per Lemma 17, then we proceed to step (2) of the encoding. Otherwise we send a [math]-bit and the naive encoding of the sequence of updates in $X$, and then we terminate the encoding procedure. By Lemma 17, the probability of this event (that no such $\mathcal{C}^{*}$ exists) is at most $3/4$.

Step 2. Since we are in step (2), we must have found a set of cells $\mathcal{C}^{*}\subseteq P(X)$ as per Lemma 17. We check if there exists an index $1\leq i^{*}\leq m$ such that $\Gamma_{i^{*}}\in\mathcal{M}(\mathcal{C})$. If such an index exists, then we proceed to step (3) of the encoding. Otherwise we send a [math]-bit and the naive encoding of the sequence of updates in $X$, and then we terminate the encoding procedure. The probability of this event (that no such index $i^{*}$ exists) is at most $(1-|\mathcal{M}(\mathcal{C})|/\binom{|\mathbb{F}|^{n}}{k})^{m}\leq\exp(-m|\mathcal{M}(\mathcal{C})|/|\mathbb{F}|^{nk})\leq\exp(-|\mathbb{F}|^{\Omega(nk)})\leq 1/100$. The second inequality holds since $m=|\mathbb{F}|^{nk/512}$ and $|\mathcal{M}(\mathcal{C})|\geq|\mathbb{F}|^{0.999\cdot nk}$.

Step 3. We send a $1$-bit and then send an encoding of the index $i^{*}$, followed by the addresses and contents444For every cell in $\mathcal{C}^{*}$, we encode its content at the end of the interval $X$. of the cells in $\mathcal{C}^{*}$. Encoding the index $i^{*}$ takes $\lg m$ bits. Encoding the address and content of one cell requires $2w$ bits. Hence, the total number of bits sent is: $1+\lg m+(2w)\cdot|\mathcal{C}^{*}|=1+\lg|\mathbb{F}|^{nk/512}+(2w)\cdot|X|\cdot\lg|\mathbb{F}|/(1024w)\leq 1+(nk)\cdot\lg|\mathbb{F}|/512+|X|\cdot\lg|\mathbb{F}|/512=1+(|X|-1)\cdot\lg|\mathbb{F}|/512+|X|\cdot\lg|\mathbb{F}|/512\leq 1+|X|\cdot\lg|\mathbb{F}|/256$.

Step 4. We send the addresses and contents555For every cell in $P(Y_{j})$, we encode its content at the end of the interval $Y_{j}$. of the cells in $P(Y_{j})$. In expectation, the total number of bits required is: $\mathbb{E}\left[|P(Y_{j})|\right]\cdot(2w)\leq\mathbb{E}\left[|P(Y)|\right]\cdot(2w)\leq|Y|\cdot\lg^{2}n\cdot(2w)=o(|X|)$. The second inequality follows from Equation 4. The last equality holds since $w=\lg n$, $|X|\simeq\gamma\cdot|Y|$ and $\gamma=\Theta(\lg^{2000}n)$ as per Equation 2.

Step 5. We iterate over the rows of the matrix $M_{X}$ from $1$ to $n$. Let the $k$ vectors in $\Gamma_{i^{*}}$ be denoted by $v_{1},\dots,v_{k}$. For each row $1\leq i\leq n$, we proceed as follows:

• (a)

We create an empty set $T_{i}$. Next, we iterate over all the vectors in $\mathbb{F}^{|R_{i}|}$ in a predefined and fixed order that is known to the decoder. For each vector $v\in\mathbb{F}^{|R_{i}|}$ in that order, if $v\notin\operatorname{span}\left(v_{1}^{|R_{i}},\dots,v_{k}^{|R_{i}},T_{i}\right)$, then we add the vector $v$ to $T_{i}$ by setting $T_{i}:=T_{i}\cup\{v\}$.

• (b)

After finishing Step 5 (a), we compute $\left\langle m_{X,i}^{|R_{i}},v\right\rangle$ for each vector $v\in T_{i}$ and send this inner product.

Sending the inner products in Step 5 (b) requires $|T_{i}|\cdot\lg|\mathbb{F}|$ bits for a given row $i$. When Step 5 (a) is finished, we have $|T_{i}|=|R_{i}|-\dim\left(\operatorname{span}\left(v_{1}^{|R_{i}},\dots,v_{k}^{|R_{i}}\right)\right)$. Hence, the total number of bits sent for the inner products for all rows is equal to:

[TABLE]

The third equality follows from Definition 15 and the fact that no two updates in the input sequence $\mathcal{O}$ change the same entry in the matrix $M$, which implies that $\sum_{i=1}^{n}|R_{i}|=u(X)$. The first inequality follows from Definition 16 and the fact that $u(X)\leq|X|$.

This concludes the description of the encoding procedure.

Claim 18**.**

The encoding described above requires fewer than $u(X)\cdot\lg|\mathbb{F}|$ bits in expectation.

Proof.

Applying union bound, we get: the probability that the encoding procedure terminates in either Step 1 or 2 is at most $3/4+1/100<4/5$. If the encoding procedure terminates in either Step 1 or 2, then the total number of bits in the encoding is (say) $\ell_{1}=1+u(X)\cdot\lg|\mathbb{F}|$.

Next, we bound the expected number of bits (say, $\ell_{2}$) used by the encoding, conditioned on the event that it executes Steps 3–5. From the description of Steps 3–5, we get:

[TABLE]

The last inequality holds since the input sequence $\mathcal{O}$ contains a query after every $n$ updates, and hence we have $u(X)\geq(1-1/n)\cdot|X|>(999/1000)\cdot|X|$ for large enough $|X|$. To summarize, the expected number of bits required by the encoding is at most $(4/5)\cdot\ell_{1}+(1/5)\cdot\ell_{2}<u(X)\cdot\lg|\mathbb{F}|$. This concludes the proof of the claim. ∎

Decoding the sequence of updates in $X$.

Since the matrix entries for the updates are fixed in advance and since these entries are mutually disjoint, one can reconstruct the sequence of updates in $X$ if one gets to know the vector $m_{X,i}^{|R_{i}}$ for each row $1\leq i\leq n$. Accordingly, the goal of the decoding procedure will be to recover these vectors $m_{X,i}^{|R_{i}}$. It will consist of the following steps.

Step 1. If the first bit of the encoding is a [math], then we just restore all updates from the naive encoding and terminate the procedure.

Step 2. If the first bit of the encoding is a $1$, then we recover the index $1\leq i^{*}\leq m$ and the set of cells $\mathcal{C}^{*}\subseteq P(X)$. Let the $k$ vectors in the set $\Gamma_{i^{*}}\subseteq\mathbb{F}^{n}$ be denoted by $v_{1},\dots,v_{k}$.

Step 3. We now reconstruct the sets $T_{i}$. For each row $1\leq i\leq n$, we create an empty set $T_{i}$ and iterate over the vectors in $\mathbb{F}^{|R_{i}|}$ in the predefined order (see Step 5(a) of the encoding). While considering a vector $v\in\mathbb{F}^{|R_{i}|}$ during any such iteration, if we find that $v\notin\operatorname{span}\left(v_{1}^{|R_{i}},\dots,v_{k}^{|R_{i}},T_{i}\right)$, then we add $v$ to $T_{i}$ by setting $T_{i}:=T_{i}\cup\{v\}$.

Step 4. We simulate the data structure through all the inputs preceding the interval $X$. Let $\mathcal{S}$ denote the collective state of the memory cells at the end of this simulation.

Step 5. For all $v\in\{v_{1},\ldots,v_{k}\}$, we recover the vector $M_{Y_{j}}\cdot v$ for the decoder. This is done as follows. We ask the data structure to answer the query $v$. We allow the data structure to write any cell while answering the query. In contrast, whenever the data structure tries to read a cell $c$ (say) while answering the query, we perform the following operations.

• (a)

If $c\in P(Y_{j})$, then we fetch the content of $c$ from Step 4 of the encoding.

• (b)

Else if $c\in\mathcal{C}^{*}\setminus P(Y_{j})$, then we fetch the content of $c$ from Step 3 of the encoding.

• (c)

Else if $c\notin\mathcal{C}^{*}\cup P(Y_{j})$, then we claim $c\notin P(X)$. To see why the claim holds, note that $\Gamma_{i^{*}}\in\mathcal{M}(\mathcal{C}^{*})$, and hence, by Definition 16 we have $\Gamma_{i^{*}}\subseteq Q(\mathcal{C}^{*})$. Since $v\in\Gamma_{i^{*}}$, we infer that $v\in Q(\mathcal{C}^{*})$. In other words, the set of cells $\mathcal{C}^{*}$ resolves the query vector $v$. Thus, by definition, the data structure does not probe any cell in $P(X)\setminus\mathcal{C}^{*}$ while answering the query vector $v$ at the $j^{th}$ query position in $Y$. Since $\mathcal{C}^{*}\subseteq P(X)$, and since we are considering a scenario where $c\notin\mathcal{C}^{*}\cup P(Y_{j})$, it follows that $c\notin P(X)$. So we fetch the content of $c$ from the state $\mathcal{S}$ of the main memory, as defined in Step (4) of the decoding.

This shows that we can recover the vectors $M_{Y_{j}}\cdot v$ for all $v\in\{v_{1},\ldots,v_{k}\}$.

Step 6. For all $v\in\{v_{1},\ldots,v_{k}\}$, we now recover the vector $M_{X}\cdot v$ for the decoder. Let $M^{\prime\prime}$ be an $n\times n$ matrix over $\mathbb{F}$ that is defined as follows. An entry $(x,y)\in[1,n]\times[1,n]$ in this matrix is set to zero if it is not updated during the interval $Y_{j}$; otherwise it is set to the value of the entry $(x,y)$ in $M_{Y_{j}}$. Note that $M_{X}=M_{Y_{j}}-M^{\prime\prime}$, and, furthermore, the matrix $M^{\prime\prime}$ is known to the decoder since we have fixed the inputs in $Y_{j}$. Accordingly, for all $v\in\{v_{1},\ldots,v_{k}\}$, the decoder computes $M_{X}\cdot v$ from the equation: $M_{X}\cdot v=M_{Y_{j}}\cdot v-M^{\prime\prime}\cdot v$. This is feasible since the decoder already knows the vector $M_{Y_{j}}\cdot v$ from step (5) above.

Step 7. For each row $1\leq i\leq n$, we now recover the vector $m_{X,i}^{|R_{i}}$ as follows.

From step (6) of the decoding, the decoder knows the inner product $\left\langle m_{X,i},v\right\rangle$ for all $v\in\{v_{1},\ldots,v_{k}\}$. Since the decoder also knows the updates in the matrix preceding $X$, from $\left\langle m_{X,i},v\right\rangle$ she can easily infer the inner product $\left\langle m_{X,i}^{|R_{i}},v^{|R_{i}}\right\rangle$ for every $v\in\{v_{1},\ldots,v_{k}\}$. Additionally, from step (5) of the encoding and step (3) of the decoding, the decoder knows every vector $v\in T_{i}$ and the corresponding inner product $\left\langle m_{X,i}^{|R_{i}},v\right\rangle$. As $\dim\left(\operatorname{span}\left(v_{1},\ldots,v_{k},T_{i}\right)\right)=|R_{i}|$, the decoder can recover the vector $m_{X,i}^{|R_{i}}$ from all these $k+|T_{i}|$ inner products.

This concludes the description of the decoding procedure, and the proof of Lemma 14.

3.4 Proof of Lemma 17

We begin by defining a new counter $C_{j}(X,Y,v)$. Consider a scenario where the data structure is asked to answer a query $v^{\prime}\in\mathbb{F}^{n}$ in the $j^{th}$ query position of the interval $Y$. The counter $C_{j}(X,Y,v^{\prime})$ keeps track of the number of times the following event occurs: While answering the query $v^{\prime}$, the data structure probes a cell that was written during the interval $X$ but was not read during the interval $Y_{j}$. Recall the definition of the counter $C_{j}(X,Y)$ from Section 1.1, and note that $C_{j}(X,Y)=\mathbb{E}_{v}\left[C_{j}(X,Y,v)\right]$. Since we have fixed the input sequence in $Y_{j}$ and the input sequence preceding the interval $X$, the counters $C_{j}(X,Y)$ and $C_{j}(X,Y,v)$ are completely determined by the sequence of values of the updates in $X$. For simplicity, henceforth we omit $Y$ from these notations and instead write them as $C_{j}(X)$ and $C_{j}(X,v)$

Claim 19**.**

Let $\mathcal{E}$ denote the event where $|P(X)|\leq 16\cdot|X|\cdot\lg^{2}n$ and $C_{j}(X)<\frac{16}{100(c+1002)}\cdot n\cdot\frac{\lg n}{\lg\lg n}$. Then we have $\Pr[\mathcal{E}]\geq 1/4$.

Proof.

Let $\mathcal{E}_{1}$ denote the event that $|P(X)|>16\cdot|X|\cdot\lg^{2}n$. Markov’s inequality and Equation 4 imply that $\Pr[\mathcal{E}_{1}]\leq 1/16$. Let $\mathcal{E}_{2}$ denote the event that $C_{j}(X)\geq\frac{16}{100(c+1002)}\cdot n\cdot(\lg n/\lg\lg n)$. Markov’s inequality and Equation 5 imply that $\Pr[\mathcal{E}_{2}]\leq 1/16$. Since $\mathcal{E}^{c}=\mathcal{E}_{1}\cup\mathcal{E}_{2}$, applying a union bound we get: $\Pr[\mathcal{E}]\geq 1-\Pr[\mathcal{E}_{1}]-\Pr[\mathcal{E}_{2}]\geq 1-1/16-1/16\geq 1/4$. ∎

For the rest of this section, we fix any input sequence $X$ that might occur under the event $\mathcal{E}$, and then prove the existence of a set of cells $\mathcal{C}^{*}\subseteq P(X)$ of size $\Delta=|X|\cdot\lg|\mathbb{F}|/(1024w)$ such that $|\mathcal{M}(\mathcal{C}^{*})|\geq|\mathbb{F}|^{0.999\cdot nk}$. This, along with Claim 19, implies Lemma 17.

Claim 20**.**

Let $V(X)\subseteq\mathbb{F}^{n}$ be the set of vectors $v\in\mathbb{F}^{n}$ such that $C_{j}(X,v)<\frac{16}{100(c+1002)}\cdot n\cdot\frac{\lg n}{\lg\lg n}$. Then we have $|V(X)|\geq|\mathbb{F}^{n}|/4$.

Proof.

Recall that we have conditioned on the event $\mathcal{E}$. Hence, Claim 19 and Markov’s inequality imply that some constant (say $(1/4)^{th}$) fraction of the vectors $v\in\mathbb{F}^{n}$ must have $C_{j}(X,v)<\frac{16}{100(c+1002)}\cdot n\cdot\lg n/\lg\lg n$. ∎

Claim 21**.**

Consider any query vector $v\in V(X)$. Pick a subset of cells $\mathcal{C}\subseteq P(X)$ of size $|\mathcal{C}|=\Delta$ uniformly at random. The probability that $\mathcal{C}$ resolves the query $v$ is at least $|\mathbb{F}|^{-0.0001\cdot n}$.

Proof.

Let $P_{v}(X)\subseteq P(X)$ be the set of cells in $P(X)$ that the data structure needs to probe while answering the query $v$ in the $j^{th}$ position of the interval $Y$. Since $v\in V(X)$, we have $C_{j}(X,v)=\lambda$ (say) where $\lambda=\frac{16}{100(c+1002)}\cdot n\cdot\lg n/\lg\lg n$. This implies that $|P_{v}(X)|\leq C_{j}(X,v)\leq\lambda$.

The random subset of cells $\mathcal{C}\subseteq P(X)$ resolves the query vector $v$ iff $P_{v}(X)\subseteq\mathcal{C}$. Hence, we can reformulate the question as follows. We are given two sets of cells $P_{v}(X)$ and $P(X)$ with $P_{v}(X)\subseteq P(X)$, $|P_{v}(X)|\leq\lambda$ and $|P(X)|\leq|X|\cdot\lg^{2}n$. Now, if we pick a subset of cells $\mathcal{C}\subseteq P(X)$ of size $|\mathcal{C}|=\Delta$ uniformly at random from $P(X)$, then what is the probability that $P_{v}(X)\subseteq\mathcal{C}$? Let the desired probability be $p_{v}(X)$. A moment’s thought will reveal that:

[TABLE]

∎

Corollary 22**.**

There exists a subset of cells $\mathcal{C}^{*}\subseteq P(X)$ of size $|\mathcal{C}^{*}|=\Delta$ such that the number of queries in $V(X)$ resolved by $v$ satisfies the following guarantee: $|Q(\mathcal{C}^{*})|\geq|\mathbb{F}|^{0.999\cdot n}$.

Proof.

Pick a subset of cells $\mathcal{C}\subseteq P(X)$ of size $|\mathcal{C}|=\Delta$ uniformly at random from $P(X)$. From Claims 20, 21 and linearity of expectation, it follows that the expected number of queries in $V(X)$ that are resolved by the set $\mathcal{C}$ is at least $|V(X)|\cdot|\mathbb{F}|^{-o(n)}\geq\left(|\mathbb{F}|^{n}/4\right)\cdot|\mathbb{F}|^{-0.0001\cdot n}=|\mathbb{F}|^{0.9999\cdot n}/4\geq|\mathbb{F}|^{0.999\cdot n}$. Hence, there must exist some such set $\mathcal{C}^{*}\subseteq P(X)$ which resolves at least $|\mathbb{F}|^{0.999\cdot n}$ many queries in $V(X)$. It follows that we must have $|Q(\mathcal{C}^{*})|\geq|\mathbb{F}|^{0.999\cdot n}$ for some subset of cells $\mathcal{C}^{*}\subseteq P(X)$ of size $|\mathcal{C}^{*}|=\Delta$. ∎

Lemma 23**.**

There are at most $|\mathbb{F}|^{(27/32)nk}$ sets of vectors $\{v_{1},\ldots,v_{k}\}\subseteq\mathbb{F}^{n}$ s.t. $\mathcal{RS}(v_{1},\dots,v_{k})<nk/32$.

Proof.

(Sketch) Since the input sequence $\mathcal{O}$ is well-spread, $|X|\geq n^{4/3}$ and $k=(|X|-1)/n$, we can apply Lemma 5 from Clifford et al. [3]. ∎

Corollary 22 and Lemma 23 imply that nearly all subsets of $k$ vectors in $Q(\mathcal{C}^{*})$ have high rank sum, and, furthermore, we have $|Q(\mathcal{C}^{*})|\geq|\mathbb{F}|^{0.999\cdot n}$. Hence, we infer that $|\mathcal{M}(\mathcal{C}^{*})|\geq|\mathbb{F}|^{0.999\cdot nk}$. This concludes the proof of Lemma 17.

4 Proof of Theorem 6

In this section, we prove Theorem 6 and we will continue using the notations introduced in Section 1.1. Further, we set the values of the parameters $\alpha,\beta,\gamma$ and $\kappa$ as follows.

[TABLE]

4.1 Defining the random input sequence $\mathcal{O}$

The (random) input sequence $\mathcal{O}$ consisting of $n$ updates and $n$ queries is defined as follows. Initially, the polynomial is the zero polynomial, i.e., all roots are set to zero. For $i=0,\dots,n-1$, operation $2i+1$ is an update setting the $i^{th}$ root of the polynomial to an element from $\mathbb{F}$ that is picked uniformly at random, and the $2(i+1)^{st}$ operation is a query that is picked uniformly at random from $\mathbb{F}$.

4.2 Proving that $\mathcal{O}$ is well-behaved

We start by defining some notations. Let $u(X)$ and $q(X)$ respectively denote the number of updates and queries in an interval $X\subseteq\mathcal{O}$. For $1\leq j\leq q(X)$, let $X_{j}$ be the sequence of inputs in $X$ preceding the $j^{th}$ query in $X$. Now consider two consecutive intervals $X,Y\subseteq\mathcal{O}$. The counter $C_{j}(X,Y)$ denotes the number of times the follow event occurs: While answering the $j^{th}$ query in $Y$, the data structures probes a cell that was last written in $X$ but not yet accessed in $Y_{j}$. Recall the definition of the counter $C(X,Y)$ from Section 1.1, and note that $C(X,Y)=\sum_{j=1}^{q(Y)}C_{j}(X,Y)$.

Lemma 24**.**

Every data structure for the dynamic polynomial evaluation problem satisfies the following property while processing the random input sequence $\mathcal{O}$ described in Section 4.1. Fix any pair of consecutive intervals $X,Y\subseteq\mathcal{O}$, where $|X|\simeq\gamma\cdot|Y|$ and $|Y|\geq|\mathcal{O}|^{\kappa}$ such that $\mathbb{E}\left[|P(X)|\right]\leq|X|\lg^{2}n$, and $\mathbb{E}\left[|P(Y)|\right]\leq|Y|\lg^{2}n$. Then we must have:

[TABLE]

Corollary 25**.**

The input sequence $\mathcal{O}$ defined in Section 4.1 is well-behaved as per Definition 1.

Proof.

If either condition (1) or condition (2) as stated in Definition 1 gets violated, then we have nothing more to prove. Henceforth, we assume that both the conditions (1) and (2) hold. Applying Lemma 24, we get:

[TABLE]

Note that $|Y|\geq|\mathcal{O}|^{\kappa}=\Theta(n^{\alpha\kappa})=\Theta(\sqrt{n})$. The last inequality holds since $\alpha=1$ and $\kappa=1/2$ as per Equation 7. Recall that the input sequence $\mathcal{O}$ contains a query after each update. Thus, the size of the interval $Y\subseteq\mathcal{O}$ is large enough for us to infer that $q(Y)=|Y|/2$. Plugging this in Equation 8, we get:

[TABLE]

To summarize, the condition (3) as stated in Definition 1 gets violated whenever the conditions (1) and (2) hold. This implies that the input sequence $\mathcal{O}$ is well-behaved. ∎

4.3 Proof of Lemma 24

We prove Lemma 24 by contradiction. Towards this end, throughout Section 4.3, we fix:

A data structure for the dynamic polynomial evaluation problem. 2. 2.

Two consecutive intervals $X,Y\subseteq\mathcal{O}$ such that $|X|\simeq\gamma\cdot|Y|$ and $|Y|\geq|\mathcal{O}|^{\kappa}$. 3. 3.

An index $1\leq j\leq q(Y)$. 4. 4.

All the inputs in $\mathcal{O}$ that appear before the beginning of the interval $X$. 5. 5.

All the inputs in $\mathcal{O}$ that appear after the $j^{th}$ query in $Y$. 6. 6.

All the inputs in $Y_{j}$.

To summarize, only the inputs in $X$ and the $j^{th}$ query in $Y$ are allowed to vary. Everything else is fixed. Conditioned on these events, we next assume that:

[TABLE]

Finally, for the sake of contradiction, we assume that:

[TABLE]

Having made these assumptions, we now show how to encode the sequence of updates in $X$ using less than $u(X)\cdot\lg|\mathbb{F}|$ bits. This leads to a contradiction since the entropy of the sequence of updates in $X$ is exactly $u(X)\cdot\lg|\mathbb{F}|$ bits. This concludes the proof of Lemma 24.

Our proof is based on a cell-sampling argument as introduced by Larsen [7]. The following lemma identifies the set of cells we will use in our encoding. In the lemma we assume that $\mathbb{F}$ is partitioned into $\ell=|\mathbb{F}|^{1/4}$ consecutive subsets of $|\mathbb{F}|^{3/4}$ elements each. We denote these subsets by $\mathbb{F}_{1},\dots,\mathbb{F}_{\ell}$. We say that a set of cells $\mathcal{C}\subset P(X)$ resolves a query $x$, if the data structure does not need to probe any cell from $P(X)\setminus\mathcal{C}$ in order to answer query $x$.

Lemma 26**.**

Assume $\mathbb{E}\left[C_{j}(X,Y)\right]<\frac{1}{200(c+1002)}\cdot\lg n/\lg\lg n$. Then there is an index $k^{*}=k^{*}(X,Y)$ such that with probability $p$ at least $1/4$ over the randomness of the updates and queries in $X$ and $Y_{j}$, there exists a set of cells $\mathcal{C}$, such that

• •

$|\mathcal{C}|=\frac{|P(X)|}{24\lg^{2}n}$, and

• •

$\mathcal{C}$* resolves at least $n+1$ queries from the set $\mathbb{F}_{k^{*}}$.*

We defer the proof of Lemma 26 to Section 4.4. Note that in the lemma the choice of the index $k^{*}$ depends on the randomness of $X$ and $Y$. Hence, the encoder will need to encode it, but this requires only $\frac{3}{4}\lg n$ bits. We now show how we can use the cells $\mathcal{C}$ from the lemma to obtain an efficient encoding of the updates and queries in the interval.

Encoding the sequence of updates in $X$.

In the encoding we consider two cases distinguishing whether the claimed set of cells from Lemma 26 exists or not. The encoder can check if such a set of cells exists by enumerating all sets of cells of size $|P(X)|/(b\lg^{2}n)$ and then verifying if one of them resolves at least $n+1$ queries from $\mathbb{F}_{k^{*}}$.

Case 1: There is no set of cells $\mathcal{C}$ with the properties from Lemma 26. In this scenario, the first bit of the encoding is a [math]. After that the encoder writes down all updates in $X$ using the naive encoding. This takes $1+u(X)\cdot\lg|\mathbb{F}|$ bits.

Case 2: The encoder finds a set of cells $\mathcal{C}$ with the properties from Lemma 26. The encoder starts by writing a $1$ bit followed by the encoding of $k^{*}$. Then it encodes the addresses and contents of the cells from $\mathcal{C}$ using $2|P(X)|/(b\lg n)$ bits. To identify which queries from $\mathbb{F}_{k^{*}}$ can be resolved without probing any cells from $P(X)\setminus\mathcal{C}$, we encode $u(X)+1$ of the queries from $\mathbb{F}_{k^{*}}$ which do not coincide with any of the roots of the polynomial that were set outside of $X$ (this can be done since $\mathcal{C}$ resolves at least $n+1$ queries and there are $n-u(X)$ roots set outside of $X$). This requires $\lg\left(\binom{|\mathbb{F}|^{3/4}}{u(X)+1}\right)$ bits. We additionally encode the permutation to restore the order of the updates in $X$ using $\lg(u(X)!)$ bits. Finally, we encode the updates and queries in $Y_{j}$ and the set $P(Y_{j})$ using the naive encoding and spending $o(u(X))$ bits.

Decoding the sequence of updates in $X$.

The decoding procedure works as follows.

If the encoded message starts with a [math], then the decoder can trivially recover all updates from $X$ and stops the computation. 2. 2.

If the encoded message starts with a $1$, then the decoder first performs all updates and queries of $\mathcal{O}$ that occured before $X$ on the data structure. The decoder further recovers the addresses and the contents of the cells in $\mathcal{C}$ and then those in $P(Y_{j})$. 3. 3.

Next, the decoder evaluates the polynomial at the positions given by the $u(X)+1$ queries that are resolved by $\mathcal{C}$ and sent by the encoder. Denote this set of queries $Q$.

For $v\in Q$, the decoder proceeds as follows: The decoder runs the query procedure of the data structure for $v$. Whenever the data structure wants to probe the cell, it first checks if the cell is in $P(Y_{j})$. If this is the case, it uses the information from $P(Y_{j})$, otherwise, it checks if the cell is in $\mathcal{C}$. If this is the case, it uses the contents of the cell in $\mathcal{C}$. Otherwise, the decoder uses the cell from the its memory.

Note that by choice of $Q$ and $\mathcal{C}$, any cell that is read from the memory cannot have been changed during the updates and queries in $X$. 4. 4.

After all queries were evaluated, the decoder can restore the values of the roots that were set during the updates in $X$ by evaluating an equation system with $u(X)+1$ equations and $u(X)$ variables. 5. 5.

The decoder recovers the order of the updates by the permutation that was encoded.

Length of the encoding.

In case 1, the encoding has an expected length of $\ell_{1}=u(X)\cdot\lg|\mathbb{F}|+1$ bits. In case 2, first observe that $|X|\leq 3u(X)$ by definition of $\mathcal{O}$. Then the expected length of the encoding is given by

[TABLE]

Note that the encoding for case 2 takes fewer bits than given by the entropy of the updates in $X$. Thus, the expected size of the encoding takes $(1-p)\ell_{1}+p\ell_{2}$ bits. As $p\geq 1/4$, this is smaller than the entropy of the updates in $X$, which is given by $u(X)\lg|\mathbb{F}|$ — a contradiction.

4.4 Proof of Lemma 26

We first prove that an index $k^{*}$ with the desired properties exists. We show this by invoking the probabilistic method. Let $C_{j}(X,Y,x)$ be $C_{j}(X,Y)$ under the assumption that the $j^{th}$ query in $Y$ is for element $x\in\mathbb{F}$. Let $t_{j}^{k}=\sum_{x\in\mathbb{F}_{k}}\mathbb{E}\left[C_{j}(X,Y,x)\right]/|\mathbb{F}_{k}|$, i.e., $t_{j}^{k}$ denotes the average number of cells probed by queries from $\mathbb{F}_{k}$. Note that $\sum_{k=1}^{\ell}\mathbb{E}\left[t_{j}^{k}\right]/|\mathbb{F}^{1/4}|=\mathbb{E}\left[C_{j}(X,Y)\right]<\lg n/(K\lg\lg n)$ for $K=80000$. By Markov’s inequality with probability at most $1/2$ over the randomness of $X$ and $Y$, $\mathbb{E}\left[C_{j}(X,Y,x)\right]\geq 4\lg n/(K\lg\lg n)$. Hence, there must be an index $k$ such that $\mathbb{E}\left[t_{j}^{k}\right]\leq 4\lg n/(K\lg\lg n)$. Thus, by the probabilistic method an index $k^{*}$ with the desired propertes must exist.

It is left to show that for $k^{*}$ the set $\mathcal{C}$ exists with probability at least $1/2$ over the randomness of $X$. Using Markov’s inequality we get that with probability at least $1/2$, $t_{j}^{k^{*}}\leq 100\mathbb{E}\left[t_{j}^{k^{*}}\right]\leq 400\lg n/(K\lg\lg n)$ and $|P(X)|\leq\mathbb{E}\left[|P(X)|\right]\leq 100|X|\lg^{2}n/24$. We show that if this event occurs, then $\mathcal{C}$ exists. Let $G_{k^{*}}(X)$ denote the set of all queries from $\mathbb{F}_{k^{*}}$ which probe at most $400\lg n/(K\lg\lg n)$ cells from $P(X)$. Observe that $|G_{k^{*}}(X)|=\Omega(|\mathbb{F}|^{3/4})$.

Let $\Delta=|P(X)|/(24\lg^{2}n)=100|X|/24$ and consider all $\Delta$-subsets of cells from $P(X)$. Any query in $G_{k^{*}}(X)$ probes at most $\mu=400\lg n/(K\lg\lg n)$ cells from $P(X)$. Then there must exist a set $\mathcal{C}$ of $\Delta$ cells which resolves at least $|G_{k^{*}}(X)|\binom{|P(X)|-\mu}{\Delta-\mu}/\binom{|P(X)|}{\Delta}$ queries:

[TABLE]

where we used that for large enough $n$, we have that $\Delta-\mu\gg 0.5\Delta$.