Computing All Restricted Skyline Probabilities on Uncertain Datasets

TL;DR

This paper investigates the computation of restricted skyline probabilities on uncertain datasets, establishing complexity bounds and proposing efficient algorithms for practical cases with linear scoring functions, validated through extensive experiments.

Contribution

It formalizes the problem, proves complexity bounds, and introduces new algorithms for linear scoring functions with various constraints, improving efficiency in uncertain data scenarios.

Findings

No truly subquadratic algorithm exists unless the orthogonal vectors conjecture fails.

Proposed algorithms achieve near-optimal and expected better time complexities.

Algorithms demonstrate effectiveness and scalability through extensive experiments.

Abstract

Restricted skyline (rskyline) query is widely used in multi-criteria decision making. It generalizes the skyline query by additionally considering a set of personalized scoring functions F. Since uncertainty is inherent in datasets for multi-criteria decision making, we study rskyline queries on uncertain datasets from both complexity and algorithm perspective. We formalize the problem of computing rskyline probabilities of all data items and show that no algorithm can solve this problem in truly subquadratic-time, unless the orthogonal vectors conjecture fails. Considering that linear scoring functions are widely used in practical applications, we propose two efficient algorithms for the case where $\calF$ is a set of linear scoring functions whose weights are described by linear constraints, one with near-optimal time complexity and the other with better expected time complexity. For special linear constraints involving a series of weight ratios, we further devise an algorithm with sublinear query time and polynomial preprocessing time. Extensive experiments demonstrate the effectiveness, efficiency, scalability, and usefulness of our proposed algorithms.

Tables

Table 1. TABLE I : Top-14 players in rskyline probability ranking.

Player	${\mathrm{Pr}}_{\mathrm{rsky}}$	Player	${\mathrm{Pr}}_{\mathrm{rsky}}$
* Russell Westbrook	0.349	* Rudy Gobert	0.142
* Nikola Jokic	0.331	* Clint Capela	0.134
Giannis Antetokounmpo	0.292	Nikola Vucevic	0.126
James Harden	0.213	Andre Drummond	0.109
Joel Embiid	0.186	Julius Randles	0.109
Luka Doncic	0.168	Kevin Durant	0.101
* Domantas Sabonis	0.162	* Jonas Valanciunas	0.095

Table 2. TABLE II : Top-14 players in skyline probability ranking.

Player	${\mathrm{Pr}}_{\mathrm{sky}}$	Player	${\mathrm{Pr}}_{\mathrm{sky}}$
Nikola Jokic	0.557	LeBron James	0.308
Russell Westbrook	0.537	Domantas Sabonis	0.283
Giannis Antetokounmpo	0.479	Stephen Curry	0.266
James Harden	0.447	Kevin Durant	0.257
Luka Doncic	0.398	Nikola Vucevic	0.236
Joel Embiid	0.339	Julius Randle	0.224
Trae Young	0.309	Damian Lillard	0.208

Equations

$$\mathrm{Pr}(D)=\prod _{t\in D}p(t)\cdot \prod _{1\le i\le m,|T_i\cap D|=0}(1-\sum _{t\in T_i}p(t)).$$

$${\mathrm{Pr}}_{\mathrm{rsky}}(t)=\sum _{D⊑\mathcal{D}}\times 1[t\in \mathrm{RSKY}(D,\mathcal{F})]$$

$$\mathrm{ARSP}=\{(t,{\mathrm{Pr}}_{\mathrm{rsky}}(t))\mid t\in I\}.$$

$${\mathrm{Pr}}_{\mathrm{rsky}}(t)=p(t)\cdot \prod _{j=1,j\ne i}^m(1-\sum _{s\in T_j,s{\prec }_{\mathcal{F}}t}p(s)).$$

$${\mathrm{Pr}}_{\mathrm{sky}}(t)=p(t)\cdot \prod _{j=1,j\ne i}^m(1-\sum _{s\in T_j,s⪯t}p(s)).$$

$$h(\omega )=\sum _{i=1}^d(s[i]-t[i])\times \omega [i]$$

$$l_i\le \omega [i]/\omega [d]\le h_{i}1\le i<d$$

$$\omega [d]>0,\sum _{i=1}^d\omega [i]=1.$$

$$h^{\prime }(r)=\sum _{i=1}^{d-1}(s[i]-t[i])\times r[i]+s[d]-t[d]$$

$$l_i\le r[i]\le h_{i}1\le i<d$$

$$h_{t,k}:x[d]=\sum _{i=1}^{d-1}((1-|k{|}_2[i])\times l_i+|k{|}_2[i]\times h_i)\times (t[i]-x[i])+t[d],$$

Full text

I Introduction

Restricted skyline (rskyline) query is a powerful tool for supporting multi-criteria decision making, which extends the skyline query by serving the specific preferences of an individual user. Given a dataset of multidimensional objects and a set of monotone scoring functions $\mathcal{F}$, the rskyline query retrieves the set of objects that are not $\mathcal{F}$-dominated by any other object. Here an object $t$ is said to $\mathcal{F}$-dominate another object $s$ if $t$ scores better than $s$ under all functions in $\mathcal{F}$. It was shown that objects returned by the rskyline query preserve the best score with respect to any function in $\mathcal{F}$, and the result size is usually smaller compared to the skyline query [1]. Due to its effectiveness and wide applications, many efficient algorithms have been proposed to efficiently answer rskyline queries on datasets where no uncertainty is involved [1, 2].

However, uncertainty is inherent in datasets used for multi-criteria decision making caused by limitations of measuring equipment, privacy issues, data incompleteness, outdated data sources, etc. [3]. Below are two application scenarios that involve answering rskyline queries on uncertain datasets.

E-commerce Scenario:* Probabilistic selling is a novel sales strategy in e-commerce [4]. Sellers create probabilistic products by setting the probability of getting any one from a set of products. A typical case is renting cars on Hotwire (www.hotwire.com/car-rentals/). The platform groups cars with varying horsepower (HP) and miles per gallon (MPG) by categories (e.g., compact SUV, median sedan) and abstracts these groups as probabilistic cars. When customers choose a probabilistic car, the platform will provide any car from the corresponding group to them with a predetermined probability. All probabilistic cars form an uncertain dataset for customers to make multi-criteria decisions. Suppose the score of a car is defined as the weighted sum of its attributes. It is unrealistic to expect customers to precisely determine weights of attributes. They can only specify rough demands like MPG is more important than HP. Then performing rskyline queries on such uncertain dataset with $\mathcal{F}=\{\omega_{1}\textsc{HP}+\omega_{2}\textsc{MPG}\mid\omega_{1}\leq\omega_{2}\}$ can retrieve choices with high probabilities getting a car with good fuel economy to aid decision-making.*

Prediction Service:* With the rapid development of machine learning, prediction services are commonly provided in fields such as finance [5], disease control [6], healthcare [7], etc. For example, given historical data of stock market, algorithms like [5] can predict the price (P) and growth rate (GR) of a socket. Such prediction is usually associated with a confidence value (i.e., the probability) and all predictions form an uncertain dataset. By performing rskyline queries over this uncertain dataset with $\mathcal{F}=\{\omega_{1}\text{P}+\omega_{2}\text{GR}\mid 0.5\times\omega_{2}\leq\omega_{1}\leq 2\times\omega_{2}\}$, we can mine an overview of stocks with high probabilities of having advantages in both price and growth rates.*

Motivated by these applications, in this paper, we investigate how to conduct rskyline queries on uncertain datasets. Similar to previous work on uncertain datasets [8, 9, 10, 11, 12, 13, 14], we model uncertainty in a dataset by describing each uncertain object with a discrete probability distribution over a set of instances. Then, we adopt the possible world semantics [15] and define the rskyline probability of an object as the accumulated probabilities of all possible worlds that have one of its instances in their rskylines. Instead of identifying objects with top-$k$ rskyline probabilities or rskyline probabilities above a given threshold, we study the problem of computing rskyline probabilities of all objects. This overcomes the difficulty of selecting an appropriate threshold and is convenient for users to retrieve results with different sizes.

To our knowledge, no work has been done to address this problem to date. Previous researches on uncertain datasets performed different tasks, such as skyline queries (e.g., [10, 16, 17, 18]), top-$k$ queries (e.g., [19, 20, 21, 22, 8]), etc. These work only considered uncertainty in datasets but not in user preferences. However, as stated in [23, 24], determining a precise scoring function for the user, which is required for top-$k$ queries, is hardly realistic, and skyline queries lack personalization. The input $\mathcal{F}$ to our problem overcomes this by considering all possible scoring functions of the user, which can be efficiently learned by algorithms like [25]. Meanwhile, due to the neglect of uncertainty in datasets, existing algorithms for answering rskyline queries [1, 2] can not be applied to our problem. An alternative approach is to convert the uncertain dataset into a certain one by representing each attribute of an object with an aggregate function like weighted sum. However, such aggregated values lose important distribution information. Objects with equal aggregated values but different instances will be treated equally. Our experiments show that this makes the aggregated result ignore objects with slightly lower aggregated values, but still appear in the rskyline result of a great number of possible worlds. We also observe that objects in the aggregated result with low rskyline probabilities will have many instances $\mathcal{F}$-dominated by others’ instances. They are actually less attractive as they only belong to the rskyline result in a small set of possible worlds.

The work most related to ours is researches on computing skyline probabilities of all objects on uncertain datasets [9, 11, 12, 13]. This problem is a special case of our problem because the dominance relation is equivalent to the $\mathcal{F}$-dominance relation when $\mathcal{F}$ contains all monotone scoring functions [1]. Although efficient algorithms were proposed for computing all skyline probabilities in [9, 11, 12, 13], none of them investigated the hardness of this problem. By establishing a fine-grained reduction from the orthogonal vector problem [26], we prove that no algorithm can compute rskyline probabilities of all objects within truly subquadratic time. This also proves the near optimality of algorithms proposed in [9, 11, 12] for computing all skyline probabilities.

In practice, one of the most common ways of specifying $\mathcal{F}$ is to impose linear constraints on weights in linear scoring functions [1]. Unfortunately, existing algorithms for computing all skyline probabilities [9, 11, 12, 13] do not suit for this case. The reason is that the constraints on weights makes the instance’s dominance region, i.e., the region contains all instances $\mathcal{F}$-dominated by this instance, irregular. We overcome this obstacle by mapping instances into a higher dimensional data space. With this methodology, we propose a near-optimal algorithm with time complexity $O(n^{2-1/d^{\prime}})$, where $d^{\prime}$ is the dimensionality of the mapped data space. Furthermore, by conducting the mapping on the fly and designing effective pruning strategies, we propose an algorithm with better expected time complexity based on the branch-and-bound paradigm.

