Range closest-pair search in higher dimensions

TL;DR

This paper extends range closest-pair search data structures to higher dimensions, providing new solutions for various query types and establishing lower bounds for orthogonal queries in dimensions three and above.

Contribution

It introduces the first nontrivial data structures for RCP in higher dimensions across multiple query types and proves a conditional lower bound for orthogonal RCP search.

Findings

Developed data structures for RCP in higher dimensions for orthogonal, simplex, halfspace, and ball queries.

Established a conditional lower bound for orthogonal RCP search in dimensions d ≥ 3.

Extended the scope of RCP search beyond the plane to higher-dimensional spaces.

Abstract

Range closest-pair (RCP) search is a range-search variant of the classical closest-pair problem, which aims to store a given set $S$ of points into some space-efficient data structure such that when a query range $Q$ is specified, the closest pair in $S \cap Q$ can be reported quickly. RCP search has received attention over years, but the primary focus was only on $\mathbb{R}^2$. In this paper, we study RCP search in higher dimensions. We give the first nontrivial RCP data structures for orthogonal, simplex, halfspace, and ball queries in $\mathbb{R}^d$ for any constant $d$. Furthermore, we prove a conditional lower bound for orthogonal RCP search for $d \geq 3$.

Tables

Table 1. Table 1: Best known results in ℝ 2 superscript ℝ 2 \mathbb{R}^{2}

Query type	Space cost	Query time	Preprocessing time
Quadrant	$O\left(n\right)$	$O\left(\log n\right)$	$O\left(n{\log }^{2}n\right)$
Strip	$O\left(n\log n\right)$	$O\left(\log n\right)$	$O\left(n{\log }^{2}n\right)$
Rectangle	$O\left(n{\log }^{2}n\right)$	$O\left({\log }^{2}n\right)$	$O\left(n{\log }^{7}n\right)$
Halfplane	$O\left(n\right)$	$O\left(\log n\right)$	$O\left(n{\log }^{2}n\right)$

Table 2. Table 2: Performances of our new RCP data structures in ℝ d superscript ℝ 𝑑 \mathbb{R}^{d}

Query type	Source	Space cost	Query time	Preprocessing time
Orthogonal	Theorem 7	$\tilde{O}\left(n\right)$	$\tilde{O}\left(\sqrt{n}\right)$	$\tilde{O}\left(n\sqrt{n}\right)$
Simplex	Theorem 12	$\tilde{O}\left(n\right)$	$\tilde{O}\left(n^{1-1/\left(2d^2\right)}\right)$	$\tilde{O}\left(n^{\left(3d^2+1\right)/\left(2d^2+1\right)}\right)$
Halfspace	Theorem 14	$\tilde{O}\left(n\right)$	$\tilde{O}\left(n^{1-1/\left(d\lfloor d/2\rfloor \right)}\right)$	$\tilde{O}\left(n^{2-1/\left(2d^2\right)}\right)$
Ball	Theorem 15	$\tilde{O}\left(n\right)$	$\tilde{O}\left(n^{1-1/\left(\left(d+1\right)\lceil d/2\rceil \right)}\right)$	$\tilde{O}\left(n^{2-1/\left(2{\left(d+1\right)}^2\right)}\right)$

Equations

$$\sum _{a\in L}{m}_a^{1-1/d}\le O(n^{1-1/d}|L{|}^{1/d})=O\left(\frac{n}{r^{1/d^2}}\right),$$

$$\sum _{a\in L}{m}_a^{1-1/\lfloor d/2\rfloor }\le O(n^{1-1/\lfloor d/2\rfloor }|L{|}^{1/\lfloor d/2\rfloor })=O\left(\frac{n}{r^{1/\lfloor d/2\rfloor }}\right),$$

Full text

1 Introduction

The closest-pair problem is one of the most fundamental problems in computational geometry and finds numerous applications in various areas, such as collision detection, traffic control, etc. In many scenarios, instead of finding the global closest-pair, people want to know the closest pair contained in some specified ranges. This results in the notion of range closest-pair (RCP) search. RCP search is a range-search variant of the classical closest-pair problem, which aims to store a given set $S$ of points into some space-efficient data structure such that when a query range $Q$ is specified, the closest pair in $S\cap Q$ can be reported quickly. RCP search has received considerable attention over the years [1, 4, 9, 10, 16, 17, 20, 19, 21, 22].

Unlike most traditional range-search problems, RCP search is non-decomposable. That is, if we partition the dataset $S$ into $S_{1}$ and $S_{2}$, given a query range $Q$, the closest pair in $S\cap Q$ cannot be obtained efficiently from the closest pairs in $S_{1}\cap Q$ and $S_{2}\cap Q$. Due to the non-decomposability, many traditional range-search techniques are inapplicable to RCP search, which makes the problem quite challenging. As such, despite of much effort made on this topic, most known results are restricted to the plane case, i.e., RCP search in $\mathbb{R}^{2}$. Beyond $\mathbb{R}^{2}$, only very specific query types have been studied, such as 2-sided box queries.

In this paper, we investigate RCP search in higher dimensions. We consider four widely-studied query types: orthogonal queries, simplex queries, halfspace queries, and ball queries. We are interested in designing efficient RCP data structures (in terms of space cost, query time, and preprocessing time) for these kinds of query ranges, and proving conditional lower bounds for these problems.

Related work. The closest-pair problem and range search are both well-studied problems in computational geometry; see [2, 18] for surveys of these two topics.

RCP search was for the first time introduced by Shan et al. [16] and subsequently studied in [1, 4, 9, 10, 17, 20, 19, 21, 22]. In $\mathbb{R}^{2}$, the query types studied include quadrants, strips, rectangles, and halfplanes. RCP search with these query ranges can be solved using near-linear space with poly-logarithmic query time. The best known data structures were given by Xue et al. [21], and we summarize the bounds in Table 1. For fat rectangles queries (i.e., rectangles of constant aspect ratio), Bae and Smid [4] showed an improved RCP data structure using $O(n\log n)$ space and $O(\log n)$ query time. In a recent work [19], Xue considered a colored version of RCP search in which the goal is to report the bichromatic closest pair contained in a query range, and proposed efficient data structures for orthogonal colored approximate RCP search (mainly in $\mathbb{R}^{2}$).

Beyond $\mathbb{R}^{2}$, the problem is quite open. To our best knowledge, the only known results are the orthogonal RCP data structure given by Gupta et al. [9] which only has guaranteed average-case performance and the approximate colored RCP data structures given by Xue [19] which can only handle restricted query types (dominance query in $\mathbb{R}^{3}$ and 2-sided box query in $\mathbb{R}^{d}$).

A key ingredient in existing solutions for RCP search in $\mathbb{R}^{2}$ is the candidate-pair method. Roughly speaking, this method tries to show that among the $\Omega(n^{2})$ point pairs, only a few (called candidate pairs) can be the answer of some query. If this can be shown, then it suffices to store the candidate pairs and search the answer among them. Unfortunately, it is quite difficult to generalize this method to higher dimensions, as the previous approaches for proving the number of candidate pairs heavily rely on the fact that the data points are given in the plane. This might be the main reason why RCP search can be efficiently solved in $\mathbb{R}^{2}$, while remaining open in higher dimensions.

