Probabilistic Top-k Dominating Query over Sliding Windows Xing Feng1 , Xiang Zhao2 , Yunjun Gao1 , and Ying Zhang2 1

2

Zhejiang University, China {3090103362,gaoyj}@zju.edu.cn The University of New South Wales, Australia {xzhao,yingz}@cse.unsw.edu.au

Abstract. Probabilistic queries on uncertain data have been intensively investigated lately. Top-k dominating query is important in many applications, e.g., decision making, as it offers choices which are better than the most of others. In this paper, we study the problem of probabilistic top-k dominating query over sliding windows. An efficient algorithm is developed to compute the exact solution. Extensive experiments are conducted to demonstrate the efficiency and effectiveness of the algorithm.

1 Introduction Spatial database has drawn attention in recent decades. Beckmann et al. [1] design the R-tree as an index for efficient computation. Roussopoulos et al. [8] study nearest neighbor queries, and propose three effective pruning rules to speed up the computation. They also the extend nearest neighbor queries to k nearest neighbor queries, which return top-k preferred objects. B¨orzs¨onyi et al. [4] is among the first to study the skyline operator, and propose an SQL syntax for the skyline query. Top-k dominating query is first studied by Yiu et al. [10], which retrieves the topk objects that are better than the largest number of objects in a dataset. This is quite different from the skyline query in [4] that retrieves objects which are not worse than other objects. Uncertain data analysis is of importance in many emerging applications, such as sensor network, trend prediction and moving objects management. There has been a lot of works focusing on uncertain data management, [5,11] to cite a few. In this work, we study probabilistic top-k dominating query over sliding windows. We employ the data model with sliding windows as used in [9,13]. In sliding windows, data is treated as a stream, and only recent n objects are considered. There are some closely related work, seen in [7,12]. However, they study objects with multiple instances. Besides, their query is to get top-k dominating objects from the total data set. While our paper studies objects from append-only data stream. And our main concern is to maintain top-k dominating objects from recent N objects where N is the window size. Probabilistic top-k dominating query is desirable in various real-life applications. Table 1 evidences a scenario of house rental, where answering such type of query can be Y. Ishikawa et al. (Eds.): APWeb 2013, LNCS 7808, pp. 782–793, 2013. c Springer-Verlag Berlin Heidelberg 2013 

Probabilistic Top-k Dominating Query over Sliding Windows

783

beneficial. Lessees are interested in knowing the top-1 house from all recent 4 advertisements. Each advertisement is associated with its house ID, post time, price, distances to supermarket and trustability. Trustability is derived from Lessee’s feedback on the lessors product quality; this “trustability” value can also be regarded as the probability that the house is the same as what it claims. We assume lower price and closer to supermarket are preferred and lessees do not care about other attributes. We also assume that lessees want a house that are better than the most of others. A top-k dominating (k = 1) query would retrieve {H1} as the result for the first 4 objects {H1, H2, H3, H4} because H1 is better than H2, H3, H4. {H4} is the result for the next sliding window {H2, H3, H4, H5}. However, we may also notice that H4 is of low trustability. It is more reasonable to take the trustability into consideration. We model such on-line selection problem as probabilistic top-k dominating query against sliding windows by regarding on-line advertisements as an append-only data stream. This query will be formally defined in Section 2. Hence, the probabilistic top-k dominating query over sliding windows provides a more reasonable solution under the given scenario. Table 1. Example of house rental House ID Post time Rent per week Distance to supermarket Trustability H1 100 days ago $167 100m 0.80 H2 97 days ago $205 340m 0.90 H3 63 days ago $206 820m 0.85 H4 55 days ago $185 110m 0.50 H5 50 days ago $230 700m 1.00 H6 43 days ago $200 760m 0.90