Then, we focus on a special linear constraint called weight ratio constraint, which is also studied in [2] for rskyline queries on certain datasets. In such case, we improve the time complexity of the $\mathcal{F}$-dominance test from $O(2^{d-1})$ to $O(d)$. This newly proposed test condition implies a Turing reduction from the problem of computing rskyline probabilities of all objects to the half-space reporting problem [27]. Based on this reduction, we propose an algorithm with polynomial preprocessing time and $O(2^{d}mn\log{n})$ query time, where $m$ and $n$ is the number of objects and instances, respectively. Subsequently, we introduce the multi-level strategy and the data-shifting strategy to further improve the query time complexity to $O(2^{d-1}\log{n}+n)$. Although this algorithm is somewhat inherently theoretical, experimental results shows that its extension for this special rskyline query on certain datasets outperforms the state-of-the-art index-based method proposed in [2]. The main contributions of this paper are summarized as follows.

1. $\bullet$

We formalize the problem of computing rskyline probabilities of all objects and prove that there is no algorithm can solve this problem in $O(n^{2-\delta})$ time for any $\delta>0$, unless the orthogonal vectors conjecture fails. 2. $\bullet$

When $\mathcal{F}$ is a set of linear scoring functions whose weights are described by linear constraints, we propose an near-optimal algorithm with time complexity $O(n^{2-1/d^{\prime}})$, where $d^{\prime}$ is the number of vertices of the preference region, and an algorithm with expected time complexity $O(mn\log{n})$. 3. $\bullet$

When $\mathcal{F}$ is a set of linear scoring functions whose weights are described by weight ratio constraints, we propose an algorithm with polynomial preprocessing time and $O(2^{d-1}\log{n}+n)$ query time. 4. $\bullet$

We conduct extensive experiments over real and synthetic datasets to demonstrate the effectiveness of the problem studied in this paper and the efficiency and scalability of the proposed algorithms.

II Problem Definition and Hardness

II-A Restricted Skyline

Let $D$ be a $d$-dimensional dataset consisting of $n$ objects. Each object $t\in D$ has $d$ numeric attributes, denoted by $t=(t[1],\cdots,t[d])$. W.l.o.g., we assume lower values are preferred than higher ones. Given a scoring function $f:\mathbb{R}^{d}\to\mathbb{R}^{+}$, the value $f(t[1],\cdots,t[d])$ is called the score of $t$ under $f$, also written as $f(t)$. Function $f$ is called monotone if for any two objects $t$ and $s$, it holds that $f(t)\leq f(s)$ if $\forall 1\leq i\leq d$, $t[i]\leq s[i]$. Let $\mathcal{F}$ be a set of monotone scoring functions, an object $t$ $\mathcal{F}$-dominates another object $s\neq t$, denoted by $t\prec_{\mathcal{F}}s$, if $\forall f\in\mathcal{F}$, $f(t)\leq f(s)$. The restricted skyline (rskyline) of $D$ with respect to $\mathcal{F}$ is the set of objects that are not $\mathcal{F}$-dominated by any other object, i.e., ${\rm RSKY}(D,\mathcal{F})=\{t\in D\mid\nexists s\in D,s\prec_{\mathcal{F}}t\}$.

II-B Restricted Skyline Probability

Let $\mathcal{D}$ denote a $d$-dimensional uncertain dataset including $m$ objects. Each uncertain object $T_{i}\in\mathcal{D}$ is a discrete probability distribution over the $d$-dimensional data space. In other word, the sample space of $T_{i}$ is a set of points $\{t_{i,1},\cdots,t_{i,n_{i}}\}$ in the $d$-dimensional data space. Each point $t_{i,j}$ is called an instance of $T_{i}$ and $T_{i}$ has probability $p(t_{i,j})$ to occur as $t_{i,j}$. We also use $T_{i}$ to denote the set of its instances $\{t_{i,1},\cdots,t_{i,n_{i}}\}$ and write $t\in T_{i}$ to mean that $t$ is an instance of $T_{i}$. For any object $T_{i}$, we assume $\sum_{t\in T_{i}}p(t_{i})\leq 1$ and $T_{i}$ can only take one instance at a time. Let $I=\cup_{i=1}^{m}T_{i}$ denote the set of all instances and $n=|I|=\sum_{i=1}^{m}n_{i}$. To cope with datasets of large scale, we use a spatial index R-tree to organize $I$.

Similar to previous work **[10, 9, 11, 12, 13, 28, 29]**, we adopt the possible world semantics **[15]** and assume objects are independent of each other. The uncertain dataset $\mathcal{D}$ is interpreted as a probability distribution over a set of datasets $D\sqsubseteq\mathcal{D}$ obtained by sampling each object $T_{i}$. And the probability of observing the possible world $D$ is

[TABLE]

Given an uncertain dataset $\mathcal{D}$ and a set of monotone scoring functions $\mathcal{F}$, the rskyline probability of an instance $t\in T_{i}$ is the accumulated possible world probabilities of all possible worlds that have $t$ in their rskyline with respect to $\mathcal{F}$. Formally,

[TABLE]

where $\mathbf{1}[\cdot]$ is the indicator function. And the rskyline probability of an object $T_{i}$, denoted by $\Pr_{\rm rsky}(T_{i})$, is defined as the sum of rskyline probabilities of all its instances.

Example 1**.**

*Consider the uncertain dataset $\mathcal{D}$ shown in Fig. 1. $D=\{t_{1,1},t_{2,1},t_{3,1},t_{4,1}\}$ is a possible world of $\mathcal{D}$ and $\Pr(D)=p(t_{1,1})\times p(t_{2,1})\times p(t_{3,1})\times p(t_{4,1})=1/36$. Let $\mathcal{F}=\{\omega[1]t[1]+\omega[2]t[2]\mid 0.5\times\omega[2]\leq\omega[1]\leq 2\times\omega[2]\}$, the set of possible worlds that have $t_{1,1}$ in their rskyline with respect to $\mathcal{F}$ is $S=\{t_{1,1}\}\times\{t_{2,2},t_{2,3}\}\times\{t_{3,2},t_{3,3}\}\times\{t_{4,1},t_{4,2}\}$. Therefore, $\Pr_{\rm rsky}(t_{1,1})=\sum_{D\in S}\Pr(D)=2/9$. Similarly, we know $\Pr_{\rm rsky}(t_{1,2})=0$. Hence, $\Pr_{\rm rsky}(T_{1})=\Pr_{\rm rsky}(t_{1,1})+\Pr_{\rm rsky}(t_{1,2})=2/9$. *

The main problem studied in this paper is as follows.

Problem 1** (All RSkyline Probabilities (ARSP)).**

Given an uncertain dataset $\mathcal{D}=\{T_{1},\cdots,T_{m}\}$ and a set of monotone scoring functions $\mathcal{F}$, compute rskyline probabilities of all instances in $I=\cup^{m}_{i=1}T_{i}$, i.e., return the set

[TABLE]

II-C Conditional Lower Bound

We show that no algorithm can solve the ARSP problem in truly subquadratic time without preprocessing, unless the orthogonal vectors conjecture fails.

$\blacktriangleright$* Orthogonal Vectors Conjecture [26]. Given two sets $A,B$, each of $n$ vectors in $\{0,1\}^{d}$, for every $\delta>0$, there is a $c\geq 1$ such that no $O(n^{2-\delta})$-time algorithm can determine if there is a pair $(a,b)\in A\times B$ such that $a\times b=0$ with $d=c\log{n}$.*

Theorem 1**.**

Given an uncertain dataset $\mathcal{D}$ and a set of monotone scoring functions $\mathcal{F}$, no algorithm can compute rskyline probabilities of all instances within $O(n^{2-\delta})$ time for any $\delta>0$, unless the Orthogonal Vectors conjecture fails.

Proof.

We establish a fine-grained reduction from the orthogonal vectors problem to the ARSP problem. Given two sets $A,B$, each of $n$ vectors in $\{0,1\}^{d}$, we construct an uncertain dataset $\mathcal{D}$ and a set $\mathcal{F}$ of monotone scoring functions as follows. First, for each vector $b\in B$, we construct an uncertain tuple $T_{b}$ with a single instance $b$ and $p(b)=1$. Then, we construct an uncertain tuple $T_{A}$ with $n$ instances $\xi(a)$ and $p(\xi(a))=\frac{1}{n}$ for all vectors $a\in A$, where $\xi(a)[i]=\frac{3}{2}$ if $a[i]=0$ and $\xi(a)[i]=\frac{1}{2}$ if $a[i]=1$ for $1\leq i\leq d$. Finally, let $\mathcal{F}$ consists of $d$ linear scoring functions $f_{i}(t)=t[i]$ for $1\leq i\leq d$, which means instance $t$ $\mathcal{F}$-dominates another instance $s$ if and only if $t[i]\leq s[i]$ for $1\leq i\leq d$. We claim that for each instance $\xi(a)\in T_{A}$, there exists an instance $b$ from other uncertain tuple $T_{b}$ $\mathcal{F}$-dominating $\xi(a)$ if and only if $a$ is orthogonal to $b$. Suppose there is a pair $(a,b)\in A\times B$ such that $a\times b=0$, then $a[i]=0$ or $b[i]=0$ for $1\leq i\leq d$. If $a[i]=0$, then $b[i]$ can be either 0 or 1 and $\xi(a)[i]=\frac{3}{2}>b[i]$. Or if $b[i]=0$, then $a[i]$ can be either 0 or 1 and $\xi(a)[i]\geq\frac{1}{2}>b[i]$. That is $b\prec_{\mathcal{F}}\xi(a)$. On the other side, suppose there is a pair of instances $b$ and $\xi(a)$ such that $b\prec_{\mathcal{F}}\xi(a)$. For each $1\leq i\leq d$, $b[i]$ is either 0 or 1 and $\xi(a)[i]$ is either $\frac{3}{2}$ and $\frac{1}{2}$. If $b[i]=0$, then $b[i]\cdot a[i]=0$. Or if $b[i]=1$, then $\xi(a)[i]=\frac{3}{2}$ since $b[i]\leq\xi(a)[i]$. So $a[i]=0$ according to the mapping $\xi(\cdot)$. Hence $a[i]\cdot b[i]=0$. Thus we conclude that there is a pair $(a,b)\in A\times B$ such that $a\times b=0$ if and only if there exists an instance $\xi(a)\in T_{A}$ with $\Pr_{\rm rsky}(\xi(a))=0$. Since $\mathcal{D}$ can be constructed in $O(nd)$ time and whether such instance exists can be determined in $O(n)$ time, any $O(n^{2-\delta})$-time algorithm for all rskyline probabilities computation for some $\delta>0$ would yield an algorithm for Orthogonal Vectors in $O(nd+n^{2-\delta}+n)=O(n^{2-\delta^{\prime}})$ time for some $\delta^{\prime}>0$ when $d=\Theta(\log{n})$, which contradicts the Orthogonal Vectors conjecture. ∎

