Succinct Approximate Rank Queries

TL;DR

This paper introduces space-efficient data structures for approximate rank queries and sliding window sums, achieving optimal space bounds and constant query time, with applications to streaming data processing.

Contribution

It provides the first succinct data structures with optimal space and constant time for approximate rank and sliding window sum queries.

Findings

Achieves lower bound on space complexity for approximate rank queries.

Develops a succinct data structure using near-optimal bits.

Enables constant-time approximate sliding window sum queries.

Abstract

We consider the problem of summarizing a multi set of elements in $\{1, 2, \ldots , n\}$ under the constraint that no element appears more than $\ell$ times. The goal is then to answer \emph{rank} queries --- given $i\in\{1, 2, \ldots , n\}$, how many elements in the multi set are smaller than $i$? --- with an additive error of at most $\Delta$ and in constant time. For this problem, we prove a lower bound of $\mathcal B_{\ell,n,\Delta}\triangleq$ $\left\lfloor{\frac{n}{\left\lceil{\Delta / \ell}\right\rceil}}\right\rfloor $ $\log\big({\max\{\left\lfloor{\ell / \Delta}\right\rfloor,1\} + 1}\big)$ bits and provide a \emph{succinct} construction that uses $\mathcal B_{\ell,n,\Delta}(1+o(1))$ bits. Next, we generalize our data structure to support processing of a stream of integers in $\{0,1,\ldots,\ell\}$, where upon a query for some $i\le n$ we provide a $\Delta$-additive approximation for the sum of the \emph{last} $i$ elements. We show that this too can be done using $\mathcal B_{\ell,n,\Delta}(1+o(1))$ bits and in constant time. This yields the first sub linear space algorithm that computes approximate sliding window sums in $O(1)$ time, where the window size is given at the query time; additionally, it requires only $(1+o(1))$ more space than is needed for a fixed window size.

Figures

Equations

$$\frac{n}{{\log }^{2}n}\log \left(\ell \cdot n+1\right)\le \frac{n}{{\log }^{2}n}\log \left((\ell +1)\cdot n\right)=n\log \left(\ell +1\right)\cdot \left(\frac{1}{{\log }^{2}n}+\frac{1}{\log \ell \log n}\right)=o(\mathcal{B}),$$

$$\frac{n}{\sqrt{\log n}}\log \left(\ell \cdot \log \left({\log }^{2}n\right)+1\right)\le n\log \left(\ell +1\right)\cdot \left(\frac{1}{\sqrt{\log n}}+\frac{2\log \log n}{\log \ell \sqrt{\log n}}\right)=o(\mathcal{B}).$$

$$(\ell +1{)}^{\sqrt{\log n}}\sqrt{\log n}\log \left(\ell \sqrt{\log n}+1\right)\le 2^{{\log }^{5/6}n+\log \log n}\log \left((\ell +1)\sqrt{\log n}\right)=o(\mathcal{B}).$$

$$n\log \left(\ell \sqrt{\log n}+1\right)\le n\log \left(\ell +1\right)\cdot \left(1+\frac{\log \log n}{\log \left(\ell +1\right)}\right)\le n\log \left(\ell +1\right)\cdot \left(1+\frac{\log \log n}{\sqrt[3]{\log n}}\right)=\mathcal{B}+o(\mathcal{B}).$$

$$\mathcal{B}_{\ell,n,\Delta}\triangleq\left\lfloor{n/\left\lceil{\mu}\right\rceil}\right\rfloor\log\big{(}{\max\left\{\left\lfloor{\mu^{-1}}\right\rfloor,1\right\}+1}\big{)}=\left\lfloor{\frac{n}{\left\lceil{\Delta/\ell}\right\rceil}}\right\rfloor\log\big{(}{\max\left\{\left\lfloor{\ell/\Delta}\right\rfloor,1\right\}+1}\big{)}.$$

$$\forall k\in \left\{1,2,\dots ,s\right\}:{\rho }_k\triangleq \lfloor {\Delta }^{-1}\cdot \sum _{d=n-\nu \cdot k+1}^n{x}_d\rfloor -\sum _{ȷ=1}^{k-1}{\rho }_{ȷ}.$$

$$\mathfrak{r}\triangleq \sum _{d=1}^n{x}_d-\Delta \cdot \sum _{ȷ=1}^s{\rho }_{ȷ}.$$

$$\text{sc}Query(i)\triangleq \mathfrak{r}-\left(\Delta -1/2\right)+\Delta \cdot \left(\sum _{ȷ=\lfloor \frac{n-i}{\nu }\rfloor +1}^s{\rho }_{ȷ}\right)-\ell \cdot {\rho }_{\lceil \frac{n-i}{\nu }\rceil }\cdot (n-i)\mathrm{mod}\nu ,$$

$$\begin{gathered} \text{sc}Query(i)\triangleq \mathfrak{r}-\left(\Delta -1/2\right)+\Delta \cdot \left(\mathcal{R}.Query\left(s\right)-\mathcal{R}.Query\left(\lfloor \frac{n-i}{\nu }\rfloor \right)\right) \\ -\ell \cdot \left((n-i)\mathrm{mod}\nu \right)\cdot \left(\mathcal{R}.Query\left(\lceil \frac{n-i}{\nu }\rceil \right)-\mathcal{R}.Query\left(\lfloor \frac{n-i}{\nu }\rfloor \right)\right). \end{gathered}$$

$$\left(\sum _{d=1}^i{x}_d\right)-\Delta <\text{sc}Query(i)<\sum _{d=1}^i{x}_d.$$

$$\xi \triangleq \sum _{d=n-\nu \lfloor \frac{n-i}{\nu }\rfloor +1}^n{x}_d-\Delta \cdot \sum _{ȷ=1}^{\lfloor \frac{n-i}{\nu }\rfloor }{\rho }_{ȷ}=\sum _{d=n-\nu \lfloor \frac{n-i}{\nu }\rfloor +1}^n{x}_d-\Delta \lfloor {\Delta }^{-1}\cdot \sum _{d=n-\nu \lfloor \frac{n-i}{\nu }\rfloor +1}^n{x}_d\rfloor .$$

$$0\le \xi \le \Delta -1.$$

$$\sum _{d=1}^i{x}_d$$

$$=\mathfrak{r}+\Delta \cdot \left(\sum _{ȷ=1}^{\lfloor \frac{n-i}{\nu }\rfloor }{\rho }_{ȷ}+\sum _{ȷ=\lfloor \frac{n-i}{\nu }\rfloor +1}^s{\rho }_{ȷ}\right)-\sum _{d=i+1}^{n-\nu \lfloor \frac{n-i}{\nu }\rfloor }{x}_d-\sum _{d=n-\nu \lfloor \frac{n-i}{\nu }\rfloor +1}^n{x}_d$$

$$=\mathfrak{r}-\xi +\Delta \cdot \sum _{ȷ=\lfloor \frac{n-i}{\nu }\rfloor +1}^s{\rho }_{ȷ}-\sum _{d=i+1}^{n-\nu \lfloor \frac{n-i}{\nu }\rfloor }{x}_d$$

$$=\text{sc}Query(i)-\xi -\sum _{d=i+1}^{n-\nu \lfloor \frac{n-i}{\nu }\rfloor }{x}_d+\Delta -1/2+\ell \cdot {\rho }_{\lceil \frac{n-i}{\nu }\rceil }\cdot (n-i)\mathrm{mod}\nu .$$

$$\text{sc}Query(i)-\sum _{d=1}^i{x}_d=\xi -\Delta +1/2,$$

$${\rho }_{\lceil \frac{n-i}{\nu }\rceil }$$

$$=\lfloor {\Delta }^{-1}\cdot \sum _{d=n-\nu \cdot \lceil \frac{n-i}{\nu }\rceil +1}^n{x}_d+{\Delta }^{-1}\cdot \left(\xi -\sum _{d=n-\nu \lfloor \frac{n-i}{\nu }\rfloor +1}^n\right)x_d\rfloor =\lfloor {\Delta }^{-1}\cdot \left(\xi +\sum _{d=n-\nu \lfloor \frac{n-i}{\nu }\rfloor +1}^{n-\nu \cdot \lceil \frac{n-i}{\nu }\rceil }{x}_d\right)\rfloor .$$

