Optimal-Cost Construction of Shallow Cuttings for 3-D Dominance Ranges in the I/O-Model

The main result in this paper is an optimal-cost construction of the $k$-level shallow cutting for 3-D dominance ranges in the I/O-model.

To demonstrate the impact of our new construction, we use shallow cuttings for 3-D dominance ranges to obtain efficient algorithms for two fundamental problems: offline 3-D dominance approximate counting and offline 3-D dominance reporting.

The key feature in the above theorem is that the construction cost bound has the term $M/B$ in the base of the logarithm which is desirable in the I/O-model (instead of base-$2$ obtained from straightforward adaptation of internal memory algorithms or base-$B$ obtained from straightforward adaption of external memory data structures for online problems). In terms of techniques, even though the final output is a relative approximation, the crucial ingredients in the algorithm are an additive error counting structure that is combined with a non-trivial van-Emde-Boas-style recursion.

The final algorithm is a combination of several ideas: filtering search (to charge the I/Os performed for a query to its output-size), optimal $k$-level shallow cuttings (which were not known before), roughly $O(\log \log N)$ levels of shallow cuttings, and a cleverly chosen base-case. The non-trivial part of the analysis is bounding the number of I/Os to perform the so-called offline-find-any procedures (defined later).

To prove the above theorems, we make use of data structures with specific requirements. For example, in Theorem 4 data structures with fast construction I/Os are considered and in Theorem 5 a data structure with large additive error is considered. Although there exist data structures with desired bounds to handle some of these queries [11, 12, 18, 19], we are not aware of any prior work that obtains these results using a common framework, which might be useful for other problems.

Our solution for additive error query can be extended to handle smaller values of error (such as $\epsilon \sqrt{NB}$). However, for our purpose an additive error of $\epsilon N^{2/3}{B}^{1/3}$ suffices.

The remaining paper is structured as follows. In Section 2, we discuss some preliminaries. In Section 3, we give an overview of two previous constructions of shallow cuttings for 3-D dominance ranges in internal memory. Then, in Section 4 we present our optimal-cost construction in the I/O-model. This is followed by two applications of our construction, offline 3-D dominance approximate counting (in Section 5) and offline 3-D dominance reporting (in the full version). In the full version, we also present the details of our supporting structures (Theorem 4 and Theorem 5) and potential directions for future work.

The problem becomes challenging in 3-D. At SODA’14, Afshani and Tsakalidis [5] obtained an optimal internal memory algorithm that constructs a $k$-level shallow cutting in $O(N{\log }_{2}N)$ time. Their algorithm constructs the outer boundary $ℬ$ of the union of the cells in $𝒞$. In 3-D the outer boundary is a $2$-dimensional, monotone, and orthogonal surface (see Figure 1(a)). The algorithm combines the sweep-plane approach with a method of maintaining a 2-D $k$-level shallow cutting under deletions. Let $z_1,\mathrm{\dots },z_N$ be the sorted sequence of $P$ in decreasing order of their $z$-coordinate values. Starting from $z=z_1$, a plane parallel to $xy$-plane is moved in the $-z$ direction. The invariant in the algorithm is to maintain a 2-D shallow cutting for the $xy$-projections of points of $P$ below the sweep-plane, by ensuring that the depth of each (inner or outer) corner in the 2-D shallow cutting lies in the range $[k,10k]$. When the sweep-plane reaches $z_i$, then $z_i$ is deleted and if the invariant is violated, then the 2-D shallow cutting of $xy$-projections of $z_{i+1},\mathrm{\dots },z_n$ is updated via a procedure called patching. See Figure 3. The precise details of the patching procedure are not necessary for our final algorithm.

The running time of their algorithm can be summarized by the following equation:

There are two bottlenecks in adapting their algorithm in the I/O-model. At any point in the sweep-plane, let $ℒ$ be the ordering of the corners in the 2-D shallow cutting based on their $x$-coordinate values. Each time a point $z_i\in P$ is deleted, a predecessor search is performed on $ℒ$. Also, the patching procedure leads to insertion and deletion of corners into $ℒ$. The predecessor search is performed to identify all the corners in $ℒ$ dominating $z_i$ and then to update the conflict lists of those corners (at no extra asymptotic cost). This is the first bottleneck, since it is not possible to perform $\mathrm{\Theta }(N)$ updates and $\mathrm{\Theta }(N)$ predecessor queries to the list $ℒ$ in $sort(N)$ I/Os. (In fact, in [8] it was established that the easier problem of batched predecessor queries requires $T_{pred}(N)=\mathrm{\Omega }({\log }_{B}N)$ I/Os per query when the preprocessing cost is bounded by a polynomial in $N$.) It is not clear how to reduce the number of predecessor queries to $o(N)$, and the lower-bound discards the standard strategy in the I/O-model of performing predecessor search queries in batches.

