Approximating Frequent Items in Asynchronous Data Stream over a Sliding Window

Abstract

In an asynchronous data stream, the data items may be out of order with respect to their original timestamps. This paper studies the space complexity required by a data structure to maintain such a data stream so that it can approximate the set of frequent items over a sliding time window with sufficient accuracy. Prior to our work, the best solution is given by Cormode et al. [1], who gave an $O(\frac{1}{∊}logWlog(\frac{∊B}{logW})min\{logW,\frac{1}{∊}\}log|U|)$-space data structure that can approximate the frequent items within an ∊ error bound, where W and B are parameters of the sliding window, and U is the set of all possible item names. We gave a more space-efficient data structure that only requires $O(\frac{1}{∊}logWlog(\frac{∊B}{logW})loglogW)$ space.

1. Introduction

Identifying frequent items in a massive data stream has many applications in data mining and network monitoring, and the problem has been studied extensively [2-5]. Recent interest has been shifted from the statistics of the whole data stream to that of a sliding window of recent data [6-9]. In most applications, the amount of data in a window is gigantic when compared with the amount of memory available in the processing units. It is impossible to store all the data and then find the exact frequent items. Existing research has focused on designing space-efficient data structures to support finding the approximate frequent items. The key concern is how to minimize the space so as to achieve a required level of accuracy.

1.1. Asynchronous Data Stream

Most of the previous work on data streams assume that items in a data stream are synchronous in the sense that the order of their arrivals is the same as the order of their creations. This synchronous model is however not suitable to applications that are distributed in nature. For example, in a sensor network, the sink collects data transmitted from sensors over a large area, and the data transmitted from different sensors would suffer different delay. It is possible that an item created at time t at a certain sensor may arrive at the sink later than an item created after t at another sensor. From the sink's viewpoint, items in the data stream are out of order with respect to their creation times. Yet the statistics to be computed are usually based on the creation times. More specifically, an asynchronous data stream (a.k.a. out-of-order data stream) [1,10,11] can be considered as a sequence (a₁, t₁), (a₂, t₂), (a₃, t₃), …, where a_i is the name of a data item chosen from a fixed universe U, and t_i is an integer timestamp recording the creation time of this item. Items arriving at the data stream are in arbitrary order regarding their timestamps, and it is possible that more than one data item has the same timestamp.

1.2. Previous Work on Approximating Frequent Items

Consider a data stream and, in particular, those data items whose timestamps fall into the last W time units (W is the size of the sliding window). An item (or precisely, an item name) is said to be a frequent item if its count (i.e., the number of occurrences) exceeds a certain required threshold of the total item count. Arasu and Manku [6] were the first to study approximating frequent items over a sliding window under the synchronous model, in which data items arrive in non-decreasing order of timestamps. The space complexity of their data structure is $O(\frac{1}{∊}{(log\frac{1}{∊})}^{2}log(∊B))$, where ∊ is a user-specified error bound and B is the maximum number of items with timestamps falling into the same sliding window. Their work was later improved by Lee and Ting [7] to $O(\frac{1}{∊}log(∊B))$ space. Recently, Cormode et al. [1] initiated the study of frequent items under the asynchronous model, and gave a solution with space complexity $O(\frac{1}{∊}logWlog(\frac{∊B}{logW})min\{logW,\frac{1}{∊}\}log|U|)$, where U is the set of possible item names. Later, Cormode et al. [12] gave a hashing-based randomized solution using $O(\frac{1}{{∊}^2}log|U|)$ space. The space complexity is quadratic in $\frac{1}{∊}$, which is less preferred, but that is a general solution that can solve other problems like finding the sum and quantiles.

The earlier work on asynchronous data stream focused on a relatively simpler problem called ∊-approximate basic counting [10,11]. Cormode et al. [1] improved the space complexity of basic counting to. $O(\frac{1}{∊}logWlog(\frac{∊B}{logW}))$ Notice that under the synchronous model, the best data structure requires $O(\frac{1}{∊}log(∊B))$ space [9]. It is believed that there is roughly a gap of logW between the synchronous model to the asynchronous model. Yet, for frequent items, the asynchronous result of Cormode et al. [1] has space complexity way bigger than that of the best synchronous result, which is $O(\frac{1}{∊}log(∊B))$ [7]. This motivates us to study more space-efficient solutions for approximating frequent items in the asynchronous model.

1.3. Formal Definition of Approximate Frequent Item Set

For any time interval I and any data item a, let f_a(I) denote the frequency of item a in interval I, i.e., the number of arrived items named a with timestamps falling into I. Define f_*(I) = Σ_a∈U f_a(I) to be the total number of all arrived items with timestamps within I.

Given a user-specified error bound ∊ and a window size W, we want to maintain a data structure to answer any ∊-approximate frequent item set query for any sub-window (specified at query time), which is in the form (ϕ, W′) where ϕ ∈ [∊, 1] is the required threshold and W′ ≤ W is the sub-window size. Suppose that τ_cur is the current time. The answer to such a query is a set S of item names satisfying the following two conditions:

• (C1) S contains every item a whose frequency in interval I = [τ_cur − W′ + 1, τ_cur] is at least ϕf_*(I), i.e., f_a(I) ≥ ϕf_*(I).

• (C2) For any item a in S, its frequency in interval I is at least (ϕ − ∊)f_*(I),i.e., f_a(I) ≥ (ϕ − ∊)f_*(I).

The set S is also called an ∊-approximate ϕ-frequent item set. For example, assume ∊ = 1%, then the query (10%, 10, 000) would return all items whose frequencies in the last 10, 000 time units are each at least 10% of the total item count, plus possibly some other items with frequency at least 9% of the total count.

1.4. Our Contribution

This paper gives a more space-efficient data structure for answering any ∊-approximate frequent item set query. Our data structure uses $O(\frac{1}{∊}logWlog(\frac{∊B}{logW})loglogW)$ words, which is significantly smaller than the one given by Cormode et al. [1] (see

Table 1. The space complexity for answering ∊-approximate frequent item set query in a sliding time window. Results from this paper are marked with [†]. Note that we assume $B\ge \frac{1}{∊}logW$; otherwise, we can always store all items in the window for exact answer, using $O(\frac{1}{∊}logW)$ words. Similarly, for the result with tardiness, we assume $B\ge \frac{1}{∊}log{d}_{max}$.

Space Complexity (words)
Synchronous [7]	$O(\frac{1}{∊}log(∊B))$
Asynchronous [1]	$O(\frac{1}{∊}logWlog(\frac{∊B}{logW})min\{logW,\frac{1}{∊}\}log|U|)$
Asynchronous [†]	$O(\frac{1}{∊}logWlog(\frac{∊B}{logW})loglogW)$
Asynchronous with tardiness [†]	$O(\frac{1}{∊}log{d}_{max}log(\frac{∊B}{log{d}_{max}})loglog{d}_{max})$

). Furthermore, this space complexity is larger than the best synchronous solution by only a factor of O(logW log logW), which is close to the expected gap of O(logW). Similar to existing data structures for this problem, it takes time linear to the data structure's size to answer an ∊-approximate frequent item set query. Furthermore, it takes $O(log(\frac{∊B}{logW})(log\frac{1}{∊}+loglogW))$ time to modify the data structure for a new data item. Occasionally, we might need to clean up some old data items that are no longer significant to the approximation; in the worst case, this takes time linear to the size of the data structure, and thus is no bigger than the query time. As a remark, the solution of Cormode et al. [1] requires $O(log(\frac{∊B}{logW})logWloglog|U|)$ time for an update.

In the asynchronous model, if a data item has a delay more than W time units, it can be discarded immediately when it arrives. In many applications, the delay is usually small. This motivates us to extend the asynchronous model to consider data items that have a bounded delay. We say that an asynchronous data stream has tardiness d_max if a data item created at time t must arrive at the stream no later than time t + d_max. If we set d_max = 0, the model becomes the synchronous model. If we allow d_max ≥ W, this is in essence the asynchronous model studied above. We adapt our data structure to take advantage of small tardiness such that when d_max is small, it uses smaller space (see Table 1) and support faster update time (which is $O(log(\frac{∊B}{log{d}_{max}})(log\frac{1}{∊}+loglog{d}_{max})))$ In particular, when d_max = Θ(1), the size and update time of our data structure match those of the best data structure for synchronous data stream.

Remark

This paper is a corrected version of a paper with the same title in WAOA 2009 [13]; in particular, the error bound on the estimates was given incorrectly before and is fixed in this version.

1.5. Technical Digest

To solve the frequent item set problem, we need to estimate the frequency of any item with relative error ∊f_*(I) where I = [τ_cur − W + 1, τ_cur] is the interval covered by the sliding window. To this end, we first propose a simple data structure for estimating the frequency of a fixed item over the sliding window. Then, we adapt a technique of Misra and Gries [14] to extend our data structure to handle any item. The result is an O(f_*(I))/λ)-space data structure that allows us to obtain an estimate for any item with an error bound of about λ logW. Here λ is a design parameter. To ensure λ logW to be no greater than ∊f_*(I), we should set λ ≤ ∊f_*(I)/logW. Since f*(I) can be as small as $\mathrm{\Theta }(\frac{1}{∊}logW)$ (the case for smaller f_*(I) can be handled by brute-force), we need to be conservative and set λ to some constant. But then the size of the data structure can be Θ(B) because f_*(I) can be as large as B. To reduce space, we introduce a multi-resolution approach. Instead of using one single data structure, we maintain a collection of O(logB) copies of our data structure, each uses a distinct, carefully chosen parameter λ so that it could estimate the frequent item set with sufficient accuracy when f_*(I) is in a particular range. The resulting data structure uses $O(\frac{1}{∊}logWlogB)$ space.

Unfortunately, a careful analysis of our data structure reveals that in the worst case, it can only guarantee estimates with an error bound of ∊f_*(H ∪ I) where H = [τ_cur − 2W + 1, τ_cur − W], not the required ∊f_*(I). The reason is that the error of its estimates over I depend on the number of updates made during I, and unlike synchronous data stream, this number for asynchronous data stream can be significantly larger than f_*(I). For example, at time τ_cur − W + 1, there may still be many new items (a, u) with timestamps u ∈ H, for which we must update our data structure to get good estimates when the sliding window is at earlier positions. Indeed, the number of updates during I can be as large as f_*(H ∪ I), and this gives an error bound of ∊f_*(H ∪ I).

To reduce the error bound to ∊f_*(I), we introduce a novel algorithm to split the data structure into independent smaller ones at appropriate times. For example, at time τ_cur − W + 1, we can split our data structure into two smaller ones D_H and D_I, and we will only update D_H for items (a, u) with u ∈ H and update D_I for those with u ∈ I. Then, when we need to find an estimate on I at time τ_cur, we only need to consult D_I, and the number of updates made to it is f_*(I). In this paper, we develop sophisticated procedures to decide when and how to split the data structure so as to enable us to get good enough estimates when sliding window moves continuously. The resulting data structure has size $O(\frac{1}{∊}{(logW)}^{2}log(\frac{∊B}{logW}))$ Then, we further make the data structure adaptive to the input size, allowing us to reduce the space to $O(\frac{1}{∊}(loglogW)logWlog(\frac{∊B}{logW}))$.