III Algorithms for ARSP Problem

with Linear Scoring Functions

The linear scoring function is one of the most commonly used scoring functions in practice **[31]**. Given a weight $\omega$, the score of an object $t$ is defined as $S_{\omega}(t)=\sum^{d}_{i=1}\omega[i]t[i]$. Since ordering any two objects by $S_{\omega}(\cdot)$ is independent from the magnitude of $\omega$, we assume $\omega$ belongs to the unit $(d-1)$-simplex $\mathbb{S}^{d-1}$, i.e., $\forall 1\leq i\leq d$, $\omega[i]\geq 0$, and $\sum^{d}_{i=1}\omega[i]=1$. To serve the specific preferences of an individual user, a notable approach is to add linear constraints $A\times\omega\leq b$ on $\mathbb{S}^{d-1}$, where $A$ is a $c\times d$ matrix and $b$ is a $c\times 1$ matrix. In this section, we propose two efficient algorithms to compute ARSP in case of $\mathcal{F}=\{S_{\omega}(\cdot)\mid\omega\in\mathbb{S}^{d-1}\wedge A\times\omega\leq b\}$.

III-A Baseline Algorithms

According to equation (2), a baseline algorithm to compute ARSP is to enumerate each possible worlds $D\sqsubseteq\mathcal{D}$, compute ${\rm RSKY}(D,\mathcal{F})$, and add $\Pr(D)$ to $\Pr_{\rm rsky}(t)$ for each $t\in{\rm RSKY}(D,\mathcal{F})$. However, this brute force algorithm is infeasible due to the exponential time complexity.

Note that for any $D\sqsubseteq\mathcal{D}$, an instance $t\in T_{i}$ belongs to ${\rm RSKY}(D,\mathcal{F})$ if and only if $T_{i}$ occurs as $t$ in $D$ and none of other objects appears as an instance that $\mathcal{F}$-dominates $t$ in $D$. Thus, $\Pr_{\rm rsky}(t)$ can be equivalently represented as

[TABLE]

The major challenge of equation (3) is to compute the product of probabilities that all other objects occur as instances that do not $\mathcal{F}$-dominate $t$. A straight approach is to perform $\mathcal{F}$-dominance tests between $t$ and all instances from other objects. With the fact that the preference region $\Omega=\{\omega\in\mathbb{S}^{d-1}\mid A\times\omega\leq b\}$ is a closed convex polytope, the $\mathcal{F}$-dominance relation between two instances can be determined by comparing their scores under the set of vertices $V$ of $\Omega$. Here a weight $\omega$ is called a vertex of $\Omega$ if and only if it is the unique solution to a $d$-subset inequalities of $A\times\omega\leq b$.

Theorem 2** ($\mathcal{F}$-dominance test [1]).**

Given a set of linear scoring functions $\mathcal{F}=\{S_{\omega}(\cdot)\mid\omega\in\mathbb{S}^{d-1}\wedge A\times\omega\leq b\}$, let $V$ be the set of vertices of the preference region $\Omega=\{\omega\in\mathbb{S}^{d-1}\mid A\times\omega\leq b\}$, an instance $t$ $\mathcal{F}$-dominates another instance $s$ if and only if $S_{\omega}(t)\leq S_{\omega}(s)$ holds for all weights $\omega\in V$.

With Theorem 2, we construct another baseline algorithm as follows. Since the preference region $\Omega$ is closed, the set of linear constraints can be transformed into a set of points using the polar duality **[32]** such that the intersection of the linear constraints is the dual of the convex hull of the points. After the transformation, the baseline invokes the quickhull algorithm proposed in **[33]** to compute the set of vertices $V$ of $\Omega$. Then it sorts the set of instances using a scoring function $S_{\omega}(\cdot)$ for some $\omega\in V$. This guarantees that if an instance $t$ precedes another instance $s$ in the sorted list, then $s\nprec_{\mathcal{F}}t$. After that, for each instance $t$, the baseline tests $t$ against every instance of other objects preceding $t$ in the sorted list to compute $\Pr_{\rm rsky}(t)$ according to equation (3). Since $V$ can be computed in $O(c^{2})$ time **[34]**, where $c$ is the number of linear constraints, and each $\mathcal{F}$-dominance test can be performed in $O(dd^{\prime})$ time, where $d^{\prime}=|V|$, the time complexity of the baseline algorithm is $O(c^{2}+dd^{\prime}n^{2})$. Although the theoretical upper bound of $d^{\prime}$ is $\Theta(c^{\lfloor d/2\rfloor})$ **[35]**, the actual size of $V$ is experimentally observed to be small.

III-B Tree-Traversal Algorithm

We say an object $t$ dominates another object $s\neq t$, denoted by $t\preceq s$, if $\forall 1\leq i\leq d,t[i]\leq s[i]$. Given an uncertain dataset $\mathcal{D}$, the skyline probability of an instance $t\in T_{i}$ is defined as

[TABLE]

The all skyline probabilities (ASP) problem aims to compute skyline probabilities of all instances **[9, 11, 12, 13]**. In case of $\mathcal{F}=\{S_{\omega}(\cdot)\mid\omega\in\mathbb{S}^{d-1}\wedge A\times\omega\leq b\}$, we show how to transform the ARSP problem to the ASP problem.

Given a $d$-dimensional uncertain dataset $\mathcal{D}$ and a set of linear scoring functions $\mathcal{F}=\{S_{\omega}(\cdot)\mid\omega\in\mathbb{S}^{d-1}\wedge A\times\omega\leq b\}$, let $V=\{\omega_{1},\cdots,\omega_{d^{\prime}}\}$ be the set of vertices of the preference region $\Omega=\{\omega\in\mathbb{S}^{d-1}\mid A\times\omega\leq b\}$ and $d^{\prime}=|V|$. For each $t\in I$, $S_{{}_{V}}(t)=(S_{\omega_{1}}(t),\cdots,S_{\omega_{d^{\prime}}}(t))$ is a $d^{\prime}$-dimensional point whose $i$-th coordinate is the score of instance $t$ under $\omega_{i}\in V$. We construct a $d^{\prime}$-dimensional uncertain dataset $\mathcal{D}^{\prime}$ as follows. For each uncertain object $T_{i}\in\mathcal{D}$, we create an uncertain object $T^{\prime}_{i}$ in $\mathcal{D}^{\prime}$. Then, for each instance $t\in T_{i}$, we compute $S_{{}_{V}}(t)$ as an instance of $T^{\prime}_{i}$ and set $p(S_{{}_{V}}(t))=p(t)$. From Theorem 2, it is directly to know that for any two instance $t,s\in I$, $t\prec_{\mathcal{F}}s$ if and only if $S_{{}_{V}}(t)\preceq S_{{}_{V}}(s)$. This means, for each $t\in I$, $\Pr_{\rm rsky}(t)=\Pr_{\rm sky}(S_{{}_{V}}(t))$. Thus, after constructing $\mathcal{D}^{\prime}$, we employ the procedure $kd$-ASP∗ on $\mathcal{D}^{\prime}$ to compute skyline probabilities of all instances in $I^{\prime}=\cup^{m}_{i=1}T^{\prime}_{i}$.

$kd$-ASP∗* is an optimized implementation of the state-of-the-art algorithm for the ASP problem proposed in [12]. The original algorithm first constructs a $kd$-tree $T$ on $I^{\prime}$, and then progressively computes skyline probabilities of all instances by performing a preorder traversal of $T$. We optimized it by integrating the preorder traversal into the construction of $T$ and pruning the construction of a subtree if all instances included in the subtree have zero skyline probabilities. Although these optimizations does not improve the time complexity, they do enhance its experimental performance.*

Concretely, $kd$-ASP∗ always keeps a path from the root of $T$ to the current reached node in the main memory. And for each node $N$ in the path, let $P$ be the set of instances contained in $N$ and $P_{\min}$ ($P_{\max}$) denote the minimum (maximum) corner of the minimum bounding rectangle of $P$, $kd$-ASP∗ maintains the following information, (1) a set $C$ including instances that dominates $P_{\max}$, (2) an array $\sigma=\langle\sigma[1],\sigma[2],\cdots\sigma[m]\rangle$, where $\sigma[i]=\sum_{t\in T_{i},S_{{}_{V}}(t)\preceq P_{\min}}p(t)$, i.e., the sum of existence probabilities over instances of $T^{\prime}_{i}$ that dominate $P_{\min}$, (3) a value $\beta=\prod_{1\leq i\leq m,\sigma[i]\neq 1}(1-\sigma[i])$, and (4) a counter $\chi=|\{i\mid\sigma[i]=1\}|$.

At the beginning, $kd$-ASP∗ initializes $C=I^{\prime}$, $\sigma[i]=0$ for $1\leq i\leq m$, $\beta=1$, and $\chi=0$ at the root node of $T$. Supposing the information of all nodes in the maintained path is available, $kd$-ASP∗ constructs the next arriving node $N$ as follows. Again, let $P$ denote the set of instances in $N$. For each instance $S_{{}_{V}}(t)\in C_{par}$, where $C_{par}$ is the set $C$ of the parent node of $N$, it tests $S_{{}_{V}}(t)$ against $P_{\min}$. If $S_{{}_{V}}(t)\preceq P_{\min}$, say $t\in T_{i}$, it updates $\sigma[i]$, $\beta$, and $\chi$ as stated in lines 12-16 of Algorithm 1. Otherwise, it further tests $S_{{}_{V}}(t)$ against $P_{\max}$ and inserts $S_{{}_{V}}(t)$ into the set $C$ of $N$ if $S_{{}_{V}}(t)\preceq P_{\max}$. When $\chi$ becomes to one, we know that $\Pr_{\rm sky}(P_{\min})=0$, and so are all instances in $N$ due to the transitivity of dominance. Therefore, $kd$-ASP∗ prunes the construction of the subtree rooted at $N$ and returns to its parent node. Otherwise, $kd$-ASP∗ keeps growing the path by partitioning set $P$ like a $kd$-tree until it reaches a node including only one instance $S_{{}_{V}}(t)$, then computes $\Pr_{\rm sky}(S_{{}_{V}}(t))$ based on $\beta$ and $\sigma$.

Example 2**.**

As shown in Fig. 2, suppose all instances of an object occur with the same probability. The original algorithm keeps a whole $kd$-tree in the main memory but $kd$-ASP∗ only maintains a path from the root node, e.g., $R_{1}\to R_{2}\to R_{5}$. Moreover, when $kd$-ASP∗ traverses from $R_{1}$ to $R_{3}$, it updates $\sigma[2]$ to $1$ and $\chi$ to $1$ since $t_{2,1}\preceq R_{3}$. This indicates that the skyline probabilities of all instances in the subtree rooted at $R_{3}$ is zero, thus $kd$-ASP∗ prunes the construction of the subtree rooted at $R_{3}$ as shown in Fig. 2(b).