The second bottleneck is the lack of I/O-efficient data structures for performing the patching procedure. The patching procedure involves constructing data structures for 3-D dominance $x$-selection and dominance $y$-selection queries on $P$, and querying them $O(N/k)$ times. For our purpose, the data structures have to be constructed in $O(sort(N))$ I/Os. In the full version, we present such data structures with query I/Os $T_{aux}(N)=O({(N/B)}^{\gamma })$ for some $\gamma \in (0,1)$ (Theorem 4). Therefore, the patching will require $O\left(\frac{N}{k}{\left(\frac{N}{B}\right)}^{\gamma }\right)$ I/Os, which is expensive.

At SODA’23, Nekrich and Rahul [13] designed a data structure for 4-D dominance reporting query by constructing several shallow cuttings for 3-D dominance ranges. However, for their application, the conflict lists of the cells were not needed, and only the cells needed to be constructed. They modified the AT-construction to design an algorithm whose running time is proportional to the number of cells constructed (specifically $O(N{\log }_{2}N)$ cells were constructed on different subsets of $P$ in $O(N{\log }_2^{5}N)$ time).

For a cell $C$ in the shallow cutting with apex point $(x,y,z)$, let $\mathrm{𝑒𝑥𝑝}(C)$ be the largest $z$-coordinate such that $(x,y,\mathrm{𝑒𝑥𝑝}(C))$ dominates less than $k$ points of $P$. Then $\mathrm{𝑒𝑥𝑝}(C)$ is defined as the expiry of $C$. For a cell $C$, its expiry $\mathrm{𝑒𝑥𝑝}(C)$ can be computed via a 3-D dominance $z$-selection query on $P$. Similar to AT-construction approach, starting from $z=+\mathrm{\infty }$, the algorithm sweeps a plane parallel to the $xy$-plane in the $-z$ direction and the same invariant is maintained. The key difference is in the event points visited by the sweep-plane algorithm. In the NR-construction, the event points will be the $\mathrm{𝑒𝑥𝑝}(C)$ values of all cells $C$ in the shallow cutting, which are stored in a simple priority-queue $𝒬$.

At each time step, we find the event with the largest $z$-coordinate $z_{\max }$ in $𝒬$ and set the $z$-coordinate of the sweep-plane to $z_{\max }$. When the cell $C$ corresponding to $z_{max}$ expires, (inner and outer) corners corresponding to $C$ have to be removed from the 2-D shallow cutting at $z_{max}$. Therefore, the patching procedure is performed. After finishing the patching procedure, (a) the events corresponding to the new inner corners in the 2-D shallow cutting are inserted into $𝒬$ and the events corresponding to the deleted corners in the 2-D shallow cutting are removed from $𝒬$, (b) for each newly created outer corner $(x,y)$ in the patching procedure, a new cell with apex point $(x,y,z_{max})$ gets created. We define $cre(C)=z_{max}$ for each cell $C$ created. The algorithm finishes when the $z$-coordinate of the sweep-plane reaches $z=-\mathrm{\infty }$. We omit the details of the NR-construction algorithm that are not needed to obtain our result. The following lemma summarizes the properties of the NR-construction that are relevant for our algorithm.

The running time of the NR-construction can be summarized as follows:

Similar to the second bottleneck in the AT-construction, the bottleneck in the NR-construction is the I/Os required to perform the dominance selection queries (with $O(sort(N))$ construction I/Os for the data structures, we have $O\left(\frac{N}{k}\right)\cdot T_{sel}(N)=O\left(\frac{N}{k}{\left(\frac{N}{B}\right)}^{\gamma }\right)$ I/Os which is expensive).

At ICALP’14, Afshani, Chan, and Tsakalidis [3] proposed an AT-construction variant (by sweeping upwards) for constructing shallow cuttings for 3-D dominance ranges in $O(N{\log }_2{\log }_{2}N)$ time in the word-RAM model. At STOC’96, Vengroff and Vitter [20] employed a structure that is similar to 3-D shallow cuttings to answer 3-D orthogonal range reporting queries. Unfortunately, the number of I/Os required to construct their data structure was not considered in their work.

Construction of shallow cuttings for halfspaces in 3-D has been another active area of research. However, typically the techniques and tools used for these problems (such as vertical decomposition, $\epsilon$-cuttings, planar graph separators) have been different from the ones used for 3-D dominance ranges. For example, at SoCG’15, Chan and Tsakalidis [10] presented an optimal deterministic internal memory algorithm for the construction of shallow cuttings for halfspaces in 3-D. Their hierarchical construction relies on the fact that the cells of the shallow cutting do not intersect (to be precise, they are interior-disjoint). While this is true in the case of shallow cuttings for 3-D halfspaces, this property is not satisfied in our problem: cells of a $k$-level shallow cutting for 3-D dominance ranges are intersecting boxes. Also, in their hierarchy the levels go down by a constant factor which is not ideal for an I/O-efficient algorithm, whereas in our construction levels will go down at a faster rate.

The main idea is to construct a hierarchy of shallow cuttings. We want to construct a $k$-level shallow cutting of $P$ where $k\ge M/c$ and $c$ is a sufficiently large constant. Let $t_i={(N/B)}^{{\delta }^i}$ and $k_i=\max (B{t}_i,k)$. We select the constant $\delta \in (0,1)$ in such way that $k_i\le k_{i-1}/10$ (for any $i$ satisfying $k_i\ge M/c$). The algorithm works in stages (starting from stage $0$). In the $i$-th stage, we construct the $k_i$-level shallow cutting. For the starting case of $0$-th stage, since $k_0=N$, the $k_0$-level shallow cutting consists of one cell containing all points of $P$. The algorithm terminates when $k_i=k$.

