Succinct Partial Sums and Fenwick Trees

TL;DR

This paper introduces two space-efficient Fenwick Tree variants that support partial sums and updates with near-optimal space and time complexity, leveraging bit-packing and sampling techniques for practicality and parallelization.

Contribution

The paper presents the first succinct Fenwick Tree implementations with nk + o(n) bits space and efficient query/update times, improving space efficiency while maintaining performance.

Findings

Achieved nk + o(n) bits space with O(log_b n) query/update time.

Supported near-optimal time complexity with only a slight increase in space usage.

Designed methods are practical, based on bit-packing and sampling, enabling simple parallelization.

Abstract

We consider the well-studied partial sums problem in succint space where one is to maintain an array of n k-bit integers subject to updates such that partial sums queries can be efficiently answered. We present two succint versions of the Fenwick Tree - which is known for its simplicity and practicality. Our results hold in the encoding model where one is allowed to reuse the space from the input data. Our main result is the first that only requires nk + o(n) bits of space while still supporting sum/update in O(log_b n) / O(b log_b n) time where 2 <= b <= log^O(1) n. The second result shows how optimal time for sum/update can be achieved while only slightly increasing the space usage to nk + o(nk) bits. Beyond Fenwick Trees, the results are primarily based on bit-packing and sampling - making them very practical - and they also allow for simple optimal parallelization.

Equations

$$\begin{array}[]{l}S_{b}(1,k)=k\\ S_{b}(n,k)=\frac{n(b-1)}{b}\cdot\left(k+\log b\right)+S_{b}(n/b,k+\log b)\end{array}$$

$$\begin{array}[]{l}S_{b}(1,k)=k\\ S_{b}(n,k)=\frac{n(b-1)}{b}\cdot\left(k+\log b\right)+\frac{nw}{b}+S_{b}(n/b,k+\log b)\end{array}$$

Full text

1 Introduction

Let $A$ be an array of $k$-bits integers, with $|A|=n$. The partial sums problem is to build a data structure maintaining $A$ under the following operations.

• •

sum$(i)$: return the value $\sum_{t=1}^{i}A[t]$.

• •

search$(j)$: return the smallest $i$ such that sum$(i)\geq j$.

• •

update$(i,\Delta)$: set $A[i]\leftarrow A[i]+\Delta$, for some $\Delta$ such that $0\leq A[i]+\Delta<2^{k}$.

• •

access$(i)$: return $A[i]$.

Note that access$(i)$ can implemented as sum$(i)-$sum$(i-1)$ and we therefore often do not mention it explicitly.

The partial sums problem is one the most well-studied data structure problems [4, 9, 3, 1, 2, 8, 6, 7]. In this paper, we consider solutions to the partial sums problem that are succinct, that is, we are interested in data structures that use space close to the information-theoretic lower bound of $nk$ bits. We distinguish between encoding data structures and indexing data structures. Indexing data structures are required to store the input array $A$ verbatim along with additional information to support the queries, whereas encoding data structures have to support operations without consulting the input array.

In the indexing model Raman et al. [8] gave a data structure that supports sum, update, and search in $\mathcal{O}(\log n/\log\log n)$ time while using $nk+o(nk)$ bits of space. This was improved and generalized by Hon et al. [6]. Both of these papers have the constrain $\Delta\leq\log^{\mathcal{O}(1)}n$. The above time complexity is nearly optimal by a lower bound of Patrascu and Demaine [7] who showed that sum, search, and update operations takes $\Theta(\log_{w/\delta}n)$ time per operation, where $w\geq\log n$ is the word size and $\delta$ is the number of bits needed to represent $\Delta$. In particular, whenever $\Delta=\log^{\mathcal{O}(1)}n$ this bound matches the $\mathcal{O}(\log n/\log\log n)$ bound of Raman et al. [8].

Fenwick [2] presented a simple, elegant, and very practical encoding data structure. The idea is to replace entries in the input array $A$ with partial sums that cover $A$ in an implicit complete binary tree structure. The operations are then implemented by accessing at most $\log n$ entries in the array. The Fenwick tree uses $nk+n\log n$ bits and supports all operations in $O(\log n)$ time. In this paper we show two succinct $b$-ary versions of the Fenwick tree. In the first version we reduce the size of the Fenwick tree while improving the sum and update time. In the second version we obtain optimal times for sum and update without using more space than the previous best succinct solutions [8, 6]. All results in this paper are in the RAM model.

Our results

We show two encoding data structures that gives the following results.

Theorem 1.1