The pseudocode of the entire algorithm is shown in Algorithm 1. As stated previously, the computation of $V$ takes $O(c^{2})$ time, where $c$ is the number of linear constraints. For each instance $t\in I$, $S_{{}_{V}}(t)$ can be computed in $O(dd^{\prime})$ time, where $d^{\prime}=|V|$. According to **[12]**, the time complexity of $kd$-ASP∗ on a set of $n$ instances in $d^{\prime}$-dimensional data space is $O(n^{2-1/d^{\prime}})$. Therefore, the overall time complexity of Algorithm 1 is $O(c^{2}+d^{\prime}dn+n^{2-1/d^{\prime}})=O(n^{2-1/d^{\prime}})$.

Next, we claim that Theorem 1 still holds even if we limit $\mathcal{F}$ into linear scoring functions whose weights are described by linear constraints. Let $\mathcal{F}$ be the set of all linear scoring functions. Given two instances $t$ and $s$, if $t\prec_{\mathcal{F}}s$, then $t[i]\leq s[i]$ for $1\leq i\leq d$ since $\omega_{i}\in\Omega$ where $\omega_{i}[i]=1$ and $\omega_{i}[j]=0$ for all $1\leq j\neq i\leq d$. If $t[i]\leq s[i]$ for $1\leq i\leq d$, it is known that $t\prec_{\mathcal{F}}s$ since all linear scoring functions are monotone. Hence, we can also conclude that $t\prec_{\mathcal{F}}s$ if and only if $t[i]\leq s[i]$ for $1\leq i\leq d$. Thus, with the same reduction established in the proof of Theorem 1, it is known that there is no subquadratic-time algorithm for the ARSP problem even if $\mathcal{F}$ is limited into linear scoring functions whose weights are described by linear constraints. This proves that Algorithm 1 achieves a near-optimal time complexity.

Remark.* Algorithm 1 also works when $kd$-ASP∗ adopts any other space-partitioning tree. The only detail that needs to be modified is the method to partition the data space (line 23-25 of Algorithm 1). In our experimental study, we implement a variant of Algorithm 1 based on the quadtree, which partitions the data space in all dimensions each time. It is observed that choosing an appropriate space-partitioning tree can improve the performance of Algorithm 1. For example, the quadtree-based implementation works well in low-dimensional data spaces, while the $kd$-tree-based implementation have better scalability for data dimensions.*

III-C Branch-and-Bound Algorithm

A drawback of Algorithm 1 is that it needs to map $\mathcal{D}$ to $\mathcal{D}^{\prime}$ in advance, in this subsection, we show how to do the mapping on the fly so that unnecessary computations can be avoided.

Recall that if instances in $I$ are sorted in ascending order according to their scores under some $f\in\mathcal{F}$, then an instance $t$ will not be $\mathcal{F}$-dominated by any instance $s$ after $t$. Assuming that instances are processed in the sorted order, $S_{{}_{V}}(t)$ may only be involved in the computation of instances after $t$. If we know ignoring $S_{{}_{V}}(t)$ has no effect on those computations, then the mapping can be avoided. Unlike conducting probabilistic rskyline analysis under top-$k$* or threshold semantics, maintaining upper and lower bounds on each instance’s rskyline probability as pruning criteria is helpless since our goal is to compute exact rskyline probabilities of all instances. Thus, the only pruning strategy can be utilized is that if an instance $t$ is $\mathcal{F}$-dominated by another instance $s$ and $\Pr_{\rm rsky}(s)$ is zero, then $\Pr_{\rm rsky}(t)$ is also zero due to the transitivity of $\mathcal{F}$-dominance. A straight method for efficiently performing this pruning strategy is to keep a rskyline of all instances processed so far whose rskyline probabilities are zero and compare the next instance to be processed against all instances in the rskyline beforehand. However, the maintained rskyline may suffer from huge scale on anti-correlated datasets. In what follows, we prove that all instances with zero rskyline probability can be safely ignored and a set $P$ of size at most $m$ is sufficient for pruning tests.*

Theorem 3**.**

All instances with zero rskyline probability can be safely discarded.

Proof:

Let $t\in T_{i}$ be an instance with $\Pr_{\rm rsky}(t)=0$. Recall the formulation of rskyline probability in equation 3, all other instances of $T_{i}$ will not be affected by $t$. This also holds for instances of other objects $T_{j}$ that are not $\mathcal{F}$-dominated by $t$. Now, suppose $s$ is an instance of $T_{j\neq i}$ and $s$ is $\mathcal{F}$-dominated by $t$. Since $t\prec_{\mathcal{F}}s$ and $\Pr_{\rm rsky}(t)=0$, it is easy to see that there exists a set of objects $\mathcal{T}=\{T_{k}\mid k\neq j\wedge k\neq i\}$ such that all instances of each object $T_{k}\in\mathcal{T}$ $\mathcal{F}$-dominate $t$. Moreover, because $\mathcal{F}$-dominance is asymmetric, it is known that there exists at least one object $T_{k}\in\mathcal{T}$, all instances of which have non-zero rskyline probability. Therefore, according to the transitivity of $\mathcal{F}$-dominance, $s$ is also $\mathcal{F}$-dominated by all instances of $T_{k}$ and thus $\Pr_{\rm rsky}(s)=0$. ∎

Theorem 4**.**

Let $V=\{\omega_{1},\cdots,\omega_{d^{\prime}}\}$ be the set of vertices of the preference region $\Omega=\{\omega\in\mathbb{S}^{d-1}\mid A\times\omega\leq b\}$, there is a set $P$ such that for any instance $t$, ${\rm Pr}_{\rm rsky}(t)=0$ if and only if $S_{{}_{V}}(t)$ is dominated by some instance $p\in P$ and $|P|\leq m$.

Proof:

We start with the construction of the pruning set $P$. For each object $T_{i}$ with $\sum_{t\in T_{i}}p(t)=1$, we insert an instance $p_{i}=(\max_{t\in T_{i}}S_{\omega_{1}}(t),\cdots,\max_{t\in T_{i}}S_{\omega_{d^{\prime}}}(t))$ into $P$. Note that the above construction also requires to map all instances into the score space in advance in order to facilitate the understanding of the proof. However, in the proposed algorithm, we construct $P$ incrementally during the computation. It is straight to verify that $|P|\leq m$ from the construction of $P$. Then, let $t$ denote an instance of object $T_{i}$, we prove that $\Pr_{\rm rsky}(t)=0$ if and only if $S_{{}_{V}}(t)$ is dominated by some $p_{j\neq i}\in P$. From equation 3, it is easy to see that $\Pr_{\rm rsky}(t)=0$ if and only if there must exist an object $T_{j\neq i}$ such that every instance $s\in T_{j}$ $\mathcal{F}$-dominates $t$ and $\sum_{s\in T_{j}}p(s)=1$. That is $S_{{}_{V}}(s)\preceq S_{{}_{V}}(t)$ holds for all instances $s\in T_{j}$ according to Theorem 2. Moreover, since a set of instances dominates another instance if and only if the maximum corner of their minimum bounding rectangle dominates that instance, it is derived that $\Pr_{\rm rsky}(t)=0$ if and only if $p_{j}=(\max_{s\in T_{j}}S_{\omega_{1}}(s),\cdots,\max_{s\in T_{j}}S_{\omega_{d^{\prime}}}(s))\preceq t$. Based on the construction of $P$, it is known that all $p_{j}$ are included in $P$, thus completing the proof. ∎

Now, we propose an algorithm with the pruning strategy. The pseudocode is shown in Algorithm 2. The algorithm first computes the set of vertices $V$ of the preference region $\Omega$ and initializes $m$ aggregated R-trees $R_{1},\cdots,R_{m}$, where $R_{i}$ is used to incrementally index $S_{{}_{V}}(t)$ for all instances $t\in T_{i}$ with $\Pr_{\rm rsky}(t)>0$ that have been processed so far. After that, the algorithm traverses the index $R$ on $I$ in a best-first manner. Specifically, it first inserts the root of R-tree into a minimum heap $H$ sorted according to its score under some $S_{\omega\in V}(\cdot)$, where the score of a node $N$ is defined as $S_{\omega}(N_{\min})$. Then, at each time, it handles the top node $N$ popped from $H$. If $S_{{}_{V}}(N_{\min})$ is dominated by some instance in $P$, then the algorithm ignores all instances in $N$ since their rskyline probabilities are zero due to the transitivity of $\mathcal{F}$-dominance. Otherwise, if $N$ is a leaf node, say $t\in T_{i}$ is contained in $N$, the algorithm computes $S_{{}_{V}}(t)$ and issues the window query with the origin and $S_{{}_{V}}(t)$ on each aggregated R-tree $R_{j\neq i}$ to compute $\sigma[j]=\sum_{s\in T_{j},s\prec_{\mathcal{F}}t}p(s)$ and inserts $S_{{}_{V}}(t)$ into $R_{i}$. Then it updates $p_{i}$, which records the maximum corner of the minimum bounding rectangle of $S_{{}_{V}}(t)$ for all instances $t\in T_{i}$ with $\Pr_{\rm rsky}(t)>0$ that have been processed so far, and inserts $p_{i}$ into $P$ if all instances in $T_{i}$ have non-zero rskyline probability. Or if $N$ is an internal node, it inserts all non-pruned child nodes of $N$ into $H$ for further computation.

With the fact that Algorithm 2 only visits the nodes which contain instances $t$ with $\Pr_{\rm rsky}(t)>0$ and never access the same node twice, it is easy to prove that the number of nodes accessed by Algorithm 2 is optimal to compute ARSP. And since $m-1$ orthogonal range queries are performed on aggregated R-trees for each instance in $I$, the expected time complexity of Algorithm 2 is $O(nm\log{n})$.

IV Sublinear-time Algorithm

for Weight Ratio Constraints

In this section, we use preprocessing to accelerate ARSP computation when $\mathcal{F}$ is a set of linear scoring functions whose weights are described by weight ratio constraints. Formally, let $R=\prod^{d-1}_{i=1}[l_{i},h_{i}]$ denote a set of user-specified ranges, weight ratio constraints $R$ on $\mathbb{S}^{d-1}$ require $\omega[d]>0$ and $l_{i}\leq\omega[i]/\omega[d]\leq h_{i}$ holds for every $1\leq i<d$. Liu et al. have investigated this special $\mathcal{F}$-dominance on traditional datasets, renamed as eclipse-dominance, and defined the eclipse query to retrieve the set of all non-eclipse-dominated objects **[2]**. We refer the readers to their paper for the wide applications of eclipse query. Although we focus on uncertain datasets, our methods can also be used to design improved algorithms for eclipse query processing as shown in our experiments.

IV-A Reduction to Half-space Reporting Problem