2. Preliminaries

Our data structures for the frequent item set problem depends on data structures for the following two related data stream problems. Let 0 < ∊ < 1 be any real number, and τ_cur be the current time.

• The ∊-approximate basic counting problem asks for data structure that allows us to obtain, for any interval I = [τ_cur − W′ + 1, τ_cur] where W′ ≤ W, an estimate f̂_*(I) of f_*(I) such that |f̂_*(I) − f_*(I)| ≤ ∊f_*(I).

• The ∊-approximate counting problem asks for data structure that allows us to obtain, for any item a and any interval I = [τ_cur − W′ + 1, τ_cur] where W′ ≤ W, an estimate f̂_a(I) of f_a(I) such that | f̂_a(I) − f_a(I)|≤ ∊f_*(I).

As mentioned in Section 1, Cormode et al. [1] gave an $O(\frac{1}{∊}logWlog(\frac{∊B}{logW}))$-space data structure _∊ for solving the ∊-approximate basic counting problem. In this paper, we give an $O(\frac{1}{∊}logWlog(\frac{∊B}{logW})loglogW)$-space data structure _∊ for solving the harder ∊-approximate counting problem. The theorem below shows how to use these two data structures to answer ∊-approximate frequent item set query.

Theorem 1

Let ∊₀ = ∊/4. Given _∊o and _∊o, we can answer any ∊-approximate frequent item set query. The total space required is $O(\frac{1}{∊}logWlog(\frac{∊B}{logW})loglogW)$.

Proof

The space requirement is obvious. Consider any ∊-approximate frequent item set query (ϕ, W′) where ∊ ≤ ϕ ≤ 1 and W′ ≤ W. Let I = [τ_cur − W′ + 1, τ_cur]. Since ∊_o = ∊/4, the estimates given by _∊o satisfy $|{\widehat{f}}_{\ast }(I)-f_{\ast }(I)|\le \frac{∊}{4}{f}_{\ast }(I)$, and for any item a, the estimates given by _∊o satisfy $|{\widehat{f}}_a(I)-f_a(I)|\le \frac{∊}{4}{f}_{\ast }(I)$ To answer the query (ϕ, W′), we return the set

$$S_{\varphi }=\{a|{\widehat{f}}_a(I)\ge (\varphi -\frac{∊}{2}I){\widehat{f}}_{\ast }(I)\}$$

which satisfies the required conditions (C1) and (C2) because

• for any item a with f_a(I) ≥ ϕf_*(I), ${\widehat{f}}_a(I)\ge f_a(I)-\frac{∊}{4}{f}_{\ast }(I)\ge (\varphi -\frac{∊}{4})f_{\ast }(I)\ge (\varphi -\frac{∊}{4})(\frac{1}{1+\frac{∊}{4}}){\widehat{f}}_{\ast }(I)\ge (\varphi -\frac{∊}{4})(1-\frac{∊}{4}){\widehat{f}}_{\ast }(I)\ge (\varphi -\frac{∊}{2}){\widehat{f}}_{\ast }(I)$, and a ∈ S_ϕ; thus (C1) is satisfied, and

• for every a ∈ S_ϕ, we have $f_a(I)\ge {\widehat{f}}_a(I)-\frac{∊}{4}{f}_{\ast }(I)\ge (\varphi -\frac{∊}{2}){\widehat{f}}_{\ast }(I)-\frac{∊}{4}{f}_{\ast }(I)\ge (\varphi -\frac{∊}{2})(1-\frac{∊}{4})f_{\ast }(I)-\frac{∊}{4}{f}_{\ast }(I)\ge (\varphi -∊)f_{\ast }(I)$; thus (C2) is satisfied.

The building block of _∊ is a data structure that counts items over some fixed interval (instead of the sliding window). For any interval I = [ℓ_I, r_I] of size W, Theorem 4 in Section 4 gives a data structure _I,∊ that uses $O(\frac{1}{∊}logWlog(\frac{∊B}{logW})loglogW)$ space, supports $O(log(\frac{∊B}{logW})\cdot (log\frac{1}{∊}+loglogW))$ update time, and enables us to obtain, for any item a and any time t ∈ I, an estimate f̂_a([t, r_I]) of f_a([t, r_I]) such that

$$|{\widehat{f}}_a([t,r_I])-f_a([t,r_I])|\le ∊f_{\ast }([t,r_I])$$

(1)

Given _I1,∊, _I2,∊, … where I_i = [(i − 1)W + 1, iW], we can obtain, for any W′ ≤ W, an estimate f̂_a([s, τ_cur]) of f_a([s, τ_cur]) where s = τ_cur − W′ + 1 as follows.

• Let I_i and I_i+1 be the intervals such that [s, τ_cur] ⊂ I_i ∪ I_i+1.

• Use _Ii,∊ to get an estimate f̂_a([s, iW]) of f_a([s, iW]), and _Ii+1,∊ an estimate f̂_a([iW + 1, (i + 1)W]) of f_a([iW + 1, (i + 1)W]).

• Our estimate f̂_a([s, τ_cur]) = f̂_a([s, iW]) + f̂_a([iW + 1, (iW + 1)W]).

By Equation (1), we have

$$|{\widehat{f}}_a([S,iW])-f_a([S,iW])|\le ∊f_{\ast }([S,iW])$$

(2)

and

$$|{\widehat{f}}_a([iW+1,(i+1)W])-f_a([iW+1,(i+1)W])|\le ∊f_{\ast }([iW+1,(i+1)W])$$

(3)

Observe that any item that arrives at or before the current time τ_cur must have timestamp no greater than τ_cur; hence f_a([iW + 1, (i + 1)W]) = f_a([iW + 1, τ_cur]) and f_*([iW + 1, (i + 1)W]) = f_*([iW +1, τ_cur]), and Equation (3) is equivalent to

$$|{\widehat{f}}_a([iW+1,(i+1)W])-f_a([iW+1,{\tau }_{\text{cur}}])|\le ∊f_{\ast }([iW+1,{\tau }_{\text{cur}}])$$

(4)

Adding Equations (2) and (4), we conclude |f̂_a([s, τ_cur]) − f_a([s, τ_cur])| ≤ ∊f_*([s, τ_cur]), as required.

Our data structure _∊ is just the collection of _I1,∊, _I2,∊, …. Note that we only need to physically store in _∊ the data structures _Ii,∊ and _Ii+1,∊ where [τ_cur − W + 1,τ_cur] ⊆ I_i ∪ I_i+1. The intervals of the earlier ones will no longer be covered by the sliding window and the corresponding _I,∊'s can be thrown away. Together with Theorem 4, we have the following theorem.

Theorem 2

The data structure _∊ solves the ∊-approximate counting problem. The space usage is $O(\frac{1}{∊}logWlog(\frac{∊B}{logW})loglogW)$ and it supports $O(log(\frac{∊B}{logW})\cdot (log\frac{1}{∊}+loglogW))$ update time.

3. A Simple Data Structure For Frequency Estimation

Let I = [ℓ_I, r_I] be any interval of size W. To simplify notation, we assume that W is a power of 2, so that logW is an integer and we can avoid the floor or the ceiling functions. In this section, we describe a simple data structure _I,λ,κ that enables us to obtain, for any item a, a good estimate of a's frequency over I. The parameters λ and κ determine its accuracy and space usage. However, its accuracy is not enough for answering any ∊-approximate frequent item set query. We will explain how to improve the accuracy in the next section.

Roughly speaking, _I,λ,κ is a set of queues $Q_{I,\lambda }^a$ i.e., ${\mathcal{C}}_{I,\lambda ,\kappa }=[Q_{I,\lambda }^a\mid a\in U]$. For an item a, the queue $Q_{I,\lambda }^a$ keeps track of the occurrences of a in I. Each node N in $Q_{I,\lambda }^a$ is associated with an interval i(N), a value v(N), and a debit d(N); v(N) counts the number of arrived items (a, u) with u ∈ i(N), and d(N) is for implementing a space reduction technique. Initially, $Q_{I,\lambda }^a$ has only one node N with i(N) = I, and v(N) = d(N) = 0. In general, $Q_{I,\lambda }^a$ is a queue 〈N₁, N₂, …, N_k〉 of nodes whose intervals form a partition of I, i.e.,

$$\langle i(N_1),i(N_2),\dots ,i(N_k)\rangle =\langle [p_1,q_1],[p_2,q_2],\dots ,[p_k,q_k]\rangle$$

where q_i−1 + 1 = p_i ≤ q_i and ∪_1≤i≤k[p_i, q_i] = I. When an item (a, u) with u ∈ I arrives, we update $Q_{I,\lambda }^a$ as follows.

$Q_{I,\lambda }^a$.Debit( )
1:	find the unique node N in $Q_{I,\lambda }^a$ with u ∈ i(N) = J = [p, q],
2:	increase the value of N by 1, i.e., v(N) = v(N) + 1;
3:	if (|J| > 1 and λ units have been added to v(N) since J is assigned to i(N)) then
4:	/* refine J */
5:	create a new node N′ and insert it to the left of N;
6:	let i(N′) = [p, m], i(N) = [m + 1, q] where m = ⌊(p + q)/2⌋;
7:	let v(N′) = 0 and d(N′) = 0;
8:	/* we make no change to v(N) and d(N) */
9:	end if

Figure 1 gives an example on how $Q_{I,\lambda }^a$ is updated using the procedure.

Obviously, a direct implementation of _I,λ,κ uses too much space. We now extend a technique of Misra and Gries [14] to reduce the space requirement. For any $Q_{I,\lambda }^a$, we say that $Q_{I,\lambda }^a$ is trivial if the queue contains only a single node N with (i) i(N) = I, and (ii) v(N) = d(N) = 0. Every queue in _I,λ,κ is trivial initially. The key for reducing the space complexity of _I,λ,κ is to maintain the following invariant throughout the execution:

• (*) There are at most κ non-trivial queues in _I,λ,κ.

We call κ the capacity of _I,λ,κ. The invariant helps us save space because we do not need to store trivial queues physically in memory. To maintain (*), each queue $Q_{I,\lambda }^a$ supports the following procedure, which is called only when $v(Q_{I,\lambda }^a)$, the total values of the nodes in $Q_{I,\lambda }^a$, is strictly greater than $d(Q_{I,\lambda }^a)$, the total debits of the nodes in $Q_{I,\lambda }^a$.

$Q_{I,\lambda }^a$.Debit( )
1:	if ( $v(Q_{I,\lambda }^a)\le d(Q_{I,\lambda }^a)$) then
2:	return error;
3:	else
4:	find an arbitrary node N of $Q_{I,\lambda }^a$ with v(N) > d(N);
5:	/* such a node must exist because $v(Q_{I,\lambda }^a)>d(Q_{I,\lambda }^a)$ */
6:	d(N) = d(N) + 1;
7:	end if