We can replace $A$ with a succinct Fenwick tree of $nk+o(n)$ bits supporting sum, update, and search queries in $\mathcal{O}(\log_{b}n)$, $\mathcal{O}(b\log_{b}n)$, and $\mathcal{O}(\log n)$ time, respectively, for any $2\leq b\leq\log^{\mathcal{O}(1)}n$.

Theorem 1.2

We can replace $A$ with a succinct Fenwick tree of $nk+o(nk)$ bits supporting sum and update queries in optimal $\mathcal{O}(\log_{w/\delta}n)$ time and search queries in $\mathcal{O}(\log n)$ time.

2 Data structure

For simplicity, assume that $n$ is a power of $2$. The Fenwick tree is an implicit data structure replacing a word-array $A[1,\dots,n]$ as follows:

Definition 1

Fenwick tree of $A$ [2]. If $n=1$, then leave $A$ unchanged. Otherwise, divide $A$ in consecutive non-overlapping blocks of two elements each and replace the second element $A[2i]$ of each block with $A[2i-1]+A[2i]$, for $i=1,\dots,n/2$. Then, recurse on the sub-array $A[2,4,\dots,2i,\dots,n]$.

To answer $sum(i)$, the idea is to write $i$ in binary as $i=2^{j_{1}}+2^{j_{2}}+\dots+2^{j_{k}}$ for some $j_{1}>j_{2}>\dots>j_{k}$. Then there are $k\leq\log n$ entries in the Fenwick tree, that can be easily computed from $i$, whose values added together yield $sum(i)$. In Section 2.1 we describe in detail how to perform such accesses. As per the above definition, the Fenwick tree is an array of $n$ indices. If represented compactly, this array can be stored in $nk+n\log n$ bits. In this section we present a generalization of Fenwick trees taking only succinct space.

2.1 Layered b-ary structure

We first observe that it is easy to generalize Fenwick trees to be $b$-ary, for $b\geq 2$: we divide $A$ in blocks of $b$ integers each, replace the first $b-1$ elements in each block with their partial sum, and fill the remaining $n/b$ entries of $A$ by recursing on the array $A^{\prime}$ of size $n/b$ that stores the sums of each block. This generalization gives an array of $n$ indices supporting sum, update, and search queries on the original array in $\mathcal{O}(\log_{b}n)$, $\mathcal{O}(b\log_{b}n)$, and $\mathcal{O}(\log n)$ time, respectively. We now show how to reduce the space of this array.

Let $\ell=\log_{b}n$. We represent our $b$-ary Fenwick tree $T_{b}(A)$ using $\ell+1$ arrays (layers) $T_{b}^{1}(A),\dots,T_{b}^{\ell+1}(A)$. For simplicity, we assume that $n=b^{e}$ for some $e\geq 0$ (the general case is then straightforward to derive). To improve readability, we define our layered structure for the special case $b=2$, and then sketch how to extend it to the general case $b\geq 2$. Our layered structure is defined as follows. If $n=1$, then $T_{2}^{1}(A)=A$. Otherwise:

• •

$T_{2}^{\ell+1}(A)[i]=A[(i-1)\cdot 2+1]$, for all $i=1,\dots,n/2$. Note that $T_{2}^{\ell+1}(A)$ contains $n/2$ elements.

• •

Divide $A$ in blocks of $2$ elements each, and build an array $A^{\prime}[j]$ containing the $n/2$ sums of each block, i.e. $A^{\prime}[j]=A[(j-1)\cdot 2+1]+A[(j-1)\cdot 2+2]$, for $j=1,\dots,n/2$. Then, the next layers are recursively defined as $T_{2}^{\ell}(A)\leftarrow T_{2}^{\ell}(A^{\prime}),\dots,T_{2}^{1}(A)\leftarrow T_{2}^{1}(A^{\prime})$.

For general $b\geq 2$, $T_{b}^{\ell+1}(A)$ is an array of $\frac{n(b-1)}{b}$ elements that stores the $b-1$ partial sums of each block of $b$ consecutive elements in $A$, while $A^{\prime}$ is an array of size $n/b$ containing the complete sums of each block. In Figure 1 we report an example of our layered structure with $b=3$. It follows that elements of $T_{b}^{i}(A)$, for $i>1$, take at most $k+(\ell-i+2)\log b$ bits each. Note that arrays $T_{b}^{1}(A),\dots,T_{b}^{\ell+1}(A)$ can easily be packed contiguously in a word array while preserving constant-time access to each of them. This saves us $\mathcal{O}(\ell)$ words that would otherwise be needed to store pointers to the arrays. Let $S_{b}(n,k)$ be the space (in bits) taken by our layered structure. This function satisfies the recurrence