$${\rho }_{\lceil \frac{n-i}{\nu }\rceil }=1⟺\xi +\sum _{d=n-\nu \lfloor \frac{n-i}{\nu }\rfloor +1}^{n-\nu \cdot \lceil \frac{n-i}{\nu }\rceil }{x}_d\ge \Delta ⟺\xi +\sum _{d=i+1}^{n-\nu \cdot \lceil \frac{n-i}{\nu }\rceil }{x}_d\ge \Delta -\sum _{d=n-\nu \lfloor \frac{n-i}{\nu }\rfloor +1}^i{x}_d.$$

$$\text{sc}Query(i)-\sum _{d=1}^i{x}_d$$

$$\ge \Delta -\sum _{d=n-\nu \lfloor \frac{n-i}{\nu }\rfloor +1}^i{x}_d-\left(\Delta -1/2+\ell \cdot (n-i)\mathrm{mod}\nu \right)$$

$$=-\sum _{d=n-\nu \lfloor \frac{n-i}{\nu }\rfloor +1}^i{x}_d+1/2-\ell \cdot (n-i)\mathrm{mod}\nu$$

$$\ge -\sum _{d=n-\nu \lfloor \frac{n-i}{\nu }\rfloor +1}^i\ell +1/2-\ell \cdot (n-i)\mathrm{mod}\nu$$

$$\ge -(\ell \nu -1)+1/2=-(\ell \lfloor \Delta /\ell \rfloor -1)+1/2\ge -\Delta +1/2.$$

$$\text{sc}Query(i)-\sum _{d=1}^i{x}_d$$

$$\le \Delta -1+\sum _{d=i+1}^{n-\nu \lfloor \frac{n-i}{\nu }\rfloor }\ell -\Delta -\ell \cdot (n-i)\mathrm{mod}\nu +1/2\le -1/2.$$

$$\text{sc}Query(i)-\sum _{d=1}^i{x}_d$$

$$=-\sum _{d=n-\nu \lfloor \frac{n-i}{\nu }\rfloor +1}^i{x}_d+1/2\le 1/2.$$

$$\text{sc}Query(i)-\sum _{d=1}^i{x}_d$$

$${\rho }_k$$

$$\le \lfloor {\Delta }^{-1}\cdot \sum _{d=\nu \cdot (k-1)+1}^{\nu \cdot k}{x}_d+\left(\lfloor {\Delta }^{-1}\cdot \sum _{d=1}^{\nu \cdot (k-1)}{x}_d\rfloor -\sum _{ȷ=1}^{k-2}{\rho }_{ȷ}\right)-{\rho }_{k-1}\rfloor$$

$$=\lfloor {\Delta }^{-1}\cdot \sum _{d=\nu \cdot (k-1)+1}^{\nu \cdot k}{x}_d\rfloor \le \lfloor {\Delta }^{-1}\cdot \nu \ell \rfloor =\lfloor {\mu }^{-1}\nu \rfloor .$$