Our contributions. In this paper, we give the first non-trivial RCP data structures for orthogonal, simplex, halfspace, and ball queries in $\mathbb{R}^{d}$, for any constant $d$. The performances of our new data structures are summarized in Table 2, where the notation $\tilde{O}(\cdot)$ hides $\log n$ factors. All these data structures have near-linear space cost, sub-linear query time, and sub-quadratic preprocessing time. For example, we obtain $\tilde{O}(n^{7/8})$ query time for two-dimensional triangular ranges, and $\tilde{O}(n^{2/3})$ query time for three-dimensional halfspaces and two-dimensional balls (i.e., disks).444Gupta et al. [9] obtained $\tilde{O}(\sqrt{n})$ query time for two-dimensional disks, but only for uniformly distributed point sets; the general problem was left open in their paper.

Furthermore, we complement these results by establishing a conditional lower bound, implying that our $\tilde{O}(\sqrt{n})$ query time bound for orthogonal RCP search in $\mathbb{R}^{d}$ for any $d\geq 3$ is likely the best possible (and in particular explaining why polylogarithmic solution seems not possible beyond two dimensions). Specifically, we show that orthogonal RCP search in $\mathbb{R}^{3}$ is at least as hard as the set intersection query problem, which is conjectured to require $\tilde{\Omega}(\sqrt{n})$ query time for linear-space structures.

Overview of our techniques. Our approach for designing these new data structures is quite different from those in the previous work. We avoid using the aforementioned candidate-pair method. Instead, our RCP data structures solve the problems as follows (roughly). For a given query range $Q$, the data structure first partitions the points in $S\cap Q$ into two subsets, say $K$ and $L$. The size of $L$ is guaranteed to be small, while $K$ may have a large size. Then the data structure computes the closest pair $\phi$ in $K$ using some pre-stored information and computes the closest pair $\phi^{\prime}$ in $L$ using the standard closest-pair algorithm (which can be done efficiently as $L$ is small). If the two points of the closest pair $\phi^{*}$ in $S\cap Q$ are both in $K$ or both in $L$, we are done. The only remaining case is that one point of $\phi^{*}$ is in $K$ while the other point is in $L$. The data structure handles this case by finding the nearest neighbor of $a$ in $Q$ for every $a\in L$ via reporting all the points in $Q$ that are “near” $a$. Using a packing argument, we can show that one only needs to report a constant number of points for each $a\in L$, and hence this procedure can be completed efficiently (since $L$ is small).

To implement this strategy, we incorporate a number of existing geometric data structuring techniques. For orthogonal RCP, we use range trees and adapt an idea from Gupta et al. [9] of classifying nodes as “heavy” and “light” (originally for solving a different problem, two-dimensional orthogonal range diameter, in near-linear space and $\tilde{O}(\sqrt{n})$ query time). For simplex RCP, we use simplicial partitions instead of range trees. For halfspace RCP, we switch to dual space and use cuttings, similar to an idea from Chan et al. [6] (for solving a different problem, halfspace range mode, in near-linear space and $\tilde{O}(n^{1-1/d^{2}})$ time). Overall, the combination of existing and new ideas is nontrivial (and interesting, in our opinion). Our conditional lower bound proof for three-dimensional orthogonal RCP is similar to some previous work (for example, Davoodi et al.’s conditional lower bound for two-dimensional range diameter [8]), and along the way, we introduce a new variant of colored range searching, color uniqueness query, which may be of independent interest.

2 Preliminaries

The first two results we need are the well-known partition lemma and cutting lemma, both of which are extensively used for solving range-search problems.

Lemma 1**.**

(Partition lemma [12])* Given a set $S$ of $n$ points in $\mathbb{R}^{d}$ and a parameter $1\leq r\leq n^{1-\delta}$ for an arbitrarily small constant $\delta>0$, one can compute in $O(n\log n)$ time a partition $\{S_{1},\dots,S_{r}\}$ of $S$ and $r$ simplices $\Delta_{1},\dots,\Delta_{r}$ in $\mathbb{R}^{d}$ such that (1) $S_{i}\subseteq\Delta_{i}$ for all $i\in\{1,\dots,r\}$, (2) $|S_{i}|=O(n/r)$ for all $i\in\{1,\dots,r\}$, and (3) any hyperplane in $\mathbb{R}^{d}$ crosses $O(r^{1-1/d})$ simplices among $\Delta_{1},\dots,\Delta_{r}$.*

Lemma 2**.**

(Cutting lemma [7])* Given a set $\mathcal{H}$ of $n$ hyperplanes in $\mathbb{R}^{d}$ and a parameter $1\leq r\leq n$, one can compute in $O(nr^{d-1})$ time a cutting of $\mathbb{R}^{d}$ into $O(r^{d})$ cells each of which is a constant-complexity polytope intersecting $O(n/r)$ hyperplanes in $\mathcal{H}$. In addition, the algorithm for computing the cutting stores the cells into an $O(r^{d})$-space data structure which can report in $O(\log r)$ time, for a specified point in $x\in\mathbb{R}^{d}$, the cell containing $x$.*

We shall also use the standard range-reporting data structures for orthogonal, simplex, and halfspace queries, stated in the following lemma:

Lemma 3**.**

Given a set $S$ of $n$ points in $\mathbb{R}^{d}$, one can build in $O(n\log^{O(1)}n)$ time an $O(n\log^{O(1)}n)$-space data structure which can

1. (a)

(Orthogonal range reporting [5])* report, for a specified orthogonal box $B$ in $\mathbb{R}^{d}$, the points in $S\cap B$ in $O(\log^{O(1)}n+k)$ time where $k=|S\cap B|$;* 2. (b)

(Simplex range reporting [12])* report, for a specified simplex $\Delta$ in $\mathbb{R}^{d}$, the points in $S\cap\Delta$ in $O(n^{1-1/d}\log^{O(1)}n+k)$ time where $k=|S\cap\Delta|$;* 3. (c)

(Halfspace range reporting [13])* report, for a specified halfspace $H$ in $\mathbb{R}^{d}$, the points in $S\cap H$ in $O(n^{1-1/\lfloor d/2\rfloor}\log^{O(1)}n+k)$ query time where $k=|S\cap H|$.*

Using a multi-level data structure that combines range trees with the above structures, we can obtain range-reporting structures for query ranges that are the intersections of an orthogonal box and a simplex/halfspace.

Lemma 4**.**

Given a set $S$ of $n$ points in $\mathbb{R}^{d}$, one can build in $O(n\log^{O(1)}n)$ time an $O(n\log^{O(1)}n)$-space data structure which can

1. (a)

(Box-simplex range reporting)* report, for a specified orthogonal box $B$ and simplex $\Delta$ in $\mathbb{R}^{d}$, the points in $S\cap B\cap\Delta$ in $O(\log^{O(1)}n+m^{1-1/d}\log^{O(1)}n+k)$ time where $m=|S\cap B|$ and $k=|S\cap B\cap\Delta|$;* 2. (b)

(Box-halfspace range reporting)* report, for a specified orthogonal box $B$ and halfspace $H$ in $\mathbb{R}^{d}$, the points in $S\cap B\cap H$ in $O(\log^{O(1)}n+m^{1-1/\lfloor d/2\rfloor}\log^{O(1)}n+k)$ time where $m=|S\cap B|$ and $k=|S\cap B\cap H|$.*

