Efficient Contour Computation of Group-based Skyline

TL;DR

This paper introduces efficient methods for computing group-based skylines in multi-dimensional datasets, including a novel structure and clustering algorithm, significantly improving speed over previous approaches.

Contribution

It proposes a new approach for group skyline computation, including a structure for candidate sets and a clustering method to efficiently identify representative groups.

Findings

Algorithms are several orders of magnitude faster than previous methods.

The G-skyline provides a complete candidate set for top-l solutions.

The RG-skyline effectively represents the contour of the G-skyline.

Abstract

Skyline, aiming at finding a Pareto optimal subset of points in a multi-dimensional dataset, has gained great interest due to its extensive use for multi-criteria analysis and decision making. The skyline consists of all points that are not dominated by any other points. It is a candidate set of the optimal solution, which depends on a specific evaluation criterion for optimum. However, conventional skyline queries, which return individual points, are inadequate in group querying case since optimal combinations are required. To address this gap, we study the skyline computation in the group level and propose efficient methods to find the Group-based skyline (G-skyline). For computing the front $l$ skyline layers, we lay out an efficient approach that does the search concurrently on each dimension and investigates each point in the subspace. After that, we present a novel structure to construct the G-skyline with a queue of combinations of the first-layer points. We further demonstrate that the G-skyline is a complete candidate set of top-$l$ solutions, which is the main superiority over previous group-based skyline definitions. However, as G-skyline is complete, it contains a large number of groups which can make it impractical. To represent the "contour" of the G-skyline, we define the Representative G-skyline (RG-skyline). Then, we propose a Group-based clustering (G-clustering) algorithm to find out RG-skyline groups. Experimental results show that our algorithms are several orders of magnitude faster than the previous work.

Figures

Tables

Table 1. TABLE I: The summary of notations.

Notation	Definition
$S\backslash laye{r}_i$	points in $S$ but not in $laye{r}_i$
$p\prec /\nprec p^{\prime }$	$p$ dominates/dose not dominate $p^{\prime }$
$p⪯p^{\prime }$	$p$ dominates or equals to $p^{\prime }$
$skyline\left(S\right)$	the skyline of dataset S
$layer\left(p_i\right)$	the skyline layer of $p_i$
$D\left(laye{r}_i\right)$	the dominance domain of $laye{r}_i$
$skylin{e}_s\left(S^{\prime }\right)$	the skyline of $S^{\prime }$ in the subspace
$D_s\left(laye{r}_i^{\prime }\right)$	the dominance domain of $laye{r}_i^{\prime }$ in the subspace
$T_S\left(p\right)$/$T_S\left(G\right)$	tail set of point $p$/group $G$ in sequence S
$G{\prec }_g{G}^{\prime }$	group $G$ g-dominates group $G^{\prime }$
$GS$	the G-skyline
$RS$	the RG-skyline

Table 2. TABLE II: Example steps of Algorithm 2.

Current point	Skyline of $laye{r}_1^{\prime }$	Skyline of $laye{r}_2^{\prime }$	MSL
$p_1$	$\left\{p_1^{\prime }\right\}$	$\left\{\right\}$	$\left\{p_1\right\},\left\{\right\}$
$p_2$	$\{p_1^{\prime },p_2^{\prime }\}$	$\left\{\right\}$	$\{p_1,p_2\},\left\{\right\}$
$p_3$	$\{p_1^{\prime },p_2^{\prime }\}$	$\left\{p_3^{\prime }\right\}$	$\{p_1,p_2\},\left\{p_3\right\}$
$p_4$	$\{p_1^{\prime },p_2^{\prime },p_4^{\prime }\}$	$\left\{p_3^{\prime }\right\}$	$\{p_1,p_2,p_4\},\left\{p_3\right\}$
$p_5$	$\{p_1^{\prime },p_4^{\prime },p_5^{\prime }\}$	$\left\{p_3^{\prime }\right\}$	$\{p_1,p_2,p_4,p_5\},\left\{p_3\right\}$

Table 3. TABLE III: Percentage of primary groups.

dataset		CORR				INDE				ANTI
$d$		2	4	6	8	2	4	6	8	2	4	6	8
$l$	2	62.5	97.6	98.8	99.5	80.3	97.9	99.6	99.9	98.1	99.9	99.8	99.9
	3	18.6	87.8	97.8	98.9	38.2	91.2	98.0	99.3	91.0	98.9	$-$	$-$
	4	2.1	84.3	$-$	$-$	16.9	87.4	$-$	$-$	88.2	$-$	$-$	$-$

Table 4. TABLE IV: k 𝑘 k -SGQ

$G_1$	LeBron James	Hakeem Olajuwon	Dirk Nowitzki	Chris Paul	very balanced
$G_2$	LeBron James	Hakeem Olajuwon	Dirk Nowitzki	Isiah Thomas	very balanced
$G_3$	LeBron James	Hakeem Olajuwon	Dirk Nowitzki	Earl Monroe	very balanced
$G_4$	LeBron James	Hakeem Olajuwon	Carmelo Anthony	Chris Paul	very balanced
$G_5$	LeBron James	Hakeem Olajuwon	Carmelo Anthony	Isiah Thomas	very balanced
$G_6$	LeBron James	Hakeem Olajuwon	Carmelo Anthony	Earl Monroe	very balanced

Equations

$$F_X(x)=$$

$$=$$

$$f_X(x)=F_X^{\prime }(x)=\frac{l{x}^{l-1}}{a^l},$$

$$b=$$

$$=$$