Note from the implementation of Debit( ) that $v(Q_{I,\lambda }^a)$ is always no smaller than $d(Q_{I,\lambda }^a)$, and for each node N of $Q_{I,\lambda }^a,v(N)\ge d(N)$. Furthermore, if $v(Q_{I,\lambda }^a)=d(Q_{I,\lambda }^a)$, then v(N) = d(N) for every node N in $Q_{I,\lambda }^a$. To maintain (*), _I,λ,κ processes a newly arrived item (a, u) with u ∈ I as follows.

I,λ,κ.Process((a, u))
1:	update $(Q_{I,\lambda }^a)$ by calling .Update((a, u));
2:	if (after the update the number of non-trivial queues becomes κ) then
3:	for each$Q_{I,\lambda }^x$ with do.Debit( );
4:	for each non-trivial queues $v(Q_{I,\lambda }^x)=d(Q_{I,\lambda }^x)$ with do
5:	delete all nodes of $Q_{I,\lambda }^x$ and make it a trivial queue;
6:	/* Note that each deleted node N satisfies v(N) = d(N). */
7:	end if

It is easy to see that Invariant (*) always holds: Initially the number m of non-trivial queues is zero, and m increases only when Process((a, u)) is on some trivial $Q_{I,\lambda }^a$; in such case $v(Q_{I,\lambda }^a)$ becomes 1 and $d(Q_{I,\lambda }^a)$ remains 0. If m becomes κ after this increase, we will debit, among other queues, $Q_{I,\lambda }^a$ and its $d(Q_{I,\lambda }^a)$ becomes 1 too. It follows that $v(Q_{I,\lambda }^a)=d(Q_{I,\lambda }^a)$, and Lines 4–5 will make $Q_{I,\lambda }^a$ trivial and m becomes less than κ again.

We are now ready to define _I,λ,κ's estimate f̂_a([t, r_I]) of f_a([t, r_I]) and analyze its accuracy. We need some definitions. For any interval J = [p, q] and any t ∈ I, we say that J covers t if t ∈ [p, q], is to the right of t if t < p, and is to the left of t otherwise. For any item a and any t ∈ I = [ℓ_I, r_I], _I,λ,κ's estimate of f_a([t, r_I]) is

• f̂a([t, r_I]) = the value sum of the nodes N currently in $Q_{I,\lambda }^a$ whose i(N) covers or is to the right of t.

For example, in Figure 1, after the update of the last item (a, 1), we can obtain the estimate f̂_a([2, 8]) = 0 + 4 + 5 = 9.

Given any node N of $Q_{I,\lambda }^a$, we say that N is monitoring a over J, or simply N is monitoring J if i(N) = J. Note that a node may monitor different intervals during different periods of execution, and the size of these intervals are monotonically decreasing. Observe that although there are about W²/2 possible sub-intervals of size-W interval I, there are only about 2W of them that would be monitored by some nodes: there is only one such interval of size W, namely I = [ℓ_I, r_I], which gives birth to two such intervals of size W/2, namely [ℓ_I, m] and [m + 1, r_I] where m = ⌊(ℓ_I + r_I)/2⌋, and so on. We call these O(W) intervals interesting intervals. For any two interesting intervals J and H such that J ⊂ H, we say that J is a descendant of H, and H is an ancestor of J. Figure 2 shows all the interesting intervals for I = [1, 8], as well as their ancestor-descendant relationship. The following important fact is easy to verify by induction.

Fact 1

Any two interesting intervals J and H do not cross, although one can contain another, i.e., either J ⊂ H, or H ⊂ J, or J ∩ H = ∅. Furthermore, any interesting interval has at most logW ancestors.

For any node N, let (N) be the set of intervals that have been monitored by N so far. The following fact can be verified from the update procedure.

Fact 2

Consider a node N in $Q_{I,\lambda }^a$, where i(N) = J.

• If J covers or is to the right of t, then all intervals in (N) cover or are to the right of t.

• If J is to the left of t, then all intervals in (N) are to the left of t.

We say that N covers or is to the right of t if the intervals in (N) cover or are to the right of t; otherwise, N is to the left of t. For any queue $Q_{I,\lambda }^a$, let alive $(Q_{I,\lambda }^a)$ be the set of nodes currently in $Q_{I,\lambda }^a$, dead $(Q_{I,\lambda }^a)$ be those nodes of $Q_{I,\lambda }^a$ that have already been deleted (because of Line 5 of the procedure Process( )), and node $(Q_{I,\lambda }^a)=\text{alive}(Q_{I,\lambda }^a)\cup \text{dead}(Q_{I,\lambda }^a)$. Note that the estimate f̂_a([t, r_i]) is the value sum of the nodes in alive $(Q_{I,\lambda }^a)$ that cover or are to the right of t. For simplicity, we need to express it more succinctly. Let

$$\text{alive}({\mathcal{C}}_{I,\lambda ,\kappa })=\cup \{\text{alive}(Q_{I,\lambda }^a)\mid {\text{Q}}_{I,\lambda }^a\in {\mathcal{C}}_{I,\lambda ,\kappa }\}$$

be the set of nodes currently in _I,λ,κ. Define dead( _I,λ,κ) and node( _I,λ,κ) similarly. For any item a and any subset X ⊆ node( _I,λ,κ), let X^a be the set of nodes in X that are monitoring a (and thus are the nodes from $Q_{I,\lambda }^a$). For any t ∈ I, let X_≥t denote the set of nodes in X that cover or are to the right of t. Define v(X) = Σ_N∈X v(N) and d(X) = Σ_N∈X d(N). Then, f̂_a([t, r_I]) can be expressed as follows:

$${\widehat{f}}_a([t,r_I])=v(\text{alive}{(Q_{I,\lambda }^a)}_{\ge t})=v(\text{alive}{({\mathcal{C}}_{I,\lambda ,\kappa })}_{\ge t}^a)$$

The following theorem analyzes its accuracy, as well as gives the size of _I,λ,κ.

Lemma 3

For any t ∈ I, f_a([t, r_I]) − $\frac{1}{\kappa }$f_*(I) ≤ f̂_a([t, r_I]) ≤ f_a([t, r_I]) + λ logW. Furthermore, _I,λ,κ has size O(f_*(I)/λ + κ) words.

Proof

Recall that ${\widehat{f}}_a([t,r_I])=v(\text{alive}{(Q_{I,\lambda }^a)}_{\ge t})$. Consider any node N ∈ alive ${(Q_{I,\lambda }^a)}_{\ge t}$. Note that v(N) = Σ_{J∈ (N)} v_add(N, J) where v_add(N, J) is the value added to v(N) during the period when i(N) = J. By Fact 2, we can divide it as v(N) = Σ{v_add(N, J) | J covers t} + Σ {v_add(N, J) | J is to the right of t}. It follows that

$$\begin{array}{ll}v(\text{alive}{(Q_{I,\lambda }^a)}_{\ge t})\hfill & ={\sum }_{N\in \text{alive}{(Q_{I,\lambda }^a)}_{\ge t}}v(N)\hfill \\ \hfill & ={\sum }_{N\in \text{alive}{(Q_{I,\lambda }^a)}_{\ge t}}\sum \{v_{\text{add}}(N,J)\mid J\text{covers}t\}+{\sum }_{N\in \text{alive}{(Q_{I,\lambda }^a)}_{\ge t}}\sum \{v_{\text{add}}(N,J)\mid J\text{is to the right of}t\}\hfill \end{array}$$

(5)

Note that ${\sum }_{N\in \text{alive}{(Q_{I,\lambda }^a)}_{\ge t}}\sum \{v_{\text{add}}(N,J)\mid J\text{is to the right of}t\}\le f_a([t,r_I])$, because if an arrived item (a, u) causes an increase of v_add(N, J) for some J that is to the right of t, then u must be in [t, r_I]. By Equation (5), to show the second inequality of the lemma, it suffices to show that $S_o={\sum }_{N\in \text{alive}{(Q_{I,\lambda }^a)}_{\ge t}}\sum \{v_{\text{add}}(N,J)\mid J\text{covers}t\}=v_{\text{add}}(N_1,J_1)+v_{\text{add}}(N_2,J_2)+\cdots +v_{\text{add}}(N_{\kappa },J_{\kappa })$ is no greater than λ logW, as follows.

Without loss of generality, suppose |J₁| ≥ |J₂| ≥ ⋯≥ |J_κ|. It can be verified that once an interval J is assigned to a node, it will not be assigned to other nodes; thus the J_i's are distinct. Furthermore, note that for 1 ≤ i < k, J_κ ⊂ J_i because (i) t is in both J_i and J_κ; (ii) J_κ is the smallest interval; and (iii) interesting intervals do not cross; thus J_κ is a descendant of J_i, and together with Fact 1, k ≤ logW. By Line 3 of the procedure Update( ), v_add(N_i, J_i) ≤ λ for 1 ≤ i ≤ k. It follows that S_o ≤ λ logW.

For the first inequality of the lemma, it is clearer to use ${\widehat{f}}_a([t,r_I])=v(\text{alive}{({\mathcal{C}}_{I,\lambda ,\kappa })}_{\ge t}^a)$. Note that every arrived item (a, u) with u ∈ [t, r_I] increments the value of some node in node ${({\mathcal{C}}_{I,\lambda ,\kappa })}_{\ge t}^a$; thus ${\widehat{f}}_a([t,r_I])\le v(\text{node}{({\mathcal{C}}_{I,\lambda ,\kappa })}_{\ge t}^a)$ and

$${\widehat{f}}_a([t,r_I])-v(\text{alive}{({\mathcal{C}}_{I,\lambda ,\kappa })}_{\ge t}^a)\le v(\text{node}{({\mathcal{C}}_{I,\lambda ,\kappa })}_{\ge t}^a)-v(\text{alive}{({\mathcal{C}}_{I,\lambda ,\kappa })}_{\ge t}^a)=v(\text{dead}{({\mathcal{C}}_{I,\lambda ,\kappa })}_{\ge t}^a)$$

From Lines 4–6 of the procedure Process( ), when we delete a node N, v(N) = d(N). Hence, $v(\text{dead}{({\mathcal{C}}_{I,\lambda ,\kappa })}_{\ge t}^a)=d(\text{dead}{({\mathcal{C}}_{I,\lambda ,\kappa })}_{\ge t}^a)$, which is equal to the total number of debit operations made to these dead nodes. Since whenever we make a debit operation to $Q_{I,\lambda }^a$, we will make a debit operation to κ − 1 other queues,

$$\kappa \cdot d(\text{dead}{({\mathcal{C}}_{I,\lambda ,\kappa })}_{\ge t}^a)\le d(\text{node}({\mathcal{C}}_{I,\lambda ,\kappa }))\le v(\text{node}({\mathcal{C}}_{I,\lambda ,\kappa }))=f_{\ast }(I)$$

(6)

In summary, we have ${\widehat{f}}_a([t,r_I])-{\widehat{f}}_a([t,r_I])=f_a([t,r_I])-v(\text{alive}{({\mathcal{C}}_{I,\lambda ,\kappa })}_{\ge t}^a)\le v(\text{dead}{({\mathcal{C}}_{I,\lambda ,\kappa })}_{\ge t}^a)=v(\text{dead}{({\mathcal{C}}_{I,\lambda ,\kappa })}_{\ge t}^a)\le f_{\ast }(I)/\kappa$, and the first inequality of the lemma follows.