We will start with some definitions. For all $1\le i\le r$, we will say that the $k_{i-1}$-level shallow cutting is the parent shallow cutting of the $k_i$-level shallow cutting. When the sweep-plane reaches $z$, then a cell $C$ is active at $z$ if $cre(C)\le z\le exp(C)$.

In the construction of the $k_i$-level shallow cutting, consider an outer corner $(x_p,y_p)$ on the 2-D shallow cutting which got created when the sweep-plane is at position $z$. Then the parent cell of point $p=(x_p,y_p,z)$ is the cell $C$ in the parent shallow cutting which satisfies the following two properties: (a) the apex point of $C$ dominates $p$, and (b) the apex point of $C$ has the smallest $y$-coordinate among all cells that are active at $z$.

A data structure built on $N^{\prime }$ points is query-expensive if the the number of I/Os required to answer a query is of the form $O({(N^{\prime }/B)}^{\gamma })$ or $O({(N^{\prime }/B)}^{\gamma }+t/B)$. Our next idea is to construct such query-expensive data structures, but only on small-sized inputs. Specifically, for the $k_i$-level shallow cutting, we will ensure that the a 3-D dominance $x,y,z$-selection query requires only $O(k_i/B)$ I/Os, and since the number of such selection queries performed is bounded by $O(N/k_i)$ (point 2 in Lemma 7), overall the selection queries will require only $O(N/B)$ I/Os. Similarly, we will ensure that generating the conflict list of a cell requires only $O(k_i/B)$ I/Os, and since there are $O(N/k_i)$ cells in the $k_i$-level cutting, generating all the conflict lists will require only $O(N/B)$ I/Os. The existence of parent cells and the following lemma will let us achieve the goal of utilizing query-expensive data structures I/O-efficiently.

By point 2 in Lemma 7, $O(N/k_i)$ $x,y,z$-selection queries are performed in the construction of a $k_i$-level shallow cutting. To perform each selection query, we first need an efficient routine to find the parent cell. Once the parent cell is found, then the selection query is performed on the data structure corresponding to the parent cell.

We will use partially persistent B-trees [7] to store the cells in the $k_{i-1}$-level shallow cutting. Versions of the partially persistent data structure are parameterized by $z$-coordinates: a cell is inserted (resp. deleted) at time $t$ if the corresponding outer corner is added to the 2-D shallow cutting (resp. removed from the 2-D shallow cutting) when the $z$-coordinate of the sweep-plane is equal to $t$. This data structure supports successor queries with respect to $y$- coordinates of its apex points: for any pair $(z_q,y_q)$ we can find the cell with the smallest $y$-coordinate among all cells of the parent shallow cutting that are active at time $z_q$ and whose $y$-coordinate is not smaller than $y_q$.

To obtain $O(sort(N))$ I/Os bound, we need the base in the logarithm to be $M/B$. To circumvent the fact that finding parent cells and operations on the priority queue require $O({\log }_B(N/k))$ query I/Os, we exploit the fact that $k$ is large.

We will need a different procedure to handle $k=O(M)$. We will perform a two-level cutting. First, we will construct an $(M/c)$-level shallow cutting of $P$ using Lemma 14. For each cell, say $C$, in the $(M/c)$-level, load its entire conflict list into the internal memory. This can be done I/O-efficiently since the size of the conflict list is $O(M)$. Next run an internal memory algorithm to compute the $k$-level shallow cutting of the conflict list of $C$. The final output is the union of the shallow cuttings obtained from each cell in the $(M/c)$-level.

The overall data structure is recursive and we start at the root with pointset $P$. Construct a $(N^{2/3}{B}^{1/3})$-level cutting $𝒞$ based on $P$ (Theorem 1). Also, construct an additive error counting structure based on $P$ (Theorem 5). Finally, for each cell $C\in 𝒞$, recurse on $P_C$, where $P_C$ is the conflict list of $C$. The recursion stops when the size of pointset becomes less than or equal to $M/c$, where $c$ is a sufficiently large constant.

The query algorithm will start from the root of the data structure. A point in $Q$ is deep if no cell in $𝒞$ contains it; otherwise, it is shallow. Using the offline-find-any procedure on $𝒞$ and $Q$, we will classify each point in $Q$ as shallow or deep. The result for the deep query points are obtained by querying the additive error counting structure. If a point $q\in Q$ is shallow, then it is assigned to one of the cells containing it. The shallow points are handled recursively. Specifically, for each cell $C\in 𝒞$, recurse on $Q_c$, where $Q_c\subseteq Q$ is the set of shallow query points assigned to $C$.

To handle the base case, where $|P|\le M/c$, first the points in $P$ are loaded into the memory. Then the query objects are streamed into the main memory one block at a time, and the results for these queries are obtained without any additional I/Os and written to the external memory.

We will first bound the number of I/Os performed by the algorithm.