On Finding Rank Regret Representatives

2.1 Formulation in the Primal Space

Define \( P \) as a set of points in \( \mathbb {R}^d \), where \( d \ge 2 \) is a constant integer. We will refer to each point in \( P \) as an object, reserving the term “point” for general points in \( \mathbb {R}^d \); for the same reason, we reserve the symbol \( o \) for objects and \( p \) for general points in \( \mathbb {R}^d \). For a point \( p \in \mathbb {R}^d \), \( p[i] \) (\( 1 \le i \le d \)) denotes its coordinate on dimension \( i \). We will sometimes treat \( p \) as a \( d \)-dimensional vector \( {\boldsymbol {p}} = ( {\boldsymbol {p}}[1],\ldots , {\boldsymbol {p}}[d]) \) where \( {\boldsymbol {p}}[i] = p[i] \).

A weight vector is a \( d \)-dimensional vector \( {\boldsymbol {w}} \) \( = \) \( ( {\boldsymbol {w}}[1], \ldots , {\boldsymbol {w}}[d]) \) where \( {\boldsymbol {w}}[i] \ge 0 \) for each \( i \in [1, d] \). The \( {\boldsymbol {w}} \)-score of an object \( o \in P \) is the dot product \( {\boldsymbol {w}} \cdot {\boldsymbol {o}} \). The \( {\boldsymbol {w}} \)-rank of \( o \), denoted as \( \textrm {rank}_ {\boldsymbol {w}}(o) \), equals \( r \) if exactly \( r - 1 \) objects in \( P \) have higher \( {\boldsymbol {w}} \)-scores than \( o \). The \( t \)-set of \( {\boldsymbol {w}} \), denoted as \( P_ {\boldsymbol {w}}(t) \), contains the objects in \( P \) with \( {\boldsymbol {w}} \)-ranks \( 1, 2, \ldots , t \), respectively. Denote by \( \mathscr{W} \) the set of all possible weight vectors.

For a non-empty subset \( S \subseteq P \), define its \( {\boldsymbol {w}} \)-rank regret under a \( {\boldsymbol {w}} \in \mathscr{W} \) as \( \begin{eqnarray*} \mathit {RR}_ {\boldsymbol {w}}(S) &=& \min _{o \in S} \textrm {rank}_ {\boldsymbol {w}}(o) \end{eqnarray*} \) and its maximum rank regret as (1) \( \begin{eqnarray} \textrm {MRR}(S) &=& \max _{ {\boldsymbol {w}} \in \mathscr{W}} \mathit {RR}_ {\boldsymbol {w}}(S). \end{eqnarray} \) \( S \) is a \( k \)-rank-regret representative of \( P \) if \( \textrm {MRR}(S) \le k \). The problem studied in this article is

Example. Figure 1 shows a set \( P \) of 6 objects in 2D space; this input set will serve as our running example throughout the article. Consider the weight vector \( {\boldsymbol {w}} = (20, 1) \). The \( {\boldsymbol {w}} \)-score of \( o_1 \) is \( (-1) \cdot 20 + 24 \cdot 1 = 4 \). The \( {\boldsymbol {w}} \)-ranks of \( o_6, o_5, o_4, o_3, o_1 \), and \( o_2 \) are 1, 2, 3, 4, 5, and 6, respectively. Thus, the 3-set of \( {\boldsymbol {w}} \) is \( \lbrace o_6, o_5, o_4\rbrace \). Let \( S = \lbrace o_3, o_4\rbrace \). Its \( {\boldsymbol {w}} \)-rank regret \( \mathit {RR}_ {\boldsymbol {w}}(S) = 3 \), namely, the \( {\boldsymbol {w}} \)-rank of \( o_4 \), which is smaller than that of \( o_3 \). Later, we will see that \( \textrm {MRR}(S) = 3 \), i.e., \( S \) is a 3-rank-regret representative of \( P \). Furthermore, \( P \) admits no smaller 3-rank-regret representatives.

Fig. 1.

View Figure

2.2 Formulation in the Dual Space

Next, we provide another formulation under the point-plane duality transformation [25] and establish its equivalence to Problem 1. Define \( \begin{equation*} \mathscr{W}_{[d]\ne 0} = \lbrace {\boldsymbol {w}} \in \mathscr{W}\mid {\boldsymbol {w}}[d] \ne 0\rbrace . \end{equation*} \) Compared to \( \mathscr{W} \), \( \mathscr{W}_{[d]\ne 0} \) leaves out the weight vectors \( {\boldsymbol {w}} \) with \( {\boldsymbol {w}}[d] = 0 \) that turn out to be unimportant:

The proof can be found in the appendix. Define \( \begin{equation*} \mathscr{W}_{[d] = 1} = \lbrace {\boldsymbol {w}} \in \mathscr{W}\mid {\boldsymbol {w}}[d] = 1\rbrace . \end{equation*} \) For any object, its \( {\boldsymbol {w}} \)-rank remains the same when \( {\boldsymbol {w}} \) is scaled by a positive factor. Thus, every \( {\boldsymbol {w}} \in \mathscr{W}_{[d]\ne 0} \) has the same \( k \)-set as \( {\boldsymbol {w^{\prime }}} = (\frac{ {\boldsymbol {w}}[1]}{ {\boldsymbol {w}}[d]}, \ldots , \frac{ {\boldsymbol {w}}[d-1]}{ {\boldsymbol {w}}[d]}, 1) \). Hence, it suffices to consider only \( \mathscr{W}_{[d] = 1} \), where the weight vectors are said to be canonical henceforth.

Under point-plane duality, each object \( o = (o[1],\ldots , o[d]) \) in \( P \) defines a dual plane (2) \( \begin{eqnarray} {\boldsymbol {x}}[d] &=& \left(\sum _{i=1}^{d-1} (-o[i]) \cdot {\boldsymbol {x}}[i] \right) - o[d] \end{eqnarray} \) in the dual space \( \mathbb {R}^d \) (the plane includes all the points \( {\boldsymbol {x}} \) in \( \mathbb {R}^d \) satisfying the equation). Denote by \( H \) the set of \( n \) dual planes obtained from \( P \) in this manner.

Example. Consider, again, the set \( P \) of points \( o_1, o_2,\ldots , o_6 \) in Figure 1. Figure 2 shows the corresponding dual planes (which are lines in 2D) \( h_1, h_2,\ldots , \) and \( h_6 \), which constitute the set \( H \). Take \( o_1 \) as an example. Recall from Figure 1 that \( o_1 \) has coordinates \( (-1, 24) \), i.e., \( o_1[1] = -1 \) and \( o_1[2] = 24 \). From Equation (2), we know that its dual plane \( h_1 \) is given by the equation \( x[2] = - o_1[1] \cdot x[1] - o_1[2] \), which is \( x[2] = - (-1) \cdot x[1] - 24 \). In Figure 2, \( x[1] \) and \( x[2] \) correspond to the “x” and “y” dimensions, respectively. This explains why \( h_1 \) is represented by the equation \( y = x - 24 \).

Fig. 2.

View Figure

Define the query space \( \mathscr{Q} \) as the set of all possible (\( d-1 \))-dimensional vectors \( {\boldsymbol {q}} = ( {\boldsymbol {q}}[1],\ldots , {\boldsymbol {q}}[d-1]) \) satisfying \( {\boldsymbol {q}}[i] \ge 0 \) for all \( i \in [1, d-1] \). Each query \( {\boldsymbol {q}} \in \mathscr{Q} \) determines a line \( \ell _ {\boldsymbol {q}} \) in the dual space \( \mathbb {R}^{d} \) that is parallel to dimension \( d \) and passes the point \( ( {\boldsymbol {q}}[1], \ldots , {\boldsymbol {q}}[d-1], -\infty) \). Consider the \( n \) intersections between \( \ell _ {\boldsymbol {q}} \) and the planes in \( H \). For each plane \( h \in H \), define its \( {\boldsymbol {q}} \)-rank, denoted as \( \textrm {rank}_ {\boldsymbol {q}}(h) \), as \( r \) if exactly \( r-1 \) intersections have smaller coordinates on dimension \( d \) than the intersection between \( \ell _ {\boldsymbol {q}} \) and \( h \). The \( t \)-set of \( {\boldsymbol {q}} \), denoted as \( H_ {\boldsymbol {q}}(t) \), includes the planes in \( H \) with \( {\boldsymbol {q}} \)-ranks \( 1, 2,\ldots , t \), respectively.