In summary, we make the following contributions in this paper: – We identify the problem of probabilistic top-k dominating query over sliding windows. To the best of our knowledge, there is no prior work regarding this. – We develop novel algorithms to continuously compute the top-k dominating objects, and analyze the complexity. – We conduct extensive experiments to demonstrate the correctness and efficiency of our algorithms. Organization. The rest of the paper is organized as follows. In Section 2, we present background information and formally define the problem. Sections 3 and 4 present the techniques for processing top-k dominating query over sliding windows. Experimental results are provided and analyzed in Section 5. Section 6 concludes the paper.

2 Preliminary This section introduces the background information, and defines the problem.

784

X. Feng et al.

2.1 Background When comparing two objects, if one object p is not worse than another q in all aspects and p is better than q in at least one aspect, we say p dominates q. Formally, we have Definition 1. Definition 1 (Dominate). Consider two distinct d-dimensional objects p and q, and p[i] denotes the i-th value of p. p dominates q (denoted by p ≺ q) iff p[i] ≤ q[i] holds for 1 ≤ i ≤ d, and there exists j, such that p[j] < q[j]. Based on Definition 1, [10] develops a score function to count the number of objects dominated by an object as μ(p) = |{p ∈ D|p ≺ p }|.

(1)

Consequently, top-k dominating query in a data set is to retrieve the top-k objects with maximal μ(p) in the data set. Given a sequence data stream DS of uncertain data objects, a possible world W is a subsequence of DS; i.e., each object α from DS can be either in W or not. For example, given a data stream with 3 objects, {a, b, c}, there are totally 8 possible worlds – {∅, {a}, {b}, {c}, {a, b}, {a, c}, {b, c}, {a, b, c}}. The probability of W to appear is the product of probabilities of all objects which appear the probabilities of in W and 1 − all objects which do not appear in W ; i.e., P (W ) = α∈W P (α) × α∈W / (1 − P (α)). We compute the μ function in Equation (1) for every object in the certain possible world W . For a top-k dominating query over sliding window, probability of each qualified possible world W is accumulated in order to get the overall probability. 2.2 Problem Definition In many applications, a data stream is append-only; that is, there is no deletion of data element involved. In this paper, we study the top-k dominating problem by employing the append-only data stream model. Given an uncertain data stream DS consisting of n uncertain objects, sliding window size W , probability threshold q, we use l to measure the dominating ability of each object in a sliding window. That is, an object dominates at least l objects in possible worlds, of which the total probability is over q in a sliding window of size W . Thus, top-k dominating over sliding windows maintains the top-k objects which are ranked according to l over sliding windows with regards to threshold q. Example 1. Consider the running example in Table 1, where we need the top-1 house over a sliding window of size N = 4, and probability threshold q = 0.6. We have in total 16 possible worlds in each window. When a window contains {H3, H4, H5, H6}, it is a little different. There are 8 possible worlds rather 16 possible worlds, since P (H5) = 1. First, we compute the dominating number of each object in every possible world (as shown in Table 2). When computing l value, we sum up the probability of each possible world according to the number of objects it dominated in descending order, till the probability exceeds the threshold q. Thus, H6 is 76.5%(38.25% + 38.25%), and H4 gets 50%(38.25% + 6.75% + 4.25% + 0.75%). H3 and H5 are both 0, since they do not dominate others. Therefore, we have H3.l = 0, H4.l = 0, H5.l = 0, and H6.l = 1; and hence, H6 is the top-1 object in the probabilistic top-1 dominating query with probability threshold = 0.6 over the sliding window {H3, H4, H5, H6}.

Probabilistic Top-k Dominating Query over Sliding Windows

785

Table 2. Dominating number in possible world Probability Possible world 0.75% H5 4.25% H3, H5 0.75% H4, H5 6.75% H5, H6 4.25% H3, H4, H5 38.25% H3, H5, H6 6.75% H4, H5, H6 38.25% H3, H4, H5, H6

H3 0 0 0 0 0 0 0 0

H4 0 0 1 0 2 0 2 3

H5 0 0 0 0 0 0 0 0

H6 0 0 0 0 0 1 0 1