$$f({\bm{x}})=\left\{\begin{array}[]{ll}\sum\limits_{i=1}^{d}\left(\max\limits_{j}\{p_{j}[i]\}-x_{i}\right),&\bigvee\limits_{j=1}^{l}\left(\bigwedge\limits_{i=1}^{d}x_{i}\leq p_{j}[i]\right)\\ -\sum\limits_{i=1}^{d}x_{i},&otherwise\end{array},\right.$$

$$d_g(G,G^{\prime })=\sqrt{\underset{u,v}{\min }\sum _{i=1}^l{d}^2(p_{u_i},p_{v_i}^{\prime })},$$

$$\min \sum _{i=1}^l\sum _{j=1}^l{\mathbf{X}}_{i,j}{\mathbf{D}}_{i,j}$$

$$\displaystyle\begin{array}[]{r@{\quad}r@{}l@{\quad}l}{\rm s.t.}&\sum\limits_{i=1}^{l}\bm{X}_{i,j}=1\\ &\sum\limits_{j=1}^{l}\bm{X}_{i,j}=1\end{array}$$

$$\bar{p}=\frac{\sum _{p_i\in C}{p}_i}{|C|}=\frac{\sum _{i\in \{j|p_j\in C\}}\left(p_0+{\Delta }_i\right)}{|C|}=p_0+\frac{\sum _{i\in \{j|p_j\in C\}}{\Delta }_i}{|C|},$$

$$\bar{G}=G_0+\frac{\sum _{G_i\in C}\Delta (G_i,G_0)}{|C|},$$

$$G_0=\left(\left(p_{v_1}^{(0)}[1],\cdots p_{v_1}^{(0)}[d]\right),\cdots ,\left(p_{v_l}^{(0)}[1],\cdots p_{v_l}^{(0)}[d]\right)\right),$$

$$\displaystyle\Delta(G_{i},G_{0})=\Big{(}$$

$$\displaystyle\Big{(}p_{u_{l}}^{(i)}[1]-p_{v_{l}}^{(0)}[1],\cdots p_{u_{l}}^{(i)}[d]-p_{v_{l}}^{(0)}[d]\Big{)}\Big{)},$$

$$\bar{G}=G_0+\frac{\sum _{i=1}^3\Delta (G_i,G_0)}{3},$$

$$G_0=(6,250,13,50,23,25),$$

$$\Delta (G_1,G_0)=$$

$$=$$

$$\Delta (G_2,G_0)=$$

$$=$$

$$\Delta (G_3,G_0)=$$

$$=$$

$$\bar{G}=(9.33,191.67,13,50,20.67,41.67).$$

$$\{(9.33,191.67),(13,50),(20.67,41.67)\}.$$

Full text

1 Introduction

Skyline, known as Maxima in computational geometry or Pareto in business management field, is of great significance for many applications. Skyline returns a subset of points that are Pareto optimal [1], indicating that these points cannot be dominated by any other points in the dataset. Though the exact optimal point depends on the specific criterion for optimum, skyline can provide a candidate set so that we can prune the non-candidates from the dataset when the optimal solution is queried.

Given a dataset $S$ with $n$ points, each point $p$ has $d$ numeric attributes and can be represented as a $d$-dimensional vector $(p[1],p[2],$ $\cdots,p[d])\in\mathbb{Rd}^{d}$, where $p[i]$ is the $i$-th attribute. Given two points $p=(p[1],p[2],\cdots,p[d])$ and $p^{\prime}=(p^{\prime}[1],p^{\prime}[2],\cdots,$ $p^{\prime}[d])$, point $p$ dominates point $p^{\prime}$ if $p[i]<p^{\prime}[i]$ for at least one attribute and $p[i]\leq p^{\prime}[i]$ for the others ($1\leq i\leq d$). The skyline of dataset $S$ is defined as a subset consisting of all points that are not dominated by any other points in $S$. Evidently, all the points in the skyline are Pareto optimal solutions.

Figure 1 illustrates ten hotels with two attributes (the price and the distance to a given destination) in the table. Travelers desire to choose a hotel with both low price and short distance. Figure 1 represents ten points in $2$-dimensional space and each point represents a hotel in Figure 1 correspondingly. When choosing hotels, travelers will not benefit by choosing $p_{5}$, $p_{6}$, $p_{8}$, or $p_{10}$ because they are dominated by $p_{4}$ and are in worse situation in both distance and price attributes. Hotels $p_{1}$, $p_{2}$, $p_{4}$, and $p_{7}$ might be chosen since they are not dominated by any other hotels. The final choice depends on the travelers’ criteria or the weights of attributes. For example, if the travelers are wealthy, they may attach more importance to the distance and choose $p_{1}$ or $p_{2}$. If they want to be cost-effective, they may prefer $p_{4}$ or $p_{7}$ because of the lower price. We can see that the skyline is a candidate set of the optimal solution, and the final decision depends on travelers’ specific criteria.

Motivation. Extensively studied in the database community, the skyline has been extended with many variants to provide a candidate set in different situations. However, traditional skyline, which focuses top-$1$ solutions, is inadequate when optimal groups, i.e., top-$l$ solutions, are searched rather than individual points. This is a very important problem with many real-world applications that is surprisingly neglected. To address this gap, group-based skyline (with size $l$), which is a candidate set of all top-$l$ solutions, is proposed. However, the few existing works either do not return complete candidate set [2, 3] or are too computationally expensive [4], so an efficient and complete method is greatly desired.

Recalling our hotel example, we suppose that a travel agency wants to collaborate with the three best hotels. If they are mainly targeting low-end travelers, they may choose hotels $\{p_{4},p_{7},p_{5}\}$ or {$p_{4}$, $p_{5}$, $p_{6}$}. If for high-end travelers, they may choose {$p_{1}$, $p_{2}$, $p_{3}$}. And they may choose {$p_{1}$, $p_{2}$, $p_{4}$}, {$p_{2}$, $p_{4}$, $p_{7}$}, or {$p_{1}$, $p_{4}$, $p_{7}$} if they want to provide a more extensive service. In some groups mentioned above, all points contained are skyline points, e.g., {$p_{1}$, $p_{2}$, $p_{4}$}, {$p_{2}$, $p_{4}$, $p_{7}$}, {$p_{1}$, $p_{4}$, $p_{7}$}, but in the others, non-skyline points may be included, e.g., {$p_{4}$, $p_{7}$, $p_{5}$}, {$p_{4}$, $p_{5}$, $p_{6}$}, {$p_{1}$, $p_{2}$, $p_{3}$}. It is apparent that the non-skyline points can also be chosen in this problem. However, the components of these groups are not arbitrary and they need to satisfy certain requirements. For instance, groups {$p_{4}$, $p_{7}$, $p_{8}$} or {$p_{4}$, $p_{7}$, $p_{6}$} cannot be the best choice since $p_{5}$ dominates $p_{6}$ and $p_{8}$, so {$p_{4}$, $p_{7}$, $p_{5}$} is better than them. We can see that it becomes more complicated when finding top-$l$ solutions.

A Group-based skyline (G-skyline111Note that we only use “G-skyline” to indicate the Pareto optimal group-based skyline proposed in [4]. For other kinds of group-based skyline [2, 3], we do not use the abbreviation.) is defined to address this problem. Consider a dataset $S$ of $n$ points in $d$-dimensional space. $G=\{p_{1},p_{2},\cdots,p_{l}\}$ and $G^{\prime}=\{p_{1}^{\prime},p_{2}^{\prime},\cdots,p_{l}^{\prime}\}$ are two different groups with $l$ points. If we can find two permutations of the $l$ points for $G$ and $G^{\prime}$, $G=\{p_{u_{1}},p_{u_{2}},\cdots,p_{u_{l}}\}$ and $G^{\prime}=\{p_{v_{1}}^{\prime},p_{v_{2}}^{\prime},\cdots,p_{v_{l}}^{\prime}\}$, letting $p_{u_{i}}\preceq p_{v_{i}}^{\prime}$ for all $i$ and $p_{u_{i}}\prec p_{v_{i}}^{\prime}$ for at least one $i$ ($1\leq i\leq l$), we say $G$ g-dominates $G^{\prime}$. All groups containing $l$ points that are not g-dominated by any other groups with the same size compose the G-skyline. Similar to conventional skyline, G-skyline is a candidate set of top-$l$ solutions. Recalling our hotel example, agencies with different criteria has different optimal groups and G-skyline contains all possible choices for all agencies. We construct G-skyline to support agencies for decision making.

G-skyline is a complete candidate set for top-$l$ solutions (proved in Section 4), but there are two critical issues, (1) it is really time-consuming and (2) it returns an oversized candidate set. To address these two problems, we (1) propose fast algorithms for the G-skyline and (2) define the Representative G-skyline (RG-skyline).

To reduce the time complexity, we optimize the algorithms proposed in [4]. We first define Multiple Skyline Layers (MSL) as the first $l$ skyline layers, which is very important in both traditional skyline and G-skyline problems. To construct MSL efficiently, our framework searches concurrently in each dimension to reduce the redundant search, and the search strategy utilizes the property of the skyline in subspace to improve efficiency. Then, based on MSL, we propose fast algorithms to construct G-skyline groups. Considering the observation that skyline points contribute more to G-skyline groups compared to non-skyline points, we use a queue to enumerate all combinations of skyline points and then find the groups that contain non-skyline points by the queue efficiently.

To reduce the output size, we introduce a distance-based representative G-skyline, RG-skyline. The key idea is to represent similar G-skyline groups with a representative group, and RG-skyline contains all these representative groups. To measure the similarity between groups, we match the points of each pair of groups and calculate the Euclidean distance between these groups. We then extend the clustering algorithm from the point level to the group level to propose a novel Group-based clustering (G-clustering) algorithm. Finally, we take the set of all cluster centers as RG-skyline.

Contributions. We briefly summarize our contributions as follows:

• •

We propose a new algorithm to construct MSL, which is significantly more efficient than existing algorithms.

• •

To address the issue of high time complexity, we propose two fast algorithms to construct G-skyline groups with the combination queue.

• •

To address the issue of oversized output, we define RG-skyline to represent the “contour” of the whole G-skyline and propose a novel G-clustering algorithm to construct it.

• •

We devise comprehensive experiments in synthetic and real datasets. The experimental results show that our algorithms are highly efficient and scalable.

Organization. The rest of the paper is organized as follows. Section 2 presents the related work. Section 3 presents the definition of MSL and the algorithmic technique to construct it. Two algorithms for finding G-skyline groups are presented in Section 4. The definition and algorithm for the RG-skyline are illustrated in Section 5. We evaluate the performance of each algorithm in Section 6. Section 7 concludes the paper.

2 Related Work

In this section, we briefly explore previous works on skyline computation. After Kung’s original work that proposed the in-memory algorithms to handle the skyline computation problem [5], skyline query has attracted extensive attention over the last decade due to its significance in computational geometry and database fields [6, 5]. [1] first studied how to process skyline queries in database systems and devised the skyline operator. Since then, the research includes improved algorithms [7, 8], progressive skyline computation [9, 10], query optimization [11, 12], top-$l$ dominating queries [13, 14, 15], and variants of skyline queries [16, 17, 18, 19]. There are also works focusing on different types of data, for example, dynamic data [20] and uncertain data [21, 22].

Group-based Skyline. In recent years, there are increasing works focusing on group-based skyline [3, 2, 23, 4]. The definition of dominance between groups in these works varies greatly. [3, 2, 23] used a single aggregate point to represent a group and find the dominance relationship of groups using the aggregate points in a traditional way. An aggregate function is responsible for generating the aggregate point, whose attribute values are aggregated over the corresponding attribute value of all points in the group. Though many aggregate functions can be considered in calculating aggregate points, only several of them, such as SUM, MIN, MAX, have been discussed in previous works. [2] used SUM to aggregate the points and [3] utilized MAX and MIN. Intuitively, SUM captures the collective strength of a group, while MIN/MAX compares groups by their weakest/strongest member on each attribute. The skyline groups constructed by these methods are not complete because not all Pareto optimal groups can be captured. Instead of aggregating data, [4] proposed a different notion of group-based skyline called G-skyline, the dominance relationship between two groups is defined based on the pair-wise dominance between points in the two groups. Compared with previous works, G-skyline gives a more complete solution. In fact, group-based skyline proposed in [2] is a subset of G-skyline in [4]. However, completeness also means high time consumption in computation thus efficient algorithms are desired. This paper is an extended version of our previous work [24], which proposed several efficient methods for G-skyline.

Representative Skyline. Due to the large output size of skyline, many research focused on representative skyline that represents the principal tradeoffs to users. [25] first proposed the representative skyline by finding the skyline points that dominate the maximum number of points, which can be called max-dominance representative skyline. Similarly, [26, 27] computed skyline points that maximize the dominated area or volume to show the “contour” of the entire skyline. [28] first proposed a distance-based representative skyline. Following that, there are several works on efficient distance-based methods [29, 30]. Their goal is to minimize the distance between representative skyline points and non-representative skyline points (representation error).

At the group level, representative skyline has a more pressing demand due to the even larger output size. There is only one existing paper for representative skyline at the group level [31]. It proposed the $k$-SGQ, which is a max-dominance representative skyline, by finding $k$ groups with maximum number of dominated points. Though $k$-SGQ is efficient and easy to construct, it tends to return very balanced groups, which is against the goal of skyline to show different tradeoffs to users. To address this gap, we propose a distance-based method, RG-skyline, to show the “contour” of the original skyline better.

3 Constructing Multiple Skyline Layers

We define Multiple Skyline Layers (MSL) of a dataset as the first $l$ layers of skyline, where the first layer is the skyline of the original dataset and the second layer is the skyline of the remaining points after the first layer is removed from the dataset and so on. MSL is indispensable in all group-based skyline algorithms, including G-skyline [4] and aggregation approaches [2, 3]. It is proved that only the first $l$ layers are necessary to find group-based skyline rather than the whole dataset [2, 3, 4]. However, very few papers study this issue, they usually focus on how to establish the group-based skyline. MSL is also useful in traditional skyline problems [32, 33, 34]. It can be computed layer by layer using a traditional skyline method but it is ineffective. In fact, [5] showed that $O\left(n\log{n}\right)$ time is needed to construct one layer. So, constructing $l$ layers costs $O\left(ln\log{n}\right)$ running time.

[4, 34, 32] laid out several new methods that can find all layers in one enumeration. [4] proposed a Binary Search (BS) algorithm with $O\left(n+\mathbb{S}_{l}\log{l}\right)$ time complexity for two- and $O\left(n\mathbb{S}_{l}\right)$ for higher-dimensional spaces, which is the state-of-the-art algorithm for MSL. BS algorithm constructs MSL by ordering the points by one dimension and determine each point’s layer in this order. It is much better but there is still great room for improvement. In this section, we investigate a high-efficiency approach to construct the first $l$ skyline layers, defined as MSL, with $O\left(\mathbb{T}_{l}\left(n^{\frac{d-1}{d}}l+\mathbb{S}_{l}\log{l}\right)\right)$ time complexity, where $\mathbb{S}_{l}$ is the number of the points in the first $l$ layers and $\mathbb{T}_{l}$ is the subspace skyline size of the $l$-th layer. Noticing $\mathbb{T}_{l}$ is 1 in the $2$-dimensional space, the time complexity becomes $O\left(\sqrt{n}l+\mathbb{S}_{l}\log{l}\right)$.

A summary of notations is given in Table I. We preprocess the dataset to make the definitions and proofs later in this article concise and normative. (1) We assume the criterion function $f(\,\,)$ monotonically decreases with each attribute, or we take the opposite of this attribute. That is, for certain point $p$, the smaller $p[i]$ ($i=1,\cdots,d$) are, the better $p$ is. (2) All attributes are normalized to $[0,a]$. (3) We regard the coincidence points as one point since they are equivalent when making decision.

Definition 1** (Skyline).**

Given a dataset $S$ of $n$ points in $d$-dimensional space. Let $p$ and $p^{\prime}$ to be two different points in $S$, $p$ dominates $p^{\prime}$, denoted by $p\prec p^{\prime}$, if for all i, $p[i]\leq p^{\prime}[i]$ and for at least one i, $p[i]<p^{\prime}[i]$, where $p[i]$ is the $i$-th dimension of $p$ and $1\leq i\leq d$. The skyline consists of the points that are not dominated by any other points in $S$.

Definition 2** (Multiple Skyline Layers (MSL)).**

Given a dataset $S$ with $n$ points in $d$-dimensional space, MSL is a multi-layer structure. $layer_{1}$ is the skyline of $S$, i.e., $layer_{1}=skyline\left(S\right)$ and $layer_{2}$ is the skyline of the complementary set of $layer_{1}$ in $S$, i.e., $layer_{2}=skyline\left(S\backslash{layer_{1}}\right)$. Generally, $layer_{i}$ is the skyline of the complementary set of the first i-1 layers in $S$, i.e., $layer_{i}\!\!=\!skyline\!\left(S\backslash{\bigcup_{j=1}^{i-1}layer_{j}}\right)$. And MSL is a multi-layer structure defined as $\{layer_{j}\}_{j=1,\cdots,l}$, where $l$ is the size of the group.

3.1 Simultaneous Search in Each Dimension

According to the definition of MSL, we need to establish the first $l$ layers by computing skyline $l$ times. To replace this ineffective way, we devise a novel method to find each layer’s points by searching the dataset one time. Noticing that the information of each layer’s points is equivalent to the information of each point’s layer, we can construct each layer by finding which layer each point belongs to. The detailed procedure is introduced below.

Definition 3** (Dominance Domain).**

Given a dataset $S$ and a skyline layer $layer_{i}$, dominance domain of $layer_{i}$ is defined as: $D\left(layer_{i}\right)=S\backslash{\bigcup_{j=1}^{i}layer_{j}}$, or $D\left(layer_{i}\right)=\bigcup_{j=i+1}^{l_{m}}layer_{j}$, where $l_{m}$ is the maximum layer number. In $2$-dimensional case, dominance domain of $layer_{i}$ is the set of points in the upper right area of $layer_{i}$ intuitively.

Property 1**.**

If a point $p\in D(layer_{i})$, there is at least one point $p^{\prime}\in layer_{i}$ making $p^{\prime}\prec p$ and if $p\notin D(layer_{i})$, there is no point $p^{\prime}\in layer_{i}$, $p^{\prime}\prec p$.

Proof**.**

When $i>1$, $layer_{i}$ is the skyline of $D(layer_{i-1})$. For certain $p\in D(layer_{i})$, there is at least one sequence $\{p_{1},p_{2},\cdots,p_{m}\}$ in $D(layer_{i-1})$, satisfying $p_{m}\preceq\cdots\preceq p_{1}\preceq p$. Since no point in $D(layer_{i-1})$ can dominate $p_{m}$, $p_{m}\in layer_{i}$. For certain $p\notin D(layer_{i})$, then $p\in layer_{j}(j\leq i)$ and no points in $layer_{i}$ can dominate it. We can get the same result when $i=1$.

Property 2**.**

The layer of point $p$ is equal to the maximal layer of the points that dominate $p$ plus 1, i.e., $layer\left(p\right)=\max\{layer\left(p^{\prime}\right)\arrowvert p^{\prime}\prec p\}+1$, and $layer(p)=1$ if $\{p^{\prime}\arrowvert p^{\prime}\prec p\}=\varnothing$.

Proof**.**

According to Definition 3 and Property 1, for any point $p$ in $layer_{i}$, where $2\leq i\leq l$. For each $m_{1}$ ($1\leq m_{1}\leq i-1$), since $p\in D(layer_{m_{1}})$, there must be at least one point in $layer_{m_{1}}$ that dominates $p$. And for each ${m_{2}}$ ($i\leq{m_{2}}\leq l$), since $p\notin D(layer_{m_{2}})$, no point in $layer_{m_{2}}$ can dominates $p$. We can see that, all points that can dominate $p$ belong to the first i-1 layers and at least one in each. So, $\max\{layer\left(p^{\prime}\right)\arrowvert p^{\prime}\prec p\}=i-1$.

Lamma 1**.**

To determine the layer of certain point $p$, we just need to compare it with all points in a hyper-cuboid space region, which is in the range $[0,p[i]]$ for each $i$ ($1\leq i\leq d$). This region contains all points that can dominate $p$ (Taking Figure 1 as an example, the lower left area of the current point $p$).

Example 1**.**

Considering the point $p_{8}$ in Figure 2, we just need to search the points in its lower left area ($p_{4}$, $p_{5}$, $p_{7}$) to determine $layer(p_{8})$. According to Property 2, $layer(p_{8})=\max\limits_{i=4,5,7}\left\{layer\left(p_{i}\right)\right\}+1=3$.

We propose a framework for MSL based on the above properties. We determine a given point’s layer by Property 2 and in order to find all points that can dominate $p$, we only need to check the hyper-cuboid region (the lower-left area in two dimensional case) according to Lemma 1. So our main idea is to slide a hyperplane over the points along each dimension concurrently and for each point visited, determine its layer and store it into the corresponding layer. The detailed algorithm is shown in Algorithm 1. We order all points $d$ times by all $d$ attributes (lines 6-7) and for each attribute, slide a hyperplane along the axis point by point in an increasing order (lines 9-25). When a point is visited by a hyperplane, compare it with all points that are already visited by this hyperplane to determine if it is dominated by any of them, and then label it with the maximal layer number of the dominating points plus one (lines 15-19). The point is then stored in the corresponding dimension and layer (lines 20-23). When a point in the $l$-th layer has been visited by all $d$ hyperplanes, the iteration stops (lines 12-14 and 24-25). We show example steps in Example 2.

Example 2**.**

Figure 3 illustrates the steps of constructing the MSL presented in Figure 2. Figure 3 shows the location of the hyperplanes during each iteration. Figure 3 shows the intermediate result at each iteration ($\left[\,\,\right]$ indicates one dimension and $\{\,\,\}$ indicates one layer). The algorithm stops at $B_{6}$ since the current point $p_{6}$ is in the $l$-th layer and has been scanned $d$ times by all hyperplanes. From this example, we can see that some points, e.g., $p_{4}$, $p_{5}$, and $p_{6}$, are visited twice by both hyperplanes and can be compared against different points for dominance. Will these comparisons return the same and correct result? Taking $p_{6}$ as an example, when visited by $A_{6}$, it is compared with the points in the left area, notated with $S_{1}=\{p_{1},p_{2},p_{3},p_{4},p_{5}\}$. Similarly, when visited by $B_{6}$, it is compared with points in the area below, notated with $S_{2}=\{p_{4},p_{5},p_{7},p_{8},p_{10}\}$. While according to Lemma 1, we only need to check the points in the lower left area, notated with $S_{0}=\{p_{4},p_{5}\}$. Because $S_{0}\in S_{1}$ and $S_{0}\in S_{2}$, we can draw the same conclusion by checking either of the two sets. Consequently, we only check when a point is first visited by a hyperplane. When it is visited again by other hyperplanes, we only save it in the corresponding dimension and layer without checking again.

Advancement. Benefiting from our novel structure, there are two main advancements in the proposed algorithm.

One advancement is that we reduce the number of points that need to be compared significantly. Similar to BS algorithm, our algorithm also prunes the comparison set of each point by ordering all points at the beginning. Besides this, we implement concurrent comparison in all dimensions, hence the number of points to investigate can be reduced significantly.

Another advancement is that our work provides an explicit condition to stop the iterations. It is proved that only the points in the first $l$ layers are necessary to construct group-based skylines, so the procedure can stop when points in the first $l$ layers are all found and labeled. In previous works, it is very complicated to determine when to stop. In fact, in BS algorithm [4], authors do not terminate the procedure until all points are enumerated in dataset $S$. But in our work, we have an explicit condition to stop the algorithm: when a point in the $l$-th layer is labeled by all $d$ hyperplanes, we can terminate the procedure.

Example 3**.**

Figure 8 gives several examples of $3$-layer MSL in an independent (INDE) synthetic dataset (points are even-distributed and independent among all attributes) in $2$-dimensional space. Shadow areas in Figures 8(a)(b)(c) represent the points need to be investigated in BS method and shadow areas in Figures 8(d)(e)(f) represent the points need to be investigated in our works. The investigation areas of our method are two narrow bands. When there is a point labeled by the two hyperplanes appearing in the third layer, the procedure can be terminated.

Efficiency Comparison. We estimate the number of points that need to be investigated in BS method [4] and in our concurrent MSL algorithm to demonstrate the efficiency improvement. To simplify the problem, we assume the dataset is INDE. A simple case in $2$-dimensional space is investigated first and then the conclusion is extended to high-dimensional spaces. We use $A_{1}$ to represent the area of shadow regions in Figures 8(a)(b)(c) and $A_{2}$ to represent that in Figures 8(d)(e)(f). We use $b$ and $c$ to represent the width of them (shown in Figure 8). And the value of each attribute is normalized into $[0,a]$ in the dataset preprocessing.

First, we give an analysis of BS method in $2$-dimensional space. We define a random variable $X_{1}$ to indicate the maximum of the first attribute of the points in $layer_{1}$. According to Definition 2, we know that $X_{1}\!\!=\!\!\{p_{i}[1]|i\!\!=\!\!\operatorname*{arg\,mim}\limits_{j}p_{j}[2],p_{j}\!\!\in\!\!S\}$, so $X_{1}\!\!\sim\!\!U(0,a)$ due to the independence of the two dimensions. We discuss in the most optimistic situation for the lower bound of $b$. We can ignore the influence of removing $layer_{1}$ when $n\!\!\gg\!\!l$ and simply regard the complementary set $D(layer_{1})$ as an even-distributed and independent dataset too. Similarly, we notate $X_{2}\!\!=\!\!\{p_{i}[1]|i\!\!=\!\!\operatorname*{arg\,mim}\limits_{j}p_{j}[2],p_{j}\!\!\in\!\!D(layer_{1})\}$ to present the maximum of the first attribute of the points in $layer_{2}$. It obeys uniform distribution approximately. To extend this, we deem that all $X_{i}\!\!\sim\!\!U(0,a)$, $i\!=\!1,2,\dots,l$ when $n\!\gg\!l$. $X$ is a random variable defined as $X\!\!=\!\!\max\{X_{1},X_{2},\dots,X_{l}\}$ and $b=E(X)=\frac{l}{l+1}a$.

Proof**.**

The probability distribution function of random variable $X$ can be represented as

[TABLE]

accordingly the probability density function is

[TABLE]

then we can get the expectation by integrating

[TABLE]

We then discuss in the most pessimistic situation to get the upper bound. $n$ is not big enough that we cannot just ignore the influence of removing $layer_{1}$ when investigating $X_{2}$. We consider that $layer_{1}$ captures most points with a small value of the second attribute and $X_{2}$ is less likely to be located in the left area that loses these points after removing $layer_{1}$. In the most extreme situation, $X_{2}$ has no possibility of falling in the left area and we can get $X_{2}\sim U(x_{1},a)$. Similarly, $Xi\sim U(x_{i-1},a)$, $1<i\leq l$. Let $X=\max\{X_{1},X_{2},\dots,X_{l}\}=X_{l}$, we can get $b=E(X)=(1-0.5^{l})a$.

In a more general situation, $b\in\left[\frac{l}{l+1}a,(1-0.5^{l})a\right]$. Since $A_{1}=a\times b$, $A_{1}\in\left[\frac{l}{l+1}a^{2},(1-0.5^{l})a^{2}\right]$. The conclusion is then extended to the high-dimensional situation. Using $A_{1}$ to present the volume of the hyper-cuboid area swept by the hyperplane, we can easily get $A_{1}\in\left[\frac{l}{l+1}a^{d},(1-0.5^{l})a^{d}\right]$.

Calculating the shadow areas in Figures 8(d)(e)(f) is a very tough task, we demonstrate a very simple model shown in Figure 4 to give a rough estimation. Also, we first study the problem in a $2$-dimensional situation and then extend it to high-dimensional space. The shadow area is swept by the two hyperplanes, which intersect each other at point $p$. Obviously, the value of $c$ is crucial in this problem and the case of the $c\times c$ square area depends on $l$ only. Assuming there are $m$ points on the edge of this area and we get the relationship $2(m-1)+1=l$ when $l$ is odd ($m=3$, $l=5$ in this example). Considering that points on the boundary just have 50% probability to fall in the area, the average number of points in the $c\times c$ area can be expressed as $n^{\prime}=m^{2}-(m-1)=\frac{l^{2}+3}{4}$. Because the density of points in the whole $a\times a$ area is constant, $c=\sqrt{\frac{n^{\prime}}{n}}a$. When $l\ll n$, the investigation area in our work $A_{2}=2ac-c^{2}\approx\sqrt{\frac{l^{2}+3}{n}}a^{2}$. We can get the same conclusion when $l$ is even.

Now considering a high-dimensional case, we need to study the $c^{d}$ hypercube area. $l$ is the number of points on the edge of this area and we have $d(m-1)+1=l$ similarly. With the relationship $c=\sqrt[d]{\frac{n^{\prime}}{n}}a$, $n^{\prime}=m^{d}-\frac{d}{2}\cdot m^{d-1}$, and $A_{2}=d\cdot ca^{d-1}-(d-1)c^{d}$, we can get $A_{2}\approx\frac{l}{\sqrt[d]{n}}a^{d}$ when $l$, $n$, $m$ are large and the overlap of hyper-cuboids are neglected. In the G-skyline problem, $n\gg l$, hence $A_{2}\ll A_{1}$, we can see that our new algorithm can reduce the cost of time highly.

3.2 Subspace Skyline Searching

We have introduced a framework to construct the MSL in Subsection 3.1, but the search technique for each point is still inadequate. Comparing with all the points visited already for dominance when processing each new point is not efficient. In this section, we illustrate some detailed searching strategies including utilizing skyline in the subspace and binary search to make searches more efficient.

A hyperplane mentioned in Subsection 3.1 is indeed a $d-1$ dimensional subspace, for instance, a line in planar space and a plane in $3$-dimensional space. When processing a point $p$, we can project it and the points that we need to compare against to the subspace. We utilize the properties of dominance in the subspace to construct the MSL. Of special note is that though points in certain $layer_{i}$, which is the skyline of $D(layer_{i-1})$, cannot dominate each other in original space, but their projections can since one attribute is neglected in the subspace.

Property 3**.**

When points are ordered increasingly by certain attribute $i$ and point $p_{2}$ is behind $p_{1}$, $p_{1}^{\prime}$ and $p_{2}^{\prime}$ are the projections of these two points in the $i$-th hyperplane. If $p_{1}^{\prime}\prec p_{2}^{\prime}$, then $p_{1}\prec p_{2}$. If $p_{1}^{\prime}\nprec p_{2}^{\prime}$, then $p_{1}\nprec p_{2}$.

Proof**.**

Since point $p_{2}$ is behind $p_{1}$, we know that $p_{1}[i]\leq p_{2}[i]$. And since $p_{1}^{\prime}\prec p_{2}^{\prime}$, we know that $p_{1}[j]\leq p_{2}[j]$ ($j=1,\cdots,i-1,i+1,\cdots,m$), and $p_{1}[j]<p_{2}[j]$ for at least one j, so we know that $p_{1}\prec p_{2}$. Similarly, when $p_{1}^{\prime}\nprec p_{2}^{\prime}$, we can infer that $p_{1}\nprec p_{2}$.

Theorem 1**.**

When investigating if current point can be dominated by certain points in the current layer in our framework, we just need to compare its projection with the subspace skyline of this layer.

Proof**.**

According to Property 3, when searching if there is a point in certain layer can dominate current point, we just need to execute this procedure in the subspace. Notate current point as $p_{0}$ and the current layer as $layer_{i}$. According to the definition of skyline, for certain point $p_{1}^{\prime}$ not in $skyline_{s}(layer_{i}^{\prime})$, there must be some points $p_{2}^{\prime},\cdots,p_{m}^{\prime}$ in $layer_{i}^{\prime}$ making $p_{m}^{\prime}\preceq\cdots p_{2}^{\prime}\preceq p_{1}^{\prime}$. Since no point can dominate $p_{m}^{\prime}$, $p_{m}^{\prime}\in skyline_{s}(layer_{i}^{\prime})$. So, if there is a point $p_{1}^{\prime}$ that can dominate current point $p_{0}^{\prime}$, there must be at least one corresponding skyline point $p_{m}^{\prime}$ dominating $p_{0}^{\prime}$, and vice versa. So, when investigating $p_{0}^{\prime}$, only points in $skyline_{s}(layer_{i}^{\prime})$ need to be compared.

Consolidating theories above, we give the detailed algorithm in Algorithm 2. To make the introduction more concise, we use the framework of BS algorithm, where the points are ordered by only one dimension. In this algorithm, we use a binary search to label the current point (lines 7-20). When searching if the current point is in certain layer, compare its projection with the skyline of this layer’s projection in the subspace (lines 8, 11, and 14, where $D_{s}(\,\,)$ is the dominance domain in the subspace). Renew the subspace skyline after each search (lines 16-19) and store the point to the corresponding layer (line 20). In fact, the tail point in BS algorithm is a special case in a $2$-dimensional dataset of our subspace skyline.

Example 4**.**

Table II shows the steps of Algorithm 2 with the example in Figure 5 ($n=5$, $d=3$, $l=2$). Taking $p_{5}$ as an example, we compare $p_{5}^{\prime}$ with the subspace skyline of each layer ($\{p_{1}^{\prime},p_{2}^{\prime},p_{4}^{\prime}\}$ and $\{p_{3}^{\prime}\}$). Once it is labeled and added to the first layer, we renew the subspace skyline of the first layer (adding $p_{5}^{\prime}$ and removing $p_{2}^{\prime}$, since it is dominated by $p_{5}^{\prime}$).

Recalling the Property 3, we know that $p_{1}^{\prime}\nprec p_{2}^{\prime}$ then $p_{1}\nprec p_{2}$. However, $p_{2}$ may dominate $p_{1}$ (when $p_{2}^{\prime}\prec p_{1}^{\prime}$ and $p_{2}^{\prime}[i]=p_{1}^{\prime}[i]$). In this case, we need to make sure $p_{2}$ is ordered in front of $p_{1}$, or the skyline returned by Algorithm 2 will be incorrect. So when ordering points by the $i$-th attribute and there are several points with the same value of this attribute, we need to find another attribute to order them increasingly. If there are still points with the same value, we keep this procedure till the order is determined.

3.3 MSL Algorithm

We introduce a framework based on simultaneous search in each dimension in Subsection 3.1 and detailed searching strategies in Subsection 3.2. The complete algorithm for MSL is a combination of the two algorithms. We search the points concurrently in all dimensions. In each dimension, we use binary search and subspace skyline to investigate each point.

Running Time. According to previous analysis in Subsection 3.1, the number of points we need to investigate is $\frac{A_{2}}{a^{d}}n=n^{\frac{d-1}{d}}l$. For those points that are not in the first $l$ layers, we only need to compare it with the subspace skyline of the $l$-th layer. There are $\mathbb{T}_{l}$ points in it, so this part costs $O\left(\mathbb{T}_{l}n^{\frac{d-1}{d}}l\right)$. For each point $p_{j}$ in the first $l$ layers, we need to search and label it, the time complexity is $O\left(\sum_{i\in BS_{j}}\mathbb{T}_{i}\right)$, where $BS_{j}$ is the set of layer index in the binary search for $p_{j}$ and $\left|BS_{j}\right|=\log{l}$. When $n\gg\mathbb{S}_{l}$, we can ignore the influence of the first $i$ layers ($1\leq i\leq l$) and regard the complementary set $D(layer_{i})$ as an even-distributed and independent dataset. In this situation, all $\mathbb{T}_{i}$, $1\leq i\leq l$, are approximately the same. Accordingly, the time complexity for investigating one points is $O\left(\mathbb{T}_{l}\log{l}\right)$ and the total cost of the second part is$\,O\left(\mathbb{T}_{l}\mathbb{S}_{l}\log{l}\right)$. Ignoring the preprocessing time, our algorithm requires $O\left(\mathbb{T}_{l}\left(n^{\frac{d-1}{d}}l+\mathbb{S}_{l}\log{l}\right)\right)$ time in total for constructing MSL. Noticing that $\mathbb{T}_{l}=1$ in the $2$-dimensional space, the time complexity becomes $O\left(\sqrt{n}l+\mathbb{S}_{l}\log{l}\right)$.

We note that the skyline layers are closely related to the $l$-skyband [9] (we use $l$ to represent the depth instead of $k$). The differences between $l$-skyband and MSL were discussed in [4]. In fact, $(l-1)$-skyband is the subset of $l$-layer MSL. There are two reasons we use MSL instead of skyband: (1) We can design efficient algorithms to construct MSL, as we shown in this section. (2) The more important reason is that MSL is a multi-layer structure. Points in the same layer cannot dominate each other. Points in the low-layer can dominate points in the high-layer, but not vice versa. These properties are very important to construct G-skyline, as shown in next section.

4 Finding G-skyline Groups

In this section, we devise a novel structure for finding G-skyline groups.

Definition 4** (G-Skyline).**

Given a dataset $S$ of $n$ points in $d$-dimensional space. $G=\{p_{1},p_{2},\cdots,p_{l}\}$ and $G^{\prime}=\{p_{1}^{\prime},p_{2}^{\prime},\cdots,$ $p_{l}^{\prime}\}$ are two different groups with $l$ points. If we can find two permutations of the $l$ points for $G$ and $G^{\prime}$, $G=\{p_{u_{1}},p_{u_{2}},\cdots,p_{u_{l}}\}$ and $G^{\prime}=\{p_{v_{1}}^{\prime},p_{v_{2}}^{\prime},\cdots,p_{v_{l}}^{\prime}\}$, letting $p_{u_{i}}\preceq p_{v_{i}}^{\prime}$ for all $i$ and $p_{u_{i}}\prec p_{v_{i}}^{\prime}$ for at least one $i$ ($1\leq i\leq l$), we say $G$ g-dominates $G^{\prime}$, denoted by $G\prec_{g}G^{\prime}$. All groups containing $l$ points that are not g-dominated by any other groups with the same size compose G-skyline, denoted by $GS$ [4].

Obviously, the Brute-force method for G-skyline is extremely time-consuming and far from practical [4]. We demonstrate some important properties of G-skyline groups that can be utilized to construct the G-skyline.

Property 4**.**

For certain $l$-size group $G$, the necessary and sufficient conditions of $G\in GS$ is that for all $p_{i}\in G$ and all $p_{j}\prec p_{i}$ in dataset $S$, $p_{j}\in G$.

Proof**.**

Necessity.* By contradiction, for certain group $G\in GS$ and point $p_{i}\in G$, assume there is a point $p_{j}$ satisfying $p_{j}\notin G$ and $p_{j}\prec p_{i}$. We construct a new group $G^{\prime}$ by using $p_{j}$ to replace $p_{i}$, then $G^{\prime}\prec_{g}G$ since $p_{j}$ dominates $p_{i}$ and all the other points are the same, which contradicts the G-Skyline definition. We come to the conclusion, for all points in a G-skyline group, all its parents are in this group.*

Sufficiency.* By contradiction, we assume that there exits a group $G$ satisfying for all $p_{i}\in G$ and all parents of $p_{i}$ are in $G$, and $G$ is not a G-skyline group. According to Definition 4, we have $G\notin GS$, so there is a group $G^{\prime}$ g-dominating $G$ and two permutations of these groups, $G^{\prime}=\{p_{u_{1}}^{\prime},p_{u_{2}}^{\prime},\cdots,p_{u_{l}}^{\prime}\}$ and $G=\{p_{v_{1}},p_{v_{2}},\cdots,p_{v_{l}}\}$, letting $p_{u_{i}}^{\prime}\preceq p_{v_{i}}$ and $p_{u_{i}}^{\prime}\prec p_{v_{i}}$ for at least one $i$ ($1\leq i\leq l$). We know that $p_{u_{i}}^{\prime}$ is a parent node of $p_{v_{i}}$, so $p_{u_{i}}^{\prime}\in G$, and assume it is notated as $p_{v_{j}}$ in $G$. Considering $G^{\prime}\prec_{g}G$, there is a point $p_{u_{j}}^{\prime}\in G^{\prime}$ making $p_{u_{j}}^{\prime}\preceq p_{v_{j}}$. Since $p_{u_{i}}^{\prime}=p_{v_{j}}$, we can get $p_{u_{j}}^{\prime}\neq p_{v_{j}}$ (there are no coincident points in the dataset $S$ after the preprocessing mentioned in Section 3) and $p_{u_{j}}^{\prime}\prec p_{v_{j}}$ strictly. For the same reason, $p_{u_{j}}^{\prime}\in G$, which can be denoted as $p_{v_{m}}$, and there is a point $p_{u_{m}}^{\prime}\in G^{\prime}$ that can dominate it, so $p_{v_{i}}\succ p_{v_{j}}\succ p_{v_{m}}\cdots$. We can continue this procedure until there is a point $p_{v_{n}}\in G$, no points in $G$ can dominate it, which is the end of the dominance chain $p_{v_{i}}\succ p_{v_{j}}\succ p_{v_{m}}\cdots\succ p_{v_{n}}$. Since all parents of $p_{v_{i}}$ are in $G$, $p_{v_{n}}$ is a parent of it and no points in $G$ can dominate $p_{v_{n}}$, $p_{v_{n}}$ is a skyline point. However, we can get a point $p_{u_{n}}^{\prime}\in G^{\prime}$ making $p_{u_{n}}^{\prime}\prec p_{v_{n}}$ according to the relationship $G^{\prime}\prec_{g}G$, which is a contradiction. We come to the conclusion that if a group $G$ satisfies for all $p_{i}\in G$ and all parents of $p_{i}$ are in $G$, $G$ is a G-skyline group.*

Property 4 is a very important property of the G-skyline. The sufficient condition is the theoretical foundation of all algorithms for Pareto optimal groups even though it has not been explicitly studied. We can demonstrate other interesting properties with Property 4. Next, we demonstrate the G-skyline is a complete candidate set of top-$l$ solutions. To do so, we demonstrate these two following properties.

Property 5**.**

For all monotonically decreasing criterion function $f(\,\,)$, the group $G$ consists of the top-$l$ solutions belongs to G-skyline.

Proof**.**

For all monotonically decreasing function $f(\,\,)$, $G$ is the set of top-$l$ solutions. For any $p_{i}\in G$, assuming there is a point $p_{j}\prec p_{i}$. It is obvious that $f(p_{j})>f(p_{i})$ according to the definition of dominance and monotonicity, so $p_{j}\in G$. Finally, we can get $G\in GS$ according to Property 4.

Property 6**.**

For all $G\in GS$, there exists at least one monotonically decreasing function $f(\,\,)$ that lets $G$ be the set of top-$l$ solutions.

Proof**.**

We prove the existence by giving a specific example. For a group $G=\{p_{1},p_{2},\cdots,p_{l}\}$ in G-skyline, the criterion function could be in the form of

[TABLE]

where ${\bm{x}}=(x_{1},x_{2},\cdots,x_{d})$ are all attributes. It is a piecewise function and decreases monotonically in all domain. All points in $G$ can get non-negative scores while points in $S\backslash G$ get negative scores, so $G$ is the top-$l$ solutions.

We come to a conclusion that all G-skyline groups can be the top-$l$ solution, while all non-skyline groups can not. So G-skyline is the exact candidate set of optimal solution. This is the main superiority over other definitions of group-based skyline [2, 3].

G-skyline is established by the MSL, however we observed that not all layers in MSL contribute equally to G-skyline. The first layer is much more important. Groups that consist of only the first layer points take a great proportion.

Definition 5** (Primary Group).**

$l$-point groups consisting of only $layer_{1}$ points in MSL are primary groups. According to the definition of G-skyline, all primary groups are G-skyline groups because every individual point cannot be dominated.

Definition 6** (Secondary Group).**

G-skyline groups that are not primary groups are defined as secondary groups.

Example 5**.**

Taking the synthetic INDE dataset ($n=1000$, $d=4$, $l=3$) as an example, there are 76 points in $layer_{1}$, 152 points in $layer_{2}$, 189 points in $layer_{3}$ in MSL and 75034 groups in G-skyline. The number of primary groups and secondary groups is $\binom{76}{3}=68450$ and 6584 respectively. We can see that the number of primary groups dominates with an overwhelming advantage.

Table III shows the percentage of primary groups in different datasets, with various parameters. We can see that the primary groups occupy a large proportion in most cases, especially with a small $l$ and a large $d$. This phenomenon motivates the following.

(1) Primary groups, which are combinations of $l$ points in $layer_{1}$, contribute to a majority number of G-skyline groups. It is important to give priority to enumerate all these combinations in the most direct and efficient way. (2) Though there are significantly more points in later layers, they contribute very little to the G-skyline groups. So, an efficient pruning strategy is desired.

Considering these motivations, we introduce two new approaches, fast PWise algorithm (F_PWise) and fast UWise algorithm (F_UWise), based on the PWise and UWise+ algorithms proposed in [4]. Here we give a very brief summary of them: Authors first constructed the directed skyline graph (DSG), which is a graph saves all points in MSL and the dominance relationship among them. DSG is then pruned with preprocessing (remove all points with more than $l-1$ parents). In DSG, points with larger index than current point/a group of points are stored as a tail set of this point/group, denoted as $T_{DSG}(p)$/$T_{DSG}(G)$. Point $p$ and all its parents form the unit group. In PWise and UWise+ algorithm, points and unit groups from the tail set of the current group are added into it to construct a new group based on Property 4. The new group is removed if it is not a G-skyline group and is outputted if the size is $l$.

4.1 Fast PWise Algorithm

In this subsection, we propose the fast PWise algorithm (F_PWise) to construct G-skyline based on the combination queue. Besides the previous pruning strategies in PWise algorithm, we give the edge pruning for DSG to make the algorithm more effective. We first give the definition of DSG and then illustrate the pruning strategy.

Definition 7** (Directed Skyline Graph (DSG)).**

A directed skyline graph is a graph where a node represents a point and an edge represents a dominance relationship. Each node has a structure as $[layer\;index;point\;index;parents;children]$

Edge Pruning. For any two points $p_{i}$ and $p_{j}$ in DSG ($p_{j}$ is in the tail set of $p_{i}$), if $p_{j}.layer-p_{i}.layer>1$, delete the edge between them. Also, taking Figure 2 as an example, we can delete ($p_{7},p_{8})$ because when adding $p_{8}$ to a group containing $p_{7}$, it must contain $p_{5}$ and $p_{4}$ too or the new group will be a non-skyline group and removed by subtree pruning [4]. We can find $p_{8}$ in the child set of $p_{5}$ hence the connection between $p_{7}$ and $p_{8}$ is not necessary.

Definition 8** (Combination Queue).**

A queue to enumerate combinations by adding elements in the tail set of current set.

We enumerate all combinations of no more than $l$ $layer_{1}$ points with a combination queue. It can output all the primary groups and can also be used to find secondary groups in the next procedure. The detailed algorithm is shown in Algorithm 3. The algorithm prunes the DSG by preprocessing [4] and edge pruning (line 1). A combination queue is used to find all primary groups (line 3). Lines 4-15 show the procedure to find the secondary group with the intermediate results of the combination queue. Lines 10-14 show the subtree pruning since a group which is not an $(i-1)$-size G-skyline group cannot be an $i$-size G-skyline group by adding a point from its tail set [4].

Example 6**.**

Figure 6 uses MSL in Figure 2 as an example to show the steps of Algorithm 3. Figure 6(a) shows a DSG, where solid line arrows point to child nodes and dotted arrows point to parent node. Node $p_{8}$ and edge ($p_{4}$, $p_{6}$) are all removed (only the solid line arrow is removed, the dotted arrows is reserved for subtree pruning). In Figure 6(b), the first column is a combination queue to enumerate all primary groups and the later two columns find secondary groups by adding points in $layer_{2}$ and $layer_{3}$ to groups in the first column.

4.2 Fast UWise Algorithm

In this subsection, we propose the fast UWise algorithm (F_UWise) by adding combination queue to UWise+ algorithm. UWise+ method constructs G-skyline by adding unit groups (groups composed of certain point and all its parents in DSG) [4]. We find all primary groups by the combination queue and secondary groups by UWise+ method. Unlike F$\_$PWise, F$\_$UWise gives these two kinds of groups independently by different methods. It is a simple combination but also performs well.

5 Finding RG-skyline Groups

We demonstrated the completeness of G-skyline in Section 4. However, it can be a rather costly process returning a huge number of groups, especially when $l$ is large, or in high-dimensional space. We introduced several efficient algorithms in Sections 3 and 4 to deal with the problem of high time consumption. In this section, we focus on the problem of huge output size by defining RG-skyline. In real-world applications, reasonable output size is very important for user experience, so we just show $k$ RG-skyline groups that represent the “contour” of the whole G-skyline to users rather than the original G-skyline. [31] computed $k$-SGQ by finding G-skyline groups that can dominate the most points. However, it only returns the groups with similar attribute patterns hence is not representative enough.

Example 7**.**

Recalling the hotel example shown in Figure 2, the $k$-SGQ groups are $\{p_{1},p_{2},p_{4}\}$, $\{p_{1},p_{4},p_{7}\}$, and $\{p_{2},p_{4},p_{7}\}$ ($l=3$, $k=3$).

We can see that a max-dominance method tends to return the groups that all their points are scattered. In fact $\{p_{1},p_{2},p_{4}\}$, $\{p_{1},p_{4},p_{7}\}$, $\{p_{2},p_{4},p_{7}\}$ are quite similar, they are all for agencies who want to provide extensive service. The agencies targeting low-end travelers (may collaborate with hotels $\{p_{4},p_{7},p_{5}\}$ or {$p_{4}$, $p_{5}$, $p_{6}$}) and high-end travelers (may prefer {$p_{1}$, $p_{2}$, $p_{3}$}) cannot find their choice in $k$-SGQ. To bridge this gap, we define a novel distance-based representative skyline in the group level, RG-skyline, to show all main patterns of groups and propose a novel G-clustering method to construct it.

Definition 9** (RG-Skyline).**

Given a G-skyline $GS$ and an integer $k$, cluster all $GS$ groups into $k$ clusters, the RG-skyline consists of $k$ cluster centers 333The clustering is on group-level thus the cluster centers returned are groups..

To construct RG-skyline, all G-skyline groups are clustered. We regard a cluster, which is considered as a category in unsupervised learning, as a pattern and use the cluster center to represent it. However, the conventional clustering algorithms are not competent in the group situation. Next, we introduce a $k$-means G-clustering algorithm. There are two steps in $k$-means algorithm, assign each observation to the cluster whose mean has the least distance and update the new means to be the centroids of the observations in the new clusters. So, in the G-clustering algorithm, we need to define how to calculate the distance between two groups (introduced in Subsetion 5.1) and how to update the cluster centers (introduced in Subsetion 5.2).

5.1 Distance Between Groups

There are several ways to measure the distance between two groups, such as aggregating a group into one point with MAX, MIN, or SUM. However, aggregate functions capture fragmentary attributes (strongest/weakest/average attributes with MAX/MIN/SUM). To address this gap, we give a new definition of distance in the group level. Considering groups with the same pattern have similar spacial distribution of points, we define the group distance by calculating the distance among their points.

Definition 10** (Group Distance).**

For two groups $G=\{p_{1},p_{2},$ $\cdots,p_{l}\}$ and $G^{\prime}=\{p^{\prime}_{1},p^{\prime}_{2},\cdots,p^{\prime}_{l}\}$, the distance between them is defined as:

[TABLE]

where $u$ and $v$ are two permutations that minimize Equation 1 and $d(\,\,)$ is the Euclidean distance between two points.

Calculating the group distance is an assignment problem [35]. We use a distance matrix $\bm{D}\in\mathbb{R}^{l\times l}$ to denote the distances between points in two groups and a Boolean matrix $\bm{X}\in\{0,1\}^{l\times l}$ to denote the matching strategy. $\bm{D}_{i,j}$ is the distance between $p_{i}$ and $p^{\prime}_{j}$; $\bm{X}_{i,j}=1$ means $p_{i}$ is matched to $p^{\prime}_{j}$ and $\bm{X}_{i,j}=0$ otherwise. An assignment problem can be formulated as:

[TABLE]

There are several existing methods to solve the assignment problem, such as Hungarian algorithm [36] and heuristic algorithms [37, 38, 39]. Nevertheless, in our RG-skyline group problem, $l$ is usually small, and these existing algorithms are inefficient (even slower than Brute-force, shown in Figure 17(a)). Compared with methods for global optimization, the greedy method is much more efficient while it usually returns an inaccurate solution. As the basic operation of G-clustering, a very fast and accurate algorithm for small scale matching is greatly desired. To bridge these gaps, we modify the greedy method and propose a Greedy+ algorithm (represented in Algorithm 4). In the naive greedy method, all elements in $\bm{D}$ are selected in an increasing order to try to establish the matching strategy. Since only one element can be chosen in each row and column, once an element is chosen, the elements in the same row or column are out of consideration, even though they are involved in the optimal matching strategy. So greedy method easily gets trapped in a local optimum. In our Greedy+ algorithm, more strategies are investigated (lines 1-11). We define the elements searched in all previous iterations as candidate matchings (lines 2, 9-11), they are better than the worst matching in the local optimization, hence with considerable probability to be involved in the global optimal solution. In Greedy+ algorithm, we investigate matching strategies covering all candidate matchings (lines 3-11) and return the best strategy (lines 12, 13).

5.2 Updating Strategy

In conventional $k$-means, we update the cluster centers by calculating the mean of each cluster. However, in G-skyline, a group is a set and all points in it are unordered, so we cannot sum groups to calculate the mean. To deal with this problem, we need to determine the sequence of points in each group. To do this, we utilize the permutations ($u$ and $v$) we get in Equation 1. However, Equation 1 only gives the permutations between each pair of groups hence cannot be used to sum several groups up. To deal with the problem, we revise the updating procedure. We first formulate the procedure in the point level and then extend the form to the group level.

In the point level, for certain cluster $C$, we have the mean $\bar{p}$:

[TABLE]

where $p_{0}$ is the previous center and $\Delta_{i}$ is the vectorial difference between $p_{i}$ and $p_{0}$.

Similarly, in the group level, the new centroid of cluster $C$ is:

[TABLE]

where the previous cluster centroid $G_{0}$ is not a set ($\left\{p^{(0)}_{1},p^{(0)}_{2},\cdots,p^{(0)}_{l}\right\}$) but a concatenated vector:

[TABLE]

and $\Delta(\,\,)$ in Equation 2 is also defined as a concatenated vector:

[TABLE]

where $u$ and $v$ are determined in Equation 1. We fix $v$ as $\{1,2,\cdots,l\}$ to give the unique solution and the vectorial difference in Equation 5.2 is denoted as $\Delta_{u}(G_{i},G_{0})$. We can see that the distance in Equation 1 d_{g}(G_{i},G_{0})=\left\Arrowvert\Delta(G_{i},G_{0})\right\Arrowvert_{2}. All additions in Equation 2 are for vectors.

Example 8**.**

For the hotel example illustrated in Figure 2, assuming there are three groups in current cluster $C=\{G_{1},G_{2},G_{3}\}$, where $G_{1}=\{p_{2},p_{4},p_{7}\}$, $G_{2}=\{p_{4},p_{5},p_{7}\}$, and $G_{3}=\{p_{2},p_{4},p_{5}\}$. The cluster center is initialized to $G_{1}$ and the new cluster center is:

[TABLE]

where

[TABLE]

[TABLE]

[TABLE]

[TABLE]

[TABLE]

The new cluster center is

[TABLE]

We can see that after updating, the cluster centers may not correspond to any G-skyline groups. When the iteration stops, for each cluster center, we find a G-skyline group with the shortest distance to replace it (please see Algorithm 5 for details).

Our final G-clustering algorithm is presented in Algorithm 5. To initialize the clustering centers (line 1), we first choose an arbitrary group and then add a group to $RS$ $k-1$ times. For each addition, we select a group in $GS$ with the largest distance to those in $RS$. In fact, our initialized clustering centers are sufficient to represent the whole G-skyline [28]. In each iteration, we assigning each group to the nearest cluster (lines 6-12) and then updating the centers with new means (lines 13-14). The iteration is terminated when the composition of each cluster remains stable (lines 2-14). After being updated many times, the cluster centers we get may not be skyline groups, so we return groups with the shortest distance as RG-skyline groups (lines 15-18).

Example 9**.**

RG-skyline groups returned by G-clustering are $\{p_{1},p_{2},p_{3}\}$, $\{p_{4},p_{5},p_{7}\}$, and $\{p_{2},p_{4},p_{5}\}$ ($l=3$, $k=3$). We can see that agencies for high-end travelers, low-end travelers, or extensive service can all find their choices.

6 Experiments

In this section, we demonstrate the effectiveness and the efficiency of our proposed methods in the synthetic and real-world datasets. All algorithms were implemented in python444All the codes and datasets used in this paper are available on https://github.com/Wenhui-Yu/Gskyline.. We conducted the experiments on a PC with Intel Core i7 2.8GHz processors, 512K L2 cash, 3M L3 cash, and 8G RAM.

Datasets. We performed each algorithm in synthetic datasets and a real NBA dataset. To examine the scalability of our methods, we generated independent (INDE), correlated (CORR), and anti-correlated (ANTI) datasets. These three types of data distribution are first proposed by [1] to simulate different actual application scenarios.

CORR is for the objects whose attributes are all correlated. As an example, an outstanding student may perform well in all subjects. ANTI is for the objects whose attributes are all anti-correlated, like the hotel example shown in Figure 1, the long distance one may have a lower price.

We crawl the data of NBA players from the official website555http://stats.nba.com. to construct the NBA dataset. There are five attributes to investigate players’ performance, points (PTS), rebounds (REB), assists (AST), steals (STL), and blocks (BLK).

6.1 MSL on the Synthetic Data

In this subsection, we run the approaches for MSL in synthetic datasets. Figure 8 gives examples of MSL and compares the number of points need to be investigated by different methods. Figures 9-11 show the running time of MSL algorithm (presented in Subsection 3.3), the binary search algorithm (BS) [4], and the baseline approach (BL, iteratively compute and remove each skyline layer).

Figure 8 compares different investigate ranges between previous methods and our method (INDE, $d=2,l=3,n=50$ in Figures 8(a)(d), $n=300$ in Figures 8(b)(e) and $n=1,000$ in Figures 8(c)(f)). Shadow areas in Figures 8(a)(b)(c) mean the points that are investigated in binary search (BS) algorithm. Shadow areas in Figures 8(d)(e)(f) mean the points need to be investigated in our approach. It is evident that there is less redundant computation in our approach. And the larger $n$ is, the more efficient our work is.

Figure 9 shows the time cost of each approach with varying group size $l$ in three different datasets respectively ($n=100,000,d=3$). It indicates that our approach outperforms others especially when the output size is large. When $l$ is very small, there are very few points in MSL (Figure 9(a), $l=2$, as an example), ordering before building MSL spends much time so that our approach is not the fastest. But with the increasing of $l$, the advantage of our approach becomes more and more significant. Another interesting observation is that running the skyline algorithm 20 times (BL, $l=20$) costs 100 times more than running it twice (BL, $l=2$). This is because when we construct and remove skylines layer by layer, there are more and more points in later layers (it is obvious in Example 5 and Figure 8(a)). It costs more time to construct later layers so the increasing of the total cost is not linear with the increasing of $l$.

Figure 10 presents the time cost of each approach with varying number of points $n$ ($d=3,l=10$). For each approach, the running time grows almost linearly with the increasing of the point number $n$ since the amount of computation is almost proportional to the scale of the dataset. Also, when output size is very small, our approach does not perform the best due to the overhead cost of ordering.

Figure 11 illustrates the running time of each approach with different number of dimensions $d$ ($n=100,000,l=2$). The result shows that the efficiency advantage of our approach decreases with the increasing of $d$. It is because in our search approach (shown in Algorithm 2), we save the subspace skyline of each MSL layer instead of the layer itself and compare with them when investigating a new point. We reduce the number of points to store and compare to save time but we waste some to update the subspace skyline each time. However, both theoretical analysis and experiment show that the scale of skyline will grow intensively with the increasing of $d$ since a large number of attributes means difficulty for points to dominate each other (and the same situation in the subspace). In this case, the time wasted for skyline updating is more than the time gained in search strategy. When $d$ is large, the framework (FW) only, shown in Algorithm 1, performs better than the whole MSL algorithm.

6.2 MSL on the NBA Data

In this section, we implemented all algorithms in a real NBA dataset. We gathered $5,000$ records of players after filtering out some inferior ones (we added 5 attributes to rank players and removed the bottom ones).

Figure 12 shows the influence of different parameters on the time cost of MSL in the NBA dataset. Figure 12(a) represents the variation of the running time with the impact of group size $l$ ($n=5,000,d=3$). We can see that our approach performs better than previous approaches. The variation of the time cost with the impact of dataset size $n$ is presented in Figure 12(b) with $d=3$ and $l=10$. The time cost does not vary intensively with the varying $n$ due to the “saturation” of each MSL layer. And the variation of the running time with the impact of dimension size $d$ is represented in Figure 12(c) when $n=5,000$ and $l=5$. As we have analyzed in Subsection 6.1, the efficiency advantage of our approach decreases distinctly with the increase of $d$ because of the dramatic increase of $\mathbb{T}_{l}$. Our approach costs $O\left(\mathbb{T}_{l}\left(n^{\frac{d-1}{d}}l+\mathbb{S}_{l}\log{l}\right)\right)$ time and becomes inefficient in high-dimensional space. So, in this case, we can implement framework (FW, shown in Algorithm 1) only instead of the whole MSL algorithm.

6.3 G-skyline on the Synthetic Data

In this section, we show the experimental result of the proposed approaches for computing G-skyline. F$\_$PWise and F$\_$UWise are executed and the baseline approach (BL) is the UWise+ algorithm, which is the best performing algorithm in [4]. To show the effectiveness of our G-skyline algorithms, we only compare the time after building MSL in the experiments, to eliminate the effect of our proposed MSL algorithm.

All existing approaches for G-skyline return a candidate set that is too large to be useful. In fact, if G-skyline is used for data pruning, primary groups are not necessary to return as result. This is because when investigating if a group is a primary group, we can search if all its points are in the skyline ($l\mathbb{S}_{1}$ times for the worst case) rather than searching if it is in G-skyline (more than $\binom{\mathbb{S}_{1}}{l}$ times for the worst case). Only when investigating if it is a secondary group, it needs to be searched in G-skyline. So, we just output secondary groups in our methods and the result shows the time cost of each approach.

Line charts in Figures 13 to 15 show the time cost of BL, F$\_$PWise and F$\_$UWise and histograms in Figures 13 to 15 show the size of G-skyline with certain varying parameter (group size $l$, number of points $n$, and number of dimensions $d$) in CORR, INDE, and ANTI dataset respectively.

Figure 13 shows the time cost and the G-skyline size with varying group size $l$ ($n=100,000,d=3$). We can see that the increasing of output size is almost exponential with the increasing of the group size $l$, accordingly the running time of each approach also increases exponentially with it.

Figure 14 shows the time cost and the output size with varying number of points $n$ ($d=5,l=2$). Distinctly, they both increase approximately linearly with the increasing of $n$.

Figure 15 shows the time cost and the size of G-skyline with varying number of dimensions $d$ ($n=100,000,l=2$), which increase approximately exponentially with the increasing of $d$.

Unit group based approach is a pretty artful way for the G-skyline problem. It fits the property of G-skyline group well and UWise+ usually performs better than PWise [4]. But in our new approaches, F$\_$PWise performs much better than F$\_$UWise in most situations, especially in a large output size. We can see that the new pruning strategy promotes the efficiency of F$\_$PWise dramatically. In addition, there are many overlaps between each unit groups. When the output size is large, there are a large number of unit groups to search and the overlap issue becomes serious whereas our point-based method is enhanced dramatically by the edge pruning.

6.4 G-skyline on the NBA Data

In this subsection, we implemented BL (UWise+), F$\_$UWise, and F$\_$PWise in NBA dataset and report the result. Figure 16 shows the output size and the time cost of G-skyline in NBA dataset with different parameters.

The line chart in Figure 16(a) shows the variation of the running time for G-skyline with the impact of group size $l$ ($n=5,000,d=3$). The improvement of our approaches is not so significant compared with that in other cases shown in Figure 16(b) or Figure 16(c), it may be because that our approaches omit primary groups, which account for a lower proportion when there are many layers in MSL (shown in Table III). As a result, the time complexity is the same order of magnitude with the baseline. Another interesting phenomenon is that in most situation, F$\_$PWise performs better, especially with a large $n$ or $d$, however F$\_$UWise generally performs better in this situation. The reason may be that with a large $l$, there are too many children of each node in DSG and enumerating them takes significant time in F$\_$PWise. And in F$\_$UWise, the overlap issue, mentioned in Subsection 6.3, is not so serious. The histogram in Figure 16(a) is the illustration of output size with different group size $l$.

The line chart in Figure 16(b) illustrates the variation of the time cost with the impact of dataset size $n$ with $d=5$ and $l=2$ and the histogram in Figure 16(b) illustrates the variation of the output size. We can observe that the output size does not vary prominently. The reason may be that the NBA dataset is correlated, so the skyline becomes “saturate” even with the increase of the dataset size, hence the running time and the output size of G-skyline keep constant.

The line chart in Figure 16(c) presents the variation of the running time with the impact of dimension size $d$ when $n=5,000$ and $l=2$. Line chart in Figure 15 and Figure 16(c) show that with the increase of $d$, F$\_$Pwise becomes more and more efficient and surpasses F$\_$UWise eventually. The reason may be that when there are more attributes, it is harder for a point to dominate another and there are fewer child nodes of each node in DSG, so the enumeration complexity reduces and F$\_$PWise becomes more efficient.

6.5 Representative skyline on the Synthetic Data

In this subsection, we devise experiments to validate the effectiveness of all algorithms for the assignment problem and the representative skyline (including $k$-SGQ and RG-skyline). Finally, we report the performance.

In Figure 17, the performance of four methods for the assignment problem (Brute-force, Hungarian, Greedy, and Greedy+) are reported. Figure 17(a) shows the cost of time of each method and Figure 17(b) shows the error. Brute-force calculates the distance by enumerating all possible matchings. We can see that though small at the beginning, the cost of Brute-force increases with the explosive exponential growth when $l$ grows. With much additional computation, Hungarian algorithm is far from satisfactory in the situation with small $l$. Greedy is the most efficient method though very inaccurate. Our proposed Greedy+ shows a good balance between cost of time and accuracy.

We then show the performance of algorithms for representative skyline: $k$-SGQ [25], G-cluster_B (G-clustering with Brute-force to match the points), and G-clustering. $k$-SGQ algorithm constructs the $k$-SGQ while G-cluster_B and G-clustering construct the RG-skyline. Figures 18 to 20 show the cost of time to calculate representative skyline in three synthetic datasets.

Figure 18 shows performance with varying $k$ ($l=3$, $n=1,000,000$, $d=2$). As shown in the figure, the time cost of $k$-SGQ keeps constant with the increasing of $k$, since we only need to iterate one time to construct the RG-skyline. G-cluster_B and G-clustering has a linear time cost with respect to $k$, since we need to iterate $k$ times. Since the time cost of Brute-force and Greedy+ are similar (represented in Figure 17(a)), their lines almost coincide.

Figure 19 illustrates performance of three algorithms with varying group size $l$ ($k=4$, $n=1,000,000$, $d=2$). Benefiting from our novel Greedy+ method, G-clustering outperforms G-cluster_B as $l$ grows.

Figure 20 presents the time cost with a varying number of points $n$ ($k=4$, $l=3$, $d=2$). The time cost of $k$-SGQ increases obviously with the increase of $n$. This is because when there are a large number of points in the dataset, it will cost more time to search how many points a group can dominate.

6.6 Representative skyline on the NBA Data

In this subsection, we report the performance of all algorithms for representative skyline in the NBA real-world dataset.

Figure 21 illustrates the time cost of $k$-SGQ, G-cluster_B, and G-clustering. The performance with varying $k$, $l$, and $n$ are shown in Figures 21(a)(b)(c) respectively. We can get the similar conclusion with experiments in the synthetic datasets, our G-clustering method performs better when $k$, $l$ are small and $n$ is large. We can see that our method costs more time than the baseline in some cases. Of particular note is that the main superiority of G-clustering is not the efficiency, but the effectiveness — it returns groups with different tradeoffs thus more representative (presented in Tables V and V).

Tables V and V present the $k$-SGQ and our RG-skyline respectively. The last column in Table V records the dominance score of current group. From the tables we can see that all groups returned by $k$-SGQ are in single pattern, i.e., they are all very balanced (i.e., get satisfactory score in all attributes) and with similar component. Considering that (group-based) skyline is devised to offer different tradeoffs to the users, $k$-SGQ is not competent to represent G-skyline. In contrast, RG-skyline performs much better: Groups in it are pretty different to each other and the coach will have more choices. For example, the coach can choose $G_{4}$ for a regular competition and $G_{1}$ for slam dunk competition. To prevent buzzer beater from opponents at the end of the competition, the coach can choose $G_{3}$ or $G_{5}$ to strengthen defense.

7 Conclusion

In this paper, we proposed several novel structures to address the G-skyline problem. First, we developed a novel algorithmic technique to build MSL using concurrent search and subspace skyline properties. We investigated all points by searching concurrently in each dimension and for a point, we compared it only with the subspace skyline of current layer. Then, we developed two new methods to find G-skyline by dividing the G-skyline groups into two categories, primary groups and secondary groups. We used a combination queue to enumerate all primary groups and then find the secondary groups in point-wise and unit group-wise algorithms. To mitigate the drawback of too many returned G-Skyline groups, we extended the clustering algorithm from the point level to the group level to propose our G-clustering algorithm, and then use it to establish the RG-skyline by finding out all cluster centers. Experimental results show that the proposed algorithms perform several orders of magnitude better than the baseline method in most situations.