Proof. We first prove (a). The data structure is simply a $d$-dimensional range tree $\mathcal{T}$ built on $S$ in which each node $\mathbf{v}\in\mathcal{T}$ is associated with a simplex range-reporting data structure built on the canonical subset $S(\mathbf{v})$ of $\mathbf{v}$ (Lemma (b)(b)). The range tree can be built in $O(n\log^{O(1)}n)$ time [5], and the data structure associated to a node $\mathbf{v}\in\mathcal{T}$ can be built in $O(|S(\mathbf{v})|\log^{O(1)}|S(\mathbf{v})|)$ time and occupies $O(|S(\mathbf{v})|\log^{O(1)}|S(\mathbf{v})|)$ space by Lemma (b)(b). Since $\sum_{\mathbf{v}\in\mathcal{T}}|S(\mathbf{v})|=O(n\log^{O(1)}n)$, we see that the entire data structure can be built in $O(n\log^{O(1)}n)$ time and occupies $O(n\log^{O(1)}n)$ space. To answer a box-simplex range-reporting query $(B,\Delta)$, we first find the $O(\log^{d}n)$ canonical nodes $\mathbf{v}_{1},\dots,\mathbf{v}_{t}$ in $\mathcal{T}$ corresponding to the box $B$, which takes $O(\log^{d}n)$ time [5]. We have $S\cap B=\bigcup_{i=1}^{t}S(\mathbf{v}_{i})$ and $S(\mathbf{v}_{i})\cap S(\mathbf{v}_{j})=\emptyset$ if $i\neq j$. Therefore, $m=|S\cap B|=\sum_{i=1}^{t}|S(\mathbf{v}_{i})|$. Then for each $i\in\{1,\dots,t\}$, we use the simplex range-reporting data structure associated to $\mathbf{v}_{i}$ to report the points in $S(\mathbf{v}_{i})\cap\Delta$, taking $O(|S(\mathbf{v}_{i})|^{1-1/d}\log^{O(1)}|S(\mathbf{v}_{i})|+k_{i})$ time where $k_{i}=|S(\mathbf{v}_{i})\cap\Delta|$, by Lemma (b)(b). Since $t=O(\log^{d}n)$ and $\sum_{i=1}^{t}k_{i}=|S\cap B\cap\Delta|=k$, the total query time is $O(\log^{O(1)}n+m^{1-1/d}\log^{O(1)}n+k)$.

We then prove (b). The data structure is simply a $d$-dimensional range tree $\mathcal{T}$ built on $S$ in which each node $\mathbf{v}\in\mathcal{T}$ is associated with a halfspace range-reporting data structure built on the canonical subset $S(\mathbf{v})$ of $\mathbf{v}$ (Lemma (c)(c)). The range tree can be built in $O(n\log^{O(1)}n)$ time [5], and the data structure associated to a node $\mathbf{v}\in\mathcal{T}$ can be built in $O(|S(\mathbf{v})|\log|S(\mathbf{v})|)$ time and occupies $O(|S(\mathbf{v})|)$ space by Lemma (c)(c). Since $\sum_{\mathbf{v}\in\mathcal{T}}|S(\mathbf{v})|=O(n\log^{O(1)}n)$, we see that the entire data structure can be built in $O(n\log^{O(1)}n)$ time and occupies $O(n\log^{O(1)}n)$ space. To answer a box-halfspace range-reporting query $(B,H)$, we first find the $O(\log^{d}n)$ canonical nodes $\mathbf{v}_{1},\dots,\mathbf{v}_{t}$ in $\mathcal{T}$ corresponding to the box $B$, which takes $O(\log^{d}n)$ time [5]. We have $S\cap B=\bigcup_{i=1}^{t}S(\mathbf{v}_{i})$ and $S(\mathbf{v}_{i})\cap S(\mathbf{v}_{j})=\emptyset$ if $i\neq j$. Therefore, $m=|S\cap B|=\sum_{i=1}^{t}|S(\mathbf{v}_{i})|$. Then for each $i\in\{1,\dots,t\}$, we use the halfspace range-reporting data structure associated to $\mathbf{v}_{i}$ to report the points in $S(\mathbf{v}_{i})\cap\Delta$, taking $O(|S(\mathbf{v}_{i})|^{1-1/\lfloor d/2\rfloor}\log^{O(1)}|S(\mathbf{v}_{i})|+k_{i})$ time where $k_{i}=|S(\mathbf{v}_{i})\cap H|$. Since $t=O(\log^{d}n)$ and $\sum_{i=1}^{t}k_{i}=|S\cap B\cap H|=k$, the total query time is $O(\log^{O(1)}n+m^{1-1/\lfloor d/2\rfloor}\log^{O(1)}n+k)$. $\Box$

3 Orthogonal RCP queries

3.1 Data structure

Let $S$ be a set of $n$ points in $\mathbb{R}^{d}$. In this section, we show how to build a RCP data structure on $S$ for orthogonal queries. First, we build a (standard) $d$-dimensional range tree $\mathcal{T}$ on $S$. Each node $\mathbf{u}$ of $\mathcal{T}$ corresponds to a canonical subset of $S$, which we denote by $S(\mathbf{u})$. We say $\mathbf{u}$ is a heavy node if $|S(\mathbf{u})|\geq\sqrt{n}$. For every pair $(\mathbf{u},\mathbf{v})$ of heavy nodes, we compute the closest pair $\phi_{\mathbf{u},\mathbf{v}}$ in $S(\mathbf{u})\cup S(\mathbf{v})$; denote by $\varPhi$ the set of all these pairs. Then we build an orthogonal range-reporting data structure $\mathcal{D}(S)$ on $S$ (Lemma (a)(a)). Our orthogonal RCP data structure consists of the range tree $\mathcal{T}$, the data structure $\mathcal{D}(S)$, and the pair set $\varPhi$.

Query procedure. Consider a query box $B$ in $\mathbb{R}^{d}$. Our goal is to find the closest pair in $S\cap B$ using the data structure described above. By searching in the range tree $\mathcal{T}$, we can find $t=O(\log^{O(1)}n)$ canonical nodes $\mathbf{c}_{1},\dots,\mathbf{c}_{t}$ corresponding to $B$. We have $S\cap B=\bigcup_{i=1}^{t}S(\mathbf{c}_{i})$. Let $I=\{i:\mathbf{c}_{i}\text{ is a heavy node}\}$ and $I^{\prime}=\{1,\dots,t\}\backslash I$. (See Figure 1(left).) For all $i,j\in I$, we obtain the pair $\phi_{\mathbf{c}_{i},\mathbf{c}_{j}}$ from $\varPhi$ and take the closest one $\phi\in\{\phi_{\mathbf{c}_{i},\mathbf{c}_{j}}:i,j\in I\}$. On the other hand, we compute $L=\bigcup_{i\in I^{\prime}}S(\mathbf{c}_{i})$. We take the closest pair $\phi^{\prime}$ in $L$. Let $\delta=\min\{|\phi|,|\phi^{\prime}|\}$. For each $a\in L$, let $\Box_{a}$ be the hypercube centered at $a$ with side-length $2\delta$. We query, for each $a\in L$, the box range-reporting data structure $\mathcal{D}(S)$ with $\Box_{a}\cap B$ to obtain the set $P_{a}=S\cap\Box_{a}\cap B$. After this, for each $a\in L$, we compute a pair $\psi_{a}$ consisting of $a$ and the nearest neighbor of $a$ in $P_{a}\backslash\{a\}$. We then take the closest one $\psi\in\{\psi_{a}:a\in L\}$. Finally, if $|\psi|<|\phi|$, then we return $\psi$ as the answer; otherwise, we return $\phi$ as the answer.