2.3 Dominance Relationships We implement our techniques based on the R-tree. Thus, we define the following relationships between a pair of entries E and E  in the R-tree. E.min denotes the lowerleft corner of the minimum bounding box (MBB) of the objects contained by E, and E.max denotes the upper-right corner of MBB. Note if an entry contains only one object α, E.min = E.max = α. An entry E is said to fully dominate another E  , iff E.max ≺ E  .min or E.max =  E .min, denoted as E ≺ E  . An entry E partially dominates E  , iff E.max ⊀ E  .min, E.min ≺ E  .max, denoted as E ≺partial E  . An entry E does not dominate E  , iff E.min ⊀ E  .max, denoted as E ⊀ E  . As depicted in Figure 1, E2 fully dominates E3, E partially dominates E2, and E1 does not dominate E.

1

0.9

E3

E1

0.8

0.7

0.6

E2

0.5

0.4

0.3

E

0.2

0.1

0

0

0.1

0.2

0.3

0.4

0.5

0.6

0.7

0.8

0.9

1

Fig. 1. Dominance relationship

3 Dominating Score Calculation As aforementioned, we may calculate the dominating score by the finding maximal l whose accumulating possibility of all the qualified possible worlds is over q. However, this can be rather time-consuming due to the exponential number of possible worlds; i.e., there are 2N possible worlds, where N is the number of all objects.

786

X. Feng et al.

We observe that the complexity can be reduced by viewing the problem from another perspective. Instead of enumerating possible worlds, we retrieve the largest l in the condition, where at least l objects exist of M objects, where M is the number of all dominated objects. Specifically, let mi,j denote the probability that exactly i objects out of j objects exist, and P (i) denote the probability that the i-th object exists. We have the following relations. ⎧ i=0 ⎨ m0,j−1 × (1 − (P (j))) mi,j = mi−1,j−1 × P (i) (2) i=j ⎩ mi−1,j−1 × P (j) + mi,j−1 × (1 − P (j)) otherwise Equation (2), known as Poisson-Binomial Recurrence [6], is widely used in uncertain database analysis [2,3]. Applying Equation (2), we propose a dynamic programming algorithm that efficiently computes l value of a certain object, encapsulated in Algorithm 1. Algorithm 1 takes Ω and α as inputs, where α is the object of which we need to compute l value, and Ω contains all the objects which are dominated by α. A matrix is used to store the intermediate result, initialized in Line 2. Then, we use Equation (2) to fill in the cells of the matrix (Lines 4 − 13). Finally, we remove mi,size from f at a time till f is less then q (Lines 15 - 17), and i − 1 is returned as the result. Algorithm 1. calDS(Ω, α) 1 2 3 4 5 6 7 8 9 10 11 12 13

if P (α) < q then return 0; m0,0 = 1; i = 1; size = |Ω|; f = P (α); while j ≤ size do m0,j = m0,j−1 × (1 − P (j)); j = j + 1; while i ≤ size do mi,i = mi−1,i−1 × P (i); j = 1; while j < i do mi,j = mi−1,j−1 × P (j) + mi,j−1 × (1 − P (j)); j = j + 1; i = i + 1;

17

i = 0; while f > q do f = f − mi,size × P (α); i = i + 1;

18

return i − 1;

14 15 16

Correctness and Complexity Analysis. It is immediate that Algorithm 1 correctly computes the l value. The most time-consuming part is the loop in Lines 7 − 13, and thus, the complexity of algorithm is O(|Ω|2 ).

Probabilistic Top-k Dominating Query over Sliding Windows

787

Example 2. Consider the running example in 2.2. We only compute H4 and H6, since Ω of H3 or H5 is empty. For H4, P (H4) = 0.5 < 0.6, and hence , H4.l = 0. For H6, P (H6) = 0.9 > 0.6, m0,1 = 0.15, m1,1 = 0.85. As 0.9 − 0.15 × P (H6) = 0.765 > 0.6, 0.765 − 0.85 × P (H6) = 0 < 0.6, the H6.l is 1. Therefore, top-1 object among {H3, H4, H5, H6} is H6.