For the space, we say that a node is born-rich if it is created because of Line 5 of the procedure Update( ) (and thus has λ items under its belt); otherwise it is born-poor. Obviously, there are at most f_*(I)/λ born-rich nodes. For born-poor nodes, we need to store at most κ of them because every queue has one born-poor node (the rightmost one), and we only need to store at most κ non-trivial queues; the space bound follows.

If we set λ = λ_i = ∊2ⁱ/logW and $\kappa =\frac{1}{∊}$, then Lemma 3 asserts that ${\mathcal{C}}_{I,\lambda ,\kappa }={\mathcal{C}}_{I,{\lambda }_i,\frac{1}{∊}}$ is an $O(\frac{f_{\ast }(I)}{∊2^i}logW+\frac{1}{∊})$-space data structure that enables us to obtain, for any item a ∈ U and any timestamp t ∈ I, an estimate f̂_a([t, r_I]) that satisfies

$$f_a([t,r_I])-∊f_{\ast }(I)\le {\widehat{f}}_a([t,r_I])\le f_a([t,r_I])+∊2^i$$

If f_*(I) does not vary too much, we can determine the i such that f_* (I) ≈ 2ⁱ, and ${\mathcal{C}}_{I,\lambda ,\kappa \frac{1}{∊}}$ is an $O(\frac{1}{∊}logW)$ space data structure that guarantees an error bound of O(∊f_*(I)). However, this approach has two obvious shortcomings:

• f_*(I) may vary from some small value to a value as large as B, the maximum number of items falling in a window of size W; hence, there may not be any fixed i that always satisfies f_* (I) ≈ 2ⁱ

• To estimate f_a([t, r_I]), we need an error bound of ∊f_*([t, r_I]), not ∊f_*(I).

We will explain how to overcome these two shortcomings in the next section.

4. Our Data Structure for ∊-approximate Counting

The first shortcoming of the approach given in Section 3 is easy to overcome: a natural idea is to maintain ${\mathcal{C}}_{I,\lambda ,\kappa \frac{1}{∊}}$ for different λ_i to handle different possible values of f_*(I). The second shortcoming is more fundamental. To overcome it, we need to modify _I,λ,κ substantially The result is a new and complicated data structure ${\mathcal{D}}_{I,∊}^Y$, where Y is an integer determining the accuracy As asserted in Theorem 7 below, this data structure uses $O(\frac{1}{∊}logWloglogW)$ space, supports $O(log\frac{1}{∊}+loglogW)$ update time, and for any t ∈ I, it offers the following special guarantee:

• When $f_{\ast }([t,r_I])\le Y,{\mathcal{D}}_{I,∊}^Y$ can return, for any item a, an estimate f̂_a([t, r_I]) of f_a([t, r_I]) such that |f̂_a([t, r_I])−f_a([t, r_I])|≤∊Y.

• When $f_{\ast }([t,r_I])>Y,{\mathcal{D}}_{I,∊}^Y$ does not have any error bound on its estimate f̂_a([t, r_I]).

Before giving the details of ${\mathcal{D}}_{I,∊}^Y$, let us explain how to use it to build the data structure _I,∊ mentioned in Section 2 for the ∊-approximate counting problem. To build _I,∊, we need another $O(\frac{1}{∊}logWlog\frac{∊B}{logW})$-space data structure _I,∊, which is a simple adaption of the data structure _∊ of Cormode et al. [1] for the ∊-approximate basic counting problem; _I,∊ enables us to find, for any t ∈ I, an estimate f̂_*([t, r_I]) of f_*([t, r_I]) such that

$$f_{\ast }([t,r_I])\le {\widehat{f}}_a([t,r_I])\le (1+∊)f_{\ast }([t,r_I])$$

(7)

_I,∊ is implemented as follows. During execution, we maintain the data structure _∊/4 of Cormode et al. to count the items in the sliding window. When τ_cur = r_I, we duplicate _∊/4 and get ′. Then, ′ is updated as if τ_cur was fixed at r_I. To get the estimate f̂_*([t, r_I]), we first obtain an estimate f′ of f_*([t, r_I]) from ′, which satisfies $|f^{\prime }-f_{\ast }([t,r_I])|\le \frac{∊}{4}{f}_{\ast }([t,r_I])$. Then, ${\widehat{f}}_{\ast }-([t,r_I])=\frac{1}{1-∊/4}{f}^{\prime }$. It can be verified that f̂_*([t, r_I]) satisfies Equation (7). Our data structure _I,∊ is composed of (i) _I,∊, and (ii) ${\mathcal{D}}_{I,∊/4}^{2^i}$ for each integer i from $log(\frac{1}{∊}logW)+1\text{to}logB$. It also maintains a brute-force $O(\frac{1}{∊}logW)$-space data structure for remembering the $\frac{1}{∊}logW$ items (a, u) with the largest u ∈ I; this brute-force data structure will be used for finding f̂_a([t, r_I]) only when $f_{\ast }([t,r_I])\le \frac{1}{∊}logW$.

Theorem 4

• The data structure _I,∊ has size $O(\frac{1}{∊}(loglogW)(logW)log(\frac{∊B}{logW}))$ words, and supports $O((log\frac{1}{∊}+loglogW)log(\frac{∊B}{logW}))$ update time.

• Given _I,∊, we can find, for any a ∈ Σ and t ∈ I, an estimate of f̂_a([t, r_I]) of f_a([t, r_I]) such that |f̂_a([t, r_I]) − f_a([t, r_I])| ≤ ∊f_*([t, r_I]).

Proof

Statement (i) is straightforward because there are $logB-log(\frac{1}{∊}logW)$ different ${\mathcal{D}}_{I,∊}^Y$, each has size $O(\frac{1}{∊}(loglogW)logW)$ and takes $O(log\frac{1}{∊}+loglogW)$ time for an update. For Statement (ii), we describe how to get the estimate and analyze its accuracy.

First, we use _I,∊ to get the estimate f̂_*([t, r_I]). If ${\widehat{f}}_{\ast }([t,r_I])\le \frac{1}{∊}logW$, then $f_{\ast }([t,r_I])\le {\widehat{f}}_{\ast }([t,r_I])\le \frac{1}{∊}logW$ and we can use the brute-force data structure to find f_a([t, r_I]) exactly. Otherwise, we determine the i with 2ⁱ⁻¹ < f̂_*([t, r_I]) ≤ 2ⁱ. Note that

• $i\ge log(\frac{1}{∊}logW)+1$ and we have the data structure ${\mathcal{D}}_{I,\frac{∊}{4}}^{2^i}$, and

• f_*([t, r_I]) ≤ f̂_*([t, r_I]) ≤ 2ⁱ.

We use ${\mathcal{D}}_{I,\frac{∊}{4}}^{2^i}$ to obtain an estimate f̂_a([t, r_I]) with $|{\widehat{f}}_a([t,r_I])-f_a([t,r_I])|\le (\frac{∊}{4})2^i$. By Equation (7), 2ⁱ⁻¹ < f̂_*([t, r_I]) ≤ (1 + ∊)f_*([t, r_I]). Combining the two inequalities we have

$$|{\widehat{f}}_a([t,r_I])|-f_a([t,r_I])|\le 2(\frac{∊}{4})(2^{i-1})<2(\frac{∊}{4})(1+∊)f_{\ast }([t,r_I])\le ∊f_{\ast }([t,r_I])$$

We now describe the construction of ${\mathcal{D}}_{I,∊}^Y$. First, we describe an $O(\frac{1}{∊}{(logW)}^2)$-space version of the data structure. Then, we show in the next section how to reduce the space to $O(\frac{1}{∊}loglogWlogW)$. In our discussion, we fix λ = ∊Y/logW and $\kappa =\frac{4}{∊}logW$.

Initially, ${\mathcal{D}}_{I,∊}^Y$ is just the data structure _I,λ,κ. By Lemma 3, we know that its size is $O(\frac{f\ast (I)}{\lambda }+\kappa )=O(\frac{f\ast (I)}{∊Y}logW+\frac{1}{∊}logW)$, which is $O(\frac{1}{∊}logW)$ when f_*(I) ≤ Y. However, it is much larger than $\frac{1}{∊}logW$ when f_*(I) ≫ Y, and to maintain small space usage in such case, we trim _I,λ,κ by throwing away a significant number of nodes. This is acceptable because _I,λ,κ only guarantees good estimates for those t ∈ I with f_*([t, r_I]) ≤ Y. The trimming process is rather tricky. The natural idea of throwing away all the nodes to the left of t when we find f_*([t, r_I]) > Y does not work because the resulting data structure may return estimates with error larger than the required ∊Y bound. For example, let I = [1, W]. For each item a_i ∈ {a₁, a₂, …, a_κ−1}, there are m = Y/κ copies of (a_i, t + 1) arrive at time W + t for every t ∈ [0, W − 1]. Also, there are m copies of (a, W) arrive at time W + t for every t ∈ [0, W − 1]. Hence, at each time W + t, there are mκ = Y items with timestamps in [t, W] arrives, m items for each of the κ item name in {a, a₁, …, a_κ−1}. We are interested in the accuracy of the estimate f̂_a([W, W]). It can be verified that at each time W + t, Lines 4–5 of the procedure Process( ) will eventually trivialize $Q_{I,\lambda }^a$ and thus f̂_a([W, W]) = 0. Since f_a([W, W]) = (t + 1)m, |f̂_a([W, W]) − f_a([W, W])| = (t + 1)m. When t = 2∊Y/m − 1, the absolute error is 2∊Y which is larger than the required error bound ∊Y.

To describe the right trimming procedure, we need some basic operations. Consider any _J,λ,κ where J = [p, q]. The following operation splits _J,λ,κ into two smaller data structures _Jℓ,λ,κ and _Jr,λ,κ where J_t = [p, m] and J_r = [m+ 1, q] with m = ⌊(p + q)/2⌋.

${\mathcal{D}}_{I,∊}^Y$.Split( J,λ,κ)
1:	for each non-trivial queue ${\mathcal{Q}}_{J,\lambda }^a\in {\mathcal{C}}_{J,\lambda ,\kappa }$ do
2:	if ( $Q_{J,\lambda }^a$ has only one node N monitoring the whole interval J) then
3:	/* refine J */
4:	insert a new node N′ immediately to the left of N with v(N′) = d(N′) = 0;
5:	i(N′) = Jℓ, and i(N) = Jr;
6:	end if
7:	divide ${\mathcal{Q}}_{J_r,\lambda }^a$ into two sub-queues and where
8:	${\mathcal{Q}}_{J_{\ell },\lambda }^a$ contains the nodes monitoring some sub-intervals of Jℓ, and
9:	${\mathcal{Q}}_{J_r,\lambda }^a$ contains those monitoring some sub-intervals of Jr;
10:	put ${\mathcal{Q}}_{J_r,\lambda }^a$ in Jℓ,λ,κ and in Jr,λ,κ.
11:	end for
12:	/* For a trivial ${\mathcal{Q}}_{J,\lambda }^a$, its two children in Jℓ,λ,κ and Jr,λ,κ are also trivial. */