We now verify the correctness of the above query procedure. Let $\phi^{*}=(a,b)$ be the closest pair in $S\cap\Delta$. It suffices to show that $|\phi|\leq|\phi^{*}|$ or $|\psi|\leq|\phi^{*}|$. Suppose $a\in S(\mathbf{c}_{i})$ and $b\in S(\mathbf{c}_{j})$. If $i,j\in I$, then $|\phi|\leq|\phi_{\mathbf{c}_{i},\mathbf{c}_{j}}|\leq|\phi^{*}|$ and we are done. Otherwise, either $i\in I^{\prime}$ or $j\in I^{\prime}$; assume $i\in I^{\prime}$ without loss of generality. It follows that $a\in L$. Since $\phi^{*}$ is the closest pair in $S\cap B$, we have $|\phi^{*}|\leq|\phi|$ and $|\phi^{*}|\leq|\phi^{\prime}|$, which implies that the distance between $a$ and $b$ is at most $\delta$. Therefore, $b\in P_{a}$. Now we have $|\psi|\leq|\psi_{a}|\leq|\phi^{*}|$, which completes the proof of the correctness.

Analysis. We analyze the performance (space, query time, and preprocessing time) of our orthogonal RCP data structure. To this end, we first bound the number of the heavy nodes. The lemma below follows immediately from the well-known fact that the sum of sizes of the canonical subsets in a range tree is $O(n\log^{d}n)$.

Lemma 5**.**

There are $O(\sqrt{n}\log^{O(1)}n)$ heavy nodes in $\mathcal{T}$.

By the above lemma, the space of the data structure is $O(n\log^{O(1)}n)$. Indeed, the range tree $\mathcal{T}$ and the data structure $\mathcal{D}(S)$ both occupy $O(n\log^{d-1}n)$ space, and the pair-set $\varPhi$ takes $O(n\log^{2d-2}n)$ space as there are $O(\sqrt{n}\log^{O(1)}n)$ heavy nodes. The preprocessing time is $O(n\sqrt{n}\log^{O(1)}n)$. Indeed, building the range tree $\mathcal{T}$ and the data structure $\mathcal{D}(S)$ takes $O(n\log^{O(1)}n)$ time. We claim that the pair-set $\varPhi$ can be computed in $O(n\sqrt{n}\log^{O(1)}n)$ time. We first find the set $\mathcal{H}$ of heavy nodes, which can be done in $O(n\log^{O(1)}n)$ time by simply checking every node of $\mathcal{T}$. For two pairs $(\mathbf{u},\mathbf{v})$ and $(\mathbf{u}^{\prime},\mathbf{v}^{\prime})$ of nodes in $\mathcal{H}$, we write $(\mathbf{u},\mathbf{v})\preceq(\mathbf{u}^{\prime},\mathbf{v}^{\prime})$ if $|S(\mathbf{u})|+|S(\mathbf{v})|\leq|S(\mathbf{u}^{\prime})|+|S(\mathbf{v}^{\prime})|$. Then “$\preceq$” is a partial order on $\mathcal{H}\times\mathcal{H}$. We consider the pairs of heavy nodes in this partial order from the smallest to the greatest. For each pair $(\mathbf{u},\mathbf{v})$, we compute $\phi_{\mathbf{u},\mathbf{v}}$ as follows. If $|S(\mathbf{u})|<2\sqrt{n}$ and $|S(\mathbf{v})|<2\sqrt{n}$, we explicitly compute $S(\mathbf{u})\cup S(\mathbf{v})$ and then compute $\phi_{\mathbf{u},\mathbf{v}}$ using the standard closest-pair algorithm in $O(\sqrt{n}\log n)$ time. Otherwise, either $|S(\mathbf{u})|\geq 2\sqrt{n}$ or $|S(\mathbf{v})|\geq 2\sqrt{n}$. Without loss of generality, assume $|S(\mathbf{u})|\geq 2\sqrt{n}$. Then the two children $\mathbf{u}_{1}$ and $\mathbf{u}_{2}$ of $\mathbf{u})$ are both heavy. Note that $\phi_{\mathbf{u},\mathbf{v}}$ is the closest one among $\phi_{\mathbf{u}_{1},\mathbf{v}},\phi_{\mathbf{u}_{2},\mathbf{v}},\phi_{\mathbf{u}_{1},\mathbf{u}_{2}}$ by construction. Also note that $(\mathbf{u}_{1},\mathbf{v})\preceq(\mathbf{u},\mathbf{v})$, $(\mathbf{u}_{2},\mathbf{v})\preceq(\mathbf{u},\mathbf{v})$, $(\mathbf{u}_{1},\mathbf{u}_{2})\preceq(\mathbf{u},\mathbf{v})$, thus $\phi_{\mathbf{u}_{1},\mathbf{v}},\phi_{\mathbf{u}_{2},\mathbf{v}},\phi_{\mathbf{u}_{1},\mathbf{u}_{2}}$ have already been computed when considering $(\mathbf{u},\mathbf{v})$. With $\phi_{\mathbf{u}_{1},\mathbf{v}},\phi_{\mathbf{u}_{2},\mathbf{v}},\phi_{\mathbf{u}_{1},\mathbf{u}_{2}}$ in hand, we can compute $\phi_{\mathbf{u},\mathbf{v}}$ in $O(1)$ time. In sum, $\phi_{\mathbf{u},\mathbf{v}}$ can be computed in $O(\sqrt{n}\log n)$ time in any case. Since $|\mathcal{H}\times\mathcal{H}|=O(n\log^{O(1)}n)$, we can compute $\varPhi$ in $O(n\sqrt{n}\log^{O(1)}n)$ time. This completes the discussion of the preprocessing time. Next, we analyze the query time. Finding the canonical nodes $\mathbf{c}_{1},\dots,\mathbf{c}_{t}$ takes $O(\log^{O(1)}n)$ time, so does computing the index sets $I$ and $I^{\prime}$. Obtaining the set $\{\phi_{\mathbf{c}_{i},\mathbf{c}_{j}}:i,j\in I\}$ and computing $\phi$ takes $O(\log^{O(1)}n)$ time since $|I|\leq t$ and $t=O(\log^{O(1)}n)$. Computing $\phi^{\prime}$ requires $O(\sqrt{n}\log^{O(1)}n)$ time, because $|L|=O(t\sqrt{n})=O(\sqrt{n}\log^{O(1)}n)$. For a point $a\in L$, reporting the points in $P_{a}$ takes $O(\log^{O(1)}n+|P_{a}|)$ time. Therefore, computing all the $P_{a}$’s can be done in $O(|L|\log^{O(1)}n+\sum_{a\in L}|P_{a}|)$ time. To bound this quantity, we observe the following fact.

Lemma 6**.**

$|P_{a}|=O(1)$* for all $a\in L$.*

Proof. We have $S\cap B=(\bigcup_{i\in I}S(\mathbf{u}_{i}))\cup L$. It suffices to show that $|(\bigcup_{i\in I}S(\mathbf{u}_{i}))\cap\Box_{a}|=O(1)$ and $|L\cap\Box|=O(1)$. Both facts follow from the Pigeonhole Principle readily. Indeed, we have $|(\bigcup_{i\in I}S(\mathbf{u}_{i}))\cap\Box_{a}|=O(1)$ because $\phi$ is the closest pair in $\bigcup_{i\in I}S(\mathbf{u}_{i})$ and $|\phi|\geq\delta$. We have $|L\cap\Box|=O(1)$ because $\phi^{\prime}$ is the closest pair in $L$ and $|\phi^{\prime}|\geq\delta$. This completes the proof. $\Box$