4 Updating Technique A naive solution to retrieving top-k dominating objects over sliding windows is to visit each object every time the window slides. When visiting an object, it also gets all the objects it dominates by traversing R-tree and then computes its l value using Algorithm 1. Eventually, it chooses k objects with maximal l values. We observe that this tedious process can be accelerated. Given a probability threshold q and a sliding window with size N , Algorithm 2 shows how we process every arriving object. Algorithm 2. Probabilistic top-k dominating over Sliding Windows 1 2 3 4 5 6 7

while a new object αnew arrives do if |S| ≤ N then insert(αnew ); else remove(αold ); insert(αnew ); collect top-k dominating objects;

When a new object αnew comes, if there are exactly N objects in the window, we remove the oldest object αold . Then, we use function insert(αnew ) to update the l value of objects. Finally we collect the top-k dominating objects using min-heap. In the following subsections, we present novel algorithms to efficiently execute Algorithm 2. We first introduce the data structure, then provide our algorithm to handle the situation when a new object is inserted (insert(αnew )), followed by an algorithm to deal with a removed old object (remove(αold )). 4.1 Aggregate R-Trees and Heap We store all the N objects in an aggregate R-tree. We store P , l and λtop-k dominating with each object as aggregate information. Specifically, P is the probability of the object, l is the measure of dominating ability regarding probabilistic threshold q. Additionally, λtop-k dominating is the last column of matrices that we use to compute l by Algorithm 1. Note that each column only depends on the previous column. In another word, when a new object αnew comes, keeping last column of the matrix is enough to update the l value. By storing these aggregate information, we do not have to recalculate the l value of all objects when a new object comes. We only need to update λtop-k dominating and l value every time a new object comes.

788

X. Feng et al.

In addition, we maintain the top-k dominating objects in a min-heap; i.e., we insert the first k objects into a min-heap. For each following object having larger l than the minimum object in the heap, we first dequeue the minimal object, and then insert the new object into the min-heap. 4.2 Insert When a new object αnew comes, we need to consider all the objects dominating it (denote as S1) and being dominated by it (denote as S2). To this end, we process the following tasks: 1) compute S1 and S2 by traversing the aggregate R-tree, 2) update l of each object in S1; and 3) compute l of the new object. Algorithm 3 describes the steps we take to handle an insertion. R is the aggregate R-tree we used to store all objects in current sliding window. S3 is used to collect all the entries which partially dominate αnew , S4 is used to collect all the entries which are partially dominated by αnew , and S34 is used to collect the entries which partially dominate αnew and are partially dominated by αnew . First, we classify all the entries to different sets (Lines 1 - 6). Then, we refine the result and get all the entries of interest, namely S1 and S2, using probe1, probe2 and probe3 (Lines 7 - 9). So far, we have finished task 1). Then, task 2) is done by updating all the entries in S1 using update (Line 10). Afterwards, we achieve task 3) by computing l of αnew (Line 11). Algorithm 3. insert(αnew ) 1 2 3 4 5 6 7 8 9 10 11

for each E ∈ R.root do ifE ≺ αnew then add E to S1; else ifαnew ≺ E then add E to S2; else ifE ≺partial αnew &αnew ⊀ E then add E to S3; else ifE ≺partial αnew &αnew ≺partial E then add E to S34; else ifαnew ≺partial E&E ⊀ αnew then add E to S4; ifS3 = ∅ then probe1(S3); ifS4 = ∅ then probe2(S4); ifS34 = ∅ then probe3(S34); ifS2 = ∅ then update1(S1); ifS1 = ∅ then αnew .l = calDS(S2, αnew );

Algorithm 4 shows how we refine S3. Note that all the entries in S3 cannot be dominated by αnew . We add entries dominating αnew to S1 (Line 4 in Algorithm 4), and leave entries which partially dominate αnew in S3 (Line 5 in Algorithm 4). Algorithm 4. probe1(S3) 1 2 3 4 5