[TABLE]

Which unfolds to $S_{b}(n,k)=\sum_{i=1}^{\log_{b}n+1}\frac{n(b-1)}{b^{i}}\cdot\left(k+i\log b\right).$ Using the identities $\sum_{i=1}^{\infty}1/b^{i}=1/(b-1)$ and $\sum_{i=1}^{\infty}i/b^{i}=b/(b-1)^{2}$, one can easily derive that $S_{b}(n,k)\leq nk+2n\log b$.

We now show how to obtain the time bounds stated in Theorem 1.1. In the next section, we reduce the space of the structure without affecting query times.

Answering sum

Let the notation $(x_{1}x_{2}\dots x_{t})_{b}$, with $0\leq x_{i}<b$ for $i=1,\dots,t$, represent the number $\sum_{i=1}^{t}b^{t-i}x_{i}$ in base $b$. $sum(i)$ queries on our structure are a generalization (in base $b$) of $sum(i)$ queries on standard Fenwick trees. Consider the base-$b$ representation $x_{1}x_{2}\dots x_{\ell+1}$ of $i$, i.e. $i=(x_{1}x_{2}\dots x_{\ell+1})_{b}$ (note that we have at most $\ell+1$ digits since we enumerate indexes starting from 1). Consider now all the positions $1\leq i_{1}<i_{2}<\dots<i_{t}\leq\ell+1$ such that $x_{j}\neq 0$, for $j=i_{1},\dots,i_{t}$. The idea is that each of these positions $j=i_{1},\dots,i_{t}$ can be used to compute an offset $o_{j}$ in $T^{j}_{b}(A)$. Then, $sum(i)=\sum_{j=i_{1},\dots,i_{t}}T^{j}_{b}(A)[o_{j}]$. The offset $o_{j}$ relative to the $j$-th most significant (nonzero) digit of $i$ is defined as follows. If $j=1$, then $o_{j}=x_{1}$. Otherwise, $o_{j}=(b-1)\cdot(x_{1}\dots x_{j-1})_{b}+x_{j}$. Note that we scale by a factor of $b-1$ (and not $b$) as the first term in this formula as each level $T^{j}(A)$ stores only $b-1$ out of $b$ partial sums (the remaining sums are passed to level $j-1$). Note moreover that each $o_{j}$ can be easily computed in constant time and independently from the other offsets with the aid of modular arithmetic. It follows that sum queries are answered in $\mathcal{O}(\log_{b}n)$ time. See Figure 1 for a concrete example of sum.

Answering update

The idea for performing $update(i,\Delta)$ is analogous to that of $sum(i)$. We access all levels that contain a partial sum covering position $i$ and update at most $b-1$ sums per level. Using the same notation as above, for each $j=i_{1},\dots,i_{t}$ such that $x_{j}\neq 0$, we update $T^{j}_{b}(A)[o_{j}+l]\leftarrow T^{j}_{b}(A)[o_{j}+l]+\Delta$ for $l=0,\dots,b-x_{j}-1$. This procedure takes $\mathcal{O}(b\log_{b}n)$ time.

Answering search

To answer $search(j)$ we start from $T^{1}_{b}(A)$ and simply perform a top-down traversal of the implicit B-tree of degree $b$ defined by the layered structure. At each level, we perform $\mathcal{O}(\log b)$ steps of binary search to find the new offset in the next level. There are $\log_{b}n$ levels, so search takes overall $\mathcal{O}(\log n)$ time.

2.2 Sampling

Let $0<d\leq n$ be a sample rate, where for simplicity we assume that $d$ divides $n$. Given our input array $A$, we derive an array $A^{\prime}$ of $n/d$ elements containing the sums of groups of $d$ adjacent elements in $A$, i.e. $A^{\prime}[i]=\sum_{j=1}^{d}A[(i-1)\cdot d+j]$, $i=1,\dots,d$. We then compact $A$ by removing $A[j\cdot d]$ for $j=1,\dots,n/d$, and by packing the remaining integers in at most $nk(1-1/d)$ bits. We build our layered $b$-ary Fenwick tree $T_{b}(A^{\prime})$ over $A^{\prime}$. It is clear that queries on $A$ can be solved with a query on $T_{b}(A^{\prime})$ followed by at most $d$ accesses on (the compacted) $A$. The space of the resulting data structure is $nk(1-1/d)+S_{b}(n/d,k+\log d)\leq nk+\frac{n\log d}{d}+\frac{2n\log b}{d}$ bits. In order to retain the same query times of our basic layered structure, we choose $d=(1/\epsilon)\log_{b}n$ for any constant $\epsilon>0$ and obtain a space occupancy of $nk+\epsilon\left(\frac{n\log\log_{b}n}{\log_{b}n}+\frac{2n\log b}{\log_{b}n}\right)$ bits. For $b\leq\log^{\mathcal{O}(1)}n$, this space is $nk+o(n)$ bits. Note that—as opposed to existing succinct solutions—the low-order term does not depend on $k$.