By the above lemma and the fact $|L|=O(\sqrt{n}\log^{O(1)}n)$, we can compute all the $P_{a}$’s in $O(\sqrt{n}\log^{O(1)}n)$ time. The pair $\psi$ can be directly obtained after knowing all the $P_{a}$’s, hence the total query time is $O(\sqrt{n}\log^{O(1)}n)$. We conclude the following.

Theorem 7**.**

Given a set $S$ of $n$ points in $\mathbb{R}^{d}$, one can construct in $\tilde{O}(n\sqrt{n})$ time an orthogonal RCP data structure on $S$ with $\tilde{O}(n)$ space and $\tilde{O}(\sqrt{n})$ query time.

3.2 Conditional hardness

In this subsection, we prove a conditional lower-bound for the orthogonal RCP query, which shows that the upper bound given in Theorem 7 is tight, ignoring $\log n$ factors. following lower-bound matches the upper-bound of Theorem 7. First, we define the following problem [14].

Problem 8**.**

(Set intersection query)* The input is a collection of sets $S_{1},S_{2},\ldots,S_{m}$ of positive reals such that $\sum_{i=1}^{m}|S_{i}|=n$. Given query indices $i$ and $j$, report if $S_{i}$ and $S_{j}$ are disjoint, or not?*

This problem can be viewed as a query version of Boolean matrix multiplication, and is conjectured to be hard: in the cell-probe model without the floor function and where the cardinality of each set $S_{i}$ is upper-bounded by $\log^{O(1)}m$, any data structure to answer the set intersection problem in $\tilde{O}(\alpha)$ time requires $\tilde{\Omega}((n/\alpha)^{2})$ space, for $1\leq\alpha\leq n$ [8, 14]. In particular, any linear-space structure is believed to require $\tilde{\Omega}(\sqrt{n})$ time.

Next we introduce an intermediate geometric problem, which may be of independent interest:

Problem 9**.**

(Set intersection query)* The input is a set $S$ of $n$ colored points in $\mathbb{R}^{2}$. Specifically, let $C$ be a collection of distinct colors, and each point $p\in S$ is associated with some color from $C$. Given a query rectangle $q$, report if all the colors are unique in $S\cap q$? In other words, is there a color which has at least two points in $S\cap q$?*

We will perform a two-step reduction: first, reduce the set intersection query to the color uniqueness query, and then reduce the two-dimensional color uniqueness query to the three-dimensional orthogonal RCP query.

Reduction from set intersection to color uniqueness in $\mathbb{R}^{2}$. Given an instance of the set intersection query, we will construct an instance of the color uniqueness query. Let $p_{1}=(1,1),p_{2}=(2,2),\ldots,p_{m}=(m,m)$, and $p_{1}^{\prime}=(m+1,1),p_{2}^{\prime}=(m+2,2),\ldots,p_{m}^{\prime}=(2m,m)$. Next, assign a unique color to each distinct element in $S_{1}\cup S_{2}\cup\ldots\cup S_{m}$. Now replace each point $p_{i}$ with $|S_{i}|$ new points such that (a) the new points are within a distance of $\varepsilon\ll 1$ from $p_{i}$, and (b) each new point picks a distinct color from the colors assigned to the elements in $S_{i}$. Perform a similar operation for points $p_{i}^{\prime}$. Let $P$ be the collection of these $2n$ new points.

To answer if $S_{i}$ and $S_{j}$ are disjoint ($j<i$), we ask a color uniqueness query on $P$ with an axis-aligned rectangle $q=[i-\varepsilon,m+j+\varepsilon]\times[j-\varepsilon,i+\varepsilon]$ (see Figure 1(right)). If there is a color which contains two points, then we report that $S_{i}$ and $S_{j}$ are not disjoint; otherwise, we report that $S_{i}$ and $S_{j}$ are disjoint. The correctness is easy to see: the key observation is that $q$ exactly contains the points of $S_{i}$ and $S_{j}$. Therefore, $S_{i}$ and $S_{j}$ are disjoint iff all the colors are unique in $P\cap q$. Reductions of this flavor have been performed before [3, 8, 11, 15].

Reduction from color uniqueness in $\mathbb{R}^{2}$ to orthogonal RCP in $\mathbb{R}^{3}$. Given an instance of the color uniqueness query, we will now construct an instance of the orthogonal RCP query in $\mathbb{R}^{3}$. Let $d_{\mbox{\scriptsize max}}$ be the maximum Euclidean distance between any two points in $S$, and let $c_{1},c_{2},\ldots,c_{|C|}$ be the $|C|$ colors in the dataset. Then each point $p=(p_{x},p_{y})\in S$ with color $c_{i}$ is mapped to a 3-d point $p^{\prime}=(p_{x},p_{y},2\cdot i\cdot d_{\mbox{\scriptsize max}})$. Let $P$ be the collection of these $n$ newly mapped points.

To answer the color uniqueness query for a rectangle $q$, we will ask an orthogonal RCP query on $P$ with the query box $q\times(-\infty,\infty)$. If the closest-pair distance is less than or equal to $d_{\mbox{\scriptsize max}}$, then we report that there is a color which contains at least two points inside $q$; otherwise, we report that all the colors are unique inside $q$. Once again, the correctness is easy to see: the key observation is that the distance between points of different colors in $P$ is at least $2\cdot d_{\mbox{\scriptsize max}}$.

The above two reductions together implies our conditional lower bound, which is presented in the following theorem.

Theorem 10**.**

*The orthogonal RCP query is at least as hard as the set intersection query. *

4 Simplex RCP queries

Let $S$ be a set of $n$ points in $\mathbb{R}^{d}$, and $r$ be a parameter to be specified shortly. In this section, we show how to build a RCP data structure on $S$ for simplex queries. First, we use Lemma 1 to compute a partition $\{S_{1},\dots,S_{r}\}$ of $S$ and $r$ simplices $\Delta_{1},\dots,\Delta_{r}$ in $\mathbb{R}^{d}$ satisfying the conditions in the lemma. For every $i,j\in\{1,\dots,r\}$, we compute the closest pair $\phi_{i,j}$ in $S_{i}\cup S_{j}$; denote by $\varPhi$ the set of all these pairs. Then we build a box-simplex range-reporting data structure $\mathcal{D}^{\prime}(S)$ on $S$ (Lemma (a)(a)). Our simplex RCP data structure consists of the partition $\{S_{1},\dots,S_{r}\}$, the simplices $\Delta_{1},\dots,\Delta_{r}$, the data structure $\mathcal{D}^{\prime}(S)$, and the pair set $\varPhi$.

Query procedure. Consider a query simplex $\Delta$ in $\mathbb{R}^{d}$. Our goal is to find the closest pair in $S\cap\Delta$ using the data structure described above. We first compute two index sets $I=\{i:\Delta_{i}\subseteq\Delta\}$, $I^{\prime}=\{i:\Delta_{i}\nsubseteq\Delta\text{ and }\Delta_{i}\cap\Delta\neq\emptyset\}$. (See Figure 2.) These index sets are computed by explicitly considering the $r$ simplices $\Delta_{1},\dots,\Delta_{r}$. For all $i,j\in I$, we obtain the pair $\phi_{i,j}$ from $\varPhi$ and take the closest one $\phi\in\{\phi_{i,j}:i,j\in I\}$. On the other hand, we compute a set $L=(\bigcup_{i\in I^{\prime}}S_{i})\cap\Delta$ by simply checking, for every $i\in I^{\prime}$ and every $a\in S_{i}$, whether $a\in\Delta$. We take the closest pair $\phi^{\prime}$ in $L$. Let $\delta=\min\{|\phi|,|\phi^{\prime}|\}$. For each $a\in L$, let $\Box_{a}$ be the hypercube centered at $a$ with side length $2\delta$. We query, for each $a\in L$, the box-simplex range-reporting data structure $\mathcal{D}^{\prime}(S)$ with $\Box_{a}$ and $\Delta$ to obtain the set $P_{a}=S\cap\Box_{a}\cap\Delta$. After this, for each $a\in L$, we compute a pair $\psi_{a}$ consisting of $a$ and the nearest neighbor of $a$ in $P_{a}\backslash\{a\}$. We then take the closest one $\psi\in\{\psi_{a}:a\in L\}$. Finally, if $|\psi|<|\phi|$, then we return $\psi$ as the answer; otherwise, we return $\phi$ as the answer.