while S3 = ∅ do E = Dequeue(S3); for each child E  of E do if E  ≺ αnew then add E  to S1; else if E  ≺partial αnew then add E  to S3;

Probabilistic Top-k Dominating Query over Sliding Windows

789

The ideas behind Algorithm 4 and Algorithm 5 are similar. We add entries which are dominated by αnew to S2 (Line 4 in Algorithm 5), and leave entries which are partially dominated by αnew in S4 (Line 5 in Algorithm 5). Algorithm 5. probe2(S4) 1 2 3 4 5

while S4 = ∅ do E = Dequeue(S4); for each child E  of E do if αnew ≺ E  then add E  to S2; else if αnew ≺partial E  then add E  to S4;

S34 is special in that it may contain entries which dominate αnew and entries which are dominated by αnew . Thus, we first partition them (Lines 1 - 8), and apply probe1 and probe2 thereafter. Algorithm 6. probe3(S34) 1 2 3 4 5 6 7 8 9 10

while S34 = ∅ do E = Dequeue(S34); for each child E  of E do if αnew ≺ E  then add E  to S1; else if E  ≺ αnew then add E  to S2; else if αnew ≺partial E  &E  ≺partial αnew then add E  to S34; else if E  ≺partial αnew &αnew ⊀ E  then add E  to S3; else if αnew ≺partial E  &E  ⊀ αnew then add E  to S4; if S3 = ∅ then probe1(S3); if S4 = ∅ then probe2(S4);

Algorithm 7 describes the update of S1. For each object at leaf node, we update its l and λtop-k dominating by using αnew . As a consequence, the time complexity of the update is O(l). Algorithm 7. update1(S1) 1 2 3 4 5 6 7 8 9 10 11

while S1 = ∅ do E = Dequeue(S1); for each child E  of E do if E  is at leaf level then Read E  ; for each child E  of E  do updateLambda(E , αnew ); updateL(E ); else

for each child E  of E  do add E  to S1;

790

X. Feng et al.

We analyse the worst case complexity of Algorithm 3; i.e., when every object is dominated by all the previous objects. Let N denote the window size. In this case, S1 contains all N objects. Immediately, the most time consuming part is in Line 11, and thus, the time complexity is given by O(N 2 ). Since Algorithm 3 is complicated, we give an example below. Example 3. Regarding the example in Table 1. We assume windows size N = 4, probabilistic threshold q = 0.6, and there are exactly H1, H2, H3 in current window. H4 comes as αnew . Before H4 comes, we use Algorithm 1 to compute the corresponding l values of H1, H2, H3. As an example, the first three columns in Table 3 shows how to compute the l value of H1. And we keep {0.015, 0.22, 0.765} as λtop-k dominating of H1. The aggregate information of other objects are listed in the first three rows of Table 4. When H4 comes, according to Algorithm 3, we first collect all objects dominating H4 in S1 and all objects dominated by H4 in S2. Here, we have S1 = {H1}, S2 = {H2, H3}. Then, we update l and λtop-k dominating of H1. Using Equation (2), we get the 4-th column in Table 3. Because (0.3825 + 0.4925) × P (H1) > q = 0.6, the l value still equals 2. And λtop-k dominating is updated as {0.0075, 0.1175, 0.4925, 0.3825}. Finally, we compute l and λtop-k dominating for H4. Because P (H4) < q = 0.6, we have l = 0 and λtop-k dominating = ∅. Therefore, the top-1 dominating query for window {H1, H2, H3, H4} is H1. Table 4. Aggregate information

Table 3. The matrix of H1

H1(0.80) H2(0.90) H3(0.85) H4(0.5) 1 0.1 0.015 0.0075 0.9 0.22 0.1175 0.765 0.4925 0.3825

House ID H1 H2 H3 H1(updated) H4

l 2 1 0 2 0

λtop-k dominating {0.015, 0.22, 0.765} {0.15, 0.85} ∅ {0.0075, 0.1175, 0.4925, 0.3825} ∅