Given a set of user-specified ranges $R=\prod^{d-1}_{i=1}[l_{i},h_{i}]$ and two instances $t$ and $s$, let $\omega^{*}$ be the optimal solution of the following linear programming (LP) problem,

[TABLE]

Under weight ratio constraints $R$, the $\mathcal{F}$-dominance test condition stated in Theorem 2 can be equivalently represented as determining whether $h(\omega^{*})\geq 0$. The crucial observation is that the sign of $h(\omega^{*})$ can be determined more efficiently without solving problem (4). To be specific, let $r^{*}$ be the optimal solution of the following LP problem,

[TABLE]

The following lemma proves that $h^{\prime}(r^{*})\geq 0$ if and only if $h(\omega^{*})\geq 0$.

Lemma 1**.**

Let $r^{*}$ and $\omega^{*}$ be the optimal solutions of LP problems (4) and (5), respectively. $h^{\prime}(r^{*})\geq 0$ if and only if $h(\omega^{*})\geq 0$.

Proof:

We first prove that if $h(\omega^{*})\geq 0$, then $h^{\prime}(r^{*})\geq 0$. Let $\omega=(r^{*}[1]/(\sum^{d-1}_{i=1}r^{*}[i]+1),\cdots,r^{*}[d-1]/(\sum^{d-1}_{i=1}r^{*}[i]+1),1/(\sum^{d-1}_{i=1}r^{*}[i]+1))$. For any $1\leq i<d$, $\omega[i]/\omega[d]=r^{*}[i]\in[l_{i},h_{i}]$. And $\sum^{d}_{i=1}\omega[i]=1$. Therefore, $\omega$ is a feasible solution of LP problem (4). Hence, $h^{\prime}(r^{*})=(\sum^{d-1}_{i=1}r^{*}[i]+1)\times h(\omega)\geq(\sum^{d-1}_{i=1}r^{*}[i]+1)\times h(\omega^{*})\geq 0$.

Next, we prove that if $h^{\prime}(r^{*})\geq 0$, then $h(\omega^{*})\geq 0$. Let $r=(\omega^{*}[1]/\omega^{*}[d],\cdots,\omega^{*}[d-1]/\omega^{*}[d])$. For any $1\leq i<d$, $\omega^{*}[i]/\omega^{*}[d]\in[l_{i},h_{i}]$. Hence, $r$ is a feasible solution of LP problem (5). Thus, $h(\omega^{*})=\omega^{*}[d]\times h^{\prime}(r)\geq\omega^{*}[d]\times h^{\prime}(r^{*})\geq 0$. ∎

Since each $r[i]=\omega[i]/\omega[d]$ can be choose independently from the corresponding interval $[l_{i},h_{i}]$, $r^{*}$ can be directly determined in $O(d)$ time. Based on this, we can perform $\mathcal{F}$-dominance test more efficiently.

Theorem 5** (Efficient $\mathcal{F}$-dominance test).**

Let $\mathcal{F}$ be a set of linear scoring functions whose weights are described by weight ratio constraints $R=\prod^{d-1}_{i=1}[l_{i},h_{i}]$, an instance $t$ $\mathcal{F}$-dominates another instance $s$ if and only if $t[d]-s[d]\leq\sum^{d-1}_{i=1}(\mathbf{1}[s[i]>t[i]]\times l_{i}+(1-\mathbf{1}[s[i]>t[i]])\times h_{i})\times(s[i]-t[i])$, where $\mathbf{1}[\cdot]$ is the indicator function.

According to Theorem 5, we present a reduction of finding all instances in $I$ that $\mathcal{F}$-dominate instance $t$ to a series of $2^{d-1}$ half-space reporting problem **[27]**, which aims to preprocess a set of points in d into a data structure so that all points lying below or on a query hyperplane can be reported quickly. We partition the data space $\mathbb{R}^{d}$ into $2^{d-1}$ regions using $d-1$ hyperplanes $x[i]=t[i]$ ($1\leq i<d$). Then, each resulted region can be identified by a $(d-1)$-bit code such that the $i$-th bit is 0 if the $i$-th attributes of instances in this region are less than $t[i]$, and 1 otherwise. We refer the region whose identifier is $k$ in decimal as region $k$. Suppose $t\in T_{i}$, let $I_{t,k}$ denote the set of instances of other uncertain objects contained in region $k$. As an example, $I_{t,0}=\{s\in I\setminus T_{i}\mid\forall 1\leq i<d.s[i]<t[i]\}$. It is easy to verify for each $0\leq k<2^{d-1}$, when performing $\mathcal{F}$-dominance test between instances in $I_{t,k}$ and $t$, the results of $d-1$ indicator functions in Theorem 5 are identical for all instances in $I_{t,k}$. Geometrically, all instances in $I_{t,k}$ that $\mathcal{F}$-dominate $t$ must lie below or on the following hyperplane,

[TABLE]

where $\lvert k\rvert_{2}[i]$ is $i$-th bit of the binary of number $k$.

Example 3**.**

The uncertain dataset used in Example 1 is plotted in Fig. 3(a). Consider instance $t_{2,3}$. Data space $\mathbb{R}^{2}$ is partitioned with the line $t[1]=t_{2,3}[1]=9$. Region 0 contains the set of instances $I_{t_{2,3},0}=\{s\in I\setminus T_{2}\mid s[1]\leq t_{2,3}[1]\}=\{t_{1,1},t_{1,2},t_{3,1},t_{3,2},t_{4,1}\}$, and region 1 contains the set of instances $I_{t_{2,3},1}=\{t_{3,3},t_{4,2}\}$. Given weight ratio constraints $R=[0.5,2]$, according to equation (6), the hyperplane $h_{t_{2,3},0}$ in region 0 is $t[2]=-0.5t[1]+16.5$ and the hyperplane $h_{t_{2,3},1}$ in region 1 is $t[2]=-2t[1]+30$. Since $t_{3,1}$ and $t_{3,2}$ ly below or on $h_{t_{2,3},0}$, we know $t_{3,1}\prec_{\mathcal{F}}t_{2,3}$ and $t_{3,2}\prec_{\mathcal{F}}t_{2,3}$. And since $t_{3,3}$ lies on $h_{t_{2,3},1}$, we know $t_{3,3}\prec_{\mathcal{F}}t_{2,3}$.

The half-space reporting problem can be efficiently solved using the well-known point-hyperplane duality **[36]**. The duality maps a point $p=(p[1],\cdots,p[d])\in^{d}$ into the hyperplane $p^{*}:x[d]=p[1]x[1]+\cdots+p[d-1]x[d-1]-p[d]$, and a hyperplane $h:x[d]=\alpha[1]x[1]+\cdots+\alpha[d-1]x[d-1]-\alpha[d]$ into the point $h^{*}=(\alpha[1]\cdots,\alpha[d])$. It is proved that if $p$ lies above (resp., below, on) $h$, then $h^{*}$ lies above (resp., below, on) $p^{*}$. Thus, the dual version of the half-space reporting problem becomes that given a set of $n$ hyperplanes in d and a query point $q$, report all hyperplanes lying above or through $q$. Let $H$ be the set of $n$ hyperplanes in d, the arrangement of $H$, denoted by $\mathcal{A}(H)$, is a subdivision of d into faces of dimension $k$ for $0\leq k\leq d$. Each face in $\mathcal{A}(H)$ is a maximal connected region of d that lies in the same subset of $H$. For a query point $q$, let $\lambda(q,H)$ denote the set of hyperplanes in $H$ lying above or through $q$. It is easy to verify that all points $p$ lying on the same face $f$ of $\mathcal{A}(H)$ have the same $\lambda(p,H)$, denoted by $\lambda(f,H)$. Thus, with a precomputation of $\lambda(f,H)$ for each face $f$ of $\mathcal{A}(H)$ and the following structure for point location in $\mathcal{A}(H)$, $\lambda(q,H)$ can be found in logarithmic time.

Theorem 6** (Structure for Point Location [37]).**

Given a set $H$ of $n$ hyperplanes in d and a query point $q$, there is a data structure of size $O(n^{d+\varepsilon})$ which can be constructed in $O(n^{d+\varepsilon})$ expected time for any $\varepsilon>0$, so that the face of $\mathcal{A}(H)$ containing $q$ can be located in $O(\log{n})$ time.

Accordingly, after building the point location structure for the set of dual hyperplanes of each $I_{t,k}$, by locating the dual point of $h_{t,k}$, we can find all instances in $I_{t,k}$ that $\mathcal{F}$-dominate $t$ efficiently. However, according to equation (3), in order to compute $\Pr_{\rm rsky}(t)$, we need to further calculate the cumulative probability of instances from the same uncertain object. In what follows, we propose an efficient algorithm to compute ARSP by modifying the above algorithm.

In the preprocessing stage, for each instance $t\in I$, say $t\in T_{i}$, the algorithm partitions $I\setminus T_{i}$ into $2^{d-1}$ sets $I_{t,k}=\{s\in I\setminus T_{i}\mid s$ in region $k$ derived by partitioning $[0,1]^{d}$ with $t\}$ ($0\leq k<2^{d-1}$). Then, for each set $I_{t,k}$, it computes the set of dual hyperplanes $I^{*}_{t,k}=\{s^{*}\mid s\in I_{t,k}\}$ and builds the point location structure on $I^{*}_{t,k}$. Finally, it constructs $\mathcal{A}(I^{*}_{t,k})$ and records an array $\sigma_{f}=\langle\sigma_{f}[1],\cdots,\sigma_{f}[m]\rangle$ for each face $f$ of $\mathcal{A}(I^{*}_{t,k})$, where $\sigma_{f}[j]=\sum_{s^{*}\in\lambda(f,I^{*}_{t,k})\wedge s\in T_{j}}p(s)$, i.e., the sum of probabilities over all instances of object $T_{j}$ lying below or on the hyperplane $p^{*}$, where $p^{*}$ is the dual hyperplane of some point $p$ lying in face $f$.

In the query processing stage, given weight ratio constraints $R=\prod^{d-1}_{i=1}[l_{i},h_{i}]$, the algorithm processes each instance $t$ as follows. It first initializes $\Pr_{\rm rsky}(t)=p(t)$ and $\sigma[i]=0$ for $1\leq i\leq m$, where $\sigma[i]$ is for recording the sum of existence probabilities of instances from object $T_{i}$ that $\mathcal{F}$-dominate $t$ found so far. Then, for each $0\leq k<2^{d-1}$, it compute the dual point $h^{*}_{t,k}$ of the hyperplane $h_{t,k}$ defined in equation (6), and performs point location query $h^{*}_{t,k}$ on the structure built on $I^{*}_{t,k}$. Let $f$ be the face returned by the point location query $h^{*}_{t,k}$, for $1\leq j\leq m$, it updates $\Pr_{\rm rsky}(t)$ to $\Pr_{\rm rsky}(t)\times(1-\sigma[j]-\sigma_{f}[j])/(1-\sigma[j])$ and adds $\sigma_{f}[j]$ to $\sigma[j]$. After all queries, it returns $\Pr_{\rm rsky}(t)$ as the final rskyline probability of $t$. Since each point location query can be performed in $O(\log{n})$ time and the update of $\Pr_{\rm rsky}(t)$ requires $O(m)$ time for each $\sigma_{f}$, the time complexity of this algorithm is $O(2^{d}mn\log{n})$.