We now verify the correctness of the above query procedure. Let $\phi^{*}=(a,b)$ be the closest pair in $S\cap\Delta$. It suffices to show that $|\phi|\leq|\phi^{*}|$ or $|\psi|\leq|\phi^{*}|$. Suppose $a\in S_{i}$ and $b\in S_{j}$. We first notice that $i,j\in I\cup I^{\prime}$. Indeed, if $i\notin I\cup I^{\prime}$ (resp., $j\notin I\cup I^{\prime}$), then $\Delta_{i}\cap\Delta=\emptyset$ (resp., $\Delta_{j}\cap\Delta=\emptyset$) and hence $S_{i}\cap\Delta=\emptyset$ (resp., $S_{j}\cap\Delta=\emptyset$), which contradicts the fact that $a\in S_{i}\cap\Delta$ (resp., $b\in S_{i}\cap\Delta$). If $i,j\in I$, then $|\phi|\leq|\phi_{i,j}|\leq|\phi^{*}|$ and we are done. Otherwise, either $i\in I^{\prime}$ or $j\in I^{\prime}$; assume $i\in I^{\prime}$ without loss of generality. It follows that $a\in L$. Since $\phi^{*}$ is the closest pair in $S\cap\Delta$, we have $|\phi^{*}|\leq|\phi|$ and $|\phi^{*}|\leq|\phi^{\prime}|$, which implies that the distance between $a$ and $b$ is at most $\delta$. Therefore, $b\in P_{a}$. Now we have $|\psi|\leq|\psi_{a}|\leq|\phi^{*}|$, which completes the proof of the correctness.

Analysis. We analyze the performance (space, query time, and preprocessing time) of our simplex RCP data structure. The space of the data structure is $O(n\log^{O(1)}n+r^{2})$, because $\mathcal{D}^{\prime}(S)$ occupies $O(n\log^{O(1)}n)$ space and $\varPhi$ occupies $O(r^{2})$ space. The preprocessing time is $O(nr\log^{O(1)}n)$. Indeed, computing the partition $\{S_{1},\dots,S_{r}\}$ and the simplices $\Delta_{1},\dots,\Delta_{r}$ takes $O(n\log n)$ time by Lemma 1. Computing $\phi_{i,j}$ for some fixed $i,j\in\{1,\dots,r\}$ can be done in $O((n/r)\log(n/r))$ time using the standard closest-pair algorithm, because $|S_{i}\cup S_{j}|=O(n/r)$. It follows that computing $\varPhi$ takes $O(nr\log n)$ time. Finally, building the data structure $\mathcal{D}^{\prime}(S)$ requires $O(n\log^{O(1)}n)$ time. As such, our simplex RCP data structure can be constructed in $O(nr\log^{O(1)}n)$ time. Next, we analyze the query time. The index sets $I$ and $I^{\prime}$ are computed in $O(r)$ time. Obtaining the set $\{\phi_{i,j}:i,j\in I\}$ and computing $\phi$ requires $O(r^{2})$ time. The set $L$ is computed by explicitly considering all the points in $\bigcup_{i\in I^{\prime}}S_{i}$ in $O(\sum_{i\in I^{\prime}}|S_{i}|)$ time. We notice that $|I^{\prime}|=O(r^{1-1/d})$, since each facet of $\Delta$ only intersects $O(r^{1-1/d})$ simplices among $\Delta_{1},\dots,\Delta_{r}$ by Lemma 1. It follows that $\sum_{i\in I^{\prime}}|S_{i}|=O(n/r^{1/d})$, because $|S_{i}|=O(n/r)$. That says, $L$ can be computed in $O(n/r^{1/d})$ time and in particular, $|L|=O(n/r^{1/d})$. Once $L$ is obtained, $\phi^{\prime}$ can be computed in $O((n/r^{1/d})\log(n/r^{1/d}))$ time using the standard closest-pair algorithm. For a point $a\in L$, reporting the points in $P_{a}$ takes $O(\log^{O(1)}n+m_{a}^{1-1/d}\log^{O(1)}m_{a}+|P_{a}|)$ time where $m_{a}=|S\cap\Box_{a}|$, by Lemma (a)(a). Therefore, computing all the $P_{a}$’s can be done in $O(\sum_{a\in L}m_{a}^{1-1/d}\log^{O(1)}n+\sum_{a\in L}|P_{a}|)$ time. To bound this quantity, we observe the following fact.

Lemma 11**.**

$\sum_{a\in L}m_{a}=O(n)$* and $|P_{a}|=O(1)$ for all $a\in L$.*

Proof. We first prove $\sum_{a\in L}m_{a}=O(n)$. Consider a point $p\in S$. Let $\Box_{p}$ be the hypercube centered at $p$ with side-length $2\delta$. Note that $p\in P_{a}$ only if $a\in\Box_{p}$ for all $a\in L$. Since $\phi^{\prime}$ is the closest pair in $L$ and $|\phi^{\prime}|\geq\delta$, we have $L\cap\Box_{p}=O(1)$ by the Pigeonhole Principle. Therefore, only a constant number of points in $L$ is contained in $p$. In other words, any point $p\in S$ is contained in $P_{a}$ for only a constant number of $a\in L$, which implies $\sum_{a\in L}m_{a}=O(n)$. Next, we prove that $|P_{a}|=O(1)$ for all $a\in L$. Clearly, $S\cap\Delta=(\bigcup_{i\in I}S_{i})\cup L$. So it suffices to show that $|(\bigcup_{i\in I}S_{i})\cap\Box_{a}|=O(1)$ and $|L\cap\Box_{a}|=O(1)$. Both facts follow from the Pigeonhole Principle readily. Indeed, we have $|(\bigcup_{i\in I}S_{i})\cap\Box_{a}|=O(1)$ because $\phi$ is the closest pair in $\bigcup_{i\in I}S_{i}$ and $|\phi|\geq\delta$. We have $|L\cap\Box_{a}|=O(1)$ because $\phi^{\prime}$ is the closest pair in $L$ and $|\phi^{\prime}|\geq\delta$. This completes the proof of $|P_{a}|=O(1)$. $\Box$

By the above lemma and Hölder’s inequality, we have

[TABLE]

which implies that computing all the $P_{a}$’s takes $O((n\log^{O(1)}n)/r^{1/d^{2}})$ time. The pair $\psi$ can be directly obtained after knowing all the $P_{a}$’s. Hence, the total query time is $O(r^{2}+(n\log^{O(1)}n)/r^{1/d^{2}})$. Setting $r=n^{d^{2}/(2d^{2}+1)}$ gives:

Theorem 12**.**