4.3 Expire When αold expires, the l value of each object dominated by αold will not change. Therefore, we only need to collect all the objects dominating αold , re-calculate their l values. Algorithm 8. remove(αold ) 1 2 3 4 5 6 7 8 9 10

for each E ∈ R.root do if E ≺ αold then add E to S1; else if E ≺partial αold then add E to S3; while S3 = ∅ do E = Dequeue(S3); for each child E  of E do if E  ≺ αold then add E  to S1; else if E  ≺partial αold then add E  to S3; update2(S1); delete αold from R;

Probabilistic Top-k Dominating Query over Sliding Windows

791

The update process of S1 is shown in Algorithm 9. For each object at leaf node, we re-calculate its l and λtop-k dominating by traversing the R-tree to collect all the objects which are dominated by the object in Ω. Algorithm 9. update2(S1) 1 2 3 4 5 6 7 8 9

while S1 = ∅ do E = Dequeue(S1); for each child E  of E do if E  is at leaf level then read E  ; for each child E  of E  do traverse R to collect all objects dominated by E  in Ω; E  .l = calDS(Ω, E  ); else

10 11

for each child E  of E  do add E  to S1;

Similarly, we provide a worst case complexity analysis of Algorithm 8. When all objects dominate all previous objects, we need to re-calculate l value of all remaining objects. Therefore, the time complexity is given by O(N 3 ), where N is the window size. Correctness. The correctness of our techniques is guaranteed by computing the exact l value of each object in current sliding window. Besides, we get the top-k dominating objects using a min-heap. This is also correct because the k objects are guaranteed to have larger l values than these not in the min-heap.

5 Experiments This section reports the experimental studies. 5.1 Setup We ran all experiments on a MacBook Pro with Mac OSX 10.8.1, 2.26GHz Intel Core 2 Duo CPU and 4G 1333 MHz RAM. We evaluated the efficiency of our algorithm against sliding window size, dimensionality, and probabilistic threshold, respectively. The default values of the parameters are listed in Table 5. Parameters are varied as follows: – sliding window size: 2k, 4k, 6k, 8k, 10k – dimensionality: 2, 3, 5 – probabilistic threshold: 0.1, 0.3, 0.5, 0.7, 0.9 We ran all experiments with 100 windows, and repeated all experiments 10 times to get an average execution time. The execution time in each following figure is the running time for processing 100 windows.

792

X. Feng et al. Table 5. Experimental parameters Notation N d D Dp Pµ q

Definition(Default Values) sliding window size (4K) dimensionality of the data set (3) data set (Anti) probabilistic distribution of appearance (uniform) expected appearance probability (0.5) probabilistic threshold (0.3)

5.2 Evaluation Figures 2, 3 and 4 show the results when window size is varied. In Figure 5, we vary the threshold probability to see the running time of baseline algorithm. In Figure 6, we vary the threshold probability to see the running time of the efficient algorithm. From the figures, we see that the efficient algorithm outperforms the baseline algorithm in all cases. 4

10

2

10

1

100

baseline efficient

2k

baseline

4k

6k

8k

10

2 efficient

10

1

10

0

10-1

10k

2k

Avg. Delay(s)

103

Avg. Delay(s)

Avg. Delay(s)

10

4k

6k

8k

10k

Fig. 3. Varying N , d = 3

Fig. 2. Varying N , d = 2

10

2 baseline

efficient

10

1

10

0

10-1

2k

4k

6k

8k

10k

Fig. 4. Varying N , d = 5

10

3 2d

3d

5d

Avg. Delay(s)

Avg. Delay(s)

As shown in Figures 2, 3 and 4, when window size increases linearly, the running time increases in a super-linear manner for of the both efficient and baseline algorithms. Moreover, we conclude, by comparing Figures 2, 3 and 4, that the running time decreases greatly with the increase of dimensionality. This is because the most timeconsuming part of the baseline algorithm is to compute l; i.e., collect all objects and apply Algorithm 1 to compute l. With higher dimensionality, there is a smaller Ω for each object. Similar conclusion can be drawn for the efficient algorithm.