Example 4**.**

Continue with Example 3. For instance $t_{2,3}$, in the preprocessing stage, the algorithm will compute dual hyperplanes of $I_{t_{2,3},0}$ and $I_{t_{2,3},1}$, build point location structures on $I^{*}_{t_{2,3},0}$ and $I^{*}_{t_{2,3},1}$, and record $\sigma_{f}$ for each face $f$ of $\mathcal{A}(I^{*}_{t_{2,3},0})$ and $\mathcal{A}(I^{*}_{t_{2,3},1})$. As an example, hyperplanes in $I^{*}_{t_{2,3},0}$ are plotted in Fig. 3(b). For face $f_{1}$, it records $\sigma_{f_{1}}[1]=\sigma_{f_{1}}[4]=0$, $\sigma_{f_{1}}[3]=p(t_{3,1})+p(t_{3,2})=2/3$ since $t^{*}_{3,1}$ and $t^{*}_{3,2}$ lie above or through every point in $f_{1}$ and for face $f_{2}$ it records $\sigma_{f_{2}}[1]=p(t_{1,1})=1/2$, $\sigma_{f_{2}}[3]=p(t_{3,1})+p(t_{3,2})=2/3$, $\sigma_{f_{2}}[4]=p(t_{4,1})=1/2$ since $t^{*}_{1,1},t^{*}_{3,1},t^{*}_{3,2}$, and $t^{*}_{4,1}$ lie above or through every point in $f_{1}$.

Then, given weight ratio constraints $R=[0.5,2]$, to compute $\Pr_{\rm rsky}(t_{2,3})$, the algorithm first initializes $\Pr_{\rm rsky}(t_{2,3})=p(t_{2,3})=1/3$ and $\sigma[i]=0$ ($1\leq i\leq 4$), then performs point location query $h^{*}_{t_{2,3},0}$ and $h^{*}_{t_{2,3},1}$ on $I^{*}_{t_{2,3},0}$ and $I^{*}_{t_{2,3},1}$ respectively to update $\Pr_{\rm rsky}(t_{2,3})$ and $\sigma[i]$ ($1\leq i\leq 4$). By locating $h^{*}_{t_{2,3},0}=(-0.5,-16.5)$, which is the dual point of $h_{t_{2,3},0}:t[2]=-0.5t[1]+16.5$, face $f_{1}$ is returned. Since only $\sigma_{f_{1}}[3]\neq 0$, the algorithm updates $\Pr_{\rm rsky}(t_{2,3})$ to $\Pr_{\rm rsky}(t_{2,3})*(1-\sigma[3]-\sigma_{f_{1}}[3])/(1-\sigma[3])=1/9$ and updates $\sigma[3]$ to $\sigma[3]+\sigma_{f_{1}}[3]=2/3$.

IV-B Sublinear-time Algorithm

To achieve a sublinear query time, the following two bottlenecks of the above algorithm should be addressed. First, for each instance, $2^{d-1}$ arrays are accessed and it seems unrealistic to merge them efficiently based on equation (3). Second, since instances are sequentially processed, the query time can not be less than $n$. In subsequent, we introduce two strategies to overcome these two inefficiencies.

Multi-level strategy.* The reason why the above algorithm has to access $2^{d-1}$ arrays for each instance $t$ is that the query point $h^{*}_{t,k}$ is different for each $I^{*}_{t,k}$. Hence, it needs to perform $2^{d-1}$ different point location queries to retrieve $\sigma_{f}$ from each $I_{t,k}$. Different from general linear constraints, the reduction ensures that given weight ratio constraints $R=\prod^{d-1}_{i=1}[l_{i},h_{i}]$, the number of point location queries performed for each instance is always $2^{d-1}$. In this case, we show how to resolve this issue with the help of multi-level strategy [38].*

A $2^{d-1}$-level structure on the set of dual hyperplanes $I^{*}=\{t^{*}\mid t\in I\}$ is a recursively defined point location structure. To be specific, an one-level structure is a point location tree built on $I^{*}$. And each face $f$ of $\mathcal{A}(I^{*})$ records the following information: (1) an array $\sigma_{f}=\langle\sigma_{f}[j]\mid 1\leq j\leq m\rangle$, where $\sigma_{f}[j]=\sum_{s^{*}\in\lambda(f,I^{*})\wedge s\in T_{j}}p(s)$, i.e., the sum of probabilities over all instances of object $T_{j}$ lying below or on the hyperplane $p^{*}$, where $p^{*}$ is the dual hyperplane of some point $p$ lying in face $f$, (2) a product $\beta_{f}=\prod^{m}_{j=1,\sigma_{f}[j]\neq 1}(1-\sigma_{f}[j])$, and (3) a count $\chi_{f}=|\{j\mid\sigma_{f}[j]=1\}|$ are also recorded for each face $f\in\mathcal{A}(I^{*})$. A $k$-level structure is an one-level structure built on $I^{*}$ and each face $f$ of $\mathcal{A}(I^{*})$ additionally contains an associated $(k-1)$-level structure built on $\lambda(f,I^{*})$.

After constructing the $2^{d-1}$-level structure on $I^{*}$, the algorithm processes weight ratio constraints $R=\prod^{d-1}_{i=1}[l_{i},h_{i}]$ as follows. For each instance $t$, it initializes hyperplanes set $H$ as $I^{*}$ and integer $k$ as zero. While $k<2^{d-1}$, it generate the dual point $h^{*}_{t,k}$ according to equation (6) and performs point location query $h^{*}_{t,k}$ on structure built on $H$. Then, let $f$ be the returned face, it updates $H$ as $\lambda(f,H)$ and $k$ as $k+1$. Note that query $h^{*}_{t,k}$ helps to find all instances lying below or on $h_{t,k}$ in the result of the first $k-1$ queries. Let $f$ be the last face returned. According to the information recorded for $f$, $\Pr_{\rm rsky}(t)$ is calculated as follows. If $\chi_{f}=0$, then $\Pr_{\rm rsky}(t)=\beta_{f}\cdot p(t)/(1-\sigma_{f}[i])$, or if $\chi_{f}=1\wedge\sigma_{f}[i]=1$, $\Pr_{\rm rsky}(t)=\beta_{f}\times p(t)$, otherwise, $\Pr_{\rm rsky}(t)=0$. Since for each instance $t\in I$, $\Pr_{\rm rsky}(t)$ can be computed in constant time after performing $2^{d-1}$ point location queries, the total time complexity of the multi-level structure based algorithm for ARSP computation is $O(2^{d-1}n\log{n})$ time.

Shift strategy.* The major obstacle to the second bottleneck is that the $2^{d-1}$ point location queries $h^{*}_{t,k}$ ($0\leq k<2^{d-1}$) are different for each instance $t$. Geometrically speaking, $R=\prod^{d-1}_{i=1}[l_{i},h_{i}]$ is a $(d-1)$-dimensional hyper-rectangle. Let $V=\{v=(v[1],\cdots,v[d-1])\mid\forall 1\leq i<d,v[i]\in\{l_{i},h_{i}\}\}$ be the set of $R$’s vertices. For $0\leq k<2^{d-1}$, we call a vertex $v\in V$ the $k$-vertex of $R$ if there are $k$ vertices before $v$ in the lexicographical order of vertices in $V$. For example, $(l_{1},\cdots,l_{d-1})$ is the 0-vertex of $R$ and $(h_{1},\cdots,h_{d-1})$ is the $(2^{d-1}-1)$-vertex of $R$. Let $v_{k}$ denote the $k$-vertex of $R$. According to equation (6), $h^{*}_{t,k}=(-v_{k}[1],\cdots,-v_{k}[d-1],-(\sum^{d-1}_{i=1}v_{k}[i]t[i]+t[d]))$. For any two instances $t$ and $s$, each pair $h*_{t,k}$ and $h^{*}_{s,k}$ differs only in the last dimension. In what follows, we introduce the shift strategy to unify the procedures of performing point location queries for all instances by making their $h^{*}_{t,k}[d]$ the same for each $0\leq k<2^{d-1}$.*

Specifically, for each instance $t\in I$, say $t\in T_{i}$, the algorithm first creates a shifted dataset $I_{t}$ by treating $t$ as the origin, i.e., $I_{t}=\{s-t\mid s\in I\setminus T_{i}\}$. Then, it merges all sets $I_{t}$ into a key-value pair set $\mathcal{I}=\{(s,\langle t\mid s\in I_{t}\rangle)\mid s\in\bigcup_{t\in I}I_{t}\}$. Finally, it construct a $2^{d-1}$-level structure on the set of dual hyperplanes $\mathcal{I}^{*}=\{s^{*}\mid(s,-)\in\mathcal{I}\}$ as stated above, except that the information recorded in the one-level structure for each face $f$ of $\mathcal{A}(\mathcal{I}^{*})$ is redefined as $\Pr_{f}=\langle\Pr_{f}[t]\mid t\in I\rangle$, where ${\rm Pr}_{f}[t]=\prod^{m}_{j=1,j\neq i}(1-\sum_{s^{*}\in\lambda(f,\mathcal{I}^{*})\wedge s+t\in T_{j}}p(s))$.

Given constraints $R=\prod^{d-1}_{i=1}[l_{i},h_{i}]$, the algorithm generates $2^{d-1}$ point location queries $h^{*}_{k}=(v_{k}[1],\cdots,v_{k}[d-1],0)$ ($0\leq k<2^{d-1})$* and executes them on the $2^{d-1}$-level structure built on $\mathcal{I}^{*}$. Let $f$ be the last face returned, $\Pr_{\rm rsky}(t)$ of each instance $t\in I$ is computed as $p(t)\times\Pr_{f}(t)$. Since the algorithm performs a total of $2^{d-1}$ point location queries, the query time is at most $O(2^{d-1}\log{n}+n)$, where the additional linear time is required for reporting the final result.

V Experiments

In this section, we present the experimental study for the ARSP problem.

V-A Experimental Setting