We say that _Jℓ,λ,κ and _Jr,λ,κ are the left and right child of _Jr,λ,κ, respectively. Figure 3 gives an example of Split( _[1,8],λ,κ), the split of _[1,8],λ,κ, which has three non-trivial queues $Q_{I,\lambda }^a$, $Q_{I,\lambda }^b$ and $Q_{I,\lambda }^c$, into _{[1, 4],λ,κ} and _{[5, 8],λ,κ}. Note that the queues for b and c in _{[1, 4],λ,κ} are trivial and we have not stored them.

Using Split( ), we can trim, for example, _{[p,p+1],λ,κ} into _{[p+1,p+1],λ,κ} as follows: Split _{[p,p+1],λ,κ} into _[p,p],λ,κ and _{[p+1,p+1],λ,κ}, and throw away _{[p, p],λ,κ}. The following recursive procedure LeftRefine( ) generalizes this idea for larger J: Given _J,λ,κ = _{[p, q],λ,κ}, it returns a list 〈 _J0,λ,κ, _J1,λ,κ, …, _Jm,λ,κ〉 where the J_i's form a partition of [p, q], and J₀ = [p, p]. Throwing away _J0,λ,κ, and the remaining _Ji,λ,κ's all together monitor [p + 1, q].

${\mathcal{D}}_{I,∊}^Y$.LeftRefine ( [p,q],λ,κ)
1:	if (|[p, q]| = |[p, p]| = 1) then
2:	return 〈 [p,p],λ,κ〉;
3:	else
4:	split [p,q],λ,κ into its left child [p, m],λ,κ and right child [m+1,q],λ,κ
5:	/* where m = ⌊(p + q)/2⌋ */;
6:	L = LeftRefine( [p, m],λ,κ);
7:	suppose L = 〈 J0,λ,κ, J1,λ,κ, …, Jk,λ,κ〉;
8:	return 〈 J0,λ,κ, …, Jk,λ,κ [m+1,q],λ,κ〉;
9:	end if

For example, LeftRefine( _[1,8],λ,κ) gives us the list 〈 _[1,1],λ,κ, _{[2, 2],λ,κ}, _{[3, 4],λ,κ}, _[5,8],λ,κ〉. Note that J₀ = [p, p] because the recursion stops only when |[p, q]| = 1. The list returned by LeftRefine( _{[p, q],λ,κ}) has another useful property, which we describe below.

Given L = 〈 _Z1,λ,κ, …, _Zk,λ,κ), we say that L is an interesting-partition covering the interval J if (i) the Z_i's are all interesting intervals and form a partition of J; and (ii) for 1 ≤ i < k, Z_i is to the left of Z_i+1, and $|Z_i|\le \frac{1}{2}|Z_{i+1}|$. The fact below can be verified by induction on the length of the list returned by LeftRefine( ).

Fact 3

Let J be an interesting interval, and L = 〈 _J0,λ,κ, …, _Jm,λ,κ〉 be the list returned by LeftRefine( _J,λ,κ). Then, the list 〈 _J1,λ,κ, …, _Jm,λ,κ 〉 (i.e., the list obtained by throwing away the head _J0,λ,κ of L) is an interesting-partition covering [p + 1, q].

For example, if [1, 8] is an interesting interval, then the list 〈 _{[2,2],λ,κ [3,4],λ,κ [5,8],λ,κ}〉 obtained by throwing away the first element _[1,1],λ,κ from LeftRefine( _[1,8],λ,κ) is an interesting-partition covering [2, 8].

We now give details of ${\mathcal{D}}_{I,∊}^Y$. Initially, it is the interesting-partition 〈C_I,λ,κ 〉 covering the whole interval I = [ℓ_I, r_I]. Throughout the execution, we maintain the following invariant:

• (**) ${\mathcal{D}}_{I,∊}^Y$ is an interesting-partition covering some [p, r_I] ⊆ I.

When ${\mathcal{D}}_{I,∊}^Y=\langle {\mathcal{C}}_{J_1,\lambda ,\kappa },\dots ,{\mathcal{C}}_{J_m,\lambda ,\kappa }\rangle$ is covering [p, r_I], it only guarantees good estimates of f_a([t, r_I]) for t ∈ [p, r_I], and this estimate is obtained by

$${\widehat{f}}_a([t,r_I])=v(\text{alive}{({\mathcal{C}}_{J_h,\lambda ,\kappa })}_{\ge t}^a)+{\sum }_{h+1\le i\le m}v(\text{alive}{({\mathcal{C}}_{J_i,\lambda ,\kappa })}^a)$$

(or equivalently, ${\widehat{f}}_a([t,r_I])=v(\text{alive}{(Q_{J_h,\lambda }^a)}_{\ge t})+{\sum }_{h+1\le i\le m}v(\text{alive}(Q_{J_i,\lambda }^a))$, where J_h is the interval in {J₁, J₂, …, J_m} that covers t. When an item (a, u) with u ∈ [p, r_I] arrives, we find the unique _Ji,λ,κ in ${\mathcal{D}}_{I,∊}^Y$ where u ∈ J_i, update it by calling _Ji,λ,κ. Process((a, u)). Note that this update has no effect on the other _J,λ,κ in ${\mathcal{D}}_{I,∊}^Y$.

During execution, we also keep track of the largest timestamp p_max ∈ I such that the estimate f̂_*(p_max,r_I]) given by _I,∊ is greater than (1 + ∊)Y (which implies f_*([p_max,r_I]) > Y because of Equation (7)). As soon as p_max falls in the interval covered by ${\mathcal{D}}_{I,∊}^Y$, we use the following procedure to trim ${\mathcal{D}}_{I,∊}^Y$ to cover the smaller interval [p_max + 1, r_I].

Suppose that L = 〈 _J1,λ,κ, …, _Ji,λ,κ) is an interesting-partition covering [p, r_I], and t ∈ [p, r_I]. Trim(L, t) constructs an interesting-partition covering [t + 1, r_I] recursively as follows.

${\mathcal{D}}_{I,∊}^Y$.Trim(L, t)
1:	find the unique Ji,λ,κ in L such that t ∈ Ji;
2:	L′ =LeftRefine( Ji,λ,κ);
3:	suppose L′ = 〈 K0,λ,κ, …, K1,λ,κ, Kℓ,λ,κ〉;
4:	if (K0 = [t, t]) then
5:	return 〈 K1,λ,κ, …, Kℓ,λ,κ, Ji+1,λ,κ, Jm,λ,κ 〉;
6:	/* i.e., throw away J1,λ,κ, …, Ji−1,λ,κ, and K0,λ,κ, */
7:	/* and return an interesting-partition covering [t + 1, rI]. */
8:	else
9:	return Trim(〈 K1,λ,κ, …, Kℓ,λ,κ, Ji+1,λ,κ, Jm,λ,κ 〉, t).
10:	/* throw away J1,λ,κ, …, Ji−1,λ,κ and K0,λ,κ */
11:	end if

For example, Figure 4 shows that when ${\mathcal{D}}_{I,∊}^Y=\langle {\mathcal{C}}_{[2,2],\lambda ,\kappa },{\mathcal{C}}_{[3,4],\lambda ,\kappa },{\mathcal{C}}_{[5,8],\lambda ,\kappa }\rangle$, $\text{Trim}({\mathcal{D}}_{I,∊}^Y,3)$ return 〈 _[4,4],λ,κ, _[5,8],λ,κ 〉. Based on Fact 3, it can be verified inductively that after ${\mathcal{D}}_{I,∊}^Y\leftarrow \text{Trim}({\mathcal{D}}_{I,∊}^Y,p_{max})$, the new ${\mathcal{D}}_{I,∊}^Y$ is an interesting-partition covering [p_max + 1, r_I]; Invariant (**) is preserved. In the rest of this section, we analyze the size of ${\mathcal{D}}_{I,∊}^Y$ and the accuracy of its estimates.

Let All be the set of all _J,λ,κ's that ever exist, i.e., if _J,λ,κ ∈ All, then either (i) it is currently in ${\mathcal{D}}_{I,∊}^Y$, or (ii) it has been in ${\mathcal{D}}_{I,∊}^Y$ some time earlier in the execution, but is thrown away during some trimming of ${\mathcal{D}}_{I,∊}^Y$. For any p ∈ I, define

$${\text{ALL}}_{\ge p}=\{{\mathcal{C}}_{J,\lambda ,\kappa }\mid {\mathcal{C}}_{J,\lambda ,\kappa }\in \text{ALL},\text{and}J\text{covers or is to the right of}p\}$$

Let v_add( _J,λ,κ) be the total value added to the nodes of _J,λ,κ during its lifespan. We now derive an upper bound on Σ _{J,λ,κ ∈ All≥p} v_add( _J,λ,κ), which is crucial for getting a tight error bound on the accuracy of ${\mathcal{D}}_{I,∊}^Y$'s estimates.

Recall that initially ${\mathcal{D}}_{I,∊}^Y=\langle {\mathcal{C}}_{I,\lambda ,\kappa }\rangle$ and thus _I,λ,κ ∈ All. For any other _J,λ,κ ∈ All, _J,λ,κ must be a child of some _H,λ,κ ∈ All (i.e., _J,λ,κ is obtained from Split( _H,λ,κ))- Given _J,λ,κ and _H,λ,κ, we say that _J,λ,κ is a descendant of _H,λ,κ, and _H,λ,κ is an ancestor of _J,λ,κ, if either (i) _J,λ,κ is a child of _H,λ,κ, or (ii) it is a child of some of _H,λ,κ's descendants. Note that the original _I,λ,κ is an ancestor of every _J,λ,κ ∈ All, and in general, any _H,λ,κ ∈ All is an ancestor of every _J,λ,κ ∈ All with J ⊂ H. We have the following lemma. (Note that we are abusing the notation here and regard ${\mathcal{D}}_{I,∊}^Y$ as a set.)

Lemma 5

Suppose that ${\mathcal{D}}_{I,∊}^Y=\langle {\mathcal{C}}_{J_1,\lambda ,\kappa },\dots ,{\mathcal{C}}_{J_m,\lambda ,\kappa }\rangle$ is covering [p, r_I]. Let $\mathit{\text{anc}}({\mathcal{D}}_{I,∊}^Y)=\mathit{\text{anc}}(\langle {\mathcal{C}}_{J_1,\lambda ,\kappa },\dots ,{\mathcal{C}}_{J_m,\lambda ,\kappa }\rangle )$ be the set $\{{\mathcal{C}}_{H,\lambda ,\kappa }\mid {\mathcal{C}}_{H,\lambda ,\kappa }\mathit{\text{is an ancestor of some}}{\mathcal{C}}_{J_i,\lambda ,\kappa }\in {\mathcal{D}}_{I,∊}^Y\}$. Then,

• ${\text{ALL}}_{\ge p}\subseteq {\mathcal{D}}_{I,∊}^Y\cup \mathit{\text{anc}}({\mathcal{D}}_{I,∊}^Y)$,

• v_add( _J,λ,κ) ≤ (1 + ∊)Y for any _J,λ,κ ∈ All, and