102

10

1

0.1

0.3

0.5

0.7

0.9

Fig. 5. Baseline, Varying q

10

2

10

1

3d

2d

5d

100 10

-1

0.1

0.3

0.5

0.7

0.9

Fig. 6. Efficient, Varying q

Probabilistic Top-k Dominating Query over Sliding Windows

793

From Figures 5 and 6, when threshold grows, the running time decreases. With larger threshold, there are more objects being pruned, i.e. objects whose probability is lower than threshold. In addition, this effect is more obvious with low dimensionality, as more objects to be pruned by the algorithm in the lower dimensional space.

6 Conclusion In this paper, we have investigated the problem of top-k dominating query in the context of sliding window on uncertain data. We first model the probability threshold based top-k dominating problem, and then present a framework to handle the problem. Efficient techniques have been presented to process such query continuously. Extensive experiments demonstrate the effectiveness and efficiency of our techniques.

References 1. Beckmann, N., Kriegel, H.-P., Schneider, R., Seeger, B.: The r*-tree: An efficient and robust access method for points and rectangles. In: SIGMOD Conference, pp. 322–331 (1990) 2. Bernecker, T., Kriegel, H.-P., Mamoulis, N., Renz, M., Z¨ufle, A.: Scalable probabilistic similarity ranking in uncertain databases. IEEE Trans. Knowl. Data Eng. 22(9), 1234–1246 (2010) 3. Bernecker, T., Kriegel, H.-P., Mamoulis, N., Renz, M., Zuefle, A.: Continuous inverse ranking queries in uncertain streams. In: Bayard Cushing, J., French, J., Bowers, S. (eds.) SSDBM 2011. LNCS, vol. 6809, pp. 37–54. Springer, Heidelberg (2011) 4. B¨orzs¨onyi, S., Kossmann, D., Stocker, K.: The skyline operator. In: ICDE, pp. 421–430 (2001) 5. Cormode, G., Garofalakis, M.N.: Sketching probabilistic data streams. In: Chan, C.Y., Ooi, B.C., Zhou, A. (eds.) SIGMOD Conference, pp. 281–292. ACM (2007) 6. Lange, K.: Numerical analysis for statisticians. Statistics and Computing (1999) 7. Lian, X., Chen, L.: Top-k dominating queries in uncertain databases. In: Kersten, M.L., Novikov, B., Teubner, J., Polutin, V., Manegold, S. (eds.) EDBT. ACM International Conference Proceeding Series, vol. 360, pp. 660–671. ACM (2009) 8. Roussopoulos, N., Kelley, S., Vincent, F.: Nearest neighbor queries. In: SIGMOD Conference, pp. 71–79 (1995) 9. Shen, Z., Cheema, M.A., Lin, X., Zhang, W., Wang, H.: Efficiently monitoring top-k pairs over sliding windows. In: Kementsietsidis, A., Salles, M.A.V. (eds.) ICDE, pp. 798–809. IEEE Computer Society (2012) 10. Yiu, M.L., Mamoulis, N.: Efficient processing of top-k dominating queries on multidimensional data. In: VLDB, pp. 483–494 (2007) 11. Zhang, Q., Li, F., Yi, K.: Finding frequent items in probabilistic data. In: SIGMOD Conference, pp. 819–832 (2008) 12. Zhang, W., Lin, X., Zhang, Y., Pei, J., Wang, W.: Threshold-based probabilistic top-k dominating queries. VLDB J. 19(2), 283–305 (2010) 13. Zhang, W., Lin, X., Zhang, Y., Wang, W., Yu, J.X.: Probabilistic skyline operator over sliding windows. In: Ioannidis, Y.E., Lee, D.L., Ng, R.T. (eds.) ICDE, pp. 1060–1071. IEEE (2009)