Datasets.* We use both real and synthetic datasets for expe-riments. The real data includes three datasets. IIP [39] contains 19,668 sighting records of icebergs with 2 attributes: melting percentage and drifting days. Each record in IIP has a confidence level according to the source of sighting, including R/V (radar and visual), VIS (visual only), RAD (radar only). We treat each record as an uncertain object with one instance and convert these three confidence levels to probabilities 0.8, 0.7, and 0.6 respectively. CAR [29] contains 184,810 cars with 4 attributes: price, power, mileage, registration year. To convert CAR into an uncertain dataset, we organize cars with the same model into an uncertain object $T$ and for each $t\in T$, we set $p(t)=1/|T|$, i.e., when a customer wants to rent a specific model of car, any car of that model in the dataset will be offered with equal probability. NBA [13] includes 354,698 game records of 1,878 players with 8 metrics: points, assists, steals, blocks, turnovers, rebounds, minutes, field goals made. We treat each player as an object $T$ and each record of the player as an instance $t$ of $T$ with $p(t)=1/|T|$.*

The synthetic datasets are generated with the same procedure described in **[10, 9, 13, 28]**. Let $m$ be the number of uncertain objects. For $1\leq i\leq m$, we first generate center $c_{i}$ of object $T_{i}$ in $[0,1]^{d}$ following independent (IND), anti-correlated (ANTI), or correlated (CORR) distribution **[40]**. Then, we generate a hyper-rectangle $R_{i}$ centered at $c_{i}$. And all instances of $T_{i}$ will appear in $R_{i}$. The edge length of $R_{i}$ follows a normal distribution in range $[0,l]$ with expectation $l/2$ and standard deviation $l/8$. And the number of $T_{i}$’s instances follows a uniform distribution over interval $[1,cnt]$. We generate $n_{i}$ instances uniformly within $R_{i}$ and assign each instance the existence probability $1/n_{i}$. Finally, we remove one instance from the first $\phi\times m$ objects so that for any $1\leq j\leq\phi\times m$, $\sum_{t\in T_{j}}p(t)<1$. Therefore, the expected number of instances in a synthetic dataset is $({cnt}/{2}-\phi)\times m$.

Constraints.* Our experiments consider two methods to generate linear constraints on weights. WR specifies weak rankings on weight attributes [41]. Given the number of constraints $c$, it requires $\omega[i]\geq\omega[i+1]$ for every $1\leq i\leq c$. IM generates constraints in an interactive manner [25]. Specifically, it first chooses a weight $\omega^{*}$ randomly in $\mathbb{S}^{d-1}$. Then, for each $1\leq i\leq c$, it generates two objects $t_{i},s_{i}$ uniformly in $[0,1]^{d}$, divide $\mathbb{S}^{d-1}$ into two subspaces with $\sum^{d}_{j=1}(t_{i}[j]-s_{i}[j])\times\omega[j]=0$, and selects the one containing $\omega^{*}$ as the $i$-th input constraint. The main difference between these two methods is that the preference region generated by WR always has $d$ vertices, while the number of vertices of the preference region generated by IM usually increases with $c$.*

Algorithms.* We implement the following algorithms in C++ and the source code is available at [42].*

1. $\bullet$

ENUM: the first baseline algorithm in Section III-A. 2. $\bullet$

LOOP: the second baseline algorithm in Section III-A. 3. $\bullet$

KDTT: the kdtree-traversal algorithm in Section III-B. 4. $\bullet$

KDTT+: the kdtree-traversal algorithm incorporating preorder traversal into tree construction in Section III-B. 5. $\bullet$

QDTT+: the quadtree-traversal algorithm incorporating preorder traversal into tree construction in Section III-B. 6. $\bullet$

B&B: the branch-and-bound algorithm in Section III-C. 7. $\bullet$

DUAL (-M/S): the dual-based algorithm in Section IV, where -M is for multi-level strategy, -S is for shift strategy.

All experiments are conducted on a machine with a 3.5-GHz Intel(R) Core(TM) i9-10920X CPU, 256GB main memory, and 1TB hard disk running CentOS 7.

V-B Effectiveness of ARSP

We verify the effectiveness of ARSP on the NBA dataset. To facilitate analysis, we extract game records in 2021 from NBA and consider 3 attributes for each player: rebound, assist, and points. We still treat each player as an object $T$ and each record of the player as an instance $t$ of $T$ with $p(t)=1/|T|$. We set $\mathcal{F}=\{\omega[1]\text{Rebound}+\omega[2]\text{Assist}+\omega[3]\text{Point}\mid\omega[1]\geq\omega[2]\geq\omega[3]\}$. Table I reports the top-14 players in rskyline probability ranking along with their rskyline probabilities. As a comparison, we also conduct the traditional rskyline query on the aggregated dataset, which is obtained by computing the average statistics for each player. We call the result aggregated rskyline for short hereafter and mark players in the aggregated rskyline with a “” sign in Table I.*

We first observe that rskyline probabilities can reflect the difference between two incomparable players in the aggregated dataset under $\mathcal{F}$. Theorem 2 claims that $t\prec_{\mathcal{F}}s$ if and only if $\forall\omega\in V,$ $S_{\omega}(t)\leq S_{\omega}(s)$. Here $V=\{\omega_{1}=(1,0,0),\omega_{2}=(1/2,1/2,0),\omega_{3}=(1/3,1/3,1/3)\}$. See Fig. 4 for scores of Nikola Jokic (NJ) and Jonas Valanciunas (JV) under weights in $V$. NH not only has a good average performance so that he is in the aggregated rskyline, but also performs best in some games so that he has a high rskyline probability. As for JV, his average performance under $\omega_{1}$ is great, making him belong to the aggregated rskyline. But his large performance variance under $\omega_{1}$ and relatively poor performance under $\omega_{2}$ and $\omega_{3}$ suggests that many of his records are $\mathcal{F}$-dominated by other players’ records. This results in his rskyline probability being pretty low. Therefore, compared to aggregated rskyline players with high rskyline probabilities, who consistently perform well, those with low rskyline probabilities are more likely to have many records being $\mathcal{F}$-dominated by other players’ records, which may be less attractive.

Second, we find that players not in the aggregated rskyline but have high rskyline probabilities is also appealing. For example, Giannis Antetokounmpo is $\mathcal{F}$-dominated by Nikola Jokic in the aggregated dataset, but his rskyline probability is higher than another four aggregated rskyline players. Compared to NJ, his scores (GA) have slightly lower averages and higher variances. In other words, he has some records, like Nikola Jokic’s, which $\mathcal{F}$-dominates most of other players’ records and he also has some records that are $\mathcal{F}$-dominated by many of other players’ records. Besides, the large performance variance also explains why Andre Drummond (AD) is $\mathcal{F}$-dominated by Jonas Valanciunas (JV) but has a higher rskyline probability. This suggests that looking for players with high rskyline probabilities can find excellent players with slightly lower averages but higher variances in performance.

Finally, a set of players with specified size can be retrieved by performing top-$k$* queries on ARSP, while the size of the aggregated rskyline is uncontrollable. From these observations, we conclude that ARSP provides a more comprehensive view on uncertain datasets than the aggregated rskyline.*

We also compare the distinction between uncertain skyline queries and uncertain rskyline queries. Similar to Table I, Table II also reports the top-14 players in skyline probability ranking along with their skyline probabilities. By analyzing these results, we obtain several interesting observations. First, the rskyline probability of an uncertain object is typically smaller than its skyline probability because the function set $\mathcal{F}$ improves the dominance ability of each instance. But excellent players like Nikola Jokic, Russell Westbrook always have both high rankings in skyline probability and rskyline probability. Second, uncertain rskyline queries can better serve the specific preferences of individual users. Given different inputs $\mathcal{F}$ from different users, rskyline probabilities of uncertain objects are variant, however, skyline probabilities of uncertain objects always remain the same. As stated in **[1]**, a skyline object may be $\mathcal{F}$-dominated by other objects. Therefore, an object with high skyline probabilities may have low rskyline probabilities, making it less attractive under $\mathcal{F}$. For instance, Trae Young’s skyline probability is 0.309 (ranked 7th) but his rskyline probability under $\mathcal{F}=\{\omega[1]\text{Rebound}+\omega[2]\text{Assist}+\omega[3]\text{Point}\mid\omega[1]\geq\omega[2]\geq\omega[3]\}$ is only 0.029 (ranked 31st).

V-C Experimental Results under Linear Constraints.

Fig. 5 and 6 show the running time of different algorithms and the size of ARSP on real and synthetic datasets. The size of ARSP is the number of instances with none-zero rskyline probabilities. Following **[10, 13*]**, the default values for object cardinality $m$, instance count $cnt$, data dimensionality $d$, region length $l$, and percentage $\phi$ of objects with $\sum_{t\in T}p(t)<1$ of synthetic datasets are set as *$m=16$K, $cnt=400$, $d=4$, $l=0.2$, and $\phi=0$. Unless otherwise stated, WR is used to generate $c=d-1$ input linear constraints for $\mathcal{F}$. All datasets are index by R-trees in main memory. Since the construction time of the R-tree is a one-time cost for all subsequent queries, it is not included in the query time. And the query time limit (INF) is set as 3,600 seconds.

*Fig. 5 (a)-(c) present the results on synthetic datasets with $m$ varying from *$2$*K to *$64$*K. Based on the generation process, the number of instances $n$ increases as $m$ grows. Thus, the running time of all algorithms and the size of ARSP increase. Due to the exponential time complexity, ENUM never finishes within the limited time. All proposed algorithms outperform LOOP by around an order of magnitude because LOOP always performs a large number of $\mathcal{F}$-dominance tests and does not include any pruning strategy. B&B runs fastest on IND and ANTI with the help of the incremental mapping and pruning strategies. As $m$ grows, the gap narrows because the more objects, the more aggregated R-trees are queried per instance. KDTT+ and QDTT+ are more effective on CORR because pruning is triggered earlier by objects near the origin during space partitioning, e.g., when *$m=2$K, QDTT+ prunes 13 child nodes of the root node on CORR, compared with 9 on IND and 5 on ANTI. Although with similar strategies, QDTT+ performs better than KDTT+. The reason is that space is recursively divided into $2^{d}$ regions in QDTT+, which results in a smaller MBR and thus a greater possibility of being pruned. Results also demonstrate our optimization techniques significantly improve the experimental performance of KDTT. As shown in Fig. 5 (d)-(f), the relative performance of all algorithms remains basically unchanged with respect to $cnt$. And the size of ARSP also increases as $cnt$ grows since the larger $cnt$, the more instances in $I$ and the less likelihood of an instance being $\mathcal{F}$-dominated by all instance of an object.

Having established ENUM is inefficient to compute ARSP, henceforth it is excluded from the following experiments. The curve of KDTT is also omitted as it is always outperformed by KDTT+. Fig. 5 (g)-(i) plot the results on synthetic datasets with varying dimensionality $d$. With the increase of $d$, the cost of $\mathcal{F}$-dominance test increases. Thus, the running time of all algorithms increases. QDTT+ and KDTT+ are more efficient than B&B on low-dimensional datasets, but their scalability is relatively poor. This is because when $d$ grows, the dataset becomes sparser, causing the subtrees pruned during the preorder traversal get closer to leaf nodes in KDTT+ and QDTT+. Moreover, the exponential growth in the number of child nodes of QDTT+ also causes its inefficiency on high-dimensional datasets. When the dataset becomes sparser, an instance is more likely not to be $\mathcal{F}$-dominated by others. Therefore, the size of ARSP increases with higher dimensionality.