• $|{\mathcal{D}}_{I,∊}^Y\cup \mathit{\text{anc}}({\mathcal{D}}_{I,∊}^Y)|\le 2logW$.

Therefore, Σ{v_add( _J,λ,κ) | _J,λ,κ ∈ All_≥p} ≤ 2(1 + ∊)Y logW.

Proof

For (1), it suffices to prove that for any ${\mathcal{C}}_{J,\lambda ,\kappa }\in {\text{ALL}}_{\ge p},{\mathcal{C}}_{J,\lambda ,\kappa }\in {\mathcal{D}}_{I,∊}^Y\cup \text{anc}({\mathcal{D}}_{I,∊}^Y)$. By definition, J covers or is to the right of p; thus J ∩ (J₁ ∪ ⋯ ∪ J_m) = J ∩ [p, r_I] ≠ ∅. Since the intervals are interesting and do not cross, there is an 1 ≤ i ≤ m such that either (i) J = J_i, and thus ${\mathcal{C}}_{J,\lambda ,\kappa }\in {\mathcal{D}}_{I,∊}^Y$, or (ii) J_i ⊂ J, which implies _J,λ,κ is an ancestor of _J,λ,κ, i.e., ${\mathcal{C}}_{J,\lambda ,\kappa }\in \text{anc}({\mathcal{D}}_{I,∊}^Y)$. (It is not possible that J ⊂ J_i, otherwise _Ji,λ,κ would have been split and should not be in the current ${\mathcal{D}}_{I,∊}^Y$. Hence, ${\mathcal{C}}_{J,\lambda ,\kappa }\in {\mathcal{D}}_{I,∊}^Y\cup \text{anc}({\mathcal{D}}_{I,∊}^Y)$.

To prove (2), suppose that J = [x, y] and v_add( _J,λ,κ) has just reached (1 + ∊)Y. This implies f_*([x, r_I]) ≥ (1 + ∊)Y, and so does its estimate f̂_*([x, r_I]) given by _I,∊ (as f_*([x, r_I]) ≤ f̂_*([x, r_I]), by Equation (7)). Then, the procedure Trim( ) will be called and _J,λ,κ will be either thrown away or split, and no more value can be added to _J,λ,κ. It follows that v_add( _J,λ,κ) ≤ (1 + ∊)Y.

For (3), recall that ${\mathcal{D}}_{I,∊}^Y=\langle {\mathcal{C}}_{J_1,\lambda ,\kappa },{\mathcal{C}}_{J_2,\lambda ,\kappa },\dots ,{\mathcal{C}}_{J_m,\lambda ,\kappa }\rangle$. Among the intervals J₁, …, J_m, interval J₁ is the leftmost interval and its left boundary ℓ_J1 = p. We now prove that ${\mathcal{D}}_{I,∊}^Y\cup \text{anc}({\mathcal{D}}_{I,∊}^Y)={\mathcal{D}}_{I,∊}^Y\cup \text{anc}({\mathcal{C}}_{J_1,\lambda ,\kappa })$ where anc( _J1,λ,κ) is the set of ancestors of _J1,λ,κ. Then, together with the facts that $|{\mathcal{D}}_{I,∊}^Y|\le logW$ (by Property (ii) of interesting-partition) and |anc( _J1,λ,κ)| ≤ logW (as each Split operation would reduce the size of interval by half), we have

$$|{\mathcal{D}}_{I,∊}^Y\cup \text{anc}({\mathcal{D}}_{I,∊}^Y)|=|{\mathcal{D}}_{I,∊}^Y\cup \text{anc}({\mathcal{C}}_{J_1,\lambda ,\kappa })|\le |{\mathcal{D}}_{I,∊}^Y|+|\text{anc}({\mathcal{C}}_{J_1,\lambda ,\kappa })|\le 2logW$$

To show ${\mathcal{D}}_{I,∊}^Y\cup \text{anc}({\mathcal{D}}_{I,∊}^Y)={\mathcal{D}}_{I,∊}^Y\cup \text{anc}({\mathcal{C}}_{J_1,\lambda ,\kappa })$, it suffices to show that for any ${\mathcal{C}}_{H,\lambda ,\kappa }\in \text{anc}({\mathcal{D}}_{I,∊}^Y)$, _H,λ,κ ∈ anc( _J1,λ,κ). Since ${\mathcal{C}}_{H,\lambda ,\kappa }\in \text{anc}({\mathcal{D}}_{I,∊}^Y)$, it is the ancestor of some ${\mathcal{C}}_{J_i,\lambda ,\kappa }\in ({\mathcal{D}}_{I,∊}^Y)$. Thus J_i = [ℓ_ji, r_ji] ⊂ H = [ℓ_H, r_H]. Since _H,λ,κ is already an ancestor, it no longer exists, and all the _J,λ,κ to its left have been thrown away. Thus, ${\mathcal{D}}_{I,∊}^Y$ has no _J,λ,κ where J is to the right of ℓ_H. This implies ℓ_H ≤ p = ℓ_J1 and ℓ_H ≤ ℓ_J1 ≤ r_J1 ≤ r_Ji ≤ r_H. It follows that J₁ ⊂ H and _H,λ,κ is an ancestor of _J1,λ,κ, i.e., _H,λ,κ ∈ anc( _J1,λ,κ).

We are now ready to analyze the accuracy of ${\mathcal{D}}_{I,∊}^Y$'s estimates.

Theorem 6

Suppose that ${\mathcal{D}}_{I,∊}^Y$ is covering [p, r_I]. For any item a and any t ∈ [p, r_I], the estimate f̂_a([t, r_I]) of f_a([t, r_I]) obtained by ${\mathcal{D}}_{I,∊}^Y$ satisfies |f̂_a([t, r_I]) − f_a([t, r_I])| ≤ ∊Y. Furthermore, ${\mathcal{D}}_{I,∊}^Y$ uses $O(\frac{1}{∊}{(logW)}^2)$ space.

Proof

Let alive $({\mathcal{D}}_{I,∊}^Y)$ be the set of nodes currently in ${\mathcal{D}}_{I,∊}^Y,\text{dead}({\mathcal{D}}_{I,∊}^Y)$ the set of those that were in ${\mathcal{D}}_{I,∊}^Y$ earlier in the execution but have been deleted, and $\text{node}({\mathcal{D}}_{I,∊}^Y)=\text{alive}({\mathcal{D}}_{I,∊}^Y)\cup \text{dead}({\mathcal{D}}_{I,∊}^Y)$. It can be verified that ${\widehat{f}}_a([t,r_I])=v(\text{alive}{({\mathcal{D}}_{I,∊}^Y)}_{\ge t}^a)$. Below, we prove that

$${\widehat{f}}_a([t,r_I])-\frac{2(1+∊)Y}{\kappa }logW\le v(\text{alive}{({\mathcal{D}}_{I,∊}^Y)}_{\ge t}^a)\le f_a([t,r_I])+\lambda logW$$

(8)

Recall that we fix λ = ∊Y/logW and $\kappa =\frac{4}{∊}logW$; the ∊Y error bound follows.

The proof of the second inequality of Equation (8) is identical to that of Lemma 3, except that we replace all occurrences of _J,λ,κ by ${\mathcal{D}}_{I,∊}^Y$. The proof of the first inequality is also similar. We still have

$$f_a([t,r_I])-v(\text{alive}{({\mathcal{D}}_{I,∊}^Y)}_{\ge t}^a)\le v(\text{node}{({\mathcal{D}}_{I,∊}^Y)}_{\ge t}^a)-v(\text{alive}{({\mathcal{D}}_{I,∊}^Y)}_{\ge t}^a)=v(\text{dead}{({\mathcal{D}}_{I,∊}^Y)}_{\ge t}^a)$$

which equals $d(\text{dead}{({\mathcal{D}}_{I,∊}^Y)}_{\ge t}^a)$. As in Lemma 3, we can derive the bound $d(\text{dead}{({\mathcal{D}}_{I,∊}^Y)}_{\ge t}^a)\le \frac{1}{\kappa }v(\text{node}({\mathcal{D}}_{I,∊}^Y))=\frac{1}{\kappa }{f}_{\ast }(I)$, but we can do better here.

Observe that for any node $N\in \text{dead}({({\mathcal{D}}_{I,∊}^Y)}_{\ge t}^a)$, N can only be in those _J,λ,κ ∈ All_≥p (because t ∈ [p, r_I]), and when we debit N, if it is in _J,λ,κ, then we debit κ − 1 other nodes in _J,λ,κ monitoring κ − 1 items other than a. Thus, $\kappa \cdot d(\text{dead}({({\mathcal{D}}_{I,∊}^Y)}_{\ge t}^a))$ is no more than the total value available in the _J,λ,κ ∈ All_≥p, which is Σ {v_add( _J,λ,κ) | _J,λ,κ ∈ All_≥p}. Together with Lemma 5 we conclude

$$\kappa \cdot d(\text{dead}{({\mathcal{D}}_{I,∊}^Y)}_{\ge p}^a)\le \sum \{v_{\text{add}}({\mathcal{C}}_{J,\lambda ,\kappa })|{\mathcal{C}}_{J,\lambda ,\kappa }\in {\text{ALL}}_{\ge p}\}\le 2(1+∊)YlogW$$

and the first inequality of Equation (8) follows.

For the size of ${\mathcal{D}}_{I,∊}^Y$, similar to the proof of Lemma 3, we can argue that the number of born-rich nodes is only $O(Y/\lambda )=O(\frac{1}{∊}logW)$, but the number of born-poor nodes can be much larger. A born-poor node of a non-trivial queue is created either when we increase the value of a trivial queue, or when we execute Lines 2-6 of procedure Split. It can be verified that every queue $Q_{J,\lambda }^a$ has at most one born-poor node, which is the rightmost node in $Q_{J,\lambda }^a$. Since there are O(logW) _J,λ,κ's in ${\mathcal{D}}_{I,∊}^Y$ and each has at most κ non-trivial queues, the number of born-poor nodes, and hence the size of ${\mathcal{D}}_{I,∊}^Y$, is $O(\kappa logW)=O(\frac{1}{∊}{(logW)}^2)$.

To reduce ${\mathcal{D}}_{I,∊}^Y$'s size from $O(\frac{1}{∊}{(logW)}^2)$ to $O(\frac{1}{∊}loglogWlogW)$, we need to reduce the number of born-poor nodes; or equivalently, the number of non-trivial queues in ${\mathcal{D}}_{I,∊}^Y$. In the next section, we give a simple idea to reduce the number of non-trivial queues and hence the size of ${\mathcal{D}}_{I,∊}^Y$ to $O(\frac{1}{∊}loglogWlogW)$. In Section 6, we show how to further reduce the size by taking advantage of the tardiness of the data stream.

5. Reducing the Size of ${\mathcal{D}}_{I,∊}^Y$

Our idea for reducing the size is simple; for every ${\mathcal{C}}_{J,\lambda ,\kappa }\in {\mathcal{D}}_{I,∊}^Y$, its capacity is no longer fixed at $\kappa =\frac{4}{∊}logW$; instead, we start with a much smaller capacity, namely $\frac{4}{∊}loglogW$, which is allowed to increase gradually during execution. To determine _J,λ,κ's capacity, we use a variable to keep track of the number f̄_*(J) of items (a, u) with u ∈ J that have arrived since _J,λ,κ's creation. Let v_J be the total value of the nodes in _J,λ,κ when it is created (v_J may not be zero if _J,λ,κ is resulted from the splitting of its parent). The capacity of _J,λ,κ is determined as follows.

• When $\frac{(c-1)}{logW}\le v_J+{\overline{f}}_{\ast }(J)<\frac{cY}{logW}$ for some integer c ≥ 1, the capacity of _J,λ,κ is $\kappa (c)=\frac{4c}{∊}loglogW$, i.e., set κ = κ(c) and allow κ(c) non-trivial queues in _J,λ,κ.

Note that when we increase the capacity of _J,λ,κ to κ(c), we do not need to do anything, except that we allow more non-trivial queues (up to κ(c)) in the data structure. Also note that when _J,λ,κ is created during the trimming process, its inherited capacity may be larger than the supposed capacity κ(c); in such case, we simply debit every non-trivial queue until some queue $Q_{J,\lambda }^a$ has $v(Q_{I,\lambda }^x)=d(Q_{I,\lambda }^x)$ and we execute Lines 4 and 5 of the procedure Process( ) to make this queue trivial. We repeat the process until the number of non-trivial queues is at most κ(c). The following theorem asserts that ${\mathcal{D}}_{I,∊}^Y$ maintains the accuracy of its estimates under this new implementation. It gives the revised size and the update time.

Theorem 7

• Suppose that ${\mathcal{D}}_{I,∊}^Y$ is currently covering [p, r_I]. For any item a ∈ Σ and any timestamp t ∈ [p, r_I], the estimate f̂_a([t, r_I]) of f̂_a([t, r_I]) obtained by the new ${\mathcal{D}}_{I,∊}^Y$ satisfies |f̂_a([t, r_I]) − f_a([t, r_I])| ≤ ∊Y.

• ${\mathcal{D}}_{I,∊}^Y$ has size $O(\frac{1}{∊}(loglogW)logW)$, and supports $O(log\frac{1}{∊}+loglogW)$ update time.

Proof

Suppose that ${\mathcal{D}}_{I,∊}^Y=\langle {\mathcal{C}}_{J_1,\lambda ,\kappa (c_1)},\dots ,{\mathcal{C}}_{J_m,\lambda ,\kappa (cm)}\rangle$. From the fact that we are using _Ji,λ,κ(ci) to monitor J_i we conclude $\frac{(c_i-1)Y}{logW}\le v_{J_i}+{\overline{f}}_{\ast }(J_i)$. It follows that ${\sum }_{1\le i\le m}\frac{c_{i}Y}{logW}\le {\sum }_{1\le i\le m}(v_{J_i}+{\overline{f}}_{\ast }(J_i))+{\sum }_{1\le i\le m}\frac{Y}{logW}$, which is O(Y) because (i) $|{\mathcal{D}}_{I,∊}^Y|=m=O(logW)$ and (ii) ${\sum }_{1\le i\le m}(v_{J_i}+{\overline{f}}_{\ast }(J_i))=O(Y)$ (otherwise ${\mathcal{D}}_{I,∊}^Y$ would have been trimmed). Thus,

$${\sum }_{1\le i\le m}{c}_i=O(logW)$$

(9)

For Statement (1), the analysis of the accuracy of f̂_a([t, r_I]) is very similar to that of Theorem 6, except for the following difference: In the proof of Theorem 6, we show that $d(\text{dead}{({\mathcal{D}}_{I,∊}^Y)}_{\ge p}^a)\le \frac{2(1+∊)Y}{\kappa }logW$, and since κ is fixed at $\frac{4}{∊}logW$, $d(\text{dead}{({\mathcal{D}}_{I,∊}^Y)}_{\ge p}^a)\le ∊Y$. Here, we also prove that $d(\text{dead}{({\mathcal{D}}_{I,∊}^Y)}_{\ge p}^a)\le ∊Y$, but we have to prove it differently because the capacities are no longer fixed.

As argued previously, any node in $\text{dead}{({\mathcal{D}}_{I,∊}^Y)}_{\ge p}^a$ is in some _J,λ,κ ∈ All_≥p. Below, we show that for any _J,λ,κ ∈ All_≥p, we can make at most $\frac{∊Y}{2logW}$ debit operations to the queue $Q_{J,\lambda }^a$ of _J,λ,κ during its lifespan. Together with the fact that |All_≥p| ≤ 2 logW, we have $d(\text{dead}{({\mathcal{D}}_{I,∊}^Y)}_{\ge p}^a)\le ∊Y$.

Consider any _J,λ,κ ∈ All_≥p. Note that the smaller its capacity, the larger the number of debit operations can be made to the queue $Q_{J,\lambda }^a$ of _J,λ,κ. To maximize the number of debit operations made to $Q_{J,\lambda }^a$, suppose that v_J = 0 and thus _J,λ,κ has the smallest capacity κ(1) when it is created. Before increasing its capacity to κ(2), _J,λ,κ can make at most $\frac{1}{\kappa (1)}\cdot \frac{Y}{logW}$ debit operations to $Q_{J,\lambda }^a$. Then, during the next $\frac{Y}{logW}$ arrivals of items (a, u) with $u\in J,\frac{Y}{logW}\le v_J+{\overline{f}}_{\ast }(J)<\frac{2Y}{logW}$, the capacity is κ(2), and at most $\frac{1}{\kappa (2)}\cdot \frac{Y}{logW}$ debit operations can be made to $Q_{J,\lambda }^a$. In general, during the period when $\frac{(c-1)Y}{logW}\le v_J+{\overline{f}}_{\ast }(J)<\frac{cY}{logW}$, at most $\frac{1}{\kappa (c)}\cdot \frac{Y}{logW}$ debit operations can be made to $Q_{J,\lambda }^a$. If the largest capacity is κ(c_max), the total number of debit operations made to $Q_{J,\lambda }^a$ is at most

$$\frac{Y}{logW}(\frac{1}{\kappa (1)}+\cdots +\frac{1}{\kappa (c_{max})})=\frac{∊Y}{4(loglogW)logW}(1+\frac{1}{2}+\cdots +\frac{1}{c_{max}})\le \frac{∊Y(ln(c_{max})+1)}{4(loglogW)logW}$$

which is smaller than $\frac{∊Y}{2logW}$ because by Equation (9), c_max = O(logW), which implies ln(c_max) + 1 ≤ 2 log logW (suppose that W is larger than some constant).

We now prove (2). Note that the total number of non-trivial queues in ${\mathcal{D}}_{I,∊}^Y$, and hence the number of born-poor nodes, is at most ${\sum }_{1\le i\le m}\kappa (c_i)={\sum }_{1\le i\le m}\frac{4c_i}{∊}loglogW$. By Equation (9), ${\sum }_{1\le i\le m}{c}_i=O(logW)$, and it follows that the size of ${\mathcal{D}}_{I,∊}^Y$ is $O(\frac{1}{∊}loglogWlogW)$.

For the update time, suppose that an item (a, u) arrives. We can find the _Ji,λ,κ in ${\mathcal{D}}_{I,∊}^Y=\langle {\mathcal{C}}_{J_1,\lambda ,\kappa },\dots ,{\mathcal{C}}_{J_m,\lambda ,\kappa }\rangle$ with u ∈ J_i using O(log m) = O(log logW) time by querying a balanced search tree storing the J_i's. By hashing (e.g., Cuckoo hashing [15], which supports constant update and query time) we can locate the queue $Q_{J_i,\lambda }^a\in {\mathcal{C}}_{J_i,\lambda ,\kappa }$ in constant time. Then, by consulting an auxiliary balanced search tree on the intervals monitored by the nodes of $Q_{J_i,\lambda }^a$, we can find and update the node N of $Q_{J_i,\lambda }^a$ with u ∈ i(N) using $O(log(Y/\lambda ))=O(log\frac{1}{∊}+loglogW)$ time. At times we may also need to execute Lines 3 and 4 of the procedure Process( ), which debits all the non-trivial queues in _Ji,λ,κ. Using the de-amortizing technique given in [16], this step takes constant time.

Note that occasionally, we may also need to clean up ${\mathcal{D}}_{I,∊}^Y$ by calling Trim( ); this step takes time linear to the size of ${\mathcal{D}}_{I,∊}^Y$, which is $O(\frac{1}{∊}(loglogW)logW)$.

6. Further Reducing the Size of ${\mathcal{D}}_{I,∊}^Y$ for Streams with Small Tardiness

Recall that in an out-of-order data stream with tardiness d_max ∈ [0, W], any item (a, u) arriving at time τ_cur satisfies u ≥ τ_cur − d_max; in other words, the delay of any item is guaranteed to be at most d_max. This section extends ${\mathcal{D}}_{I,∊}^Y$ to a data structure ${ℰ}_{I,∊}^Y$ that takes advantage of this maximum delay guarantee to reduce the space usage. The idea is as follows. Since there is no new item with stamps smaller than τ_Cur − d_max, we will not make any further change to those nodes to the of left τ_cur − d_max and hence can consolidate these nodes to reduce space substantially. To handle those nodes with timestamps in [τ_cur − d_max, τ_cur], we use the data structure given in Section 5; since it is monitoring an interval of d_max instead of W, its size is $O(\frac{1}{∊}(loglog{d}_{max})log{d}_{max})$ instead of $O(\frac{1}{∊}(loglogW)logW)$.

To implement ${ℰ}_{I,∊}^Y$, we need a new operation called consolidate. Consider any list of queues $\langle Q_{J_1,\lambda }^a,Q_{J_2,\lambda }^a,\dots ,Q_{J_m,\lambda }^a\rangle$, where J₁, J₂, …, J_m are ordered from left to right and form a partition of the interval J_1‥m = J₁ ∪ ⋯ ∪ J_m. We consolidate them into a single queue $Q_{J_{1‥m},\lambda }^a$ as follows:

• Concatenate the queues into a single queue, in which the nodes preserve the left-right order.

• Starting from the leftmost node, check from left to right every node N in the queue, if N is not the rightmost node and v(N) < λ, merge it with the node N′ immediately to its right, i.e., delete N, set v(N′) = v(N) + v(N′), d(N′) = d(N) + d(N′) and (N′) = (N) ∪ (N′).

Note that after the consolidation, the resulting queue $Q_{J_{1‥m},\lambda }^a$ has at most one node (the rightmost one) with value smaller than λ.

Given the list 〈 _J1,λ,κ(c1), …, _Jm,λ,κ(cm)〉, we consolidate them into ${\mathcal{C}}_{J_{1‥m},\lambda ,\frac{1}{∊}}$ by first consolidating, for each item a, the queues $Q_{J_1,\lambda }^a,\dots ,Q_{J_m,\lambda }^a$ in _J1,λ,κ(c1), …, _Jm,λ,κ(cm) into the queue $Q_{J_{1‥m},\lambda }^a$ and put it in ${\mathcal{C}}_{J_{1‥m},\lambda ,\frac{1}{∊}}$. Then, we apply Lines 3–5 of procedure Process( ) repeatedly to reduce the number of non-trivial queues in the data structure to $\frac{1}{∊}$.

We are now ready to describe how to extend ${\mathcal{D}}_{I_1,∊}^Y$ to ${ℰ}_{I,∊}^Y$. In our discussion, we fix $\lambda =\frac{∊Y}{log{d}_{max}}$, and without loss of generality, we assume that I = [1, W]. Recall that p_max denotes the largest timestamp in I such that f̂_*([p_max, r_I]) > (1 + ∊)Y (which implies f_*([p_max, r_I]) > Y). We partition I into sub-windows I₁, I₂, …, I_m, each of size d_max (i.e., I_i = [(i − 1)d_max, id_max]). We divide the execution into different periods according to τ_cur, the current time.

• During the 1st period, when τ_cur ∈ [1, d_max] = I₁, ${ℰ}_{I,∊}^Y$ simply is ${\mathcal{D}}_{I_1,∊}^Y$.

• During the 2nd period, when τ_cur = I₂, ${ℰ}_{I,∊}^Y$ maintains ${\mathcal{D}}_{I_2,∊}^Y$ in addition to ${\mathcal{D}}_{I_1,∊}^Y$.

• During the 3rd period, when τ_cur ∈ I₃, ${ℰ}_{I,∊}^Y$ maintains ${\mathcal{D}}_{I_3,∊}^Y$ in addition to ${\mathcal{D}}_{I_2,∊}^Y$. Also, the ${\mathcal{D}}_{I_1,∊}^Y=\langle {\mathcal{C}}_{J_1,\lambda ,\kappa (c_1)},\dots ,{\mathcal{C}}_{J_m,\lambda ,\kappa (c_m)}\rangle$ is consolidated into ${\mathcal{C}}_{I_1,\lambda ,\frac{1}{∊}}$.

• In general, during the ith period, when ${\tau }_{\text{cur}}\in [(i-1)d_{max}+1,i{d}_{max}]=I_i,{ℰ}_{I,∊}^Y$ maintains ${\mathcal{D}}_{I_{i-1},∊}^Y$ and ${\mathcal{D}}_{I_i,∊}^Y$, and also ${\mathcal{C}}_{I_{1‥i-2},\lambda ,\frac{1}{∊}}$ where I_1‥i−2 = I₁ ∪ I₂ ∪ ⋯ ∪ I_i−2. Observe that in this period, there is no item (a, u) with u ∈ I_1‥i−2 arrives (because the tardiness is d_max), and thus we do not need to update ${\mathcal{C}}_{I_{1‥i-2},\lambda ,\frac{1}{∊}}$. However, we will keep throwing away any node N in ${\mathcal{C}}_{I_{1‥i-2},\lambda ,\frac{1}{∊}}$ as soon as we know i(N) is to the left of p_max + 1.

• When entering the (i + 1)st period, we do the followings: Keep ${\mathcal{D}}_{I_i,∊}^Y$, create ${\mathcal{D}}_{I_{i+1},∊}^Y$, merge _{I1‥i−2,λ,κ} with ${\mathcal{D}}_{I_{i-1},∊}^Y=\langle {\mathcal{C}}_{J_1,\lambda ,\kappa (c_1)},\dots ,{\mathcal{C}}_{J_m,\lambda ,\kappa (c_m)}\rangle$, and then get ${\mathcal{C}}_{I_{1‥i-1},\lambda ,\frac{1}{∊}}$ by consolidating $\langle {\mathcal{C}}_{I_{1‥i-2},\lambda ,\frac{1}{∊}},{\mathcal{C}}_{J_1,\lambda ,\kappa (c_1)}\dots ,{\mathcal{C}}_{J_m,\lambda ,\kappa (c_m)}\rangle$.

Given any t ∈ [p_max + 1, r_I], the estimate of f_a([t, r_I]) given by ${ℰ}_{I,∊}^Y$ is

$${\widehat{f}}_a([t,r_I])=v(\text{alive}{({ℰ}_{I,∊}^Y)}_{\ge t}^a)$$

The following theorem gives the accuracy of ${\widehat{f}}_a([t,r_I]),{ℰ}_{I,∊}^Y$'s size and its update time.

Theorem 8

• For any t ∈ [p_max + 1, r_I], the estimate f̂_a([t, r_I]) given by ${ℰ}_{I,∊}^Y$ satisfies

  $$f_a([t,r_I])-2∊Y\le {\widehat{f}}_a([t,r_I])\le f_a([t,r_I])+2∊Y$$

• ${ℰ}_{I,∊}^Y$ has size $O(\frac{1}{∊}(loglog{d}_{max})log{d}_{max})$, and supports $O(log\frac{1}{∊}+loglog{d}_{max})$ update time.

Proof

Recall that I is partitioned into sub-intervals I₁, I₂, …, I_m. Suppose that t ∈ I_κ. Note that if we had not performed any consolidation,

$$v(\text{alive}{({ℰ}_{I,∊}^Y)}_{\ge t}^a)=v(\text{alive}{({\mathcal{D}}_{I_{\kappa },∊}^Y)}_{\ge t}^a)+{\sum }_{\kappa +1\le i\le m}v(\text{alive}{({\mathcal{D}}_{I_i,∊}^Y)}^a)$$

Note that for κ + 1 ≤ i ≤ m, $v(\text{alive}{({\mathcal{D}}_{I_i,∊}^Y)}^a)\le f_a(I_i)$, and for $v(\text{alive}{({\mathcal{D}}_{I_{\kappa },∊}^Y)}_{\ge t}^a)$ since |I_κ|= d_max, the same argument used in the proof of Lemma 3 gives us $v(\text{alive}{({\mathcal{D}}_{I_{\kappa },∊}^Y)}_{\ge t}^a)\le f_a([t,r_{I_k}])+\lambda log{d}_{max}$. Hence

$$v(\text{alive}{({ℰ}_{I,∊}^Y)}_{\ge t}^a)=v(\text{alive}{({\mathcal{D}}_{I_{\kappa },∊}^Y)}_{\ge t}^a)+{\sum }_{\kappa +1\le i\le m}v(\text{alive}{({\mathcal{D}}_{I_i,∊}^Y)}^a)\le f_a([t,r_{I_{\kappa }}])+\lambda log{d}_{max}+{\sum }_{\kappa +1\le i\le m}{f}_a(I_i)=f_a([t,r_I])+\lambda log{d}_{max}$$

(10)

The consolidation step may add errors to $v(\text{alive}{({ℰ}_{I,∊}^Y)}_{\ge t}^a)$. To get a bound on them, let N₁, N₂, … be the nodes for a in ${ℰ}_{I,∊}^Y$, ordered from left to right. Suppose that t ∈ N_h. Note that

• the consolidation step will added at most λ units to v(N_h) before we move on to consider the node immediately to its right, and

• for node N_i with i ≥ h + 1, any node N that has been merged to N_i must be to the right of of N_h, and thus is to the right of t; it follows that N is contributing v(N) to $v(\text{alive}{({ℰ}_{I,∊}^Y)}_{\ge t}^a)$ in Equation (10) and its merging will not make any change.

In conclusion, the consolidation steps introduce at most λ extra errors, and Equation (10) becomes $v(\text{alive}{({ℰ}_{I,∊}^Y)}_{\ge t}^a)\le f_a([t,r_I])+\lambda logW+\lambda \le f_a([t,r_I])+2∊Y$, which is the second inequality of the lemma.

To prove the first inequality, suppose that we ask for the estimate f̂_a([t, r_I]) during the ith period, when we have ${\mathcal{C}}_{I_{1‥i-2},\lambda ,\frac{1}{∊}}$, ${\mathcal{D}}_{I_{i-1},∊}^Y$ and ${\mathcal{D}}_{I_i,∊}^Y$. Recall that _{I1‥i−2, λ,∊} comes from consolidating ${\mathcal{D}}_{I_1,∊}^Y,{\mathcal{D}}_{I_2,∊}^Y,\dots ,{\mathcal{D}}_{I_{i-2},∊}^Y$. As in all our Previous analyses, we have

$$f_a([t,r_I])-v(\text{alive}{({ℰ}_{I,∊}^Y)}_{\ge t}^a)\le v(\text{node}{({ℰ}_{I,∊}^Y)}_{\ge t}^a)-v(\text{alive}{({ℰ}_{I,∊}^Y)}_{\ge t}^a)=d(\text{dead}{({ℰ}_{I,∊}^Y)}_{\ge t}^a)$$

(Note that the merging of nodes during consolidations would not take away any value). To get a bound on $d(\text{dead}{({ℰ}_{I,∊}^Y)}_{\ge t}^a)$, suppose that p_max ∈ I_κ. Then, all the nodes to the left of I_κ have been thrown away. Among ${\mathcal{D}}_{I_{\kappa },∊}^Y,{\mathcal{D}}_{I_{\kappa +1},∊}^Y,\dots ,{\mathcal{D}}_{I_m,∊}^Y$, only ${\mathcal{D}}_{I_{\kappa },∊}^Y$ may have been trimmed. Note that

• $d(\text{dead}{({ℰ}_{I,∊}^Y)}_{\ge t}^a)\le d(\text{dead}{({\mathcal{D}}_{I_{\kappa },∊}^Y)}_{\ge p_{max}}^a)+{\sum }_{\kappa +1\le \ell \le m}d(\text{dead}{({\mathcal{D}}_{I_{\ell },∊}^Y)}^a)$,

• as in the proof of Theorem 7, we can argue that $d(\text{dead}{({\mathcal{D}}_{I_{\kappa },∊}^Y)}_{\ge p_{max}}^a)\le ∊Y$, and

• for the other ${\mathcal{D}}_{I_{\ell },∊}^Y$, since their capacity is at least $\frac{1}{∊}$

$${\sum }_{\kappa +1\le \ell \le m}d(\text{dead}{({\mathcal{D}}_{I_{\ell },∊}^Y)}^a)\le {\sum }_{\kappa +1\le \ell \le m}{f}_{\ast }(I_{\ell })/(1/∊)\le ∊f_{\ast }([p_{max}+1,r_I])\le ∊Y$$

Thus, $d(\text{dead}{({ℰ}_{I,∊}^Y)}_{\ge t}^a)\le 2∊Y$, and the first inequality follows.

For Statement (2), note that both ${\mathcal{D}}_{I_{i-1},∊}^Y$ and ${\mathcal{D}}_{I_i,∊}^Y$ have size $O(\frac{1}{∊}loglog{d}_{max}log{d}_{max})$ (by Theorem 7, and |I_i−1| = |I_i| = d_max), and for ${\mathcal{C}}_{J_{1‥i-2},\lambda ,\frac{1}{∊}}$, it has size $O(Y/\lambda +\frac{1}{∊})=O(\frac{1}{∊}log{d}_{max})$; thus the size of ${ℰ}_{I,∊}^Y$ is $O(\frac{1}{∊}loglog{d}_{max}log{d}_{max})$. For the update time, it suffices to note that it is dominated by the update times of ${\mathcal{D}}_{I_{i-1},∊}^Y$ and ${\mathcal{D}}_{I_i,∊}^Y$.