$$\displaystyle T\bigg{[}\mathcal{W}\Big{[}ind-($$

$$\displaystyle+SC\bigg{[}\Big{\lfloor}ind$$

$$\displaystyle-C\bigg{[}$$

$$\displaystyle-T\bigg{[}\mathcal{W}\left[\big{\lfloor}{\left({(ind-i)\mod n}\right)/\sqrt{\log n}}\big{\rfloor}+1,\ldots,ind-i\right]\bigg{]}$$

$$\left(\mu =o\left(\frac{n}{\log n}\right)\right)\wedge \left[(\mu =o(1))\vee (\mu =\omega (1))\vee (\mu \in \mathbb{N})\vee ({\mu }^{-1}\in \mathbb{N})\right],$$

Full text

1 Introduction

1.1 Background

Static dictionaries are data structures that encode a set $S\subseteq\left\{1,2,\ldots,n\right\}$ and efficiently answer membership queries of the form “is $i\in S$?” (for some $i\in\left\{1,2,\ldots,n\right\}$). This problem was extensively studied and memory efficient data structures that allow $O(1)$ time queries for it were suggested for several different models [6, 12, 20].

An extension of the dictionary problem is the Rank query, which given an identifier $i\leq n$ returns the number of elements in $S$ that are smaller than or equal to $i$. For this problem as well, multiple papers proposed space efficient solutions with a constant query time [16, 21, 22]. The inverse problem, called Select query, asks for the ID of the $i^{th}$ smallest element in $S$ and was also shown to have space efficient data structures that support constant time queries [7, 21].

A seemingly different research area is the design of streaming algorithms. For many domains, such as networking, economics and databases, the ability to process large data streams is vital. As data varies over time, recent data is often considered more relevant; this motivated the study of sliding window algorithms, in which only the last $n$ elements are of interest. The sliding window model was studied for many problems such as summing [3, 10, 14]; counting the number of distinct elements [2, 13]; finding frequent elements [4, 15]; answering set membership queries [5, 17, 19]; and other problems [1, 9, 18, 23]. All these works share a common goal – they significantly reduce the memory consumption; in return, they settle for approximate, rather than exact, solutions. Given sufficient space, we can solve such problems exactly simply by adding the newly arriving item into our summary and deleting the element that has left the window. However, in many applications the window size is too large and the memory requirement becomes a major bottleneck. In this paper, we show how rank queries can be used for streaming.

Even if modern RAM memories seem to be enough for storing large element sequences, there are many advantages in minimizing the memory requirements. Routers, for example, often rely on the scarce SRAM which allows access at the speed in which they are required to route packets. If the measurement algorithms are not compact enough to fit into the small SRAM, they must access the slower DRAM that does not allow real time queries. This can be a significant limitation for applications that require timely insights about the traffic, such as load balancing or denial of service attack identification. Similarly, when implementing in software we can gain speed if we fit our algorithm into the CPU cache and reduce DRAM access. Smaller data structures might even fit in a single cache line and can be pinned there to maximize the measurement performance.

The works mentioned above significantly reduce the space requirements compared to storing the entire window in memory. However, these algorithms assume that the window size is known in advance and their data structures only allow queries about the predetermined window size to be answered efficiently. While we can maintain a different sketch for every window size that is of interest, this may be prohibitively expensive in terms of both memory and update time. Further, the goal of these algorithms is to enable memory feasible solutions to what would otherwise require storing the exact window in memory; thus, duplicating the data structures for multiple window sizes undermines the purpose for which they were created.

1.2 Our Contributions

Our first contribution is the extension of exact succinct rankers to multi sets in which every element can appear at most $\ell$ times. Previous works have considered multi sets under cardinality constraint for all elements combined. Here we address the natural case where every element may appear at most $\ell$ times, but no cardinality constraint (smaller than $n\cdot\ell$) is known for the multi set. Our approach requires $(1+o(1))n\log\left({\ell+1}\right)$ bits and allows $O(1)$ time rank queries.

Our next contribution are novel approximate set and multi set representations that allow computing rank queries with an additive error of $\Delta$, while using less space than required for storing the multi set itself. For this problem, we prove a \mathcal{B}_{\ell,n,\Delta}=\left\lfloor{\frac{n}{\left\lceil{\Delta/\ell}\right\rceil}}\right\rfloor\log\big{(}{\max\left\{\left\lfloor{\ell/\Delta}\right\rfloor,1\right\}+1}\big{)} bits lower bound and a propose a succinct data structure that uses $\mathcal{B}_{\ell,n,\Delta}(1+o(1))$ bits. To the best of our knowledge, this is the first algorithm that provides approximate rank queries in $O(1)$ time using less memory than the set / multi set encoding requires.

Next, we extend the notion of approximate rankers to streams and propose algorithms that process a stream of integers in $\left\{0,1,\ldots,\ell\right\}$ and answer sliding window sum queries in $O(1)$ time. Unlike previous works [2, 3, 10], we get the window size at query time. That is, our algorithm can compute the sum of any window size while previous works assume that the size is fixed. Interestingly, our construction is succinct even when compared with the lower bound derived in [3] for fixed size windows. Thus, with a $(1+o(1))$ space overhead we allow the algorithm to support all window sizes. This is a major improvement over the naive approach of maintaining a separate algorithm instance for every window size that is of interest, in both space and time complexity.

We note that our approach also allows approximating the sum of historical intervals that can be used for drill-down queries. For example, assume that we are monitoring a 100Gbps link on a backbone router such that at each second we get the utilized bandwidth (i.e., we can set $\ell=100\cdot 2^{30}$ bits). Now, assume that we identify a distributed denial of service attack and want to study the link utilization pattern before and during the attack. Our algorithm allows us to estimate the bandwidth between any time interval $t_{1}-t_{2}$ (for $t_{2}\leq t_{1}\leq n$) simply by subtracting the estimate for the sum of the last $t_{2}$ seconds from the estimate of the last $t_{1}$ seconds’ sum.

2 Related Work

2.1 Dictionaries

Consider a set $S\subseteq\left\{1,2,\ldots,n\right\}$. A dictionary is a data structure that supports membership queries of the form “Is $x$ in $S$?”. Several hashing-based works proposed methods for efficiently encoding $S$ while supporting constant time membership queries [6, 12, 20, 24]. Dictionaries were then naturally extended to the Indexable Dictionary problem that also supports the operations:

Rank$(i)$: given $i\in\left\{1,2,\ldots,n\right\}$, return $|\left\{y\in S:y\leq i\right\}|$. 2. 2.

Select$(i)$: given $i\in\left\{1,2,\ldots,|S|\right\}$, return the $i^{th}$ smallest element in $S$.

The problem of storing sets (and multisets, with the appropriate generalizations of the Rank and Select procedures) drew lots of attention from the research community [16, 21, 22]. Of special interest to us is the work of Jacobson [16] that allows constant time rank queries using $n+o(n)$ memory. Jacobson’s idea was to look at the characteristic vector of the set, i.e., a $\left\{0,1\right\}^{n}$ bits vector whose $i^{th}$ entry is set if $i\in S$. Thus, the Rank query reduces to counting the number of set bits that precede some index $i$ given at query time. To achieve this, Jacobson breaks the vector into $(\log n)^{2}$ sized chunks. At the end of each chuck, Jacobson keeps the number of set bits that precede it. Since there are $n/(\log n)^{2}$ such chucks, and each is encoded using $\log n$ bits, this requires $n/\log n=o(n)$ bits. Next, Jacobson focuses on each specific chunk and divides it into a sequence of $(1/2\cdot\log n)$-sized sub-chunks. At the end of each sub-chunk, Jacobson stores its number of preceding set bits within the current chunk using $O(\log\log n)$ bits. Once again, the number of sub-chunks is $n/(1/2\cdot\log n)$ so the total memory required is $O(n\frac{\log\log n}{\log n})=o(n)$ bits. Finally, Jacobson counts the number of set bits within each sub-chunk using a lookup table. In the table, the keys are all binary vectors of size at most $1/2\cdot\log n$ and the values are the number of set bits; thus, the table’s overall memory consumption is $O(\sqrt{n}\log n\log\log n)=o(n)$.

In this paper, we present a succinct structure for rank queries of multi sets in which each element appears at most $\ell$ times. This is different than the multi set representations of [20, 21] that considered cardinality constraint for the entire multi set, but without any further restriction on the number of appearances of a single item. We also provide an encoding that supports additive approximations of rank queries in less memory than required for encoding the multi set.

2.2 Algorithms that Sum over Sliding Windows

Approximating the sum of the last $n$ elements over an integer stream, known as Basic-Summing, was first introduced by Datar et al. [10]. They assumed that each element is in $\left\{0,1,\ldots,\ell\right\}$ and proposed a $(1+\epsilon)$ multiplicative approximation algorithm. Their data structure, named Exponential Histogram $(\mathit{EH})$, is based on keeping timestamps of element sequences called buckets such that the last $n$ elements fit into $O(\epsilon^{-1}\log\left({\ell\cdot n}\right))$ buckets. Each bucket requires $O(\log n)$ bits to store the timestamp in addition to $O(\log{\log\left({\ell\cdot n}\right)})$ bits to store the bucket size. Overall, the number of bits required by their algorithm is $O\left({\epsilon^{-1}\left({\log^{2}n+\log\ell\cdot\left({\log n+\log\log\ell}\right)}\right)}\right)$ and it operates in amortized time $O\left({\frac{\log\ell}{\log n}}\right)$ or $O(\log(\ell\cdot n))$ worst case. The EH approach was then extended in [1] for other statistics over sliding windows, such as median and variance. In [14], Gibbons and Tirthapura presented a $(1+\epsilon)$ multiplicative algorithm that operates in constant worst case time while using similar space for $\ell=n^{O(1)}$. In [3], we studied the potential memory savings one can get by replacing the $(1+\epsilon)$ multiplicative guarantee with a $\Delta$ additive approximation. We showed that $\Theta\left({\frac{\ell\cdot n}{\Delta}+\log n}\right)$ bits are required and sufficient.

In a sliding window, the last $n$ elements get similar weight while older items do not affect the sum. Cohen and Strauss [8] considered more general aging models where older data has lower weight, but the rate in which the weight decreases may be different than that of sliding windows.

Recently, we studied [2] the affect that allowing an error in the window size has on the required memory of approximate summing algorithms. Specifically, we showed that if upon a query the algorithm is required to return a tuple $\langle w,\widehat{S_{w}}\rangle$ such that $w\in\{n,n+1,\ldots,n(1+\tau)\}$ and $|\widehat{S_{w}}-S_{w}|<\Delta$ then $\Theta\left({\tau^{-1}\log\left({\frac{\tau\cdot\ell\cdot n}{\Delta}}\right)+\log n}\right)$ bits are needed.

All of the algorithms above assume that the window size is fixed. Here, we propose solutions that are succinct, even when compared to a lower bound derived here for static data, or to the bound for a fixed size window as in [3].

It is worth mentioning that these data structures do allow computing the sum of a window whose size is given at the query time. Alas, the query time will be slower as they do not keep aggregates that allow quick computation. Specifically, we can compute a $(1+\epsilon)$ multiplicative approximation using a slightly extended version of EH [11] in $O(\log\epsilon^{-1}+\log\log n)$ time by a binary search for the block with the right timestamp. We can also use the data structure of [3] for an additive approximation of $\Delta$ in $O\left({\min\left\{\frac{\ell\cdot n}{\Delta},n\right\}}\right)$ time, and utilize [2]’s structure for a $(\tau,\Delta)$-approximation in time $O(\tau^{-1})$. In this paper we offer solutions that operate in $O(1)$ time.

3 Preliminaries

We say that an algorithm is succinct if it uses $\mathcal{B}(1+o(1))$ bits, where $\mathcal{B}$ is the information-theoretic lower bound for the problem it solves. Throughout the paper, we assume the standard word RAM model with a word size of $\Theta\left({\log n+\log\ell}\right)$. For simplicity of presentation, we also assume that ${n/(\log n)^{2}}$ and $\sqrt{\log n}$ are integers.

Definition 3.1** (Approximation).**

Given a value $V$ and a constant $\epsilon>0$, we say that $\widehat{V}$ is an $\epsilon$-additive approximation of $V$ if $V-\epsilon<\widehat{V}\leq V$.111We use one-sided error, and strict inequality as this simplifies our computations.

Next, we define the notion of an $(\ell,n,\Delta)$-Ranker – a structure that can answer approximate rank queries in a memory efficient manner. Specifically, $(\ell,n,1)$-Ranker is a succinct encoding of a multi-set over $\left\{0,1,\ldots,n\right\},$ such that no element appears more than $\ell$ times, that supports $O(1)$ time rank queries.

Definition 3.2** (Static Ranker).**

An $(\ell,n,\Delta)$-Ranker, for some $\ell,n,\Delta\in\mathbb{N}^{+}$, is an algorithm that preprocesses a sequence in $\left\{0,1,\ldots,\ell\right\}^{n}$ and when queried with some $i\leq n$ returns a $\Delta$-additive approximation $\widehat{S_{i}}$ of the sum of the first $i$ elements, ${S_{i}}$, in $O(1)$ time.

We proceed with the definition of a Sliding Ranker, extending $(\ell,n,\Delta)$-Rankers to streams, while focusing on the last elements in the stream for supporting sliding window queries.

Definition 3.3** (Sliding Ranker).**

*An $(\ell,n,\Delta)$-Sliding Ranker, for some $\ell,n,\Delta\in\mathbb{N}^{+}$, is an algorithm that processes a stream of integers in $\left\{0,1,\ldots,\ell\right\}$ and when queried for some $i\leq n$ returns a $\Delta$-additive approximation $\widehat{S_{i}}$ of the last $i$ elements sum, ${S_{i}}$, in $O(1)$ time. *

4 $(\ell,n,\Delta)$-Rankers

In order to construct an $(\ell,n,\Delta)$-Ranker, we first discuss the special case of zero-error ($\Delta=1$).

4.1 An $(\ell,n,1)$-Ranker

Here, we provide a succinct construction of $(\ell,n,1)$-Ranker, for any $\ell,n$. Intuitively, this generalizes Jacobson’s ranker [16] that addresses binary sequences ($\ell=1$). As we show, his lookup table approach works for “small” values of $\ell$. In other cases, such as $\ell\geq n$, we can split the vector into smaller and smaller intervals (i.e., sub-sub-chunk, etc.), but if the number of levels is constant, storing a lookup table for the smallest level is infeasible in $o(\mathcal{B})$ space. Thus, we use a different trick for large $\ell$ values for computing within-sub-chunk sums in $O(1)$. We avoid keeping the and the characteristic vector; instead, we keep a $n$-sized array in which each entry contains the sum of the sub-chunk up to that point. For example, if the sub-chunk was $\langle 1,0,1\rangle$, we store $\langle 1,1,2\rangle$ regardless of vector entries outside this sub-chunk. Since $\ell$ is “large”, this takes $o(\mathcal{B})$ space.

We start by noting that since the number of sequences in $\left\{0,1,\ldots,\ell\right\}^{n}$ is $(\ell+1)^{n}$, any algorithm that computes such rank queries (exactly) requires $\mathcal{B}\triangleq{n\log(\ell+1)}$ bits. We also note that without a query time constraint this is achievable, as we can simply store the entire data and when queried sum the required interval in $O(n)$ time. Thus, if $n=O(1)$ (i.e., we have a small array of potentially large numbers), then the same idea works and we therefore require $\mathcal{B}$ bits; hence, we hereafter assume that $n=\omega(1)$. Next, we will prove the following:

Theorem 4.1**.**

For any $\ell,n\in\mathbb{N}^{+}$, there exists an $(\ell,n,1)$-Ranker that uses $\mathcal{B}(1+o(1))$ bits.

We start by breaking the sequence into chunks of size $\log^{2}n$, keeping the cumulative sums at the end of each chunk. The required number of bits for these sums is at most

[TABLE]

where the last equation follows from $n=\omega(1)$.

Next, we break the chunks into sub-chunks of size $\sqrt{\log n}$ and keep the cumulative sum from the beginning of the most recent chunk at the each sub-chunk’s end. The memory consumption of these sub-chunk aggregates is then no more than

[TABLE]

We are left with the task of efficiently computing the sub-chunk sums. Here, we split our construction depending on the relation between $\ell$ and $n$.

• •

$\ell+1\leq 2^{\sqrt[3]{\log n}}$.

In this case, we adopt Jacobson’s lookup table approach. Specifically, we create a lookup table $T:\left\{0,1,\ldots,\ell\right\}^{\sqrt{\log n}}\times\left\{0,1,\ldots,\sqrt{\log n}-1\right\}\to\left\{0,1,\ldots,\ell\cdot\sqrt{\log n}\right\}$; the key of each table entry is a $\sqrt{\log n}$-sized sequence of elements in $\left\{0,1,\ldots,\ell\right\}$ and an index $k\in\left\{0,1,\ldots,\sqrt{\log n}-1\right\}$. Its value is the sum of the first $k$ sequence entries. In order to use the table, we also store the characteristic vector itself using $n\log\left({\ell+1}\right)$ bits. The size of the table is then

[TABLE]

Thus our overall memory consumption is $n\log\left({\ell+1}\right)\cdot(1+o(1))$. Unfortunately, while we can consider smaller and smaller sequence aggregates, constructing such a lookup table will prevent the algorithm from being succinct when $\ell$ is large (e.g., for $\ell\geq n$).

• •

$\ell+1>2^{\sqrt[3]{\log n}}$.

In this case, we return to the cumulative approach. Instead of storing the characteristic vector (and without a lookup table) we store for each element the cumulative sum from the beginning of its sub-chunk. Since the sub-chunks are of size $\sqrt{\log n}$, the number of bits this takes is

[TABLE]

We conclude that in all cases our construction requires $\mathcal{B}(1+o(1))$ bits and is thus succinct.

4.2 An $(\ell,n,\Delta)$-Ranker for $\Delta>1$

We start by proving a lower bound on the memory required by any $(\ell,n,\Delta)$-Ranker. For convenience, we denote $\mu\triangleq\Delta/\ell$. We only consider $\Delta\in\left\{2,\ldots,\ell\cdot n\right\}$, as $\Delta=1$ means zero-error and $\Delta>n\cdot\ell$ allows the algorithm to always return [math], regardless of the input.

Theorem 4.2**.**

Let $\ell,n,\Delta\in\mathbb{N}^{+}$, then the number of bits required by any deterministic $(\ell,n,\Delta)$-Ranker is at least

[TABLE]

Proof 4.3**.**

We denote $I\triangleq\left\{\min\left\{\Delta\cdot k,\ell\right\}\mid k\in\left\{0,1,\ldots,\max\left\{\left\lfloor{\mu^{-1}}\right\rfloor,1\right\}\right\}\right\}\subseteq\left\{0,1,\ldots,\ell\right\}$ and $\bar{I}\triangleq\left\{\sigma^{\left\lceil{\mu}\right\rceil}\mid\sigma\in I\right\}$. Next, consider all inputs that contain a sequence of $\left\lfloor{n/\left\lceil{\mu}\right\rceil}\right\rfloor$ blocks padded by zeros, such that each block is a member of $\bar{I}$; that is, consider $\mathcal{I}\triangleq\bar{I}^{\left\lfloor{n/\left\lceil{\mu}\right\rceil}\right\rfloor}\cdot 0^{n\mod\left\lceil{\mu}\right\rceil}$. Notice that each literal is in the range $\left\{0,1,\ldots,\ell\right\}$ and that each input is of size $n$ as required. We show that every two inputs in $\mathcal{I}$ must lead to distinct configurations in the $(\ell,n,\Delta)$-Ranker, thereby implying a $\left\lceil{\log|\mathcal{I}|}\right\rceil$ bits lower bound as required. Let $x_{1}=x_{1,1}x_{1,2}\cdots x_{1,\left\lfloor{n/\left\lceil{\mu}\right\rceil}\right\rfloor}0^{n-(n\mod\left\lceil{\mu}\right\rceil)},\ x_{2}=x_{2,1}x_{2,2}\cdots x_{1,\left\lfloor{n/\left\lceil{\mu}\right\rceil}\right\rfloor}0^{n-(n\mod\left\lceil{\mu}\right\rceil)}$ be two distinct inputs in $\mathcal{I}$ such that $x_{\alpha,\beta}\in\bar{I}$ for any $\alpha\in\left\{1,2\right\},\beta\in\left\{1,\ldots,\left\lfloor{n/\left\lceil{\mu}\right\rceil}\right\rfloor\right\}$. Denote by $t\triangleq\min\left\{\gamma\in\left\{1,\ldots,\left\lfloor{n/\left\lceil{\mu}\right\rceil}\right\rfloor\right\}\mid x_{1,\gamma}\neq x_{2,\gamma}\right\}$ the first block’s index in which $x_{1}$ differs from $x_{2}$. Now consider a query for $i\triangleq\left\lceil{\mu}\right\rceil\cdot t$. If $\mu\leq 1$, then $\left\lfloor{n/\left\lceil{\mu}\right\rceil}\right\rfloor=n$ and (due to the definition of $I$) $|x_{1,t}-x_{2,t}|\geq\Delta$, which implies an error of at least $\Delta$ for at least one of the inputs. On the other hand, $\mu>1$ means that $I=\left\{0,\ell\right\}$ and thus either $x_{1,t}=0^{\left\lceil{\mu}\right\rceil},x_{2,t}=\ell^{\left\lceil{\mu}\right\rceil}$ or $x_{1,t}=\ell^{\left\lceil{\mu}\right\rceil},x_{2,t}=0^{\left\lceil{\mu}\right\rceil}$. In either case, the difference in sums is at least ${\left\lceil{\mu}\right\rceil}\cdot\ell\geq\Delta$. We established that if two inputs in $\mathcal{I}$ lead to the same configuration, the error for one of them would be at least $\Delta$ while we assumed it is strictly lower.

We now present a succinct construction of an $(\ell,n,\Delta)$-Ranker. Denote $\nu\triangleq\max\left\{\left\lfloor{\mu}\right\rfloor,1\right\},s\triangleq\left\lfloor{n/\nu}\right\rfloor$ and $z\triangleq\left\lfloor{\mu^{-1}\nu}\right\rfloor$. For creating an $(\ell,n,\Delta)$-Ranker, we first show how to “compress” the input into a smaller problem that we solve exactly. Intuitively, we create a new $s$-long input $\bar{{\rho}}$, such that each of its elements is bounded by $z$, and then employ a $(z,s,1)$-Ranker, $\mathcal{R}$. Alas, if $\mu=\omega(1)$, this is not enough to allow succinct encoding; for this, we also compute the fraction of the input’s sum that is not accounted for in $\bar{{\rho}}$ and use it for answering queries. Given an input $\bar{x}\in\left\{0,1,\ldots,\ell\right\}^{n}$, we create $\bar{{\rho}}$ iteratively as follows222If $(n\mod\nu)\neq 0$, we implicitly define ${\rho}_{\left\lceil{\frac{n}{\nu}}\right\rceil}\triangleq 0$ and $\mathcal{R}.Query\left({\left\lceil{\frac{n}{\nu}}\right\rceil}\right)\triangleq\mathcal{R}.Query\left({\left\lfloor{\frac{n}{\nu}}\right\rfloor}\right).$ :

[TABLE]

Then, we compute the remainder:

[TABLE]

After computing $\bar{{\rho}}\in\left\{0,1,\ldots,z\right\}^{s}$, we feed it into a $(z,s,1)$-Ranker denoted $\mathcal{R}$. Given a query for some $i\leq n$, we returnfootnote 2

[TABLE]

which we can compute in $O(1)$ as follows: 333We note that if our ranker $\mathcal{R}$ was originally constructed to compute the sum of the last $i$ elements rather than the first, only two queries were needed.

[TABLE]

Lemma 4.4**.**

[TABLE]

Proof 4.5**.**

We denote the error in the representation of the last $\nu\left\lfloor{\frac{n-i}{\nu}}\right\rfloor$ items by

[TABLE]

Observe that $\xi=\left({\sum_{d=n-\nu\left\lfloor{\frac{n-i}{\nu}}\right\rfloor+1}^{n}x_{d}\mod\Delta}\right)$ and hence

[TABLE]

Next, we use (1) to obtain

[TABLE]

We now perform a case analysis, based on the value of $\mu$ and start with the simpler case where $\mu<2$. In this case, we have $\nu=1$ and thus we can rearrange (4) as:

[TABLE]

and using (3) we immediately get $\left({\sum_{d=1}^{i}x_{d}}\right)-\Delta<{\sc Query}(i)<\sum_{d=1}^{i}x_{d}$.

Next, we focus on the case of $\mu\geq 2$. Thus, we hereafter have $\nu=\left\lfloor{\mu}\right\rfloor$ and $\forall\jmath\in\left\{1,2,\ldots,s\right\}:\bar{{\rho}}_{\jmath}\in\left\{0,1\right\}$. We now consider if and when both ${\rho}_{\left\lceil{\frac{n-i}{\nu}}\right\rceil}=1$ and $(n-i)\mod\nu\neq 0$ (which implies $\left\lceil{\frac{n-i}{\nu}}\right\rceil=\left\lfloor{\frac{n-i}{\nu}}\right\rfloor+1$); observe that

[TABLE]

Thus, if $(n-i)\mod\nu\neq 0$, then

[TABLE]

Next, we split to cases based on the value of ${\rho}_{\left\lceil{\frac{n-i}{\nu}}\right\rceil}$:

• •

${\rho}_{\left\lceil{\frac{n-i}{\nu}}\right\rceil}=1$. In this case, according to (4) and (5) we have:

[TABLE]

On the other hand, we bound the error from above as follows:

[TABLE]

• •

${\rho}_{\left\lceil{\frac{n-i}{\nu}}\right\rceil}=0$. Similarly to before, using (4) and (5) we get:

[TABLE]

Now, we use the fact that both ${\sc Query}(i)$ and $\sum_{d=1}^{i}x_{d}$ are integers to deduce that ${\sc Query}(i)-\sum_{d=1}^{i}x_{d}<1/2\implies{\sc Query}(i)-\sum_{d=1}^{i}x_{d}\leq 0$. Finally, we bound the error from above:

[TABLE]

We conclude that in all cases we have $\left({\sum_{d=1}^{i}x_{d}}\right)-\Delta<{\sc Query}(i)<\sum_{d=1}^{i}x_{d}$.

Next, we show that the value of each entry in $\bar{{\rho}}$ is smaller than $z$, as stated.

Lemma 4.6**.**

For any $k\in\left\{1,2,\ldots,s\right\}$, ${\rho}_{k}\leq\left\lfloor{\mu^{-1}\nu}\right\rfloor$.

Proof 4.7**.**

Notice that ${\rho}_{1}=\left\lfloor{\Delta^{-1}\cdot{\sum_{d=1}^{\nu}x_{d}}}\right\rfloor\leq\left\lfloor{\Delta^{-1}\cdot\nu\ell}\right\rfloor=\left\lfloor{\mu^{-1}\nu}\right\rfloor$. For other $k$ values, we have

[TABLE]

We now bound $\mathfrak{r}$ for analyzing the space of our construction; the proof appears in Appendix A.

Lemma 4.8**.**

For any input $x\in\left\{0,1,\ldots,\ell\right\}^{n}$, the remainder in (1) satisfies $\mathfrak{r}<2\Delta$.

Follows is an analysis of our ranker.

Lemma 4.9**.**

Let $\ell,n,\Delta\in\mathbb{N}^{+}$ and $\mu\triangleq\Delta/\ell$. The number of bits required by our ranker is (1+o(1))\cdot\left\lfloor{n/\max\left\{\left\lfloor{\mu}\right\rfloor,1\right\}}\right\rfloor\cdot\log\big{(}{\left\lceil{\mu^{-1}}\right\rceil+1}\big{)}.

Proof 4.10**.**

Our construction has two components: the exact ranker $\mathcal{R}$ and the remainder $\mathfrak{r}$. As $\mathcal{R}$ is a $(z,s,1)$-Ranker, where $s\triangleq\left\lfloor{n/\nu}\right\rfloor$ and $z\triangleq\left\lfloor{\mu^{-1}\nu}\right\rfloor$, it requires $(1+o(1))\cdot{s\log\left({z+1}\right)}$ bits according to Theorem 4.1. Recalling that $\nu=\max\left\{\left\lfloor{\mu}\right\rfloor,1\right\}$ gives us the desired $\mathcal{B}_{\ell,n,\Delta}(1+o(1))$ bound. Finally, Lemma 4.8 tells us that $\mathfrak{r}<2\Delta$ and can therefore be represented using $O(\log\Delta)=o(\mathcal{B}_{\ell,n,\Delta})$ bits.

Theorem 4.11**.**

Let $\ell,n,\Delta\in\mathbb{N}^{+}$ such that $(\mu=o(1))\vee(\mu=\omega(1))\vee(\mu\in\mathbb{N})\vee(\mu^{-1}\in\mathbb{N})$, the construction above is an $(\ell,n,\Delta)$-Ranker that uses $\mathcal{B}_{\ell,n,\Delta}(1+o(1))$ bits.444In other cases, our construction uses at most $B(2+o(1))$ bits but might not be succinct.

Proof 4.12**.**

Recall that \mathcal{B}_{\ell,n,\Delta}=\left\lfloor{n/\left\lceil{\mu}\right\rceil}\right\rfloor\log\big{(}{\max\left\{\left\lfloor{\mu^{-1}}\right\rfloor,1\right\}+1}\big{)} while our algorithm uses (1+o(1))\cdot\left\lfloor{n/\max\left\{\left\lfloor{\mu}\right\rfloor,1\right\}}\right\rfloor\cdot\log\big{(}{\left\lceil{\mu^{-1}}\right\rceil+1}\big{)} bits. If $\mu=o(1)$, we have \mathcal{B}_{\ell,n,\Delta}=n\log\big{(}{\left\lfloor{\mu^{-1}}\right\rfloor+1}\big{)}=(1-o(1))n\log\mu^{-1} when our structure takes (1+o(1))\cdot n\cdot\log\big{(}{\left\lceil{\mu^{-1}}\right\rceil+1}\big{)}=(1+o(1))n\log\mu^{-1} bits. Similarly, if $\mu=\omega(1)$ then $\mathcal{B}_{\ell,n,\Delta}=\left\lfloor{n/\left\lceil{\mu}\right\rceil}\right\rfloor=(1-o(1))\cdot\left({n/\mu}\right)$ while we require $(1+o(1))\cdot\left\lfloor{n/\left\lfloor{\mu}\right\rfloor}\right\rfloor=(1+o(1))\cdot\left({n/\mu}\right)$. The case for $(\mu=\Theta(1))\wedge((\mu\in\mathbb{N})\vee(\mu^{-1}\in\mathbb{N}))$ follows from similar arguments.

5 $(\ell,n,\Delta)$-Sliding Rankers

As in the case of static data rankers, we first consider the exact case where $\Delta=1$.

5.1 An $(\ell,n,1)$-Sliding Ranker

In this section, we provide a construction for an $(\ell,n,1)$-Sliding Ranker that requires $\mathcal{B}(1+o(1))$ bits, where $\mathcal{B}\triangleq n\log\left({\ell+1}\right)$ is the information-theoretic lower bound even without considering sliding windows. Intuitively, we adapt our $(\ell,n,1)$-Ranker construction to the sliding window setting by incrementally building the chunks and sub-chunks. We start by breaking the stream into $n$-sized frames. As in the original construction, we split the frames into $(\log n)^{2}$ sized chunks, where each chunk is further divided into $\sqrt{\log n}$-sized sub-chunks. In the case where $\ell+1\leq 2^{\sqrt[3]{\log n}}$, we keep a $O(2^{\log^{5/6}n+\log\log n}\log\left({\ell\sqrt{\log n}}\right))$ sized lookup table that maps each sequence in $\left\{0,1,\ldots,\ell\right\}^{\leq\sqrt{\log n}}$ to its sum. If $\ell+1>2^{\sqrt[3]{\log n}}$, we simply track the sums within a sub-chunk by keeping the cumulative sum for each item. We keep the chunk aggregates in a ${n/(\log n)^{2}}$-sized circular buffer, and the sub-chunk aggregates in a similar structure of size ${n/\sqrt{\log n}}$. Finally, we “reset” the frame accumulator every $n$ elements, so that each chunk’s aggregate is always smaller than $n\cdot\ell$. Since each of the chunk aggregates requires $O(\log(\ell n))$ bits and each of the sub-chunk aggregates takes $O(\log(\ell\log n))$ bits, our overall space consumption is as required. Our $(\ell,n,1)$-Sliding Ranker construction is illustrated in Figure 1, while the query procedure is exemplified in Figure 2. In Appendix D we provide an algorithm for the $\ell+1>2^{\sqrt[3]{\log n}}$ case; here, we hereafter assume that $\ell+1\leq 2^{\sqrt[3]{\log n}}$.

Our algorithm uses the following variables:

• •

$C$ - a cyclic buffer of ${n/(\log n)^{2}}$ integers, each allocated with $\left\lceil{\log(\ell n+1)}\right\rceil$ bits.

• •

$SC$ - a cyclic buffer of $n/\sqrt{\log n}$ integers, each allocated with $\left\lceil{\log(\ell\log^{2}n+1)}\right\rceil$ bits.

• •

$\mathit{total}$ - the sum of elements inside the current frame.

• •

$ind$ - the index of the most recent item, modulo $n$.

• •

$T$ - a lookup table mapping sequences of length $\leq\sqrt{\log n}$ to their sums.

• •

$\mathcal{W}$ - the last $n$ elements window.

We give a pseudo code of our $(\ell,n,1)$-Sliding Ranker in Algorithm 1.

We now formulate the properties of the algorithm; the theorem’s proof is deferred to Appendix B due to lack of space.

Theorem 5.1**.**

Algorithm 1 is an $(\ell,n,1)$-Sliding Ranker that uses $\mathcal{B}(1+o(1))$ memory bits.

5.2 An $(\ell,n,\Delta)$-Sliding Ranker for $\Delta>1$

Similarly to the way we used $(\ell,n,1)$-Rankers to construct $(\ell,n,\Delta)$-Rankers for any $\Delta\in\left\{2,\ldots\ell\cdot n\right\}$, we now use the exact $(\ell,n,1)$-Sliding Ranker for constructing an $(\ell,n,\Delta)$-Sliding Ranker.

Intuitively, we split the stream into blocks of size $\nu$ and construct the remainder $\mathfrak{r}$ gradually; whenever a block ends, we compute a new ${\rho}_{k}$ value and feed it into an exact $(z,s,1)-\emph{Sliding Ranker}$ we use as a black box. When queried, we employ our exact ranker and remainder to estimate the relevant sum, similarly to our $(\ell,n,\Delta)$-Ranker queries from Section 4.2. However, if we simply sum the elements using $\mathfrak{r}$, it will require $\Omega(\log{\ell})$ bits; this will not allow us to remain succinct if $\mu=\Omega(1)$ as the lower bound for this case is $\mathcal{B}_{\ell,n,\Delta}=O(n)$ and is independent of $\ell$ (given that $\mu=\Delta/\ell$ is fixed). To solve this, we follow [3]’s approach and round every arriving element, representing it using $\mathfrak{b}\triangleq\left\lceil{\log\left({n/\mu}\right)+\log\log n}\right\rceil$ bits. That is, if $x\in\left\{0,1,\ldots,\ell\right\}$ arrived, we consider $Round_{\mathfrak{b}}(x)\triangleq 2^{-\mathfrak{b}}\ell\cdot\left\lfloor{\frac{x2^{\mathfrak{b}}}{\ell}}\right\rfloor$ instead. To compensate for the rounding error, we will need blocks of size smaller than that we used in our $(\ell,n,\Delta)$-Ranker construction; specifically, we set $\nu\triangleq\max\left\{\left\lfloor{\mu\cdot\left({1-1/\log n}\right)}\right\rfloor,1\right\}$. Additionally, when $\mu<1$ the block size has to remain $1$, so we have to compensate for the rounding error by other means; this is achieved by reducing the “sensitivity” to $\widetilde{\Delta}\triangleq\left\lfloor{\Delta\cdot\left({1-1/\log n}\right)}\right\rfloor$.555If $\widetilde{\Delta}=1$, then we simply apply the exact algorithm from the previous subsection. The parameters for the exact ranker are then $s\triangleq\left\lfloor{n/\nu}\right\rfloor$ and $z\triangleq\left\lfloor{\mu^{-1}\nu}\right\rfloor$. Our algorithm uses the following variables:

• •

$\mathfrak{R}$ - a $(z,s,1)-\emph{Sliding Ranker}$, as described in Section 5.1.

• •

$\mathfrak{r}$ - tracks the sum of elements that is not yet recorded in $\mathfrak{R}$.

• •

$o$ - the offset within the block.

A pseudo code of our method appears in Algorithm 2.

Next follows a memory analysis of the algorithm with a proof given in Appendix C.

Lemma 5.2**.**

Algorithm 2 requires (1+o(1))\cdot\left\lfloor{n/\max\left\{\left\lfloor{\mu}\right\rfloor,1\right\}}\right\rfloor\cdot\log\big{(}{\left\lceil{\mu^{-1}}\right\rceil+1}\big{)}+O\left({\log n}\right) bits.

This allows us to conclude, similarly to Theorem 4.11, that our algorithm is succinct if the error satisfies $\Delta=o\left({\frac{\ell\cdot n}{\log n}}\right)$. We also note that a $\left\lfloor{\log n}\right\rfloor$ lower bound was shown in [3] even when only fixed sized windows (where $i\equiv n$) are considered. Thus, our algorithm always requires at most $O(\mathcal{B}_{\ell,n,\Delta})$, even if the allowed error is $\Omega\left({\frac{\ell\cdot n}{\log n}}\right)$.

Corollary 5.3**.**

Let $\ell,n,\Delta\in\mathbb{N}^{+}$ such that $\mu\triangleq\Delta/\ell$ satisfies

[TABLE]

then Algorithm 2 is succinct. For other parameters, it uses $O(\mathcal{B}_{\ell,n,\Delta})$ space.

The following theorem, whose proof is deferred to Appendix E due to lack of space, shows the correctness of the algorithm.

Theorem 5.4**.**

Algorithm 2 is an $(\ell,n,\Delta)$-Sliding Ranker.

6 Discussion

In this paper, we studied the properties of data structures that support approximate rank queries for multi sets in which each element in $\left\{1,2,\ldots,n\right\}$ appears at most $\ell$ times. We showed a lower bound for the problem and succinct constructions that require $(1+o(1))$ times as much memory. We then extended our approach and provided algorithms that process data streams and handle sliding window sum queries. Unlike previous work, we do not assume that the window size is fixed but rather get it at the query time. Interestingly, we show that this is doable in constant time and an additional $(1+o(1))$ space factor.

In the future, we would like to study structures that allow approximate select queries in $O(1)$ time. This will allow efficient approximate-percentile computation for multi sets. We note that this is already achievable with our data structure in $O(\log n)$ time using a binary search over the rank queries. We also plan to explore the possibility of creating approximate rankers with a multiplicative error rather than additive. Finally, we wish to extend our approach to problems other than summing; e.g., computing heavy hitters for a sliding window whose size is given at the query time.

Appendix A Proof of Lemma 4.8

Proof A.1**.**

[TABLE]

If $\mu\leq 1$, then $\nu=1$ and thus $\mathfrak{r}\leq\Delta-1$. Otherwise, we have $\mathfrak{r}\leq\Delta-1+(\mu-1)\ell\leq 2\Delta-\ell-1$.

Appendix B Proof of Theorem 5.1

We start with analyzing the memory requirements of our algorithm.

Lemma B.1**.**

Algorithm 1 uses $\mathcal{B}(1+o(1))$ memory bits.

Proof B.2**.**

We have $n/(\log n)^{2}$ chunks, each represented using $O(\log(\ell n))$ bits. Similarly, each of the $n/\sqrt{\log n}$ sub-chunk aggregates requires $O(\log\left({\ell\log n}\right))$ bits as its value is bounded by $\log\left({\ell\log^{2}n}\right)$. Our window, $\mathcal{W}$ uses $n\log\left({\ell+1}\right)$ bits, while the $\mathit{total}$ and $ind$ variables require $O(\log n)$ bits. Thus, the overall space consumption is $\mathcal{B}(1+o(1))$.

We are now ready to prove the theorem.

Proof B.3**.**

Denote the stream by $x_{1},x_{2},\ldots,x_{k\cdot n+m}$, such that the most recent element’s index is $k\cdot n+m$, where $m\in[n-1]$ is the offset within the current frame and $k$ frames were completed so far. We assume that $k\geq 1$. The case for $k=0$ follows from similar arguments. We start with a few straight forward observations. Notice that $C[0]$ always contains the sum of the last frame that was completed; that is, $C[0]=\sum_{d=(k-1)n+1}^{k\cdot n}x_{d}$. Next, for any positive $j\in\left[n/(\log n)^{2}-1\right]$, we have that $C[j]$ contains the sum of the last $j$-indexed chunk that was completed, i.e.,

[TABLE]

Similarly, we have that $\forall\jmath\in[2n/\log n]$:

[TABLE]

Given a query for $i\leq n$, the goal of an $(\ell,n,1)$-Sliding Ranker is to return the quantity $S\triangleq\sum_{d=k\cdot n+m-i+1}^{k\cdot n+m}x_{d}$. First, we express the sum of elements from the beginning of the previous frame, $S_{P}$, as:

[TABLE]

Next, since $ind=(k\cdot n+m\mod n)=m$, we have that

$C[0]=\sum_{d=(k-1)n+1}^{k\cdot n+m}x_{d}$. 2. 2.

$C\left[\left\lfloor{ind/(\log n)^{2}}\right\rfloor\right]=\sum_{d=kn+1}^{\left\lfloor{ind/(\log n)^{2}}\right\rfloor}x_{d}$. 3. 3.

$SC\left[\left\lfloor{ind/\sqrt{\log n}}\right\rfloor\right]=\sum_{d=\left\lfloor{ind/(\log n)^{2}}\right\rfloor+1}^{\left\lfloor{(k\cdot n+m)/\sqrt{\log n}}\right\rfloor}x_{d}$. 4. 4.

$T\left[x_{\left\lfloor{ind/\sqrt{\log n}}\right\rfloor+1},\ldots,x_{k\cdot n+m}\right]=\sum_{d=\left\lfloor{(k\cdot n+m)/\sqrt{\log n}}\right\rfloor+1}^{k\cdot n+m}x_{d}$.

Notice that if $i\geq m$, these are the first four summands of Line 18; if $i<m$, then we do not add $C[0]$ to the sum. In both cases, we are left with the need to subtract the sum of elements, starting from the beginning of the relevant frame, that are not a part of the last $i$ items. Similarly to the above, we have that the sum from the beginning of the previous frame to the $i+1$ newest item is: $\sum_{d=(k-1)n+1}^{k\cdot n+m-i}x_{d}$. If the last $i$ items are all contained in the current frame (i.e., $i<m$), then we have:

[TABLE]

In this case, we get:

$C[0]=\sum_{d=(k-1)n+1}^{kn}x_{d}$. 2. 2.

$C\left[\left\lfloor{(ind-i)/(\log n)^{2}}\right\rfloor\right]=\sum_{d=kn+1}^{\left\lfloor{k\cdot n+m/(\log n)^{2}}\right\rfloor}x_{d}$. 3. 3.

$SC\left[\left\lfloor{(ind-i)/\sqrt{\log n}}\right\rfloor\right]=\sum_{d=\left\lfloor{(k\cdot n+m-i)/(\log n)^{2}}\right\rfloor+1}^{\left\lfloor{(k\cdot n+m-i)/\sqrt{\log n}}\right\rfloor}x_{d}$. 4. 4.

$T[x_{\left\lfloor{(ind-i)/\sqrt{\log n}}\right\rfloor+1},\ldots,x_{ind-i}]=\sum_{d=\left\lfloor{(k\cdot n+m-i)/\sqrt{\log n}}\right\rfloor+1}^{k\cdot n+m-i}x_{d}$.

Here, we cancel the effect of $C[0]$ simply by not adding it as one of the summands (the If condition of Line 16). Quantities  2,3 and 4 are the three subtrahends of our query procedure. Finally, if $i\geq m$ we do add the value of $C[0]$, and thus in all cases we successfully compute the sum of the last $i$ elements.

Appendix C Proof of Lemma 5.2

Proof C.1**.**

The algorithm utilizes three variables: $\mathfrak{R}$ that requires $(1+o(1))\cdot s\log\left({z+1}\right)$, $\mathfrak{r}$ that uses $O(\mathfrak{b}\log\nu)$ bits, and $o$ is allocated with $\left\lceil{\log n}\right\rceil$ bits. Overall, the number of bits used by our construction is

[TABLE]

*Since $\nu=\max\left\{\left\lfloor{\mu\cdot(1-o(1))}\right\rfloor,1\right\}$, we get the desired bound. *

Appendix D An $(\ell,n,1)$-Sliding Ranker for $\ell+1>2^{\sqrt[3]{\log n}}$

Here, we detail the construction for the case of large $\ell$ value. We do the same splitting into frames, chunks, and sub-chunks as before. However, the large value of $\ell$ does not allow us to succinctly store the lookup table as before. Instead, we keep for each element the sum from the beginning of its sub-chunk, similarly to our solution in Theorem 4.1. Our algorithm uses the following variables:

• •

$C$ - a cyclic buffer of ${n/(\log n)^{2}}$ integers, each allocated with $\left\lceil{\log(\ell n+1)}\right\rceil$ bits.

• •

$SC$ - a cyclic buffer of $n/\sqrt{\log n}$ integers, each allocated with $\left\lceil{\log(\ell\log^{2}n+1)}\right\rceil$ bits.

• •

$\mathit{total}$ - the sum of elements in the current frame.

• •

$\mathit{subTotal}$ - the sum of elements in the current sub-chunk.

• •

$ind$ - the most recent element’s index, modulo $n$.

• •

$\mathcal{W}$ - a cyclic array that contains for each item the sum from the beginning of its sub-chunk.

We give a pseudo code of our $(\ell,n,1)$-Sliding Ranker in Algorithm 3. Next, we analyze the properties of the algorithm.

Theorem D.1**.**

Algorithm 3 uses $\mathcal{B}_{\ell,n,\Delta}(1+o(1))$ memory bits for $\ell+1>2^{\sqrt[3]{\log n}}$.

Proof D.2**.**

Similarly to the analysis in Lemma B.1, the algorithm uses $o(\mathcal{B}_{\ell,n,\Delta})$ bits for keeping the chunk and sub-chunk aggregates. Here, we replaced the lookup table and the array of window elements by an array that stores the within-sub-chunk cumulative sum for each element. That is, each entry in the $n$-sized array stores a number in $\left\{0,1,\ldots,\ell\cdot\sqrt{\log n}\right\}$ and thus the array requires $n\cdot\log\left({\ell\cdot\sqrt{\log n}+1}\right)\leq n\log(\ell+1)\left({1+\frac{\log{\log n}}{\log\left({\ell+1}\right)}}\right)=(1+o(1))\mathcal{B}_{\ell,n,\Delta}$ bits overall.

Theorem D.3**.**

Algorithm 3 is an $(\ell,n,1)$-Sliding Ranker.

Proof D.4**.**

*Observe that the query procedure of our algorithm is equivalent to that of Algorithm 1, except for the part where it uses the lookup table. We now use the $\mathit{subTotal}$ variable to compute the sum of the current sub-chunk instead of looking it up in the table. The sum of elements that preceded the last $i$ items in $(ind-i)$’s sub-chunk is then retrieved from $\mathcal{W}\left[ind-i\right]$. As we simply track the sum of items prior to that index in $\mathit{subTotal}$ and then store it in $\mathcal{W}$ (see line 5), we get its value immediately. Thus, our estimation procedure is equivalent to that of Algorithm 1 and using Theorem 5.1 we establish our correctness. *

Appendix E Proof of Theorem 5.4

Proof E.1**.**

For the proof, we define a few quantities that we also use in our query procedure $\mathit{numElems}\triangleq\left\lceil{\frac{i-o}{\nu}}\right\rceil,\mathit{totalSum}\triangleq\mathfrak{R}.\mbox{\sc Query}\left({\mathit{numElems}}\right),\mathit{oldest_{\rho}}\triangleq\mathit{totalSum}-\mathfrak{R}.\mbox{\sc Query}\left({\mathit{numElems}-1}\right)$ and $\mathit{out}\triangleq\left({\nu-\left({(i-o)\mod\nu}\right)}\right)$ as in our Query function; see Figure 3 for illustration. We assume that the index of the most recent element is

[TABLE]

such that $o\in[\nu-1]$ is the offset within the current block and that $x_{1}$ is the first element in the newest block of $\mathit{oldest_{\rho}}$. By the correctness of the $\mathfrak{R}$ Sliding Ranker, and as illustrated in Figure 3, we have that $\mathit{totalSum}$ is the sum of the last $\mathit{numElems}$ added to $\mathfrak{R}$, that $\mathit{oldest_{\rho}}$ is the value of the element that represents the last block that overlaps with the queried window. Also notice that $\mathit{out}$ is the number of elements in that block that are not a part of the window.

For any $t\in\mathbb{N}$, we denote by $\mathfrak{r_{t}}$ the value of $\mathfrak{r}$ after the $t^{th}$ item was added; e.g., $\mathfrak{r_{h}}$ is the value of $\mathfrak{r}$ at the time of the query and $\mathfrak{r_{0}}$ is its value after the last block has ended. For other variables, we consider their value at the query time.

When a block ends, we effectively perform $\mathfrak{r}\leftarrow\mathfrak{r}\mod\widetilde{\Delta}$ (lines 6 and 7) and thus:

[TABLE]

Our goal is to estimate the quantity

[TABLE]

Recall that our estimation (Line 17) is:

[TABLE]

where the last equality follows from the fact that within a block we simply sum the rounded values (Line 4). Next, observe that we sum the rounded values in each block and that if $\mathfrak{r}$ is decreased by $k\cdot\widetilde{\Delta}$ (for some $k\in\mathbb{N}$) in Line 7, then we set one of the last $\mathit{numElems}$ elements added to $\mathfrak{R}$ to $k$. This means that:

[TABLE]

Plugging (9) into (8) gives us

[TABLE]

Joining (10) with (7), we can express the algorithm’s error as:

[TABLE]

where $\xi$ is the rounding error which is defined as

[TABLE]

Since each rounding of an integer $x\in\left\{0,1,\ldots,\ell\right\}$ has an error of at most $\frac{\ell}{2^{\mathfrak{b}}}$, and as we round $i\leq n$ elements, we have that the rounding error satisfies

[TABLE]

where the last inequality is immediate from our choice of the number of bits that is $\mathfrak{b}\triangleq\left\lceil{\log\left({n/\mu}\right)+\log\log n}\right\rceil$. We now split to cases based on the value of $\mu$. As in the $(\ell,n,\Delta)$-Ranker case, we start with the simpler $\mu<2\cdot\left({1-1/\log n}\right)$ case, in which $\nu=1$ (and consequently, $out\equiv 0$). This allows us to write the algorithm’s error of (11) as

[TABLE]

We now use (6),(12) and the definition of $\widetilde{\Delta}$ to obtain:

[TABLE]

Similarly, we can bound it from below:

[TABLE]

We established that if $\nu=1$ we obtain the desired approximation. Henceforth, we focus on the case where $\mu\geq 2\cdot\left({1-1/\log n}\right)$, and thus $\nu=\left\lfloor{\mu\cdot\left({1-1/\log n}\right)}\right\rfloor$ and $\mathit{oldest_{\rho}}\in\left\{0,1\right\}$. We now consider two cases, based on the value of $\mathit{oldest_{\rho}}$.

$\bm{\mathit{oldest_{\rho}}=1}$** case.

---

In this case, we know that after the processing of element $x_{\nu}$ the value of $\mathfrak{r}$ was at least $\widetilde{\Delta}$ (Line 6). This implies that $\mathfrak{r_{0}}+\sum_{d=1}^{\nu}Round_{\mathfrak{b}}(x_{d})\geq\widetilde{\Delta}$ and equivalently*

[TABLE]

Substituting this in (11), and applying (12), we get that:

[TABLE]

In order to bound the error from above we use (6) and (12):

[TABLE] 2. 2.

$\bm{\mathit{oldest_{\rho}}=0}$** case.

*** Here, since the value of $\mathit{oldest_{\rho}}$ was is [math], we have that $\mathfrak{r_{0}}+\sum_{d=1}^{\nu}Round_{\mathfrak{b}}(x_{d})<\widetilde{\Delta}$ and thus*

[TABLE]

We use this for the error expression of (11) to get:

[TABLE]

We now use (6), (12), and the fact that $\mathit{out}\leq\nu$ to bound the error from below as follows:

[TABLE]

Finally, we need to cover the case of $i\leq o$. In this case, we return $\mathfrak{r}-\left({\widetilde{\Delta}-1/2}\right)$ as the estimate. This directly follows from (6) and the fact that within a block we simply sum the rounded values (Line 4). We established that in all cases $-\Delta<\widehat{S_{i}}-S_{i}<0$, thereby proving the theorem.