Example (cont.). The dimensionality \( d \) of the dual space is 2. Hence, the query space \( \mathscr{Q} \) in Figure 2 is one dimensional (\( = d - 1 \)), because of which we will simplify the vector representation \( {\boldsymbol {q}} \) into a real value \( q \). Consider the query \( q \) \( = \) 20. Line \( \ell _q \) is the vertical line \( x = 20 \), namely, the line parallel to dimension \( d = 2 \) (i.e., \( y \)-axis) and passing the point \( ( {\boldsymbol {q}}[1], -\infty) = (20, -\infty) \). The lines in \( H \) intersect \( \ell _q \) in the bottom-up order of \( h_6, h_5, h_4, h_3, h_1, h_2 \) (see Figure 2). The \( q \)-ranks of \( h_6, h_5, h_4, h_3, h_1 \), and \( h_2 \) are, therefore, \( 1, 2, \ldots , 6, \) respectively.

It is rudimentary to verify the following one-one correspondence between \( \mathscr{W}_{[d]=1} \) and \( \mathscr{Q} \):

Example (cont.). Consider the canonical weight vector \( {\boldsymbol {w}} = (20, 1) \); recall that \( {\boldsymbol {w}} \) is canonical if and only if \( {\boldsymbol {w}}[2] = 1 \). As mentioned in an earlier example, the \( {\boldsymbol {w}} \)-ranks of \( o_6, o_5, o_4, o_3, o_1 \), and \( o_2 \) are 1, 2, 3, 4, 5, and 6, respectively. These are identical to the \( q \)-ranks (where \( q = 20 \)) of their corresponding dual planes, namely, \( h_6, h_5, h_4, h_3, h_1, h_2 \), respectively (see the previous example for how the \( q \)-ranks are computed.

Given a non-empty subset \( {\mathscr{S}}\subseteq H \), we define its \( {\boldsymbol {q}} \)-rank regret as \( \begin{equation*} \mathit {RR}_ {\boldsymbol {q}}({\mathscr{S}}) = \min _{h \in {\mathscr{S}}} \textrm {rank}_ {\boldsymbol {q}}(h) \end{equation*} \) and accordingly the maximum rank regret of \( {\mathscr{S}} \) as (3) \( \begin{eqnarray} \textrm {MRR}^{\prime }({\mathscr{S}}) &=& \max _{ {\boldsymbol {q}} \in \mathscr{Q}} \mathit {RR}_ {\boldsymbol {q}}({\mathscr{S}}). \end{eqnarray} \)

Problems 1 and 2 are equivalent:

4.1 Connections to Regret-Ratio Minimizing Sets

In this subsection, each object \( o \in P \) is assumed to have positive coordinates \( o[1],\ldots , o[d] \), which can be achieved by shifting the coordinate system appropriately. Accordingly, the score of an object is always non-negative under any weight vector \( {\boldsymbol {w}} \).

Define \( \textrm {gain}_ {\boldsymbol {w}}(P,k) \) as the lowest \( {\boldsymbol {w}} \)-score of the objects in the \( k \)-set of \( {\boldsymbol {w}} \). Given a subset \( S \subseteq P \), Chester et al. [22] defined its \( k \)-regret ratio under \( {\boldsymbol {w}} \) as \( \begin{eqnarray*} k\textrm {-regratio}_ {\boldsymbol {w}}(S) &=& \frac{max\lbrace 0, \textrm {gain}_ {\boldsymbol {w}}(P,k) - \textrm {gain}_ {\boldsymbol {w}}(S,1)\rbrace }{\textrm {gain}_ {\boldsymbol {w}}(P,k)} \end{eqnarray*} \) and its maximum \( k \)-regret ratio as \( \begin{eqnarray} k\textrm {-regratio}(S) &=& \max _{ {\boldsymbol {w}} \in \mathscr{W}} k\textrm {-regratio}_ {\boldsymbol {w}}(S). \end{eqnarray} \) In the \( k \)-regret minimizing set problem, given an integer \( k \in [1, n] \) and a size threshold \( s \), we want to find a subset \( S \) with \( |S| = s \) to minimize \( k\textrm {-regratio}(S) \).

\( \textrm {MRR}(S) \) (see Equation (1)) has a connection to \( k\textrm {-regratio}(S) \):

In 2D space, the \( k \)-regret minimizing set problem can be settled in \( \tilde{O}(n^2) \) time [16] (where \( \tilde{O}(.) \) hides a \( \text{polylog}n \) factor). Problem 1 can then be settled in \( \tilde{O}(n^2) \) time. By Lemma 5, it suffices to find the smallest \( s \in [1, n] \) such that some subset \( S \subseteq P \) of size \( s \) achieves \( k\textrm {-regratio}(S) = 0 \). Since \( k\textrm {-regratio}(S) \) monotonically decreases when \( |S| \) increases, we can discover the desired \( s \) with binary search, which requires solving \( O(\log n) \) instances of the \( k \)-regret minimizing set problem. In the next subsection, we will present an algorithm with a more appealing time complexity of \( \tilde{O}(nk) \).

When \( d = 3 \), Agarwal et al. [3] proved the NP-hardness of the following problem: given a size threshold \( s \in [1, n] \), decide whether there is an \( S \) with \( |S| = s \) and \( 2\textrm {-regratio}(S) = 0 \). This implies that the 3D version Problem 1 is NP-hard even when \( k = 2 \). To see why, if we could find in polynomial time an \( S \subseteq P \) satisfying \( \textrm {MRR}(S) \le k \) with the smallest \( |S| \), then we could settle the above decision problem by comparing \( |S| \) to \( s \) (by Lemma 5). The NP-hardness at \( d = 3 \) indicates that Problem 1 is NP-hard for all \( d \ge 3 \).

4.2 A Faster 2D Algorithm

4.2.1 Levels.

In general, let \( H \) be a set of \( n \) planes in \( \mathbb {R}^d \). Fix an arbitrary point \( p \in \mathbb {R}^d \) and a plane \( h \) that does not pass \( p \). We say that \( p \) is above \( h \) if we must move \( p \) toward the negative direction of dimension \( d \) for \( p \) to touch \( h \); otherwise, \( p \) is below \( h \). The level of \( p \) is the number of planes in \( H \) below \( p \). The \( l \)-level (\( l \in [0, n] \)) is the set of all points in \( \mathbb {R}^d \) whose levels are exactly \( l \), and the \( (\le l) \)-level is the set of all points in \( \mathbb {R}^d \) whose levels are at most \( l \). Example. To illustrate the above concepts, Figure 5 shows a set \( H \) of 2D planes (lines) that are taken directly from Figure 2. Every number indicates the level at the point where the number is placed. The gray area represents the \( (\le 2) \)-level, the striped area represents the 3-level, and their union is the \( (\le 3) \)-level.

Fig. 5.

View Figure

In 2D space, the \( (\le k) \)-level induced by \( H \) consists of non-overlapping polygons (see Figure 5) whose edges we refer to as boundary edges. There are \( O(nk) \) boundary edges [5, 23] and they can be computed in \( \tilde{O}(nk) \) time [32]. See Figure 6 for an illustration.

Fig. 6.

View Figure

4.2.2 Algorithm.

We can rephrase (the 2D version of) Problem 2 in terms of levels. Recall that the input is a set \( H \) of lines in the dual space \( \mathbb {R}^2 \) and the query space \( \mathscr{Q} \) is the interval \( [0, \infty) \). Each query \( q \in \mathscr{Q} \) corresponds to a point \( (q, -\infty) \) at the bottom of the dual space. Imaging shooting a ray \( \rho \) from \( (q, -\infty) \) upwards, which stops right before leaving the \( (\le k-1) \)-level. \( H_q(k) \) (the \( k \)-set of \( q \)) includes exactly those lines of \( H \) intersecting with \( \rho \). A subset \( {\mathscr{S}}\subseteq H \) hits \( q \) if \( {\mathscr{S}} \) has at least one line intersecting with \( \rho \). The goal of Problem 2 is to find the smallest \( {\mathscr{S}} \) that hits all queries in \( \mathscr{Q} \).

Example (cont.). Recall that the gray area of Figure 6 corresponds to the \( (\le 2) \)-level defined by the set of lines in Figure 5. Assuming \( k = 3 \), the rays shot from points \( (q_1, -\infty) \) and \( (q_2, -\infty) \) are \( \rho _1 \) and \( \rho _2 \), respectively. \( {\mathscr{S}}= \lbrace h_1, h_2, h_3\rbrace \) hits \( q_1 \), but does not hit \( q_2 \), meaning that \( {\mathscr{S}} \) contains at least a line in the 3-set of \( q_1 \), but nothing in that of \( q_2 \). Hence, \( {\mathscr{S}} \) is not a solution to Problem 2. An optimal solution is \( {\mathscr{S}}= \lbrace h_3, h_4\rbrace \) (it hits all queries). Optimal solutions are not unique; e.g., \( {\mathscr{S}}= \lbrace h_2, h_5\rbrace \) is another example.

Next, we explain how to solve Problem 2 in \( \tilde{O}(nk) \) time. Define an envelop chain as a sequence \( C \) of line segments \( \sigma _1, \sigma _2, \ldots , \sigma _{|C|} \) such that:

• every segment of \( C \) is in the \( (\le k-1) \)-level and is part of a line in \( H \), i.e., the segment’s support line;

• \( C \) is connected, namely, \( \sigma _{i} \) and \( \sigma _{i+1} \) share an endpoint for all \( i \in [1, |C|-1] \);

• \( C \) is x-monotone, namely, any vertical line in \( \mathbb {R}^2 \) can intersect with at most one segment in \( C \);

• \( C \) is concave, namely, the support line of \( \sigma _i \) has a larger slope than that of \( \sigma _{i+1} \) (equivalently, we need to make a right turn in walking from \( \sigma _i \) onto \( \sigma _{i+1} \)).

Example (cont.). In Figure 6. The sequence AC, CD, DF is connected, x-monotone but not concave (we make a left turn in walking from AC to CD). Two envelop examples are AF, FK, KO and AG, GO.

The length of an envelop chain \( C = \sigma _1, \sigma _2,\ldots , \sigma _{|C|} \) is \( |C| \). The projection of \( C \) onto the \( x \)-axis gives an interval \( [x_1, x_2] \) (specifically, \( x_1 \) and \( x_2 \) are the \( x \)-coordinates of the left endpoint and right endpoint of \( \sigma _1 \) and \( \sigma _{|C|} \), respectively). Let \( H[C] \) be the set of support lines of \( \sigma _1, \sigma _2, \ldots , \sigma _{|C|} \).

Lemma 6.

Let \( C^* \) be an envelop chain of the minimum length whose x-projection covers the entire \( \mathscr{Q}= [0, \infty) \). Then, \( H[C^*] \) is an optimal solution to Problem 2.

Proof.

It is obvious that \( H[C^*] \) hits all possible queries and, hence, is a legal solution to Problem 2. Next, we will prove that every optimal solution \( {\mathscr{S}} \) to Problem 2 defines an envelop chain \( C \) with \( H[C] ={\mathscr{S}} \) such that the x-projection of \( C \) covers \( \mathscr{Q} \). This implies the correctness of the lemma.

The upper boundary of the \( (\le 0) \)-level of \( {\mathscr{S}} \) must be an envelop chain \( C \). Furthermore, every \( h \in {\mathscr{S}} \) must contribute an edge to the \( (\le 0) \)-level; otherwise, \( h \) is completely above \( C \), because of which \( {\mathscr{S}}\setminus \lbrace h\rbrace \) must still hit all the queries, giving a contradiction to the optimality of \( {\mathscr{S}} \). \( C \) is thus the envelop chain promised.□

Example (cont.). In Figure 6, no envelop chains of length 1 have an x-projection covering \( \mathscr{Q} \). However, the x-projection of \( C = \) AF, FP covers \( \mathscr{Q} \). Hence, \( H[C] = \lbrace h_3, h_4\rbrace \) must be an optimal solution (this corresponds to \( \lbrace p_3,p_4\rbrace \) in Figure 1).

We are now ready to clarify our algorithm for computing \( C^* \). The algorithm, summarized in Figure 7, combines a dynamic programming strategy of Reference [22] with ideas specific to our context. Let \( e \) be a boundary edge in the \( (\le k-1) \)-level of \( H \) (Lines 1–3), \( p \) be the right endpoint of \( e \), and \( p[1] \) be the \( x \)-coordinate of \( p \). Define \( \it {minlen}(e) \) as the smallest length of all envelop chains \( C \) such that

Fig. 7.

View Figure

• the last segment of \( C \) contains \( e \);

• the x-projection of \( C \) covers \( [0, p[1]] \).

Call \( e \) terminal if its right endpoint falls on the dual space’s right boundary. \( {\it OPT} \) (i.e., \( |C^*| \)) must be equal to the \( \it {minlen}(e) \) of some terminal boundary edge \( e \) (Lines 14 and 15).

Example (cont.). Set \( k = 3 \). For the boundary edge \( \texttt {CD} \) in Figure 6, we have \( \it {minlen}(\texttt {CD}) = 1 \), because there is a monotone chain \( C \) with only one segment BD such that (i) BD contains CD and (ii) the x-projection of \( C \) covers \( [0, \texttt {D}[1]] \). Similarly, \( \it {minlen}(\texttt {LP}) = 2 \), evidenced by the monotone chain \( C = \) AF, FP; this \( C \) is an optimal solution to Problem 2.

To describe the computation of \( \it {minlen}(e) \) (Lines 4–13), let us view each boundary edge \( e \) in the \( (\le k-1) \)-level as a directed edge pointing from the left endpoint to the right endpoint. Trivially, \( \it {minlen}(e) = 1 \) if the x-projection of \( e \) covers the coordinate 0 (Line 5). Otherwise, let \( p \) be the left endpoint of \( e \) and \( \textrm {IN}(p) \) be the set of incoming edges of \( p \) in the \( (\le k-1) \)-level (Lines 7 and 8). For each \( e^{\prime } \in \textrm {IN}(p) \), define its contribution as

• \( \it {minlen}(e^{\prime }) \) if \( e^{\prime } \) and \( e \) are on the same line in \( H \) (Line 10);

• \( 1 + \it {minlen}(e^{\prime }) \) if \( e^{\prime } \) has a greater slope than \( e \) (Line 11) ;

• \( \infty \) otherwise (Line 12).

Then, \( \it {minlen}(e) \) equals the minimum contribution of all \( e^{\prime } \in \textrm {IN}(p) \) (Line 13).

If \( m \) is the total number of boundary edges in the \( (\le k-1) \)-level, then it is now straightforward to compute the \( \it {minlen}(e) \) of all those edges \( e \) in \( \tilde{O}(m) \) time by dynamic programming. This produces the value of \( {\it OPT} \). It is standard to construct an optimal solution \( C^* \) from the above dynamic programming process using the same time complexity. As all the boundary edges can be found in \( \tilde{O}(m) = \tilde{O}(nk) \) time (Section 4.2.1), we have arrived at

Theorem 7.

When \( d = 2 \), Problem 2 (hence, Problem 1) can be settled in \( \tilde{O}(nk) \) time.

5.1 Overview of Our Approximation Schemes

Denote by \( {\it OPT} \) the size of an optimal \( k \)-rank-regret representative of the input \( P \). In terms of result quality, our goal is to compute a \( c_1 k \)-rank-regret representative of size \( c_2 \cdot {\it OPT} \) where \( 1 \le c_1 = \tilde{O}(1) \) and \( 1 \le c_2 = \tilde{O}(1) \). If an algorithm can always return such representatives, then we call it a bi-criteria approximation algorithm. Even better, if an algorithm guarantees \( c_1 = 1 \) and \( c_2 \ge 1 \), then we refer to it as a size-approximation algorithm; similarly, if an algorithm guarantees \( c_1 \ge 1 \) and \( c_2 = 1 \), then we refer to it as a regret-approximation algorithm.

The \( k \)-rank-regret representative problem is NP-hard when \( d \ge 3 \) (Section 4.1). To tackle this computation barrier, we want to design bi-criteria algorithms finishing in \( f(k) \cdot \tilde{O}(n) \) time, where \( f(k) \) is a monotonic function depending only on \( k \) and satisfying \( f(k) = \tilde{O}(1) \) for \( k = O(\text{polylog}n) \). Such algorithms have practical significance, because users prefer small values of \( k \) in real-world applications. In particular, when \( k = O(\text{polylog}n) \) (we believe this already fulfills the needs of most applications), the running time of those algorithms is bounded by \( \tilde{O}(n) \).

Motivated by this, we say that a bi-criteria approximation algorithm \( \mathscr{A} \) is fixed-parameter near-linear if its running time is bounded by \( f(k) \cdot \tilde{O}(n) \). This name suggests that if the parameter \( k \) is “fixed” (i.e., \( \tilde{O}(1) \)), then the computation time is “near-linear” (i.e., \( \tilde{O}(n) \)). We will strive to design such algorithms whenever possible. As it will turn out, they exist for dimensionalities \( d = 2 \) and 3 but do not exist for \( d \ge 4 \) (unless major breakthroughs could be made in computational geometry). For \( d \ge 4 \), therefore, we will drop the fixed-parameter near-linear requirement and, instead, aim to design bi-criteria algorithms that terminate in polynomial time (for arbitrary \( k \)).

5.2 Shallow Cutting

A simplex in \( \mathbb {R}^d \) is a \( d \)-dimensional convex polytope with \( d + 1 \) vertices. A 1D simplex is an interval, a 2D simplex is a triangle, a 3D simplex is a tetrahedron, and so on. A prism in \( \mathbb {R}^d \) is a special \( d \)-dimensional simplex that has a vertex at the bottom of \( \mathbb {R}^d \), namely, the vertex’s \( d \)th coordinate is \( -\infty \). Figure 8 shows an example for \( d = 2 \) and 3, respectively. A 2D prism has the shape of an infinitely extending trapezoid, which can be thought of as a triangle whose lower vertex is at the bottom of \( \mathbb {R}^2 \). Likewise, a 3D prism can be thought of as a tetrahedron whose lower vertex has \( z \)-coordinate \( -\infty \).

Fig. 8.

View Figure

Let \( H \) be a set of \( n \) planes in \( \mathbb {R}^d \). Fix some integer \( k \in [0, n] \) and a constant \( \lambda \gt 0 \). A \( (\lambda , k/n) \)-shallow-cutting of \( H \) is a set \( \Xi \) of prisms satisfying:

• Every prism in \( \Xi \) is covered by the \( (\le (1+\lambda)k) \)-level;

• The union of all prisms in \( \Xi \) covers the \( (\le k) \)-level;

• Each prism \( \Delta \in \Xi \) intersects with \( O(1+k) \) planes in \( H \), which constitute the conflict set of \( \Delta \), denoted as \( H_\Delta \).

Example. To further illustrate the above concepts, Figure 9 shows a \( (\lambda , k/n) \)-shallow cutting \( \Xi \) where \( n = 6 \), \( k = 2 \), and \( \lambda = 1 \). \( \Xi \) consists of the four prisms \( \Delta _1, \ldots , \Delta _4 \) as shown. The union of all those prisms covers the \( (\le 2) \)-level, but is also contained in the \( (\le 4) \)-level. The conflict set \( H_{\Delta _4} \), for example, includes \( h_4, h_5 \), and \( h_6 \).

Fig. 9.

View Figure

5.3 A 2D Algorithm

We will describe a regret-approximation algorithm to solve Problem 1 with \( d = 2 \). Our goal is to find a small subset \( S \subseteq P \) that is a \( ck \)-rank-regret representative where \( c = 2+\delta \) and \( \delta \gt 0 \) can be an arbitrarily small constant.

We will work on the corresponding instance of Problem 2. Here, the input is a set \( H \) of \( n \) lines in \( \mathbb {R}^2 \), from which we want to extract a subset \( {\mathscr{S}} \) to make sure \( \mathit {RR}_ {\boldsymbol {q}}({\mathscr{S}}) \le ck \) for every query \( {\boldsymbol {q}} \in \mathscr{Q} \). The query space \( \mathscr{Q} \) is \( [0, \infty) \). Accordingly, we will represent each query simply as a real-value \( q \ge 0 \).

A rank-sum lemma. Consider any query \( q \in [0, \infty) \) and the vertical line \( \ell _q \) passing the point \( (q, -\infty) \). Let \( h \) be a line in \( H \) and \( p \) be the intersection point between \( h \) and \( \ell _q \). Recall that \( \textrm {rank}_q(h) \) (i.e., the \( q \)-rank of \( h \)) equals 1 plus the number of lines below \( p \) in \( H \). The lemma states an important property about \( \textrm {rank}_q(h) \):

The above will be subsumed by Lemma 16, which, however, requires a more sophisticated argument. Understanding the proof of Lemma 9 will make it easier to follow that of Lemma 16. Let us first see an illustration in Figure 9. Line \( h_5 \) has \( q_1 \)-rank 2 and \( q_2 \)-rank 2 (see \( q_1 \) and \( q_2 \) in the figure). The lemma assures us that \( h_5 \) has \( q \)-rank at most 3 for any \( q \in [q_1, q_2] \).

Proof.

Given a query \( q \), define (i) \( p_q \) as the intersection point between \( h \) and \( \ell _q \), and (ii) \( \rho _q \) as the downward-shooting ray that emanates from but does not include \( p_q \). Let \( S_q \) be the set of lines in \( H \) intersecting with \( \rho _q \). \( |S_{q_1}| = \textrm {rank}_{q_1}(h) - 1 \) and \( |S_{q_2}| = \textrm {rank}_{q_2}(h) - 1 \). We will prove that, for any \( q \in [q_1, q_2] \), any line \( h^{\prime } \in S_q \) must belong to either \( S_{q_1} \) or \( S_{q_2} \). This indicates \( |S_q| \le |S_{q_1}| + |S_{q_2}| \), from which the lemma follows.

Let \( p^{\prime }_{q_1} \) (or \( p^{\prime }_{q_2} \)) be the intersection point between \( h^{\prime } \) and \( \ell _{q_1} \) (or \( \ell _{q_2} \), respectively), as shown in Figure 10. Assume that \( h^{\prime } \) belongs to neither \( S_{q_1} \) nor \( S_{q_2} \), which means that \( p^{\prime }_{q_1} \) and \( p^{\prime }_{q_2} \) must be on or above \( h \). Hence, the entire segment \( p^{\prime }_{q_1}p^{\prime }_{q_2} \) must be on or above \( h \). Therefore, the \( q \)-rank of \( h^{\prime } \) cannot be lower than that of \( h \), contradicting \( h^{\prime } \in S_q \).

Fig. 10.

View Figure

□

The algorithm. Figure 11 shows the pseudocode of our algorithm. We start by using Lemma 8 to obtain a \( (\delta /2, \) \( (k-1)/n) \)-shallow cutting \( \Xi \) on \( H \). Remember that Lemma 8 also produces the conflict set of each prism \( \Delta \), namely, the set \( H_\Delta \subseteq H \) of lines intersecting with \( \Delta \) (Line 1).

Fig. 11.

View Figure

For each line \( h \in H \), we generate an interval \( \mathcal {I}_h \) as follows (Line 4). First, identify the leftmost (or rightmost) prism \( \Delta _1 \) (or \( \Delta _2 \), respectively) intersecting \( h \). Let \( \sigma _1 \) be the part of \( h \) that appears in \( \Delta _1 \); note that \( \sigma _1 \) is a segment. Obtain similarly a segment \( \sigma _2 \) with respect to \( \Delta _2 \). Define \( I_1 \) (or \( I_2 \)) as the x-projection of \( \sigma _1 \) (or \( \sigma _2 \), respectively). The interval \( \mathcal {I}_h \) is the minimum bounding interval of \( I_1 \) and \( I_2 \). See Figure 12 for an illustration. In the special case where \( h \) intersects with no prisms of \( \Xi \), define \( \mathcal {I}_h \) as the empty interval.

Fig. 12.

View Figure

Denote by \( {\mathscr{S}}^* \) an optimal solution to Problem 2. We observe:

Define \( \mathcal {I}= \lbrace \mathcal {I}_h \mid h \in H \rbrace \) (Line 5). We find a subset \( \mathcal {J}\subseteq \mathcal {I} \) of the smallest size having the property that the union of all the intervals in \( \mathcal {J} \) covers \( \mathscr{Q} \) (Line 6). The existence of \( \mathcal {J} \) is guaranteed by Lemma 11. Finally, we return \( {\mathscr{S}}= \lbrace h \in H \mid \mathcal {I}_h \in \mathcal {J}\rbrace \) as our final result (Lines 7 and 8).

5.4 A 3D Algorithm

The 3D space can also be dealt with using shallow cutting in a manner similar to what was described in the 2D algorithm. We move the proof of the following theorem to the appendix, because the details are somewhat repetitive.

Remark. Theorem 13 is mainly of theoretical interest. Its primary purpose is to prove the existence of fixed-parameter near-linear algorithms in 3D space. The algorithm in Theorem 13, unfortunately, is a bit sophisticated and may not be suitable for practical implementation (for this reason, we will omit it in the experiments). In Sections 6 and 7, we will develop alternative algorithms for 3D space.

5.5 Hardness of Dimensions d ≥ 4

In this subsection, we will prove that no fixed-parameter near-linear algorithms exist for \( d \ge 4 \) subject to a conjecture on a well-known problem in computational geometry.

An object \( o \in P \) is an extreme point of \( P \) if it is a vertex of the convex hull of \( P \). The extreme point problem, where the goal is to report all the extreme points of \( P \), has been extensively studied. The first major result was a 1993 algorithm due to Matousek [48] that has running time \( O(n^{2-2/(\lceil d/2 \rceil + 1) + \epsilon }) \). In his 1996 paper [18], Chan pointed out that the time can be improved to \( O(n^{2-2/(\lceil d/2 \rceil + 1)}) \). In the same paper, Chan gave an output-sensitive algorithm with time \( \tilde{O}(n + (n \cdot {\it OUT})^{1-1/(\lceil d/2 \rceil + 1)}) \), where \( {\it OUT} \) is the number of extreme points. For \( d = 4 \), the bound is \( \tilde{O}(n \) \( + \) \( (n \cdot {\it OUT})^{2/3}) \), which still remains the best today.

In this subsection, we will provethe following.

\( \tilde{O}(n + {\it OUT}^{4/3}) \) compares more favorably with Chan’s bound \( \tilde{O}(n \) \( + \) \( (n \cdot {\it OUT})^{2/3}) \) and would make an exciting result. An impossibility result in 4D space trivially holds for \( d \ge 5 \) as well.

Proof for \( {\boldsymbol {c = 1}} \). Denote by \( X \) the set of extreme points of \( P \). The optimal 1-rank-regret representative is the set \( S^* \) of objects each maximizing the score of at least one weight vector. Thus, \( S^* \subseteq X \).

\( S^* \) is only a subset of \( X \), because we have restricted each weight vector \( {\boldsymbol {w}} \) to take non-negative components \( w[1], \ldots , w[4] \). By requiring each \( w[i] \) (\( i \in [1, 4] \)) to be positive or negative independently, we obtain \( 2^4 = 16 \) instances of Problem 1, all on the same \( P \). Denote by \( S^*_j \) (\( 1 \le j \le 16 \)) the optimal 1-rank-regret representative of the \( j \)th instance. \( X \) must be the union of \( S^*_1, \ldots , S^*_{16} \).

Let us run \( \mathscr{A} \) on each of the 16 instances on \( P \), by forcing the input \( k \) to 1. Denote by \( S_j \) the output of \( \mathscr{A} \) for the \( j \)th instance. Since \( c = 1 \), it must hold that \( S^*_j \subseteq S_j \) for all \( j \in [1, 16] \). Furthermore, the \( \tilde{O}({\it OPT}) \)-output-size requirement of \( \mathscr{A} \) guarantees \( |S_j| = |S^*_j| \cdot \tilde{O}(1) \). The total running time of \( \mathscr{A} \) in solving all the instances is \( f(1) \cdot \tilde{O}(n) = \tilde{O}(n) \).

Set \( S = S_1 \cup S_2 \cup \cdots \cup S_{16} \). Because \( \begin{equation*} |S| \le 16 \cdot \max _{j=1}^{16} |S_j| = \tilde{O}\left(\max _{j=1}^{16} |S^*_j|\right) = \tilde{O}(|X|) = \tilde{O}({\it OUT}), \end{equation*} \) we can find \( X \) in \( \tilde{O}({\it OUT}^{4/3}) \) time by running Chan’s algorithm on \( S \). This gives an overall algorithm to compute \( X \) in \( \tilde{O}(n + {\it OUT}^{4/3}) \) time.

Proof for \( {\boldsymbol {c \gt 1}} \). We can extend the argument to any \( c = O(\text{polylog}n) \). The crucial idea is to create a new dataset \( P^{\prime } \) by duplicating each object (of \( P \)) \( c \) times. The argument then proceeds as before except that \( \mathscr{A} \) should be applied to the 16 instances on \( P^{\prime } \). The property \( S^*_j \subseteq S_j \) is now rephrased as: for every object \( o \in S^*_j \), at least one of its copies exists in \( S_j \). To understand why, note that there must be a weight vector \( {\boldsymbol {w}} \) such that \( o \) has \( {\boldsymbol {w}} \)-rank 1 in \( P \). Thus, if none of the \( c \) copies of \( o \) is in \( S_j \), then the best \( {\boldsymbol {w}} \)-rank (in \( P^{\prime } \)) of the objects in \( S_j \) under \( {\boldsymbol {w}} \) is at least \( c+1 \), contradicting the fact that the algorithm must have a maximum rank regret \( c \cdot k = c \). The rest of the argument then runs through with no difficulty. This completes the proof of Theorem 14.

5.6 Algorithms for Dimensions d ≥ 4

Next, we explain how to obtain a polynomial-time size-approximation algorithm for Problem 1 when \( d \ge 4 \).

A hitting-set approach. Recall that the \( k \)-set \( P_ {\boldsymbol {w}}(k) \) of a weight vector \( {\boldsymbol {w}} \) contains the objects in \( P \) with ranks at most \( k \). A subset \( S \subseteq P \) hits a \( k \)-set \( P_ {\boldsymbol {w}}(k) \) if \( S \cap P_ {\boldsymbol {w}}(k) \ne \emptyset \). Problem 1 essentially aims to find the smallest subset hitting all the \( k \)-sets.

Although the number of weight vectors is infinite, the number of distinct \( k \)-sets is finite, because different weight vectors may end up having the same \( k \)-set. Let \( \mathcal {K} \) be the collection of all the (distinct) \( k \)-sets \( \lbrace K_1, \ldots , K_s\rbrace \) where \( s = |\mathcal {K}| \). Problem 1 then becomes a hitting set problem: Find the smallest subset \( S \subseteq \bigcup _{i=1}^s K_i \) such that \( S \cap K_i \ne \emptyset \) for every \( i \in [1, s] \). The standard greedy algorithm runs in time \( \tilde{O}(sk) \) and guarantees a subset \( S \) of size at most \( {\it OPT}\cdot (1 + \ln n) \).

There is considerable work on bounding the number \( s \) of \( k \)-sets. Currently, the best bound is \( O(n k^{1/3}) \) [26] for \( d = 2 \), \( O(n k^{3/2}) \) for \( d = 3 \) [57], and in general \( O(n^{\lfloor d/2 \rfloor } k^{\lceil d/2 \rceil - c_d}) \) for fixed \( d \ge 4 \) [4], where \( c_d \) is a tiny constant that tends to 0 very quickly as \( d \) grows. We must also account for the time to enumerate all the \( k \)-sets. Enumeration can be done in \( \tilde{O}(nk + sk) \) expected time [32] in 2D, \( \tilde{O}(nk^2 + sk) \) expected time [2] in 3D, and \( O(n^{\lfloor d/2 \rfloor } k^{\lceil d/2 \rceil } + sk) \) expected time [49] in fixed \( d \)-dimensional space with \( d \ge 4 \).

The above discussion gives:

It is interesting to compare the 3D result of Theorem 15 to that of Theorem 13. The time complexity of Theorem 15 is \( O(n k^{5/2}) \) at \( d = 3 \), while that of Theorem 13 is \( \tilde{O}(nk^2) \). If \( k = \text{polylog}n \), then the two time complexities are within a factor of \( \tilde{O}(1) \). For larger \( k \), e.g., when \( k \) is a polynomial of \( n \), Theorem 15 actually yields a better time bound. However, Theorem 15 produces size-approximation algorithms (i.e., the approximation ratio on size is 1; see Section 5.1), whereas Theorem 13 can only guarantee \( \tilde{O}(1) \) approximation ratios on size and rank regret.

Remark. The hitting set instance mentioned earlier is actually an instance of the geometric hitting set problem. By replacing the standard greedy algorithm with the re-weighting algorithm of Reference [36] for geometric hitting set, we can reduce the approximation ratio from \( 1 + \ln n \) to \( O(\log {\it OPT}) \) at the cost of slightly higher computation time. We will not delve into further details in this article.

k-set enumeration. Theorem 15 requires enumerating all possible \( k \)-sets, for which purpose the algorithms in References [4, 7, 26, 57] are rather complicated. To alleviate the issue, we describe a practical method that does not improve the complexities in Theorem 15, but is much easier to implement. Our method is adapted from an algorithm in Reference [7], which, however, requires the sophisticated concept of k-set polytope (see Reference [7] for details). Instead, we will adopt an intuitive graph perspective.

We call a \( k \)-set clean if it has size \( k \).² As far as the hitting set approach is concerned, it suffices to consider the set \( \mathcal {K}_\it {clean} \) of clean \( k \)-sets [4, 7, 26, 57]. Let us introduce the \( k \)-set graph \( G(V,E) \) where

• \( V = \mathcal {K}_\it {clean} \);

• \( E \) has an edge between two \( k \)-sets (a.k.a. vertices) \( K_1 \) and \( K_2 \) if and only if \( |K_1 \cap K_2| = k-1 \).

\( G(V,E) \) is connected, namely, it has a single connected component.

Figure 13 shows an algorithm for generating \( \mathcal {K}_\it {clean} \) incrementally by performing a BFS (breadth first search) on \( G \). After finding an arbitrary clean \( k \)-set (Line 1), the algorithm adds it to a queue (Line 2) and continues the traversal until the queue is empty (Line 3). At every iteration, the algorithm removes a \( k \)-set \( K \) (i.e., a vertex in \( G \)) from the queue (Line 4) and generates another set \( K^{\prime } \) of size \( k \) by replacing exactly one object \( o \in K \) with an object \( o^{\prime } \in P \setminus K \) (Lines 5–7). If \( K^{\prime } \) does not belong to \( \mathcal {K}_\it {clean} \), then the algorithm checks whether \( K^{\prime } \) is a valid \( k \)-set. If so, then \( K^{\prime } \) is a neighbor vertex of \( K \) in \( G \) and, hence, is added to \( \mathcal {K}_\it {clean} \) and to the queue (Lines 8 and 9). After the BFS finishes, the final \( \mathcal {K}_\it {clean} \) is returned (Line 10).

Fig. 13.

View Figure

Deciding whether \( K^{\prime } \) is a \( k \)-set can be done through linear programming. Specifically, the answer is yes if and only if there exist a weight vector \( {\boldsymbol {w}} \) and a real value \( \tau \) such that

• \( {\boldsymbol {o}} \cdot {\boldsymbol {w}} \gt \tau \) for every object \( {\boldsymbol {o}} \in K^{\prime } \);

• \( {\boldsymbol {o}} \cdot {\boldsymbol {w}} \lt \tau \) for every object \( {\boldsymbol {o}} \in P \setminus K^{\prime } \).

Motivated by this, we construct a linear program that has \( d+2 \) variables: \( {\boldsymbol {w}}[1], \ldots , {\boldsymbol {w}}[d], \tau \), and \( g \): The above program never returns a negative \( g \) (because setting \( {\boldsymbol {w}} = {\boldsymbol {0}} \) and \( \tau = g = 0 \) gives a feasible solution). The required \( {\boldsymbol {w}} \) and \( \tau \) exist if and only if the returned \( g \) is positive.

7.1 A Rank Sum Lemma in Arbitrary Dimensions

We will consider Problem 2. Recall that the input is a set \( H \) of planes in \( \mathbb {R}^d \); and the query space \( \mathscr{Q} \) includes all \( (d-1) \)-dimensional vectors \( {\boldsymbol {q}} \) such that \( {\boldsymbol {q}}[i] \ge 0 \) for every \( i \in [1, d-1] \). We want to find an \( {\mathscr{S}}\subseteq H \) such that, for every query \( {\boldsymbol {q}} \), \( {\mathscr{S}} \) contains a plane \( h \) satisfying \( \textrm {rank}_ {\boldsymbol {q}}(h) \le k \).

The rest of this subsection serves as a proof of the following.

Note how Lemma 16 generalizes Lemma 9: The interval \( [q_1, q_2] \) in Lemma 9 is a simplex \( \Delta \) in one-dimensional space.

Proof.

The proof uses the same ideas as in the proof of Lemma 9. Each query \( {\boldsymbol {q}} \) corresponds to the point \( ( {\boldsymbol {q}}[1],\ldots , {\boldsymbol {q}}[d-1], -\infty) \) at the bottom of the dual space \( \mathbb {R}^d \). Denote by \( \ell _ {\boldsymbol {q}} \) the line parallel to dimension \( d \) and passing \( ( {\boldsymbol {q}}[1], \ldots , {\boldsymbol {q}}[d-1], -\infty) \). Define (i) \( p_ {\boldsymbol {q}} \) as the intersection point between \( h \) and \( \ell _ {\boldsymbol {q}} \), and (ii) \( \rho _ {\boldsymbol {q}} \) as the open downward-shooting ray that emanates from \( p_ {\boldsymbol {q}} \) but does not include \( p_ {\boldsymbol {q}} \). Let \( S_ {\boldsymbol {q}} \) be the set of lines in \( H \) intersecting with \( \rho _ {\boldsymbol {q}} \). \( |S_{ {\boldsymbol {{ {\boldsymbol {q}}_1}}}}| = \textrm {rank}_ {\boldsymbol {{ {\boldsymbol {q}}_1}}}(h) - 1 \) and \( |S_{{ {\boldsymbol {q}}_2}}| = \textrm {rank}_{{ {\boldsymbol {q}}_2}}(h) - 1 \). We will prove that, for any \( {\boldsymbol {q}} \) on the segment \( {\boldsymbol {q}}_1 {\boldsymbol {q}}_2 \), any plane \( h^{\prime } \in S_ {\boldsymbol {q}} \) must belong to either \( S_{{ {\boldsymbol {q}}_1}} \) or \( S_{{ {\boldsymbol {q}}_2}} \). This indicates \( |S_ {\boldsymbol {q}}| \le |S_{{ {\boldsymbol {q}}_1}}| + |S_{{ {\boldsymbol {q}}_2}}| \), from which the lemma will follow.

Let \( p^{\prime }_{{ {\boldsymbol {q}}_1}} \) (or \( p^{\prime }_{{ {\boldsymbol {q}}_2}} \)) be the intersection point between \( h^{\prime } \) and \( \ell _{{ {\boldsymbol {q}}_1}} \) (or \( \ell _{{ {\boldsymbol {q}}_2}} \), respectively); Figure 15 illustrates this for \( d = 3 \). Assume that \( h^{\prime } \) belongs to neither \( S_{{ {\boldsymbol {q}}_1}} \) nor \( S_{{ {\boldsymbol {q}}_2}} \), which means that \( p^{\prime }_{{ {\boldsymbol {q}}_1}} \) and \( p^{\prime }_{{ {\boldsymbol {q}}_2}} \) must be on or above \( h \). Hence, the entire segment \( p^{\prime }_{{ {\boldsymbol {q}}_1}}p^{\prime }_{{ {\boldsymbol {q}}_2}} \) must be on or above \( h \). Therefore, the \( {\boldsymbol {q}} \)-rank of \( h^{\prime } \) cannot be lower than that of \( h \), contradicting \( h^{\prime } \in S_ {\boldsymbol {q}} \).

Fig. 15.

View Figure

□

Before proving the proposition, we would like to remind the reader that \( {\boldsymbol {q}} \) is a convex combination of \( { {\boldsymbol {q}}_1} \), \( {\boldsymbol {q}}_2, \ldots , { {\boldsymbol {q}}_m} \) if and only if \( {\boldsymbol {q}} = \sum _{i=1}^m \alpha _i {\boldsymbol {q}}_i \) for \( m \) real values \( \alpha _1, \ldots , \alpha _m \) in \( [0, 1] \) satisfying \( \sum _{i=1}^m \alpha _i = 1 \).

Lemma 16 now follows from the above proposition, using the well-known fact that any vector \( {\boldsymbol {q}} \) inside a simplex \( \Delta \) can be expressed as a convex combination of the \( d \) vertex vectors of \( \Delta \).

7.2 Algorithm

Our algorithm attacks Problem 2 and takes a set \( H \) of planes in the dual space as the input.

Rectangle protection. Let \( R \) be a hyper-rectangle in the query space \( \mathscr{Q} \) and \( {\boldsymbol {q}}_1 \), \( {\boldsymbol {q}}_2, \ldots , { {\boldsymbol {q}}}_{2^{d-1}} \) be the query vectors at the corners of \( R \). Consider an arbitrary plane \( h \in H \). Define \( r_1, \ldots , r_d \) as the \( d \) greatest values in \( \begin{eqnarray*} \lbrace \textrm {rank}_{ {\boldsymbol {q}}_1}(h), \textrm {rank}_{ {\boldsymbol {q}}_2}(h), \ldots , \textrm {rank}_{ {\boldsymbol {q}}_{2^{d-1}}}(h)\rbrace . \end{eqnarray*} \) We say that \( h \) protects \( R \) if (6) \( \begin{eqnarray} \sum _{i=1}^d r_i &\le & k + d - 1. \end{eqnarray} \) The sum \( \sum _{i=1}^d r_i \) is the aggregated rank of \( h \) on \( R \).

Space partition. Lemma 17 inspires us to divide \( \mathscr{Q} \) into non-overlapping \( (d-1) \)-dimensional rectangles each protected by a plane in \( H \). The space partition algorithm in Figure 16 starts with an empty \( {\mathscr{S}} \) (Line 1) and a queue storing only one rectangle, i.e., \( \mathscr{Q} \) itself. In each iteration, the algorithm removes a rectangle \( R \) from the queue (Lines 3–4) and checks whether \( R \) is protected by a plane in \( {\mathscr{S}} \) (Line 5). If not, then it adds to \( {\mathscr{S}} \) a plane \( h \in H \) that protects \( R \) (Lines 6 and 7). If such an \( h \) does not exist, then the algorithm splits \( R \) into two equi-size rectangles on the dimension where \( R \) has the longest extent and enqueue both. When the queue is empty, every possible query falls in a protected rectangle, making it safe to return \( {\mathscr{S}} \) as a \( k \)-rank-regret representative (Line 9).

Fig. 16.

View Figure

When \( \mathscr{Q} \) is finite, the algorithm is guaranteed to terminate due to two observations. First, each split creates strictly smaller rectangles. Second, when a rectangle \( R \) contains only one query \( {\boldsymbol {q}} \), the plane \( h \in H \) with \( {\boldsymbol {q}} \)-rank 1 definitely protects \( R \) (in this case, \( r_1 = r_2 = \cdots = r_d = 1 \) and, hence, (6) holds). \( \mathscr{Q} \) is finite in practice, because a weight representation has a bounded precision (e.g., 64 bits) in a computer.

8.1 Experiments Setup

Datasets. We used real datasets in the experiments. All values were normalized into the range \( [0,1] \) and discretized into granularity of 0.01.

• BlueNile dataset³: Blue Nile (BN) is the largest online diamond retailer in the world. We collected its catalog that contained 116,300 diamonds at the time of our collection. We considered the scalar attributes Carat, Depth, LengthWidthRatio, Table, and Price. For all attributes, except Price, higher values were preferred. The value of diamonds is sensitive to these measurement such that small changes in scores may mean a lot in terms of the quality of the jewel. For example, while the listed diamonds at Blue Nile range from 0.23 carat to 20.97 carat, minor changes in the carat affect the price. We considered two similar diamonds, where one was 0.5 carat in weight and the other was 0.53 carat. Even though all other measures were similar, the second diamond was 30% more expensive than the first one. This is also true for Depth, LengthWidthRatio, and Table. The phenomenon that slight changes in the scores may dramatically affect the value (and the rank) of the items highlights the motivation of rank-regret.

• US Department of Transportation flight dataset⁴: The US Department of Transportation (DoT) database is widely used by third-party websites to identify the on-time performance of flights, routes, airports, and airlines. After removing the records with missing values, the dataset contains 457,892 records, for all flights conducted by the 14 US carriers in the last months of 2017; we consider the scalar attributes Dep-Delay, Taxi-Out, Actual-elapsed-time, Arrival-Delay, Air-time, and Distance for our experiments.

As mentioned, BN and DoT datasets are 5D and 6D in their entirety. We generated \( d \)-dimensional versions (where \( d \in [2, 5] \) for BN and \( d \in [2, 6] \) for DoT) of each dataset by including the first \( d \) attributes in the order mentioned earlier.

Algorithms Evaluated. We will evaluate all the algorithms proposed in this article under different settings. Specifically, we will present two sets of experiments for the 2D and multi-dimensional cases (MD) where \( d \ge 3 \), involving the following algorithms:

• net-extreme-skyline (2D, MD): Proposed in Section 3, this algorithm uses sampling to construct an \( \epsilon \)-net. It further shrinks the size of the \( \epsilon \)-net by removing the dominated items. Following Theorem 4 and Lemma 3, using a sample size of \( O(\frac{n}{k} \log n) \) the algorithm returns a \( k \)-representative set with probability at least \( 1-1/n^2 \).

• exact (2D): The exact 2D algorithm works based on Theorem 7 and finds an optimal \( k \)-representative by constructing an envelop chain as a sequence of line segments in \( \tilde{O}(nk) \) time.

• shallow-cutting (2D): The shallow-cutting algorithm, proposed in Section 5.3, provides a 2D regret-approximation algorithm for finding a \( (2 + \delta)k \)-representative of size at most \( {\it OPT} \), where \( \delta \gt 0 \) can be an arbitrarily small constant, in \( O(n\log n) \) time. The value of \( \delta \) was set to 1, i.e., the regret approximation ratio was 3.

• k-set (2D, MD): The \( k \)-set algorithm is a size-approximation algorithm that provides a \( k \)-representative of size at most \( {\it OPT}\cdot O(\log {\it OPT}) \) by first enumerating the \( k \)-sets and modeling the problem as an instance of hitting set. We will see in our experiments that this algorithm is expected to perform well when \( k \) is small.

• rand-k-set (2D, MD): Due to the high complexity of enumerating the \( k \)-sets, the randomized algorithm in Section 6 serves as a practical alternative for enumerating the \( k \)-sets. Algorithm rand-\( k \)-set is the same as the \( k \)-set algorithm, except that the former uses the randomized algorithm for enumerating the \( k \)-sets. The distribution \( \mathcal {D} \) was set to uniformity for rand-\( k \)-set, which essentially says that we aimed to capture all weight vectors, instead of biasing toward particular vectors. The parameter \( \delta \) for rand-\( k \)-set was set to 0.01.

• space-partitioning (2D, MD): The space-partitioning algorithm works based on the rank sum lemma proposed in Section 7.1. As will be shown in the experiments, this algorithm is expected to perform well as long as \( k \) is not excessively small.

We preceded each of the above methods with a preprocessing step to shrink the input \( P \) of Problem 1. As defined in Section 3, an object \( o \) dominates another one \( o^{\prime } \) if \( o[i] \ge o^{\prime }[i] \) for all \( i \in [1, d] \). The \( k \)-skyband of \( P \) includes every object \( o \in P \) that is dominated by at most \( k-1 \) other objects in \( P \). The \( k \)-set of any weight vector must be fully contained in the \( k \)-skyband [53]. Therefore, as opposed to \( P \) itself, we can solve Problem 1 on its \( k \)-skyband instead, which is usually much smaller. For any fixed dimensionality \( d \), the \( k \)-skyband can be found in \( \tilde{O}(n) \) time [58].

Evaluation measurements. We will evaluate the algorithms using three measures: (i) time, (ii) representative size, and (iii) rank-regret. Time evaluates the efficiency of an algorithm, while representative size and rank-regret measures evaluate how effective the algorithm is in finding good and compact representatives.

Default values. In every experiment, we vary one parameter while fixing the other parameters to the following default values: \( k=8 \), \( d=4 \), and \( n=116,\!300 \) for BN and \( 457,\!892 \) for DoT.

8.2 Performance Evaluation

Having provided the proof of concept, we proceed to evaluate the performance of our algorithms under different settings.

Number of extreme points. As mentioned in Section 1, the 1-rank-regret representative of a dataset comprises the points on the boundary of the convex hull, i.e., the extreme points, which guarantee to contain the top choice of any linear ranking function. However, the number of extreme points can be very large. Table 2 shows the number of extreme points in the BN and DoT datasets at various dimensionalities. As will become evident in the upcoming experiments, the number of extreme points is usually several times the size of the rank-regret representative we find. This further strengthens our motivation and supports the necessity of developing efficient algorithms for discovering (small) rank-regret representatives. 2D, varying \( k \). Henceforth, we will follow the paradigm explained in Section 8.1, namely, in every experiment, we will study the impact of one parameter, while fixing the other parameters to their default values.

The value of \( k \) greatly impacts the ability to reduce the size of the rank-regret representative. For example, when \( k=1 \), all the items on the boundary of the convex hull appear in the representative. As the value of \( k \) increases, it gives us the freedom to have more choices for every ranking function, hence more opportunity to find items that cover large portions of the ranking functions. Besides the size of the representative, the running time of the algorithms may also depend on the choice of \( k \). Therefore, as the first 2D experiment, we vary the value of \( k \) while fixing other parameters to their default values. The results are provided in Figures 17 to 22.

Fig. 17.

View Figure

Figures 17 and 18 show the time taken by each algorithm to find a representative. First, one can observe that the \( k \)-set algorithm was significantly slower than all other algorithms and its running time rapidly increased as the value of \( k \) increased. The reason for the algorithm’s bad running time is that it requires enumerating all the \( k \)-sets before solving a hitting set problem. Therefore, the running time of the algorithm significantly depends on the number of \( k \)-sets. The number of \( k \)-sets, however, depends on the value of \( k \). As observed in the experiments on both the BN and DoT datasets, the increase in the value of \( k \) resulted in a significant increase in the number of \( k \)-sets, causing the poor running time of the algorithm. Even though the rest of the algorithms did not have running times as bad as \( k \)-set, still rand-\( k \)-set had a worse running time and it got worse as \( k \) increased. The main reason why rand-\( k \)-set outperformed \( k \)-set in the running time is that, compared to the graph enumeration approach for finding the \( k \)-sets, rand-\( k \)-set used a more efficient randomized algorithm for the same purpose. We also note that, at least theoretically, rand-\( k \)-set may miss the \( k \)-sets of certain weight vectors, resulting in a potentially smaller number of \( k \)-sets in some cases. Among other algorithms, the exact 2D algorithm, even though initially fast, took noticeably more time than the others as \( k \) increased. Net-extreme-skyline (labeled nes in the legend) had a stable running time (but not the fastest) for different values of \( k \). The shallow-cutting and space-partitioning algorithms (labeled sc and sp in the legend) had similar running time and both were significantly faster than all other algorithms across all values of \( k \). We note that shallow-cutting is an algorithm specifically designed for 2D, while space-partitioning works for arbitrary dimensionalities.

Fig. 18.

View Figure

Figures 19 and 20 show the size of the output (representative set) found by each algorithm, while Figures 21 and 22 show the rank-regret of the output. Please note that the exact algorithm guarantees to the optimal set (i.e., minimum size), while the output of the other algorithms is approximate. Among the approximation algorithms, net-extreme-skyline consistently returned the largest sets but its output always satisfied the rank-regret of \( k \). The outputs of all other algorithms were very close to optimality, a strong indication that they are effective in finding compact sets. The \( k \)-set and space partitioning algorithms always guarantee the rank-regret of \( k \), rand-\( k \)-set and net-extreme-skyline ensure the guarantee with very high probability, and shallow cutting was parameterized for a 3-approximate assurance on rank-regret. By comparing the exact algorithm with all other algorithms in Figures 21 and 22, one can notice that, interestingly, except shallow-cutting, the output of all algorithms satisfied the rank-regret of \( k \). In fact, the same is nearly true for shallow-cutting whose rank regret was always bounded by \( k \), except in a single case (BN, \( k = 64 \)).

Fig. 19.

View Figure

Fig. 20.

View Figure

Fig. 21.

View Figure

Fig. 22.

View Figure

2D, varying the dataset size (\( n \)). Rank regret representatives are compact representatives that are intended to be significantly smaller than the dataset size. The connection to \( \epsilon \)-nets (Section 3) provides an upper-bound on the size of the representative set that, however, needs to be \( 1/k \) of the original dataset. Therefore, our earlier results in Figures 19 and 20 suggest that traditional sampling approaches for finding an \( \epsilon \)-net are not necessarily effective in practical scenarios. Our objective is to find the minimal set that satisfies the rank regret constraint. Recall that Section 3 also gave a lower-bound \( n/k \) on the size of any \( \epsilon \)-net in the worst case. Despite this negative result, Figures 19 and 20 indicate that this lower bound can be excessively pessimistic on real data. To further demonstrate these phenomena, in the next experiment, we varied the dataset size, while observing the algorithms performance, rank-regret, and the output size for each algorithm and setting.

The results are provided in Figures 23 to 28. For every dataset, we controlled \( n \) by randomly selecting 20%, 40%, 60%, 80%, and 100% of the data. First, as in Figures 23 and 24, the running time of the algorithms was stable as the value of \( n \) increased. Among different algorithms, \( k \)-set had the longest running time and shallow-cutting had the least. Figures 25 and 26 show the output size for the BN and DoT datasets, while Figures 27 and 28 show the rank-regret of the generated results obtained by different algorithms. Similarly to the previous experiments, the output of net-extreme-skyline had the maximum size, while the others were close to the optimum (the output size of the exact algorithm). Furthermore, all algorithms returned representatives achieving a rank-regret of \( k \), except shallow-cutting, which guaranteed 3-approximation. These observations imply that all algorithms except shallow-cutting found near-optimal solutions. A perhaps more important observation is that even though the theoretical lower bound from the \( \epsilon \)-net interpretation suggests that the output size should be only a constant factor smaller than the dataset (recall \( k = 8 \), the default value, here), in practice this number may be only a handful and hardly increase with \( n \). MD, varying \( k \). After evaluating the 2D solutions, we now turn our attention to MD where \( d\ge 3 \). In the upcoming experiments, we study the impact of varying the value of \( k \) on the performance of different MD algorithms. Figures 29 to 34 show the results across different settings for the BN and DoT datasets.

Fig. 23.

View Figure

Fig. 24.

View Figure

Fig. 25.

View Figure

Fig. 26.

View Figure

Fig. 27.

View Figure

Fig. 28.

View Figure

Fig. 29.

View Figure

First, looking at the running time of the algorithms in Figures 29 and 30, net-extreme-skyline was the fastest across different cases, while \( k \)-set did not scale well with \( k \). An interesting observation, however, is that while the running time of \( k \)-set and rand-\( k \)-set monotonically increased with \( k \), that of space-partitioning actually decreased as \( k \) went up. The reason for the increase in the running time of \( k \)-set and rand-\( k \)-set is that (assuming \( k\lt n/2 \)) the number of \( k \)-sets escalates as \( k \) increases. This forces both algorithms to spend more time enumerating the \( k \)-sets and solving the hitting set problem. For larger \( k \), however, the space-partitioning algorithm finds more opportunity to prune the search space, simply because it essentially looks for common elements in larger sets, which are the top-\( k \) results (which are supersets of the results of smaller \( k \)). These observations together indicate that (rand-)\( k \)-set and space partitioning are complimentary algorithms for finding rank-regret representatives in different settings.

Fig. 30.

View Figure

Next, we studied the output size (Figures 31 and 32) and rank-regret (Figures 33 and 34) for the BN and DoT datasets. Recall that, in theory, the space partitioning and \( k \)-set algorithms guarantee the rank-regret of \( k \), while rand-\( k \)-set and net-extreme-skyline guarantee the same with very high probability. However, in all settings across the two datasets, every algorithm managed to find \( k \)-rank representatives. The net-extreme-skyline algorithm, in spite of being fast, failed to find compact representatives, especially as \( k \) increases. The rand-\( k \)-set and \( k \)-set algorithms generated the smallest outputs, and their representative sizes decreased as \( k \) increased. In particular, for all settings with \( k \gt 10 \) in both datasets the output size was always less than 10, fully echoing the motivation of rank-regret representatives. MD, varying the number \( d \) of dimensions. In this experiment, we evaluate different MD algorithms for different values of \( d \). The results are provided in Figures 35 to 40.

Fig. 31.

View Figure

Fig. 32.

View Figure

Fig. 33.

View Figure

Fig. 34.

View Figure

Fig. 35.

View Figure

Let us first look into the running time of the algorithms across different settings (Figures 35 and 36). The \( k \)-set algorithm failed to scale beyond four dimensions, because the exact (graph-traversal) algorithm in Section 5.6 for enumerating the \( k \)-sets did not finish within the time budget (20,000 seconds). In contrast, the rand-\( k \)-set algorithm (being efficient in finding the \( k \)-sets) scaled much better with respect to \( d \). The time performance of the space-partitioning algorithm worsened as \( d \) became larger, due to the curse of dimensionality, i.e., significant enlargement in the search space. The net-extreme-skyline had the best time performance but, as discussed next, it failed to find compact representatives. Figures 37 and 38 show the output size, and Figures 39 and 40 show the rank-regret of the generated output for the BN and DoT datasets. Similar to the previous experiments, all algorithms were able to ensure the rank-regret of \( k=8 \) across different settings. Evidently, the representative sets of net-extreme-skyline were fairly large, especially as \( d \) increased, while (rand-)\( k \)-set managed to secure small representatives in all cases.

Fig. 36.

View Figure

Fig. 37.

View Figure

Fig. 38.

View Figure

Fig. 39.

View Figure

Fig. 40.

View Figure

MD, varying the dataset size \( n \). Finally, we conclude our experiments by studying the impact of varying the dataset size on the performance of different algorithms. To do so, similar to the corresponding 2D experiments, we selected 20% to 100% of the BN and DoT datasets for the default values of \( k = 8 \) and \( d = 4 \). The results are provided in Figures 41 to 46.

Fig. 41.

View Figure

Looking at Figures 41 and 42, one can see that, even as the value of \( n \) increased, all algorithms had a stable running time for all values of \( n \). Also, looking at Figures 45 and 46, one can see that the output of all algorithms satisfied the rank-regret requirement (\( k=8 \)) in all settings, as is consistent with the previous experiments. As shown in Figures 43 and 44, the output of net-extreme-skyline was the largest, while (rand-)\( k \)-set could find representatives with size around 10 in all the scenarios.

Fig. 42.

View Figure

Fig. 43.

View Figure

Fig. 44.

View Figure

Fig. 45.

View Figure

Fig. 46.

View Figure