Given a set $S$ of $n$ points in $\mathbb{R}^{d}$, one can construct in $\tilde{O}(n^{(3d^{2}+1)/(2d^{2}+1)})$ time a simplex RCP data structure on $S$ with $\tilde{O}(n)$ space and $\tilde{O}(n^{1-1/(2d^{2})})$ query time.

Note that our data structure above can also handle constant-complexity polytope RCP queries (with the same query procedure and query time). In other words, the data structure can be used to report, for specified $O(1)$ halfspaces $H_{1},\dots,H_{c}$ in $\mathbb{R}^{d}$, the closest pair in $S\cap(\bigcap_{i=1}^{c}H_{i})$ in $\tilde{O}(n^{1-1/(2d^{2})})$ time.

5 Halfspace RCP queries

Let $S$ be a set of $n$ points in $\mathbb{R}^{d}$, and $r$ be a parameter to be specified shortly. In this section, we show how to build an RCP data structure on $S$ for halfspace queries. The same method can also result in an RCP data structure for ball queries, using the standard lifting argument. Since halfspace query is a special case of simplex query, the simplex RCP data structure in the last section can be directly used to answer halfspace RCP queries. But in fact, for halfspace RCP queries, we can achieve better bounds.

It suffices to consider the halfspaces which are regions below non-vertical hyperplanes, namely, halfspaces of the form $x_{d}\leq a_{1}x_{1}+\cdots+a_{d-1}x_{d-1}$. By duality, a point $a\in S$ maps to a hyperplane $a^{*}$ in the dual space (which is also a copy of $\mathbb{R}^{d}$). Also, a non-vertical hyperplane $h$ in the primal $\mathbb{R}^{d}$ maps to a point $h^{*}$ in the dual space. The property of duality guarantees that $a$ is above (resp., below) $h$ iff $h^{*}$ is above (resp., below) $a^{*}$ for all $a\in S$ and all hyperplanes $h$ (see Figure 3). Define $\mathcal{H}=\{a^{*}:a\in S\}$. We use Lemma 2 to cut $\mathbb{R}^{d}$ (the dual space) into $R=O(r^{d})$ cells $\Xi_{1},\dots,\Xi_{R}$ each of which is a constant-complexity polytope intersecting $O(n/r)$ hyperplanes in $\mathcal{H}$. For $i\in\{1,\dots,R\}$, let $S_{i}=\{a:a^{*}\text{ is below }\Xi_{i}\}$. We associate to the cell $\Xi_{i}$ the closest pair $\phi_{i}$ in $S_{i}$. Furthermore, we build a simplex range-reporting data structure $\mathcal{D}(S)$ on $S$ (Lemma (b)(b)) and a box-halfspace range-reporting data structure $\mathcal{D}^{\prime}(S)$ in $S$ (Lemma (b)(b)). Our halfspace RCP data structure consists of the cells $\Xi_{1},\dots,\Xi_{R}$ (with the associated pairs $\phi_{1},\dots,\phi_{r}$) and the data structures $\mathcal{D}(S)$ and $\mathcal{D}^{\prime}(S)$. The cells $\Xi_{1},\dots,\Xi_{R}$ are stored in the way mentioned in Lemma 2 (so that we can do point location efficiently).

Query procedure. Consider a query halfspace $H$ that is the region below a non-vertical hyperplane $h$. Our goal is to find the closest pair in $S\cap H$ using the data structure described above. To this end, we first find the cell $\Xi_{i}$ such that $h^{*}\in\Xi_{i}$. Let $V$ be the set of the vertices of $\Xi_{i}$. We have $V=O(1)$ by Lemma 2. For every $v\in V$, let $H_{v}$ be the halfspace above the non-vertical hyperplane $v^{*}$ in the primal $\mathbb{R}^{d}$. Using $\mathcal{D}(S)$, we find the points in $S\cap(H\cap H_{v})$ for all $v\in V$ and obtain the set $L=\bigcup_{v\in V}S\cap(H\cap H_{v})$. We take the closest pair $\phi^{\prime}$ in $L$. Let $\delta=\min\{|\phi_{i}|,|\phi^{\prime}|\}$ (recall that $\phi_{i}$ is the pair associated to $\Xi_{i}$). For each $a\in L$, let $\Box_{a}$ be the hypercube centered at $a$ with side-length $2\delta$. We query, for each $a\in L$, the box-halfspace range-reporting data structure $\mathcal{D}^{\prime}(S)$ with $\Box_{a}$ and $H$ to obtain the set $P_{a}=S\cap\Box_{a}\cap H$. After this, for each $a\in L$, we compute a pair $\psi_{a}$ consisting of $a$ and the nearest neighbor of $a$ in $P_{a}\backslash\{a\}$. We then take the closest one $\psi\in\{\psi_{a}:a\in L\}$. Finally, if $|\psi|<|\phi_{i}|$, then we return $\psi$ as the answer; otherwise, we return $\phi_{i}$ as the answer.

We now verify the correctness of the above query procedure. First of all, we claim that $S\cap H=S_{i}\cup L$. Indeed, we have $L\subseteq S\cap H$ by definition and $S_{i}\subseteq S\cap H$ because $a^{*}$ is below $\Xi_{i}$ (and hence below $h^{*}$) for all $a\in S_{i}$; this implies $S_{i}\cup L\subseteq S\cap H$. To see $S\cap H\subseteq S_{i}\cup L$, let $a\in S\cap H$ be a point. If $a^{*}$ is below $\Xi_{i}$, then $a\in S_{i}$. Otherwise, there exists $v\in V$ such that $a^{*}$ is above $v$. It follows that $a\in S\cap(H\cap H_{v})\subseteq L$. Therefore, $S\cap H\subseteq S_{i}\cup L$ and $S\cap H=S_{i}\cup L$. With this observation in hand, we first show that the returned answer is a pair in $S\cap H$. It suffices to show that both $\phi_{i}$ and $\psi$ are pairs in $S\cap H$. The two points of $\phi_{i}$ are both in $S_{i}$ and hence in $S\cap H$. To see $\psi$ is a pair in $S\cap H$, suppose $\psi=\psi_{a}$ for $a\in L$. By definition, $\psi_{a}$ consists of $a$ and the nearest neighbor of $a$ in $P_{a}\backslash\{a\}$. We have $a\in L\subseteq S\cap H$ and $P_{a}\subseteq L\subseteq S\cap H$, hence $\psi$ is a pair in $S\cap H$. Next, we show that the returned answer is the closest pair in $S\cap H$. Let $\phi^{*}=(a,b)$ be the closest-pair in $S\cap H$. It suffices to show that $|\phi_{i}|\leq|\phi^{*}|$ or $|\psi|\leq|\phi^{*}|$. If $a,b\in S_{i}$, then $|\phi_{i}|\leq|\phi^{*}|$ and we are done. Otherwise, assume $a\notin S_{i}$ and thus $a\in L$, without loss of generality. Since $\phi^{*}$ is the closest pair in $S\cap H$, we have $|\phi^{*}|\leq|\phi_{i}|$, which implies that the distance between $a$ and $b$ is at most $\delta$. Therefore, $b\in P_{a}$. Now we have $|\psi|\leq|\psi_{a}|\leq|\phi^{*}|$, which completes the proof of the correctness.