Fig. 5 (j)-(l) show the effect of $l$ by varying $l$ from 0.1 to 0.6. As $l$ increases, the number of instances $\mathcal{F}$-dominated by all instances of an object decreases. Thus, the size of ARSP and the running time of all algorithms increase. Compared to others, B&B is more sensitive to $l$ since it determines not only the number of instances to be processed but also the time consumed in querying aggregated R-trees.

Fig. 5 (m)-(o) show the runtime of different algorithms and the size of ARSP on synthetic datasets with different $\phi$. According to equation 3, the more objects $T$ with $\sum_{t\in T}p(t)<1$, the less instances with zero rskyline probabilities. Hence, the running time and the size of ARSP both increase as $\phi$ increases. Similar to $l$, $\phi$ also affects B&B greatly since the larger $\phi$, the fewer instances are added to the pruning set $P$.

Fig. 5 (p)-(q) plot the effect of $c$ on IND and ANTI ($d=6$). Results on CORR are omitted, in which the running time of all algorithms and the size of ARSP decrease as $c$ grows. The reason is that the preference region narrows with the growth of $c$, which enhances the $\mathcal{F}$-dominance ability of each instance. Therefore, more instances are pruned during the computation. Whereas, this also results in the need to perform more $\mathcal{F}$-dominance tests to compute rskyline probabilities of unpruned instances. The trends of the running time on IND and ANTI reflect the compromise of these two factors. B&B perform inconsistently as its pruning strategy is more effective on IND.

Fig. 5 (r)-(t) show the results under linear constraints generated by IM. Running time of all algorithms and the size of ARSP show similar trends to WR under all parameters except $c$. As stated above, the $\mathcal{F}$-dominance ability of each instance improves with the growth of $c$. Thus, as shown in Fig. 5(t), the running time of all algorithms decreases, except QDTT+. This is because the number of vertices of the preference region generated by IM increases as $c$ grows (see the curve of $V$), thus leading to the dimensional disaster of the quadtree. This also accounts for the failure of QDTT+ when $d\geq 5$ in Fig. 5(s).

Experimental results on real datasets confirm the above ob-servations. Fig. 6 (a) shows the results on IIP with varying $m$. As introduced in the datasets’ description, each records in IIP is treated as an uncertain object with one instance. This means $\phi=1$, i.e., every object $T$ in IIP satisfies $\sum_{t\in T}p(t)<1$. Thus, the size of ARSP is the number of input instances. And B&B almost degenerates into LOOP, since no instances are pruned and no computations are reused. Fig. 6 (b)-(c) show the results on CAR and NBA with different $m$. It is noticed that attribute variance is pretty large in these two datasets, e.g., in NBA, about half of the players got zero points in some games but more than 20 points in other games. Therefore, relative performance of algorithms are similar to synthetic datasets with large $l$. This also holds for results on NBA with different $d$ and $c$ which are shown in Fig. 6 (d)-(e).

V-D Experimental Results under Weight Ratio Constraints.

Since the data structure stated in Theorem 6 is theoretical in nature, we introduce a specialized version of DUAL-MS for $d=2$ to avoid this. Recall that for each instance $t$, we reduce the computation of $\Pr_{\rm rsky}(t)$ to $2^{d-1}$ half-space reporting problems in section IV-A. When $d=2$, we notice that these two half-space queries can be reinterpreted as a continuous range query. See Fig. 7(a) for an illustration. When processing $t_{2,3}$, we can regard $t_{2,3}$ as the origin, ray $y=t_{2,3}[2],x\geq t_{2,3}[1]$ as the base. Then each instance can be represented by an angle, e.g., $\theta=\pi+\arctan\frac{12-5}{9-6}$ for $t_{3,1}$. In such case, the two query halfspaces $h_{t_{2,3},0}:t[2]\leq-0.5t[1]+16.5$ and $h_{t_{2,3},1}:t[2]\leq-2t[1]+30$ can be transformed to the range query $[\pi-\arctan\frac{1}{2},2\pi-\arctan 2]$ with respect to angle. After the transformation, we can simply use a binary search tree to organize the instances instead of the point location tree. We give an implementation of this specialized DUAL-MS and evaluate its performance on IIP dataset. As a comparison, we attach a simple preprocessing strategy to KDTT+, which removes all instances with zero skyline probability from $I$ in advance. Fig. 7(b) shows the running time of these two algorithms. It is noticed that although the query efficiency is improved, the huge preprocessing time and memory consumption prevents its application on big datasets.

The above drawbacks of DUAL-MS are alleviated when it comes to process eclipse queries. This is because eclipse is always a subset of skyline $S$, which has a logarithmic size in expectation. Meanwhile, the multi-level strategy is no longer needed since for each object $t\in S$, $t$ belongs to the eclipse of $D$ iff all point location queries on $S^{*}_{t,k}$ ($0\leq k<2^{d-1}$) return emptiness. We implement the DUAL-S for eclipse query processing, in which we use a $kd$-tree to index the dataset constructed by performing shifted strategy. For comparison, we also implement the state-of-the-art index-based algorithm QUAD **[2]** in C++ and compare their efficiency and scalability with respect to data cardinality $n$, data dimensionality $d$, and ratio range $q$. Similar to **[2]**, the defaulted value is set as $n=2^{14}$, $d=3$, and $q=[0.36,2.75]$.

As shown in Fig. 8 (a)-(b), the running time of these two algorithms increases as $n$ and $d$ grows. DUAL-S outperforms QUAD by at least an order of magnitude and even more on high-dimensional datasets. The reason is that QUAD needs to iterate over the set of hyperplanes returned by the window query performed on its Intersection Index, and then reports all objects with zero order vector as the final result. This takes $O(s^{2})$ time, where $s$ is the skyline size of the dataset. But DUAL-S excludes an object from the result if there is a query returns non-empty result, which only take $O(s)$ time. Moreover, the hyperplane quadtree adopted in QUAD scales poorly with respect to $d$ for the following two reasons. On the one hand, the tree index has a large fan-out since it splits all dimensions at each internal node. On the other hand, the number of intersection hyperplanes of a node decreases slightly relative to its parent, especially on high-dimensional datasets, which results in an unacceptable tree height. Moreover, as shown in Fig. 8(c), QUAD is more sensitive to the ratio range than DUAL-S because the number of hyperplanes returned by the window query actually determines the running time.

VI Related Work

In this section, we elaborate on two pieces of previous work that are most related to ours.

Queries on uncertain datasets.* Pei et al. first studied how to conduct skyline queries on uncertain datasets [10]. They proposed two algorithms to identify objects whose skyline probabilities are higher than a threshold $p$. Considering inherent limitations of threshold queries, Atallah and Qi first addressed the problem of computing skyline probabilities of all objects [9]. They proposed a $\tilde{O}(n^{2-1/(d+1)})$-time algorithm by using two basic all skyline probabilities computation methods, weighted dominance counting method and grid method, to deal with frequent and infrequent objects, respectively. With a more efficient sweeping method for infrequent objects, Atallah et al. improved the time complexity to $\tilde{O}(n^{2-1/d})$ [11]. However, the utilities of these two algorithms are limited to 2D datasets because of a hidden factor exponential in the dimensionality of the dataset, which came from the high dimensional weighted dominance counting algorithm. To get rid of this, Afshani et al. calculated skyline probabilities of all instances by performing a pre-order traversal of a modified KD-tree [12]. With the well-know property of the KD-tree, it is proved that the time complexity of their algorithm is $O(n^{2-1/d})$. More practically, Kim et al. introduced an in-memory Z-tree structure in all skyline probabilities computation to reduce the number of dominance tests, which has been experimentally demonstrated to be efficient [13]. However, it is non-trivial to revise these algorithms for computing all skyline probabilities to address the problem studied in this paper. This is because all of them rely on the fact that the dominance region of an instance is a hyper-rectangle, which no longer holds under $\mathcal{F}$-dominance.*

Somehow related to what we study in this paper are those works on top-$k$* queries on uncertain datasets [20, 21, 19, 22, 8]. Under the possible world model, top-$k$ semantics are unclear, which give rise to different definitions, e.g., to compute the most likely top-$k$ set, the object with high probability to rank $i$-th, the objects having a probability greater than a specified threshold to be included in top-$k$, etc. Our work differs from theirs as an exactly input weight is required in these studies, whereas we focus on finding a set of non-$\mathcal{F}$-dominated objects where $\mathcal{F}$ is a set of user-specified scoring functions. In other word, our work can be regarded as extending theirs by relaxing the input preference into a region.*

Operators with restricted preference.* Given a set of monotone scoring functions $\mathcal{F}$, Ciaccia and Martinenghi defined $\mathcal{F}$-dominance and introduced two restricted skyline operators, ND for retrieving the set of non-$\mathcal{F}$-dominated objects and PO for finding the set of objects that are optimal according to at least one function in $\mathcal{F}$. And they designed several linear programming based algorithms for these two queries, respectively. Mouratidis and Tang extended PO under top-$k$ semantic when $\mathcal{F}$ is a convex preference polytope $\Omega$, i.e., they studied the problem of identifying all objects that appear in the top-$k$ result for at least one $\omega\in\Omega$ [23]. Liu et al. investigated a case of $\mathcal{F}$-dominance where $\mathcal{F}$ consists of $d-1$ constraints on the weight ratio of other dimensions to the user-specified reference dimension [2]. They defined eclipse query as retrieving the set of all non-eclipse-dominated objects and proposed a series of algorithms. These works only consider datasets without uncertainty, and we extend above dominance-based operators to uncertain datasets. Their techniques can not be applied to our problem since the introduction of uncertainty makes the problem challenging as for each instance, we now need to identify all instances that $\mathcal{F}$-dominate it.*

VII Conclusions

In this paper, we study the problem of computing ARSP to aid multi-criteria decision making on uncertain datasets. We first prove that no algorithm can compute ARSP in truly subquadratic time without preprocessing, unless the orthogonal vectors conjecture fails. Then, we propose two efficient algorithms to compute ARSP when $\mathcal{F}$ is a set of linear scoring functions whose weights are described by linear constraints. We use preprocessing techniques to further improve the query time under weight ratio constraints. Our thorough experiments over real and synthetic datasets demonstrate the effectiveness of ARSP and the efficiency of our proposed algorithms. For future directions, there are two possible ways. On the one hand, conducting rskyline analysis on datasets with continuous uncertainty remains open, where it becomes expensive to make the integral for computing the dominance probability. On the other hand, it is still worthwhile to investigate concrete lower bounds of the ARSP problem under some specific dimensions.