3 Optimal-time sum and update

In this section we show how to obtain optimal running times for sum and update queries in the RAM model. We can directly apply the word-packing techniques described in [7] to speed-up queries; here we only sketch this strategy, see [7] for full details. Let us describe the idea on the structure of Section 2.1, and then plug in sampling to reduce space usage. We divide arrays $T^{j}_{b}(A)$ in blocks of $b-1$ entries, and store one word ($w$ bits) for each such block. We can pack $b-1$ integers of at most $w/(b-1)$ bits each (for an opportune $b$, read below) in the word associated with each block. Since blocks of $b-1$ integers fit in a single word, we can easily answer sum and update queries on them in constant time. sum queries on our overall structure can be answered as described in Section 2.1, except that now we also need to access one of the packed integers at each level $j$ to correct the value read from $T^{j}_{b}(A)$. To answer update queries, the idea is to perform update operations on the packed blocks of integers in constant time exploiting bit-parallelism instead of updating at most $b-1$ values of $T^{j}_{b}(A)$. At each update operation, we transfer one of these integers on $T^{j}_{b}(A)$ (in a cyclic fashion) to avoid overflowing and to achieve worst-case performance. Note that each packed integer is increased by at most $\Delta$ for at most $b-1$ times before being transferred to $T^{j}_{b}(A)$, so we get the constraint $(b-1)\log((b-1)\Delta)\leq w$. We choose $(b-1)=\frac{w}{2(\log w+\delta)}$. Then, it is easy to show that the above constraint is satisfied. The number of levels becomes $\log_{b}n=\mathcal{O}(\log_{w/\delta}n)$. Since we spend constant time per level, this is also the worst-case time needed to answer sum and update queries on our structure. To analyze space usage we use the corrected formula

[TABLE]

yielding $S_{b}(1,k)\leq nk+2n\log b+\frac{nw}{b-1}$. Replacing $b-1=\frac{w}{2(\log w+\delta)}$ we achieve $nk+\mathcal{O}(n\delta+n\log w)$ bits of space.

We now apply the sampling technique of Section 2.2 with a slight variation. In order to get the claimed space/time bounds, we need to further apply bit-parallelism techniques on the packed integers stored in $A$: using techniques from [5], we can answer sum, search, and update queries in $\mathcal{O}(1)$ time on blocks of $w/k$ integers. It follows that we can now use sample rate $d=\frac{w\log n}{k\log(w/\delta)}$ without affecting query times. After sampling $A$ and building the Fenwick tree above described over the sums of size-$d$ blocks of $A$, the overall space is $nk(1-1/d)+S_{b}(n/d,k+\log d)=nk+\frac{n\log d}{d}+\mathcal{O}(\frac{n\delta}{d}+\frac{n\log w}{d})$. Note that $d\leq\frac{w^{2}}{k\log(w/\delta)}\leq w^{2}$, so $\log d\in\mathcal{O}(\log w)$ and space simplifies to $nk+\mathcal{O}(\frac{n\delta}{d}+\frac{n\log w}{d})$. The term $\frac{n\delta}{d}$ equals $\frac{n\delta k\log(w/\delta)}{w\log n}$. Since $\delta\leq w$, then $\delta\log(w/\delta)\leq w$, and this term therefore simplifies to $\frac{nk}{\log n}\in o(nk)$. Finally, the term $\frac{n\log w}{d}$ equals $\frac{n\log w\cdot k\log(w/\delta)}{w\log n}\leq\frac{nk}{(w\log n)/(\log w)^{2}}\in o(nk)$. The bounds of Theorem 1.2 follow.

3.0.1 Parallelism

Note that sum and update queries on our succinct Fenwick trees can be naturally parallelized as all accesses/updates on the levels can be performed independently from each other. For sum, we need $\mathcal{O}(\log\log_{b}n)$ further time to perform a parallel sum of the $\log_{b}n$ partial results. It is not hard to show that—on architectures with $\log_{b}n$ processors—this reduces sum/update times to $\mathcal{O}(\log\log_{b}n)$/$\mathcal{O}(b)$ and $\mathcal{O}(\log\log_{w/\delta}n)$/$\mathcal{O}(1)$ in Theorems 1.1 and 1.2, respectively.