Analysis. We analyze the performance (space, query time, and preprocessing time) of our halfspace RCP data structure. The space of the data structure is $O(n\log^{O(1)}n+R)$, because $\mathcal{D}(S)$ occupies $O(n)$ space, $\mathcal{D}^{\prime}(S)$ occupies $O(n\log^{O(1)}n)$ space, and storing $\Xi_{1},\dots,\Xi_{R}$ (with the associated pairs $\phi_{1},\dots,\phi_{R}$) requires $O(R)$ space. Next, we analyze the query time. Determining the cell $\Xi_{i}$ takes $O(\log r)$ time by Lemma 2. For each $v\in V$, reporting the points in $S\cap(H\cap H_{v})$ takes $O(n^{1-1/d}\log^{O(1)}n+k_{v})$ time where $k_{v}=|S\cap(H\cap H_{v})|$. We claim that $a^{*}$ intersects $\Xi_{i}$ for any $a\in S\cap(H\cap H_{v})$. Indeed, $a^{*}$ is below $h$ because $a\in H$ and is above $v$ because $a\in H_{v}$. Thus, $a^{*}$ intersects the segment connecting $h^{*}$ and $v$. Since $h^{*},v\in\Xi_{i}$, $a^{*}$ intersects $\Xi_{i}$. It follows that $k_{v}=O(n/r)$ by Lemma 2. Furthermore, because $V=O(1)$, $L$ can be computed in $O(n^{1-1/d}\log^{O(1)}n+\sum_{v\in V}k_{v})=O(n^{1-1/d}\log^{O(1)}n+n/r)$ time and $|L|=O(\sum_{v\in V}k_{v})=O(n/r)$. Once $L$ is obtained, $\phi^{\prime}$ can be computed in $O((n/r)\log(n/r))$ time using the standard closest-pair algorithm. For a point $a\in L$, reporting the points in $P_{a}$ takes $O(\log^{O(1)}n+m_{a}^{1-1/\lfloor d/2\rfloor}\log^{O(1)}m_{a}+|P_{a}|)$ time where $m_{a}=|S\cap\Box_{a}|$, by Lemma (b)(b). By exactly the same argument in the proof of Lemma 11, we have the following observation:

Lemma 13**.**

$\sum_{a\in L}m_{a}=O(n)$* and $|P_{a}|=O(1)$ for all $a\in L$.*

By the above lemma and Hölder’s inequality, we have

[TABLE]

which implies that computing all the $P_{a}$’s takes $O(n\log^{O(1)}n/r^{1/\lfloor d/2\rfloor})$ time. The pair $\psi$ can be directly obtained after knowing all the $P_{a}$’s. Hence, the total query time is $O(\log r+n\log^{O(1)}n/r^{1/\lfloor d/2\rfloor})$. Finally, we analyze the preprocessing time. The data structures $\mathcal{D}(S)$ and $\mathcal{D}^{\prime}(S)$ can both be constructed in $O(n\log^{O(1)}n)$ time by Lemma (b)(b) and (b)(b). The cells $\Xi_{1},\dots,\Xi_{R}$ can be computed in $O(nr^{d-1})$ time by Lemma 2. So it suffices to show how to compute the pairs $\phi_{1},\dots,\phi_{R}$ efficiently. To this end, we build a simplex RCP data structure on $S$ as described in Theorem 12, which takes $\tilde{O}(n^{(3d^{2}+1)/(2d^{2}+1)})$ time. Fix $i\in\{1,\dots,R\}$ and let $V$ be the set of the $O(1)$ vertices of $\Xi_{i}$. For $v\in V$, let $H_{v}^{\prime}$ be the halfspace below the hyperplane $v^{*}$ in the primal space. We claim that $S_{i}=S\cap(\bigcap_{v\in V}H_{v}^{\prime})$. To see this, consider a point $a\in S$. We have $a\in S_{i}$ iff $a^{*}$ is below $\Xi_{i}$ iff $v$ is below $a^{*}$ for all $v\in V$, or equivalently, $a\in H_{v}^{\prime}$ for all $v\in V$. Thus, $S_{i}=S\cap(\bigcap_{v\in V}H_{v}^{\prime})$. We can then compute the closest pair $\phi_{i}$ in $S_{i}$ using the simplex RCP data structure with the query range $\bigcap_{v\in V}H_{v}^{\prime}$ (as mentioned at the end of Section 4, our simplex RCP data structure can handle queries which are intersections of constant number of halfspaces). Computing $\phi_{i}$ takes $O(n^{1-1/(2d^{2})}\log^{O(1)}n)$ time, and hence computing all pairs $\phi_{1},\dots,\phi_{R}$ takes $O(Rn^{1-1/(2d^{2})}\log^{O(1)}n)$ time. In sum, the preprocessing time of our halfspace RCP data structure is $O((nr^{d-1}+n^{(3d^{2}+1)/(2d^{2}+1)}+Rn^{1-1/(2d^{2})})\log^{O(1)}n)$. Setting $r=n^{1/d}$ gives:

Theorem 14**.**

Given a set $S$ of $n$ points in $\mathbb{R}^{d}$, one can construct in $\tilde{O}(n^{2-1/(2d^{2})})$ time a halfspace RCP data structure on $S$ with $\tilde{O}(n)$ space and $\tilde{O}(n^{1-1/(d\lfloor d/2\rfloor)})$ query time.

Appendix A Ball RCP queries

The same approach as in Theorem 14 also works for ball RCP queries, by applying the standard lifting transformation to map $d$-dimensional balls to $(d+1)$-dimensional halfspaces. Note that, in general, ball RCP queries in $\mathbb{R}^{d}$ cannot be reduced to halfspace RCP queries in $\mathbb{R}^{d+1}$ using the lifting argument, as the lifting map does not preserve pairwise distances of the points. However, our approach for handling halfspace queries (together with the lifting argument) can actually be applied to answer ball queries. An easy way to see this is the following. The lifting map $\rho:\mathbb{R}^{d}\rightarrow\mathbb{R}^{d+1}$ is defined as $(x_{1},\dots,x_{d})\mapsto(x_{1},\dots,x_{d},\sum_{i=1}^{d}x_{i}^{2})$. Let $\pi:\mathbb{R}^{d+1}\rightarrow\mathbb{R}^{d}$ be the projection map $(x_{1},\dots,x_{d},x_{d+1})\mapsto(x_{1},\dots,x_{d})$. Then $\pi\circ\rho=\text{id}_{R^{d}}$. Define a distance function $f:\mathbb{R}^{d+1}\times\mathbb{R}^{d+1}\rightarrow\mathbb{R}^{d+1}$ as $f(a,b)=\lVert\pi(a)-\pi(b)\rVert_{2}$. Clearly, we have $\lVert a-b\rVert_{2}=f(\rho(a),\rho(b))$ for all $a,b\in\mathbb{R}^{d}$. Therefore, the lifting argument reduces ball RCP search in $\mathbb{R}^{d}$ to halfspace RCP search in $\mathbb{R}^{d+1}$ under the distance function $f$. Now observe that our halfspace RCP data structure works even under the distance function $f$. Indeed, all of our RCP data structures in this paper only requires the distance function to satisfy two conditions: (1) closest-pair algorithms with near-linear time exist and (2) packing argument works. It is clear that the distance function $f$ satisfies both of the requirements. As such, we obtain a halfspace RCP data structure under the distance function $f$ with the same performance as in Theorem 14, which in turn gives us a ball RCP data structure.

Theorem 15**.**

Given a set $S$ of $n$ points in $\mathbb{R}^{d}$, one can construct in $\tilde{O}(n^{2-1/(2(d+1)^{2})})$ time a ball RCP data structure on $S$ with $\tilde{O}(n)$ space and $\tilde{O}(n^{1-1/((d+1)\lceil d/2\rceil)})$ query time.