Fair Near Neighbor Search: Independent Range Sampling in High Dimensions

TL;DR

This paper introduces fair algorithms for high-dimensional near neighbor search that ensure all points within a radius have equal probability of being returned, addressing fairness issues in traditional LSH methods.

Contribution

It proposes new data structures for fair similarity search that guarantee equal opportunity among points, including a black-box approach and a specialized structure for inner product similarity.

Findings

Fair data structures ensure equal probability for all near points

Experimental results reveal unfairness in existing methods

New approaches improve fairness in recommendation systems

Abstract

Similarity search is a fundamental algorithmic primitive, widely used in many computer science disciplines. There are several variants of the similarity search problem, and one of the most relevant is the $r$-near neighbor ($r$-NN) problem: given a radius $r>0$ and a set of points $S$, construct a data structure that, for any given query point $q$, returns a point $p$ within distance at most $r$ from $q$. In this paper, we study the $r$-NN problem in the light of fairness. We consider fairness in the sense of equal opportunity: all points that are within distance $r$ from the query should have the same probability to be returned. In the low-dimensional case, this problem was first studied by Hu, Qiao, and Tao (PODS 2014). Locality sensitive hashing (LSH), the theoretically strongest approach to similarity search in high dimensions, does not provide such a fairness guarantee. To address this, we propose efficient data structures for $r$-NN where all points in $S$ that are near $q$ have the same probability to be selected and returned by the query. Specifically, we first propose a black-box approach that, given any LSH scheme, constructs a data structure for uniformly sampling points in the neighborhood of a query. Then, we develop a data structure for fair similarity search under inner product that requires nearly-linear space and exploits locality sensitive filters. The paper concludes with an experimental evaluation that highlights (un)fairness in a recommendation setting on real-world datasets and discusses the inherent unfairness introduced by solving other variants of the problem.

Equations

$$\mathrm{Pr}[{\text{OUT}}_{i,\mathbf{q}}=\mathbf{p}\mid {\text{OUT}}_{i-1,{\mathbf{q}}_{i-1}}={\mathbf{p}}_{i-1},\dots ,{\text{OUT}}_{1,{\mathbf{q}}_1}={\mathbf{p}}_1]=\frac{1}{|B_S(\mathbf{q},r)}.$$

$$S_{i,{\ell }_i(\mathbf{q})}=\{\mathbf{p}:\mathbf{p}\in S,{\ell }_i(\mathbf{p})={\ell }_i(\mathbf{q})\}$$

$$O\left(\left(n^{\rho }+\frac{b_S(\mathbf{q},cr)}{b_S(\mathbf{q},r)+1}\right)\log n\right).$$

$$\text{E}\left[\mu \right]$$

$$\le L+L\cdot \sum _{\mathbf{p}\in S\setminus B_S(\mathbf{q},r)}\frac{\text{Pr}\left[{\ell }_1(\mathbf{q})={\ell }_1(\mathbf{p})\right]}{b_S(\mathbf{q},r)+1}$$

$$\le L+L\frac{b_S(\mathbf{q},cr)p_1+n{p}_2}{b_S(\mathbf{q},r)+1}=O\left(\left(n^{\rho }+\frac{b_S(\mathbf{q},cr)}{b_S(\mathbf{q},r)+1}\right)\log n\right),$$

$$p_j={\left(\sum _{i=0}^{k-1}\frac{1-{\lambda }_{\mathbf{q},i}/\lambda }{k}\right)}^{j-1}\frac{{\lambda }_{\mathbf{q},h}}{k\lambda }\frac{1}{{\lambda }_{\mathbf{q},h}}={\left(1-\frac{b_S(\mathbf{q},r)}{k\lambda }\right)}^{j-1}\frac{1}{k\lambda }.$$

$$\text{Pr}\left[OUT=\mathbf{p}\right]=\sum _{j=1}^{+\infty }{p}_j=\sum _{j=1}^{+\infty }{\left(1-\frac{b_S(\mathbf{q},r)}{k\lambda }\right)}^{j-1}\frac{1}{k\lambda }=\frac{1}{b_S(\mathbf{q},r)}.$$

$$O\left(\left(n^{\rho }+\frac{b_S(\mathbf{q},c\cdot r)}{b_S(\mathbf{q},r)+1}\right){\log }^{5}n\right).$$

$$p^{\prime }={\left(1-\frac{b_S(\mathbf{q},r)}{k\lambda }\right)}^{\Sigma }\le e^{-\Sigma b_S(\mathbf{q},r)/(k\lambda )}\le e^{\Theta \left(-\Sigma /\log n\right)}\le \frac{1}{2n^2}.$$

$$\text{Pr}\left[OU{T}_i=\mathbf{p}|OU{T}_{i-1}={\mathbf{p}}_{i-1},\dots OU{T}_1={\mathbf{p}}_1\right]=$$

$$=\text{Pr}\left[OU{T}_i=\mathbf{p}\right]=\frac{1}{b_S(\mathbf{q},r)}$$

$$O\left((n^{\rho }+b_S(\mathbf{q},cr)-b_S(\mathbf{q},r)){\log }^{2}n\right).$$

$$\text{Pr}\left[\text{find x}\right]$$

$$-\text{Pr}\left[\forall i:⟨{\mathbf{a}}_i,\mathbf{x}⟩<{\Delta }_{\mathbf{x}}\right]-\text{Pr}\left[\forall i:⟨{\mathbf{a}}_i,\mathbf{q}⟩<{\Delta }_{\mathbf{q}}\right].$$

$$\frac{1}{\sqrt{2\pi }}\frac{1}{t+1}{e}^{-t^2/2}\le \mathrm{Pr}(Z\ge t)\le \frac{1}{\sqrt{\pi }}\frac{1}{t+1}{e}^{-t^2/2}.$$

$$Z\ge \frac{\alpha {\Delta }_{\mathbf{q}}-f(\alpha ,\epsilon )-\alpha {\Delta }_{\mathbf{x}}}{\sqrt{1-{\alpha }^2}}.$$

$$\text{Pr}\left[Z\ge -\frac{f(\alpha ,\epsilon )}{\sqrt{1-{\alpha }^2}}\right]$$

$$=1-\text{Pr}\left[Z\ge \frac{f(\alpha ,\epsilon )}{\sqrt{1-{\alpha }^2}}\right]$$

$$\ge 1-\frac{\text{Exp}\left(-\frac{(f(\alpha ,\epsilon ){)}^2}{2(1-{\alpha }^2)}\right)}{\sqrt{2\pi }\left(\frac{f(\alpha ,\epsilon )}{\sqrt{1-{\alpha }^2}}+1\right)}\ge 1-\epsilon .$$

$$\text{Pr}\left[\forall i:⟨{\mathbf{a}}_i,\mathbf{x}⟩<{\Delta }_{\mathbf{x}}\right]$$

$$={\left(1-\text{Pr}\left[⟨{\mathbf{a}}_1,\mathbf{x}⟩\ge {\Delta }_{\mathbf{x}}\right]\right)}^m$$

$$\le {\left(1-\frac{\text{Exp}[-{\Delta }_{\mathbf{x}}^2/2]}{\sqrt{2\pi }({\Delta }_x+1)}\right)}^m.$$

$$\text{Pr}\left[\max \{⟨\mathbf{a},\mathbf{q}⟩\}\ge t\right]$$

$$\text{Pr}\left[⟨\mathbf{a},\mathbf{q}⟩\ge \alpha {\Delta }_{\mathbf{q}}-f(\alpha ,\epsilon )\mid ⟨\mathbf{a},\mathbf{x}⟩={\Delta }_{\mathbf{x}}\right]\le$$

$$\le \text{Pr}\left[⟨\mathbf{a},\mathbf{q}⟩\ge \alpha {\Delta }_{\mathbf{q}}-f(\alpha ,\epsilon )\mid ⟨\mathbf{a},\mathbf{x}⟩=t_{\mathbf{x}}\right]$$

$$\le \text{Pr}\left[⟨\mathbf{a},\mathbf{q}⟩\ge \alpha t_{\mathbf{q}}-f(\alpha ,\epsilon )\mid ⟨\mathbf{a},\mathbf{x}⟩=t_{\mathbf{x}}\right].$$

$$\text{Pr}\left[⟨\mathbf{a},\mathbf{q}⟩\ge \alpha t_{\mathbf{q}}-f(\alpha ,\epsilon )\mid ⟨\mathbf{a},\mathbf{x}⟩=t_{\mathbf{x}}\right]\le \frac{\text{Exp}\left(-\frac{(\alpha t_{\mathbf{q}}-f(\alpha ,\epsilon )-\beta t_{\mathbf{x}}{)}^2}{2(1-{\beta }^2)}\right)}{\sqrt{\pi }\left(\frac{(\alpha t_{\mathbf{q}}-f(\alpha ,\epsilon )-\beta t_{\mathbf{x}})}{\sqrt{1-{\beta }^2}}+1\right)}$$

$$\le \text{Exp}\left(-\frac{(\alpha t_{\mathbf{q}}-f(\alpha ,\epsilon )-\beta t_{\mathbf{x}}{)}^2}{2(1-{\beta }^2)}\right)$$

$$\stackrel{(1)}{=}\text{Exp}\left(-\frac{(\alpha -\beta {)}^2{t}_{\mathbf{x}}^2}{2(1-{\beta }^2)}\left(1+O(1/\log \log n)\right)\right)$$

$$={\left(\frac{1}{m}\right)}^{\frac{(\alpha -\beta {)}^2}{1-{\beta }^2}+o(1)},$$

$$m\cdot \text{Exp}\left(-(\alpha t_{\mathbf{q}}{)}^2\left(1/2-f(\alpha ,\epsilon )/(\alpha t_{\mathbf{q}})+f(\alpha ,\epsilon {)}^2/(2(\alpha t_{\mathbf{q}}{)}^2)\right)\right),$$

Full text

Similarity search; Locality Sensitive Hashing; Fairness; Sampling

††ccs: Theory of computation Sketching and sampling††ccs: Information systems Nearest-neighbor search

1. Introduction

In recent years, there has been an increasing interest in building algorithms that achieve fairness under certain technical definitions of fairness (Dwork et al., 2012). This was for example highlighted by the PODS 2019 invited talk on algorithmic fairness given by Venkatasubramanian (Venkatasubramanian, 2019). The goal is to remove, or at least minimize, unethical behavior such as discrimination and bias in algorithmic decision making. There is no unique definition of fairness (see (Hardt et al., 2016) and references therein), but different formulations that depend on the computational problem and on the ethical goals we aim for. Fairness goals are often defined in the political context of socio-technical systems (of the President, 2016), and have to be seen in an interdisciplinary spectrum covering many fields outside computer science (Selbst et al., 2019). In machine learning, algorithmic fairness is often considered with respect to a classification process. The concept of “equal opportunity” requires that people who can achieve a certain advantaged outcome, such as finishing a university degree or paying back a loan, have equal opportunity of being able to get access to it in the first place, such as getting into a university program or getting approval of a loan.

Bias can arise even at a low level within basic data structures that are used by decision-making algorithms as a black-box (see discussion in (Har-Peled and Mahabadi, 2019)). It is possible that some techniques for boosting performance, like randomization and approximation that result in non-deterministic behavior, add to the overall algorithmic bias. For instance, some database indexes for fast search might give an (unexpected) advantage to some portions of the input data.

In this paper, we will propose what fairness could mean in the setting of similarity search. Similarity search is an important primitive in many applications in computer science such as machine learning, recommender systems, and data mining. One of the most common formulations of similarity search is the $r$-near neighbor ($r$-NN) problem: for a given radius $r>0$, a distance function $\mathcal{D}(\cdot,\cdot)$ that reflects the (dis)similarity between two data points, and a set $S$ of data points, the $r$-NN problem requires to construct a data structure that, given a query point $\mathbf{q}$, returns a point $\mathbf{p}$ such that $\mathcal{D}(\mathbf{p},\mathbf{q})\leq r$, if such a point exists. As we will see, common existing data structures for similarity search have a behavior that introduces bias in the output. Our goal is to capture and algorithmically remove this bias from these data structures.

We consider fairness in the sense of equal opportunity. Our goal is to develop a data structure for the $r$-near neighbor problem where all points within distance $r$ from the given query have the same probability to be returned: if $B_{S}(\mathbf{q},r)$ is the ball of input points at distance at most $r$ from a query $\mathbf{q}$, we would like that each point in $B_{S}(\mathbf{q},r)$ is returned as near neighbor of $\mathbf{q}$ with probability $1/|B_{S}(\mathbf{q},r)|$. For all constructions presented in this paper, these guarantees hold only in the absence of a failure event that happens with probability at most $\delta$ for some small $\delta>0$. In other words, we aim at solving the following sampling problem:

Definition 0.

Consider a set $S\subseteq\mathcal{X}$ of $n$ points in a metric space $(\mathcal{X},\mathcal{D})$. The $r$-near neighbor sampling problem ($r$-NNS) asks to construct a data structure for $S$ to solve the following task with probability at least $1-\delta$: Given query $\mathbf{q}$, return a point $\mathbf{p}$ uniformly sampled from the set $B_{S}(\mathbf{q},r)$.

To see an example application for such a system, consider a recommender system used by a newspaper to recommend articles to users. Popular recommender systems based on matrix factorization (Koren et al., 2009) give recommendations by computing the inner product similarity of a user feature vector with all item feature vectors using some efficient similarity search algorithm. It is common practice to recommend those items that have the largest inner product with the user. However, in general it is not clear that it is desirable to recommend the “closest” articles. Indeed, it might be desirable to recommend articles that are on the same topic but are not too aligned with the user feature vector, and may provide a different perspective (Abiteboul et al., 2017). Knowing a solution to the $r$-NNS problem allows to make a recommendation slightly further away from the user feature vector, but still within a certain distance threshold, as likely to be returned as the closest feature vectors.

The $r$-NNS problem can also be seen as a special case of query sampling in database systems (Olken and Rotem, 1995b), where the goal is to return a random sample of the output of a given query, for efficiently providing statistics on the query. This could for example be used in discrimination discovery in existing data bases (Luong et al., 2011): by performing independent queries to obtain a sample with statistical significance, we can reason about the distribution of attribute types. We could report on discrimination if the population counts grouped by a certain attribute differ much more than we would expect them to. We will return to the implications in database systems in the related work section.

To the best of our knowledge, previous results focused on exact near neighbor sampling in the Euclidean space up to three dimensions (Afshani and Phillips, 2019; Afshani and Wei, 2017; Hu et al., 2014; Olken and Rotem, 1995b). Although these results might be extended to $\mathbb{R}^{d}$ for any $d>1$, they suffer the curse of dimensionality as the query time increases exponentially with the dimension, making the data structures too expensive in high dimensions. These bounds are unlikely to be significantly improved since several conditional lower bounds show that an exponential dependency on $d$ in query time or space is unavoidable for exact near neighbor search (see e.g., (Alman and Williams, 2015; Williams, 2005)).

A common solution to the near neigbor problem in high dimensions is provided by the locality-sensitive hashing (LSH) framework proposed by Indyk and Motwani (Indyk and Motwani, 1998). In this framework, which is formally introduced in Section 2, data points are hashed into buckets and only colliding points are inspected when answering a query. Locality-sensitive hash functions are designed in such a way that the collision probability between two points is a decreasing function of their distance (Charikar, 2002). As we will show in Section 2, the standard LSH approach is not suitable for solving the $r$-NNS problem. While the uniformity property required in $r$-NNS can be trivially achieved by finding all $r$-near neighbor of a query and then randomly selecting one of them, this is computationally inefficient since the query time is a function of the size of the neighborhood. One contribution in this paper is the description of a much more efficient data structure, that still uses LSH in a black-box way.

Observe that the definition above does not require different query results to be independent. If the query algorithm is deterministic and randomness is only used in the construction of the data structure, the returned near neighbor of a query will always be the same. Furthermore, the result of a query $\mathbf{q}$ might influence the result of a different query $\mathbf{q}^{\prime}$. This motivates us to extend the $r$-NNS problem to the scenario where we aim at independence.

Definition 0.

Consider a set $S\subseteq\mathcal{X}$ of $n$ points in a metric space $(\mathcal{X},\mathcal{D})$. The $r$-near neighbor independent sampling problem ($r$-NNIS) asks to construct a data structure for $S$ that for any sequence of up to $n$ queries $\mathbf{q}_{1},\mathbf{q}_{2},\ldots,\mathbf{q}_{n}$ satisfies the following properties with probability at least $1-\delta$:

1. (1)

For each query $\mathbf{q}_{i}$, it returns a point $\textnormal{OUT}_{i,\mathbf{q}_{i}}$ uniformly sampled from $B(\mathbf{q}_{i},r)$; 2. (2)

The point returned for query $\mathbf{q}_{i}$, with $i>1$, is independent of previous query results. That is, for any $\mathbf{p}\in B(\mathbf{q}_{i},r)$ and any sequence $\mathbf{p}_{1},\ldots,\mathbf{p}_{i-1}$, we have that

[TABLE]

We note that in the low-dimensional setting (Hu et al., 2014; Afshani and Wei, 2017; Afshani and Phillips, 2019), the $r$-near neighbor independent sampling problem is usually called independent range sampling (IRS).

1.1. Results

We propose several solutions to the $r$-NN(I)S problem under different settings. We hope that our fairness view on independent range sampling gives a new perspective to fair similarity search. On the technical side, the paper contributes the following methods:

• •

Section 3 describes a solution to the $r$-near neighbor sampling problem with running time guarantees matching those of standard LSH up to polylog factors. The data structure uses an independent permutation of the data points and inspects buckets according to the order of points under this permutation.

• •

Section 4 shows how to solve the independent sampling case. The query time still matches that of standard LSH up to poly-logarithmic factors. Each bucket is equipped with a count-sketch and the algorithm works by repeatedly sampling points within a certain window from the permutation.

• •

In Section 5 we introduce an easy-to-implement nearly-linear space data structure based on the LSH filter approach put forward in (Andoni et al., 2017a; Christiani, 2017). As each input point appears once in the data structure, the data structure can be easily adapted to solve the NNIS problem.

• •

Lastly, in Section 6 we present an empirical evaluation of (un)fairness in traditional recommendation systems on real-world datasets, and we then analyze the additional computational cost for guaranteeing fairness.

We observe that both data structures in Sections 4 and 5 solve the NNIS problem. The first data structure is distance-agnostic since it uses as a black-box a given LSH schema and can be automatically applied to any distance measure by just selecting the proper LSH schema. On the other hand, the second data structure is simpler, uses only near-linear space, but comes with a slower query time. Additionally, it does not use LSH as a black-box and works only for some distances: we describe it for similarity search under inner product, although it can be adapted to some other metrics (like Euclidean and Hamming distances) with standard techniques.

1.2. Previous work

Independent Range Sampling

The IRS problem is a variant of a more general problem known as random sampling queries, introduced in the 1980s for computing statistics from a database: given a database and a query (e.g., range, relational operator), return a random sample of the query result set. The random sample can be used for estimating aggregate queries (e.g., sum or count) or for query optimization. We refer to the survey (Olken and Rotem, 1995a) for a more detailed overview. One of the first results on range sampling is by Olken and Rotem (Olken and Rotem, 1995b), who proposed a data structure based on a R-tree for sampling points within a region described by a union of polygons. Hu et al. introduced in (Hu et al., 2014) the IRS problem, where the focus is on extracting independent random samples. The paper presents a data structure for the unweighted, dynamic version in one dimension. Later, Afshani and Wei (Afshani and Wei, 2017) proposed a data structure that solves the weighted case in one dimension, and the unweighted case in three dimensions for half-space queries. In a very recent paper, Afshani and Phillips (Afshani and Phillips, 2019) extended this line of work and provide a lower bound for the worst-case query time with nearly-linear space.

Applications of Independent Range Sampling

Since near-neighbor search in the context of recommender systems works usually on medium- to high-dimensional data sets, we see IRS as a natural primitive to introduce a concept of fairness into recommender systems. As mentioned in (Afshani and Phillips, 2019), IRS is a useful statistical tool in data analysis and has been used in the database community for many years. Instead of obtaining the set of all $r$-near neighbors, which could be a very costly operation, an analyst (or algorithm) might require only a small sample of “typical” data points sampled independently from a range to provide statistical properties of the data set. Another useful application is diversity maximization in a recommender system context. As described by Adomavicius and Kwon in (Adomavicius and Kwon, 2014), recommendations can be made more diverse by sampling $k$ items from a larger top-$\ell$ list of recommendations at random. Our data structures could replace the final near neighbor search routine employed in such systems. Finally, we observe that IRS can have applications even in the context of discrimination discovery. For instance Luong et al. (Luong et al., 2011) used $k$ nearest neighbor search for detecting significant differences of treatment among users with similar, legally admissible, characteristics. Our data structure can be used in this context for speed up the procedure by sampling a subset of points.

Concurrent Work.

Concurrently and independently of a first draft of our work111Note to the reviewer: We omit a reference to preserve anonymity., Har-Peled and Mahabadi (Har-Peled and Mahabadi, 2019) considered two variants of the fairness notion discussed in this paper:

• •

Exact neighborhood. This coincides with our fairness notion in Definition 2 except that sampling probabilities are allowed to differ by a multiplicative factor of $1+\varepsilon$.

• •

Approximate neighborhood. This relaxed notion, which allows a faster algorithm, requires sampling to be uniform over some set $S^{\prime}$ that includes all $r$-near neighbors and does not include any points that are at distance more than $cr$ from $q$, for some constant $c>1$.

From a technical point of view, the algorithm described in (Har-Peled and Mahabadi, 2019) resembles the algorithm defined in Section 5. The algorithm described there solves the exact neighboorhood version in the special case of near-linear space LSH data structures. The work of Har-Peled and Mahabadi generalizes this variant to the super-linear space regime by using approximate counting. For the exact neighborhood variant with fixed $\varepsilon>0$, their query time bound is $\tilde{O}\left(n^{\rho}\,\frac{b_{S}({\bf q},cr)}{b_{S}({\bf q},r)}\right)$. Our time bound for $\varepsilon=0$ is better: $\tilde{O}\left(n^{\rho}+\frac{b_{S}({\bf q},cr)}{b_{S}({\bf q},r)}\right)$, see Theorem 1 for details.

For the approximate neighborhood variant with fixed $\varepsilon>0$, the algorithm of (Har-Peled and Mahabadi, 2019) has query time $\tilde{O}(n^{\rho})$, which is better than our query time if $n^{\rho}\ll\frac{b_{S}({\bf q},cr)}{b_{S}({\bf q},r)}$. However, we argue that approximate neighborhood is a relatively weak notion of fairness in that it can lead to very different sampling probabilities for different elements at the same distance from ${\bf q}$. Our discussion uses notation introduced in Section 2.2, so readers who are interested in the formal details should consult that section. The fairness guarantee is weak even for the particular sets $S$ that occur in the algorithm of (Har-Peled and Mahabadi, 2019), namely sets of the form $S^{\prime}=S({\bf q},cr)\cap\left(\bigcup_{i}S_{i,\ell_{i}({\bf q})}\right)$ where $S_{i,\ell_{i}({\bf q})}$ is defined in (1). With high probability $S({\bf q},r)\subseteq S^{\prime}$, so each element at distance at most $r$ is sampled with roughly the same probability. However, for elements at distance between $r$ and $cr$ the sampling probability depends on their local neighborhoods. Consider elements $x_{1},x_{2}\in S$ that have the same distance from ${\bf q}$ and each appear in $S^{\prime}$ with probability $1/2$, while both appear in $S^{\prime}$ with probability $1/4$. Furthermore, suppose that conditioned on $x_{2}\not\in S^{\prime}$, the expected size of $S^{\prime}$ is constant. Then it is easy to see that $x_{1}$ is sampled with probability $\Omega(1)$. Moreover, suppose $x_{2}$ is part of a tight cluster of $\Omega(n)$ points from $S$ that all have the same hash value with high probability. Then conditioned on $x_{2}\in S^{\prime}$, the size of $S^{\prime}$ is $\Omega(n)$ with high probability. This means that $x_{2}$ is sampled with probability $O(1/n)$. It is not hard to confirm that the above scenario is possible for concrete LSH families and data sets. We will provide one such example in the experimental evaluation, described in Section 6.2.

Experiments in (Har-Peled and Mahabadi, 2019) consider the MNIST data set, but only report on the uniformly of samples within the set $S^{\prime}$. Thus, they do not shed light on whether sampling probabilities differ in practice because of correlations in the choice of $S^{\prime}$.

1.3. Discussion of Fairness Assumptions

In the context of our problem definition we assume—as do many papers on fairness-related topics—an implicit world-view described by Friedler et al. in (Friedler et al., 2016) as “what you see is what you get”. WYSIWYG means that a certain distance between individuals in the so-called “construct space” (the true merit of individuals) is approximately represented by the feature vectors in “observed space”. As described in their paper, one has to subscribe to this world-view to achieve certain fairness conditions. Moreover, we acknowledge that our problem definition requires to set a threshold parameter $r$ which might be internal to the dataset. This problem occurs frequently in the machine learning community, e.g., when score thresholding is applied to obtain a classification result. Kannan et al. discuss the fairness implications of such threshold approaches in (Kannan et al., 2019).

We want to stress that we do not claim that the $r$-near neighbor independent sampling problem is the fairness definition in the context of similar search. We think of it as a suitable starting point for discussion, and acknowledge that the application will often motivate the desired fairness property. For example, in the case of a recommender system, we might want to consider a weighted case where closer points are more likely to be returned. As discussed in the concurrent work section (and exemplified in the experimental evaluation), a standard LSH approach does not have such guarantees albeit its monotonic collision probability function. We leave the weighted case as an interesting direction for future work.

2. Preliminaries

2.1. Near neighbor search

Let $(\mathcal{X},\mathcal{D})$ be a high dimensional metric space over the set $\mathcal{X}$ with distance function $\mathcal{D}(\cdot,\cdot):\mathcal{X}\times\mathcal{X}\rightarrow\mathbb{R}_{\geq 0}$. As an example, we can set $\mathcal{X}=\mathbb{R}^{d}$ and let $\mathcal{D}(\cdot,\cdot)$ denote the $\ell_{p}$ norm, with $p\in\{1,2,+\infty\}$. Given a set $S\subseteq\mathcal{X}$ of $n$ points in the metric space $(\mathcal{X},\mathcal{D})$ and a radius $r>0$, the $r$-Near Neighbor ($r$-NN) problem is to construct a data structure that, for any given query point $\mathbf{q}\in\mathcal{X}$, returns a point $\mathbf{p}\in S$ such that $\mathcal{D}(\mathbf{q},\mathbf{p})\leq r$, if such a point exists. In search of efficient solutions to the $r$-NN problem, several works have targeted the approximate version, named $(c,r)$-Approximate Near Neighbor ($(c,r)$-ANN) where $c>1$ is the approximation factor: for any given query $\mathbf{q}\in\mathcal{X}$, the data structure can return a point $\mathbf{p}$ with distance $\mathcal{D}(\mathbf{q},\mathbf{p})\leq c\cdot r$. We refer to the survey (Alexandr Andoni, 2018) for an overview on techniques for approximate near neighbor search in high dimensions. We say that two points $\mathbf{p},\mathbf{q}$ are $r$-near if $\mathcal{D}(\mathbf{p},\mathbf{q})\leq r$, $(c,r)$-near if $r<\mathcal{D}(\mathbf{p},\mathbf{q})\leq c\cdot r$, and far if $\mathcal{D}(\mathbf{p},\mathbf{q})>c\cdot r$ (if $r$ is clear in the context, we will use the term near instead of $r$-near). We use $B_{S}(\mathbf{q},r)$ to denote the points in $S$ within the ball of radius $r$ and center $\mathbf{q}$ (i.e. $B_{S}(\mathbf{q},r)=\{p\in S\colon\mathcal{D}(\mathbf{p},\mathbf{q})\leq r\}$), and let $b_{S}(\mathbf{q},r)=|B_{S}(\mathbf{q},r)|$.

For the sake of notational simplicity, we assume that evaluating a distance $\mathcal{D}(\cdot,\cdot)$ or a hash function takes ${O}\left(1\right)$ time, and that each entry in $\mathcal{X}$ can be stored in ${O}\left(1\right)$ memory words. If this is not the case and a point in $\mathcal{X}$ requires $\sigma$ words and $\tau$ time for reading a point, computing $\mathcal{D}(\cdot,\cdot)$ or a hash function (with $\sigma\leq\tau)$, then it suffices to add the additive term $n\cdot\sigma$ to our space bounds (we store a point once in memory and then refer to it with constant size pointers), and multiply construction and query times by a factor $\tau$ (since the time of our algorithms is almost equivalent to the number of distance computations or hash computations). We assume the length of a memory word to be ${\Theta}\left(\log n\right)$ bits, where $n$ is the input size.

Comment. In some settings, the distance between points is described in terms of similarity rather than distance. The metric space $\mathcal{X}$ features a similarity measure $\mathcal{S}(\cdot,\cdot):\mathcal{X}\times\mathcal{X}\rightarrow\mathbb{R}_{\geq 0}$. The $r$-NN problem under the similarity measure $\mathcal{S}$ requires to construct a data structure that, for any given query point $\mathbf{q}\in\mathcal{X}$, returns a point $\mathbf{p}\in S$ such that $\mathcal{S}(\mathbf{q},\mathbf{p})\geq r$. The $(c,r)$-ANN version is defined equivalently, with $c\in(0,1)$. Some examples used in this paper are the inner product where $\mathcal{X}=\mathbb{R}^{d}$ and $\mathcal{S}(\cdot,\cdot)$ denotes the inner product, and the Jaccard similarity where $\mathcal{X}$ is the family of all subsets of $\{1,\ldots,d\}$ where $\mathcal{S}(\mathbf{q},\mathbf{p})=|\mathbf{q}\cap\mathbf{p}|/|\mathbf{q}\cup\mathbf{p}|$ .

2.2. Locality Sensitive Hashing

Locality Sensitive Hashing (LSH) is a common tool for solving the ANN problem and was introduced in (Indyk and Motwani, 1998).

Definition 0.

A distribution $\mathcal{H}$ over maps $h\colon\mathcal{X}\rightarrow U$, for a suitable set $U$, is called $(r,c\cdot r,p_{1},p_{2})$-sensitive if the following holds for any $\mathbf{x}$, $\mathbf{y}\in\mathcal{X}$:

• •

if $\mathcal{D}(\mathbf{x},\mathbf{y})\leq r$, then $\Pr_{h}[h(\mathbf{x})=h(\mathbf{y})]\geq p_{1}$;

• •

if $\mathcal{D}(\mathbf{x},\mathbf{y})>c\cdot r$, then $\Pr_{h}[h(\mathbf{x})=h(\mathbf{y})]\leq p_{2}$.

The distribution $\mathcal{H}$ is called an LSH family, and has quality $\rho=\rho(\mathcal{H})=\frac{\log p_{1}}{\log p_{2}}$.

For the sake of simplicity, we assume that $p_{2}\leq 1/n$: if $p_{2}>1/n$, then it suffices to create a new LSH family $\mathcal{H}_{K}$ obtained by concatenating $K={\Theta}\left(\log_{p_{2}}(1/n)\right)$ i.i.d. hashing functions from $\mathcal{H}$. The new family $\mathcal{H}_{K}$ is $(r,cr,p_{1}^{K},p_{2}^{K})$-sensitive and $\rho$ does not change.

The standard approach to $(c,r)$-ANN using LSH functions is the following. Let $\ell_{1},\ldots,\ell_{L}$ be $L$ functions randomly and uniformly selected from $\mathcal{H}$. The data structure consists of $L$ hash tables $H_{1},\ldots H_{L}$: each hash table $H_{i}$ contains the input set $S$ and uses the hash function $\ell_{i}$ to split the point set into buckets. For each query $\mathbf{q}$, we iterate over the $L$ hash tables: for any hash function, compute $\ell_{i}(\mathbf{q})$ and compute, using $H_{i}$, the set

[TABLE]

of points in $S$ with the same hash value; then, compute the distance $\mathcal{D}(\mathbf{q},\mathbf{p})$ for each point $\mathbf{p}\in S_{i,\ell_{i}(\mathbf{q})}$. The procedure stops as soon as a $(c,r)$-near point is found. It stops and returns $\perp$ if there are no remaining points to check or if it found more than $3L$ far points (Indyk and Motwani, 1998). By setting $L={\Theta}\left(p_{1}^{-1}\log n\right)$, the above data structure returns, with probability at least $1-1/n$, a $(c,r)$-near point of $\mathbf{q}$ in time ${O}\left(L\right)={O}\left(n^{\rho}\log n\right)$ and space ${O}\left(Ln\right)={O}\left(n^{1+\rho}\log n\right)$, assuming that the hash function can be computed in ${O}\left(1\right)$ time and each hash value requires ${O}\left(1\right)$ space. By avoiding stopping after $3L$ far points have been found, the above data structure can be adapted to return a $r$-near point of $\mathbf{q}$ in expected time ${O}\left(n^{\rho}\log n+b_{S}(\mathbf{q},cr)\right)$.

Standard LSH families do not satisfy the fairness definitions introduced above. Consider the simple case with the data set $S=\{\mathbf{x},\mathbf{y}\}$ and where $\mathcal{D}(\mathbf{x},\mathbf{y})=r$ and query $\mathbf{q}=\mathbf{x}$: with a standard LSH approach, we have that $\mathbf{q}$ collides with $\mathbf{x}$ with probability 1, while $\mathbf{q}$ collides with $\mathbf{y}$ only once in expectation; therefore, it is likely that the first near point of $\mathbf{q}$ found by the data structure is $\mathbf{x}$. This is true even if the order in which the $L=\tilde{O}\left(p_{1}^{-1}\right)$ hash tables are visited is randomized. However, if performance is not sought, the standard LSH method can be easily adapted to randomly return a point in $B_{S}(q,r)$: it suffices to find all near neighbors of $\mathbf{q}$ and to randomly select one of them. However, this approach could require expected time $\tilde{O}\left(b_{S}(\mathbf{q},r)n^{\rho}+b_{S}(\mathbf{q},cr)\right)$.

2.3. Sketch for distinct elements

In Section 4 we will use sketches for estimating the number of distinct elements. Consider a stream of $n$ elements $x_{1},\ldots x_{m}$ in the domain $[n]=\{1,\ldots,n\}$ and let $F_{0}$ be the number of distinct elements in the stream (i.e., the zeroth-frequency moment). Several papers have studied sketches (i.e., compact data structures) for estimating $F_{0}$. For the sake of simplicity we use the simple sketch in (Bar-Yossef et al., 2002), which generalizes the seminal result by Flajolet and Martin (Flajolet and Martin, 1985). The data structure consists of $\Delta={\Theta}\left(\log(1/\delta)\right)$ lists $L_{1},\ldots L_{\Delta}$; for $1\leq w\leq\Delta$, $L_{w}$ contains the $t={\Theta}\left(1/\epsilon^{2}\right)$ distinct smallest values of the set $\{\psi_{w}(x_{i}):1\leq i\leq m\}$, where $\psi_{w}:[n]\rightarrow[n^{3}]$ is a hash function picked from a pairwise independent family. It is shown in (Bar-Yossef et al., 2002) that the median $\hat{F}_{0}$ of the values $tn^{3}/v_{0},\ldots,tn^{3}/v_{\Delta}$, where $v_{w}$ denotes the $t$-th smallest value in $L_{w}$, is an $\epsilon$-approximation to the number of distinct elements in the stream with probability at least $1-\delta$: that is, $(1-\epsilon)F_{0}\leq\hat{F}_{0}\leq(1+\epsilon)F_{0}$. The data structure requires ${O}\left(\epsilon^{-2}\log m\log(1/\delta)\right)$ bits and ${O}\left(\log(1/\epsilon)\log m\log(1/\delta)\right)$ query time. A nice property of this sketch is that if we split the stream in $k$ segments and we compute the sketch of each segment, then it is possible to reconstruct the sketch of the entire stream by combining the sketches of individual segments (the cost is linear in the sketch size).

3. $r$-near neighbor sampling

We start with a simple data structure for the $r$-near neighbor sampling problem in high dimensions that leverages on LSH: with high probability, for each given query $\mathbf{q}$, the data structure returns a point uniformly sampled in $B_{S}(\mathbf{q},r)$. We will then see that, with a small change in the query procedure, the data structure supports independent sampling when the same query point is repeated.

The main idea is quite simple. We initially assign a (random) rank to each point in $S$ using a random permutation, and then construct the standard LSH data structure for solving the $r$-NN problem on $S$. For a given query $\mathbf{q}$ and assuming that all points in $B_{S}(\mathbf{q},r)$ collide with $\mathbf{q}$ at least once, the data structure returns the point in $B_{S}(\mathbf{q},r)$ with the lowest rank in the random permutation. The random permutation, which is independent of the collision probability, guarantees that all points in $B_{S}(\mathbf{q},r)$ have the same probability to be returned as near point.

Construction.

Let $\mathcal{H}$ be an $(r,c\cdot r,p_{1},p_{2})$-sensitive LSH family with $p_{2}={O}\left(1/n\right)$ (see Section 2.2). Let $\ell_{1},\ldots,\ell_{L}$ be $L={\Theta}\left(p_{1}^{-1}\log n\right)$ hash functions selected independently and uniformly at random from $\mathcal{H}$. The $n$ points in $S$ are randomly permuted (possibly, with an universal hash family over maps $\mathcal{X}\rightarrow[n^{3}]$) and let $r(\mathbf{p})$ denote the rank of point $\mathbf{p}\in S$ after the permutation. For each $\ell_{i}$, we partition the input points $S$ according to the hash values of $\ell_{i}$ and denote with $S_{i,j}=\{\mathbf{p}:\mathbf{p}\in S,\ell_{i}(\mathbf{p})=j\}$ the set of points with hash value $j$ under $\ell_{i}$. We store points in each $S_{i,j}$ sorted by increasing ranks.

Query.

Let $\mathbf{q}$ be the query point. The query procedure extracts from the set $S_{\mathbf{q}}=\bigcup_{i=1}^{L}S_{i,\ell_{i}(\mathbf{q})}$ (i.e., points colliding with $\mathbf{q}$ under the $L$ hash functions) the $r$-near point of $q$ with lowest rank. This is done as follows. Initialize $r_{\text{min}}=+\infty$ and $\mathbf{x}_{\text{min}}=\perp$, where $\perp$ denotes a special symbol meaning ”no near neighbor”. For each $i$ in $\{1,\ldots L\}$, scan $S_{i,j}$ until an $r$-near point $\mathbf{x}_{i}$ is found or the end of the array is reached: in the first case and if $r_{\text{min}}>r(\mathbf{x}_{i})$, we set $r_{\text{min}}=r(\mathbf{x}_{i})$ and $\mathbf{x}_{\text{min}}=\mathbf{x}_{i}$ (we note that $\mathbf{x}_{i}$ is the $r$-near point in $S_{i,j}$ with lowest rank). After scanning the $L$ buckets, we return $\mathbf{x}_{\text{min}}$.

Theorem 1.

With high probability $1-1/n$, the above data structure solves the $r$-NNS problem: given a query $\mathbf{q}$, each point $\mathbf{p}\in B_{S}(\mathbf{q},r)$ is returned as near neighbor of $\mathbf{q}$ with probability $1/b_{S}(\mathbf{q},r)$. The data structure requires ${\Theta}\left(n^{1+\rho}\log n\right)$ words, ${\Theta}\left(n^{1+\rho}\log n\right)$ construction time, and the expected query time is

[TABLE]

Proof.

Since $L={\Theta}\left(p_{1}^{-1}\log n\right)$, all points in $B_{S}(\mathbf{q},r)$ collide with $\mathbf{q}$ at least once (i.e., $B_{S}(\mathbf{q},r)\subseteq\bigcup_{i=1}^{L}S_{i,\ell_{i}(\mathbf{q})}$) with probability at least $1-1/n$. The initial random permutation guarantees that each point in $B_{S}(\mathbf{q},r)$ has probability $1/b_{S}(\mathbf{q},r)$ to have the smallest rank in $B_{S}(\mathbf{q},r)$, and hence to be returned as output.

The space complexity and construction time follow since the algorithm builds and stores $L$ tables with $n$ references to points in $S$. To upper bound the expected query time, we introduce the random variable $X_{\mathbf{p},i}$ for each point $\mathbf{p}$ with $\mathcal{D}(\mathbf{p},\mathbf{q})>r$: $X_{\mathbf{p},i}$ takes value 1 if $\mathbf{p}$ collides with $\mathbf{q}$ under $\ell_{i}$ and if it has a rank smaller than all points in $B_{S}(\mathbf{q},r)$; $X_{\mathbf{p},i}$ is 0 otherwise. Points $\mathbf{p}$ and $\mathbf{q}$ collide with probability $\textnormal{Pr}\left[\ell_{i}(\mathbf{q})=\ell_{i}(\mathbf{p})\right]$ and $\mathbf{p}$ has rank smaller than points in $B_{S}(\mathbf{q},r)$ with probability $1/(b_{S}(\mathbf{q},r)+1)$; thus we have that $\textnormal{E}\left[X_{\mathbf{p},i}\right]=\textnormal{Pr}\left[\ell_{i}(\mathbf{q})=\ell_{i}(\mathbf{p})\right]/(b_{S}(\mathbf{q},r)+1)$ (note that the random bits used for LSH construction and for the initial permutation are independent). Let $\mu$ be the number of points inspected by the query algorithm over all repetitions. By linearity of expectation, we get:

[TABLE]

since $p_{2}={O}\left(1/n\right)$. ∎

We observe that our data structure for $r$-NNS automatically gives a data structure for $r$-NN that improves the standard LSH approach: the standard approach incurs a $\tilde{O}\left(n^{\rho}+b_{S}(\mathbf{q},cr)\right)$ expected query time for worst-case data sets, while our data structure is never worse than $\tilde{O}\left(n^{\rho}+b_{S}(\mathbf{q},cr)/(b_{S}(\mathbf{q},r)+1)\right)$ in expectation. This is consequence of the initial random permutation that breaks long chains of consecutive $(c,r)$-near points. We remark that all of our methods have an additional running time term that scales with $b(\mathbf{q},cr)/b(\mathbf{q},r)$. This makes running time data-dependent in the following sense: If $c$ is increased (by the user), the $\rho$-value of the LSH will decrease (decreasing the running time), but we pay for it with a possible increase in $b(\mathbf{q},cr)/b(\mathbf{q},r)$. However, we will see in Section 6.3 that this ratio is small in some real-world datasets.

3.1. Sampling points with/without replacement

The data structure for $r$-NNS can be easily adapted to return $k$ points uniformly sampled without replacement from $B_{S}(\mathbf{q},r)$: by assuming for well-definedness that $k\leq b_{S}(\mathbf{q},r)$, it suffices to return the $k$ points at distance at most $r$ in $S_{\mathbf{q}}$ with the smallest ranks. On the other hand, a set of $k$ points uniformly sampled with replacement from $B_{S}(\mathbf{q},r)$ can be obtained by slightly changing the above data structure for NNS: we repeat $k$ times the query $\mathbf{q}$, but after each query we perform a random perturbation of ranks. Details of this approach are presented in Appendix A in the supplemental material. The data structure will sample independently a point in $B_{S}(\mathbf{q},r)$ at every repetition of the same query $\mathbf{q}$. Unfortunately, performing a random perturbation of ranks in the NNS data structure does not guarantee independence among different query points, and thus does not solve the NNIS problem. In the following section we extend the data structure in such a way that it guarantees independence.

4. $r$-near neighbor independent sampling

In this section, we present a data structure that solves the $r$-NNIS problem with high probability. Let $S$ be the input set of $n$ points and let $\Lambda$ be the sequence of the $n$ input points after a random permutation; the rank of a point in $S$ is its position in $\Lambda$. We first highlight the main idea of the query procedure, then we describe its technical limitations and how to solve them.

Let $k\geq 1$ be a suitable value that depends on the query point $\mathbf{q}$, and assume that $\Lambda$ is split into $k$ segments $\Lambda_{i}$, with $i\in\{0,\ldots,k-1\}$. (We assume for simplicity that $n$ and $k$ are powers of two.) Each segment $\Lambda_{i}$ contains the $n/k$ points in $\Lambda$ with rank in $[i\cdot n/k,(i+1)\cdot n/k)$ We denote with $\lambda_{\mathbf{q},i}$ the number of near neighbors of $\mathbf{q}$ in $\Lambda_{i}$, and with $\lambda\geq\max_{i}\{\lambda_{\mathbf{q},i}\}$ an upper bound on the number of near neighbors of $\mathbf{q}$ in each segment. By the initial random permutation, we have that each segment contains at most $\lambda={\Theta}\left((b_{S}(\mathbf{q},r)/k)\log n\right)$ near neighbors with probability at least $1-1/n^{2}$. The query algorithm works in three steps: A) Select uniformly at random an integer $h$ in $\{0,\ldots,k-1\}$ (i.e., select a segment $\Lambda_{h}$); B) With probability $\lambda_{\mathbf{q},h}/\lambda$ move to step C, otherwise repeat step A; C) Return a point uniformly sampled among the near neighbors of $q$ in $\Lambda_{h}$. All random choices are independent.

The above procedure guarantees that the returned near neighbor point is uniformly sampled in $B_{S}(\mathbf{q},r)$. Indeed, a point $\mathbf{p}\in B_{S}(\mathbf{q},r)$ in segment $\Lambda_{h}$ is sampled and returned at step C with probability $\textnormal{Pr}\left[OUT=\mathbf{p}\right]=\sum_{j=1}^{+\infty}p_{j}$, where $p_{j}$ is the probability of returning $\mathbf{p}$ at the $j$-th iteration (i.e., after repeating $j$ times step A). We have:

[TABLE]

The term with exponent $j-1$ is the probability that step A is repeated $j-1$ times; the second term is the probability of selecting segment $\Lambda_{h}$ during the $j$-th iteration and then to move to step C; the third term is the probability of returning point $\mathbf{p}$ in step C. Then:

[TABLE]

As all random choices are taken independently at query time, the solution guarantees the independence among output points required by Definition 2.

The above approach however cannot be efficiently implemented. The first problem is that each segment might contain a large number of points with distance larger than $r$: these points are not used by the query algorithm, but still affect the running time as the entire segment must be read to find all near neighbors. We solve this problem by filtering out far points with LSH: at query time, we use LSH to retrieve only the near neighbors (and a small number of $(c,r)$-near and far points) that are in the selected segment. A second issue is due to segment size: to improve performance, segments should be small and contain at least one near neighbor of $\mathbf{q}$; thus, the number $k$ of segments should be set to $b_{S}(\mathbf{q},r)$. However, $b_{S}(\mathbf{q},r)$ is not known at query time. Hence, we initially set $k=2\hat{s_{\mathbf{q}}}$, where $\hat{s_{\mathbf{q}}}$ is a $1/2$-approximation of the number $s_{\mathbf{q}}$ of points colliding with $\mathbf{q}$; such an estimate can be computed with the count distinct sketch from Section 2. As $\hat{s_{\mathbf{q}}}$ can be much larger than $b_{S}(\mathbf{q},r)$, we expect to sample several segments without near neighbors: thus, for every $\Sigma={\Theta}\left(\log^{2}n\right)$ sampled segments with no near neighbors of $\mathbf{q}$, we repeat the procedure with a smaller value of $k$ (i.e., we set $k=k/2$). We are now ready to fully describe our data structure.

Construction

Let $\ell_{1},\ldots,\ell_{L}$ be $L={\Theta}\left(p_{1}^{-1}\log n\right)$ hash functions selected independently and uniformly at random from an $(r,cr,p_{1},p_{2})$-sensitive LSH family $\mathcal{H}$, with $p_{2}={O}\left(1/n\right)$. Let $r(\mathbf{p})$ be the rank of point $\mathbf{p}\in S$ after a random permutation of the $n$ data points. For each $\ell_{i}$, we partition the input points $S$ according to the hash values of $\ell_{i}$ and denote with $S_{i,j}=\{\mathbf{p}:\mathbf{p}\in S,\ell_{i}(\mathbf{p})=j\}$ the set of points with hash value $j$ under $\ell_{i}$. We associate to each non-empty bucket $S_{i,j}$: 1) an index (e.g., a balance binary tree) for efficiently retrieving all points in $S_{i,j}$ with ranks in a given range; 2) a count distinct sketch of $S_{i,j}$ (see Section 2.3) with $\epsilon=1/2$ and $\delta=1/(6n^{2})$. (For buckets containing less that ${\Theta}\left(\log n\right)$ points of $S$, we do not store a count distinct sketch since it requires more space than the points; we generate the sketch from $S_{i,j}$ every time it is required.) We observe that any segment $\Lambda_{i}$ can be constructed by collecting all points in every $S_{{i^{\prime}},j}$ with ranks in $[i\cdot n/k,(i+1)\cdot n/k)$.

Query

Consider a query $\mathbf{q}$ and let $S_{\mathbf{q}}=\bigcup_{i=1}^{L}S_{i,\ell_{i}(\mathbf{q})}$ and $S_{\mathbf{q},r}=S_{\mathbf{q}}\cap B(\mathbf{q},r)$. A $1/2$-approximation $\hat{s_{\mathbf{q}}}$ of $s_{\mathbf{q}}=|S_{\mathbf{q}}|$ follows by merging the count distinct sketches associated with buckets $S_{i,\ell_{i}(\mathbf{q})}$ for each $i\in\{1,\ldots,L\}$. We note that $s_{\mathbf{q},r}=|S_{\mathbf{q},r}|$ cannot be estimated with sketches since they cannot distinguish near and far points. The query algorithm is the following (for simplicity, we assume $n$ to be a power of two):

1. (1)

Merge all count distinct sketches of buckets $S_{i,\ell_{i}(\mathbf{q})}$, for each $i\in\{1,\ldots,L\}$, and compute a $1/2$-approximation $\hat{s_{\mathbf{q}}}$ of $s_{\mathbf{q}}$, such that $s_{\mathbf{q}}/2\leq\hat{s_{\mathbf{q}}}\leq 1.5s_{\mathbf{q}}$. 2. (2)

Set $k$ to the smallest power of two larger than or equal to $2\hat{s_{\mathbf{q}}}$; let $\lambda={\Theta}\left(\log n\right)$, $\sigma_{\textnormal{fail}}=0$ and $\Sigma={\Theta}\left(\log^{2}n\right)$. 3. (3)

Repeat the following steps until successful or $k<2$:

1. (a)

Assume the input sequence $\Lambda$ to be split into $k$ segments $\Lambda_{i}$ of size $n/k$, where $\Lambda_{i}$ contains the points in $S$ with ranks in $[i\cdot n/k,(i+1)\cdot n/k)$. 2. (b)

Randomly select an index $h$ uniformly at random from $\{0,\ldots,k-1\}$. Using the index in each bucket, retrieve the set $\Lambda^{\prime}_{\mathbf{q},h}=S_{\mathbf{q},r}\cap\Lambda_{h}$, that is all points with rank in $[h\cdot n/k,(h+1)\cdot n/k)$ and with distance at most $r$ from $\mathbf{q}$. Set $\lambda_{\mathbf{q},h}=|\Lambda^{\prime}_{\mathbf{q},h}|$. 3. (c)

Increment $\sigma_{\textnormal{fail}}$. If $\sigma_{\textnormal{fail}}=\Sigma$, then set $k=k/2$ and $\sigma_{\textnormal{fail}}=0$. 4. (d)

With probability $\lambda_{\mathbf{q},h}/\lambda$, declare success. 4. (4)

If the previous loop ended with success, return a near neighbor of $\mathbf{q}$ sampled uniformly at random in $\Lambda^{\prime}_{\mathbf{q},h}$; otherwise return $\perp$.

Theorem 1.

With probability at least $1-1/n$, the above data structure solves the $r$-near neighbor independent sampling problem. The data structure requires ${\Theta}\left(n^{1+\rho}\log n\right)$ words, ${O}\left(n^{1+\rho}\log^{2}n\right)$ construction time, and the expected query time is:

[TABLE]

Proof.

Let $\mathbf{q}$ be a query and assume that $b_{S}(\mathbf{q},r)\geq 1$. We start by bounding the initial failure probability of the data structure. By a union bound, we have that the following three events hold simultaneously with probability at least $1-1/(2n^{2})$:

1. (1)

All near neighbors in $B_{S}(\mathbf{q},r)$ collide with $\mathbf{q}$ under at least one LSH function. By suitably setting the constant in $L={\Theta}\left(p_{1}^{-1}\log n\right)$, the claim holds with probability at least $1-1/(6n^{2})$. 2. (2)

Count distinct sketches provide a $1/2$-approximation of $s_{\mathbf{q}}$. By setting $\delta=1/(6n^{2})$ in the count distinct sketch construction (see Section 2.3), the approximation guarantee holds with probability at least $1-1/(6n^{2})$. 3. (3)

When $k=2^{\lceil\log s_{\mathbf{q},r}\rceil}$, every segment of size $n/k$ contains no more than $\lambda={\Theta}\left(\log n\right)$ points from $S_{\mathbf{q},r}$. As points are initially randomly permuted, the claim holds with probability at least $1-1/(6n^{2})$ by suitably setting the constant in $\lambda={\Theta}\left(\log n\right)$.

From now on assume that these events are true. We proceed to show that, with probability at least $1-1/(2n^{2})$, the algorithm returns a point uniformly sampled in $B_{S}(\mathbf{q},r)$. In other words, for $\mathbf{p}\in B_{S}(\mathbf{q},r)$, we show that $\textnormal{Pr}\left[OUT=\mathbf{p}\right]=1/b_{S}(\mathbf{q},r)$.

Let us first discuss the additional failure event. There exists a non-zero probability that the algorithm returns $\perp$ even when $b_{S}(\mathbf{q},r)\geq 1$: the probability of this event is upper bounded by the probability $p^{\prime}$ that a near neighbor is not returned in the $\Sigma$ iteration where $k=2^{\lceil\log s_{\mathbf{q},r}\rceil}$ (the actual probability is even lower, since a near neighbor can be returned in an iteration where $k>2^{\lceil\log s_{\mathbf{q},r}\rceil}$). By suitably setting constants in $\lambda={\Theta}\left(\log n\right)$ and $\Sigma={\Theta}\left(\log^{2}n\right)$, we get:

[TABLE]

This shows that with probability at least $1-1/n^{2}$, the initial three events hold and the algorithm returns a near neighbor. As each point in $B_{S}(\mathbf{q},r)$ has the same probability $1/(k\lambda)$ to be returned during an iteration of step 3, we have that all points in $B_{S}(\mathbf{q},r)$ are equally likely to be sampled. By applying a union bound, we have that the claim also holds with probability at least $1-1/n$ for any sequence of $n$ queries. Moreover, as soon as the aforementioned events 1,2 and 3 hold, the output probabilities are not affected by the random choices used for generating the initial permutation, LSH construction and count distinct sketches. Our data structure then solves the $r$-NNIS problem.

We now focus on the space and time complexity of the data structure. For each bucket $S_{i,j}$, we use ${O}\left(|S_{i,j}|\right)$ memory words for storing the index and the count distinct sketch. Therefore, the space complexity of our data structure is dominated by the $L$ LSH tables, that is ${\Theta}\left(n^{1+\rho}\log n\right)$ memory words. The construction time is ${\Theta}\left(n^{1+\rho}\log^{2}n\right)$, where the additional multiplicative $\log n$ factor is due to sketch construction.

The expected query time can be upper bounded by assuming that the algorithm returns a point in $B_{S}(\mathbf{q},r)$ only when $k$ is equal to the smallest power of two larger than $b_{S}(\mathbf{q},r)$ (i.e., $k=2^{\lceil\log s_{\mathbf{q},r}\rceil}$). The cost of each iteration of step 3 is dominated by step 3.b, where the set $\Lambda^{\prime}_{\mathbf{q},h}$ is constructed: the set is obtained by first extracting all points with rank in $[hn/k,(h+1)n/k)$ from buckets $S_{i,\ell_{i}(\mathbf{q})}$, for each $i\in\{1,\ldots,L\}$, and then by discarding those points with distance larger than $r$ from $\mathbf{q}$. For each bucket, we expect to find $b_{S}(\mathbf{q},r)/k={O}\left(1\right)$ near neighbors of $\mathbf{q}$, $b_{S}(\mathbf{q},c\cdot r)p_{1}/k={O}\left(b_{S}(\mathbf{q},c\cdot r)p_{1}/b_{S}(\mathbf{q},r)\right)$ $(c,r)$-near neighbors, and not more than $np_{2}={O}\left(1\right)$ far points. Since there are $L={\Theta}\left(p_{1}^{-1}\log n\right)$ buckets and the rank query for reporting points within a given rank costs ${O}\left(\log n+o\right)$ in each bucket (where $o$ is the output size), the cost of each iteration of step 3 is ${O}\left(\left(n^{\rho}+b_{S}(\mathbf{q},c\cdot r)/b_{S}(\mathbf{q},r)\right)\log^{2}n\right)$. This bound extends to all $k>2^{\lceil\log s_{\mathbf{q},r}\rceil}$, since the denominator in the calculations is only larger in this case. When $k\sim b_{S}(\mathbf{q},r)$, we expect ${O}\left(\log n\right)$ iterations of step 3 before returning a near neighbor of $\mathbf{q}$ (recall that step 3.d is successful with probability ${O}\left(1/\log n\right)$).

Finally, we bound the cost of all iterations where $k>2^{\lceil\log s_{\mathbf{q},r}\rceil}$. Since $\hat{s_{\mathbf{q}}}\leq 2n$, we observe that the $k$ value is adapted $O(\log n)$ times in step 3.d. For each fixed value of $k$, ${O}\left(\log^{2}n\right)$ iterations of step 3 are carried out. These factors yield the claimed bound on the expected running time. The case $b_{S}(\mathbf{q},r)=0$ is similar to $b_{S}(\mathbf{q},r)=1$ with the algorithm returning $\perp$ after the last iteration. ∎

5. Independent sampling in nearly-linear space

In this section we study another approach to obtain a data structure for the $r$-NNIS problem. The method uses nearly-linear space by storing each data point exactly once in each of $\Theta(\log n)$ independent data structures. The presented approach is simpler than the solution found in the previous section since it avoids any additional data structure on top of the basic filtering approach described in (Christiani, 2017). It can be seen as a particular instantiation of the more general space-time trade-off data structures that were recently described in (Andoni et al., 2017b; Christiani, 2017). It can also be seen as a variant of the empirical approach discussed in (Eshghi and Rajaram, 2008) with a theoretical analysis. Compared to (Andoni et al., 2017b; Christiani, 2017), it provides much easier parameterization and a simpler way to make it efficient. We provide here a succinct description of the data structure. All proofs can be found in Appendix B in the supplemental material.

In this section it will be easier to state bounds on the running time with respect to inner product similarity on unit length vectors in $\mathbb{R}^{d}$. We define the $(\alpha,\beta)$-NN problem analogously to $(c,r)$-NN, replacing the distance thresholds $r$ and $cr$ with $\alpha$ and $\beta$ such that $-1<\beta<\alpha<1$. This means that the algorithm guarantees that if there exists a point $\mathbf{p}$ with inner product at least $\alpha$ with the query point, the data structure returns a point $\mathbf{p}^{\ast}$ with inner product at least $\beta$ with constant probability. The reader is reminded that for unit length vectors we have the relation $\left\lVert\mathbf{p}-\mathbf{q}\right\rVert^{2}_{2}=2-2\langle{\mathbf{p}},{\mathbf{q}}\rangle$. We will use the notation $B_{S}(\mathbf{q},\alpha)=\{\mathbf{p}\in S\mid\langle{\mathbf{p}},{\mathbf{q}}\rangle\geq\alpha\}$ and $b_{S}(\mathbf{q},\alpha)=|B_{S}(\mathbf{q},\alpha)|$. We define the $\alpha$-NNIS problem analogously to $r$-NNIS with respect to inner product similarity.

5.1. Description of the data structure

Construction

Given $m\geq 1$ and $\alpha<1$, let $t=\lceil 1/(1-\alpha^{2})\rceil$ and assume that $m^{1/t}$ is an integer. First, choose $tm^{1/t}$ random vectors $\mathbf{a}_{i,j}$, for $i\in[t],j\in[m^{1/t}]$, where each $\mathbf{a}_{i,j}=(a_{1},\ldots,a_{d})\sim\mathcal{N}(0,1)^{d}$ is a vector of $d$ independent and identically distributed standard normal Gaussians.222As tradition in the literature, we assume that a memory word suffices for reaching the desired precision. See (Charikar, 2002) for a discussion. Next, consider a point $\mathbf{p}\in S$. For $i\in[t]$, let $j_{i}$ denote the index maximizing $\langle{\mathbf{p}},{\mathbf{a}_{i,j_{i}}}\rangle$. Then we map the index of $\mathbf{p}$ in $S$ to the bucket $(j_{1},\ldots,j_{t})\in[m^{1/t}]^{t}$, and use a hash table to keep track of all non-empty buckets. Since a reference to each data point in $S$ is stored exactly once, the space usage can be bounded by $O(n+tm^{1/t})$.

Query

Given the query point $\mathbf{q}$, evaluate the dot products with all $tm^{1/t}$ vectors $\mathbf{a}_{i,j}$. For $\varepsilon\in(0,1)$, let $f(\alpha,\varepsilon)=\sqrt{2(1-\alpha^{2})\ln(1/\varepsilon)}$. For $i\in[t]$, let $\Delta_{\mathbf{q},i}$ be the value of the largest inner product of $\mathbf{q}$ with the vectors $\mathbf{a}_{i,j}$ for $j\in[m^{1/t}]$. Furthermore, let $\mathcal{I}_{i}=\{j\mid\langle{\mathbf{a}_{i,j}},{\mathbf{q}}\rangle\geq\alpha\Delta_{\mathbf{q},i}-f(\alpha,\varepsilon)\}$. The query algorithm checks the points in all buckets $(i_{1},\ldots,i_{t})\in\mathcal{I}_{1}\times\dots\times\mathcal{I}_{t}$, one bucket after the other. If a bucket contains a close point, return it, otherwise return $\perp$.

Theorem 1.

Let $S\subseteq\mathcal{X}$ with $|S|=n$, $-1<\beta<\alpha<1$, and let $\varepsilon>0$ be a constant. Let $\rho=\frac{(1-\alpha^{2})(1-\beta^{2})}{(1-\alpha\beta)^{2}}$. There exists $m=m(\alpha,\beta,n)$ such that the data structure described above solves the $(\alpha,\beta)$-NN problem with probability at least $1-\varepsilon$ in linear space and expected time $n^{\rho+o(1)}$.

We remark that this result is equivalent to running time statements found in (Christiani, 2017) for the linear space regime, but the method is considerably simpler. The analysis connects storing data points in the list associated with the largest inner product with well-known bounds on the order statistics of a collection of standard normal variables as discussed in (David and Nagaraja, 2004).

5.2. Solving $\alpha$-NNIS

Construction

Set $L=\Theta(\log n)$ and build $L$ independent data structures $\text{DS}_{1},\ldots,\text{DS}_{L}$ as described above. For each $p\in S$, store a reference from $p$ to the $L$ buckets it is stored in.

Query

For query $\mathbf{q}$, evaluate all $tm^{1/t}$ filters in each individual DSℓ. Let $\mathcal{I}$ be the set of buckets $(i_{\ell,1},\ldots,i_{\ell,t})$ above the query threshold, for each $\ell\in[L]$, and set $T=|\mathcal{I}|$. Enumerate the buckets from 1 to $T$ in a random order over all repetitions. Let $k_{i}$ be the number of data points in bucket $i\in[T]$, and set $K=\sum k_{i}$. First, check for the existence of a near neighbor by running the standard query algorithm described above on every individual data structure. This takes expected time $n^{\rho+o(1)}+O\left(\frac{b_{S}(\mathbf{q},\beta)}{b_{S}(\mathbf{q},\alpha)+1}\log n\right)$, assuming points in a bucket appear in random order. If no near neighbor exists, output $\perp$ and return. Otherwise, perform the following steps until success is declared:

1. (A)

Choose a random integer $i$ in $\{1,\ldots,T\}$, where the probability of choosing $i$ equals $k_{i}/K$. 2. (B)

Choose a random point $\mathbf{p}$ from bucket $i$ uniformly at random. Using the $L$ references of $\mathbf{p}$ to its buckets, compute $c_{\mathbf{p}}$, $0\leq c_{\mathbf{p}}\leq L$, the number of times $\mathbf{p}$ occurs in the $T$ buckets, in time $O(L)$. 3. (C)

If $\mathbf{p}$ is a near neighbor, report $\mathbf{p}$ and declare success with probability $1/c_{\mathbf{p}}$. 4. (D)

If $\mathbf{p}$ is a far point, remove $\mathbf{p}$ from the bucket and decrement $k_{i}$ and $K$.

After a point $\mathbf{p}$ has been reported, move all far points removed during the process into their bucket again. We assume that removing and inserting a point takes constant time in expectation.

Theorem 2.

Let $S\subseteq\mathcal{X}$ with $|S|=n$ and $-1<\beta<\alpha<1$. The data structure described above solves the $\alpha$-NNIS problem in nearly-linear space and expected time $n^{\rho+o(1)}+O((b_{S}(\mathbf{q},\beta)/(b_{S}(\mathbf{q},\alpha)+1))\log^{2}n)$.

Proof.

Set $L=\Theta(\log n)$ such that with probability at least $1-1/n^{2}$, all points in $B_{S}(\mathbf{q},\alpha)$ are found in the $T$ buckets. Let $\mathbf{p}$ be an arbitrary point in $B_{S}(\mathbf{q},\alpha)$. We show that $\mathbf{p}$ is returned by the query algorithm with probability $1/b_{S}(\mathbf{q},\alpha)$. This statement follows by the more general observation that the point $\mathbf{p}$ picked in step B is a weighted uniform point among all points present in the buckets after $i$ iterations of the algorithm. That means that if there are $K^{\prime}$ points in the buckets, the probability of choosing $\mathbf{p}$ is $c_{\mathbf{p}}/K^{\prime}$. If $\mathbf{p}$ resides in bucket $i$, the probability of reporting $\mathbf{p}$ is $k_{i}/K^{\prime}\cdot 1/k_{i}\cdot 1/c_{\mathbf{p}}=1/(K^{\prime}c_{\mathbf{p}})$. Since $\mathbf{p}$ is stored in $c_{\mathbf{p}}$ different buckets, the probability of reporting $\mathbf{p}$ is $1/K^{\prime}$. Since this property holds in each round, each near neighbor has equal chance of being reported by the algorithm.

We proceed to proving the running time statement in the case that there exists a point in $B_{S}(\mathbf{q},\alpha)$. (See the discussion above for the case $b_{S}(\mathbf{q},\alpha)=0$.) Observe that evaluating all filters, checking for the existence of a near neighbor, removing far points, and putting far points back into the buckets contributes $n^{\rho+o(1)}$ to the expected running time (see Appendix B in the supplemental material for details). We did not account for repeatedly carrying out steps A–C yet for rounds in which we choose a non-far point. To this end, we next find a lower bound on the probability that the algorithm declares success in a single such round. First, observe that there are $O(b_{S}(\mathbf{q},\beta)\log n)$ non-far points in the $T$ buckets (with repetitions). Fix a point $\mathbf{p}\in B_{S}(\mathbf{q},\alpha)$. With probability $\Omega(c_{\mathbf{p}}/(b_{S}(\mathbf{q},\beta)\log n))$, $\mathbf{p}$ is chosen in step B. Thus, with probability $\Omega(1/(b_{S}(\mathbf{q},\beta)\log n))$, success is declared for point $\mathbf{p}$. Summing up probabilities over all points in $B_{S}(\mathbf{q},\alpha)$, we find that the probability of declaring success in a single round is $\Omega(b_{S}(\mathbf{q},\alpha)/(b_{S}(\mathbf{q},\beta)\log n))$. This means that we expect $O(b_{S}(\mathbf{q},\beta)\log n/b_{S}(\mathbf{q},\alpha))$ rounds until the algorithm declares success. Each round takes time $O(\log n)$ for computing $c_{\mathbf{p}}$ (which can be done by marking all buckets that are enumerated), so we expect to spend time $O((b_{S}(\mathbf{q},\beta)/b_{S}(\mathbf{q},\alpha))\log^{2}n)$ for these iterations, which concludes the proof. ∎

6. Experimental Evaluation

This section presents a principled experimental evaluation that sheds light on the general fairness implications of our problem definitions. The evaluation contains both a validation of the (un)fairness of traditional approaches in a recommendation setting on real-world datasets, an empirical study of unfairness in approximate approaches (such as presented in (Har-Peled and Mahabadi, 2019)), and a short discussion of the additional cost introduced by solving the exact neighborhood problem. The code, raw result files, and the experimental log containing more details are available at https://github.com/alfahaf/fair-near-neighbor-search.

We stress that the evaluation is meant to be orthogonal to the data structure questions solved in the previous sections. The aim of this evaluation is to complement the theoretical study with a case study focusing on the fairness implications of solving the near-neighbor problem.

To carry out this study, we chose the MovieLens and Last.FM datasets available at https://grouplens.org/datasets/hetrec-2011 and converted them to a set representation. This representation was obtained by collecting, for each user, all movies rated at least 4 (MovieLens, 2 112 users, 65 536 unique movies) and the top-20 artists (Last.FM, 1 892 users, 18 739 unique artists), respectively. The average set size is 178.1 ($\sigma=187.5$) and 19.8 ($\sigma=1.78$), respectively. We measure the similarity of two user sets $\mathbf{X}$ and $\mathbf{Y}$ by their Jaccard similarity $J(\mathbf{X},\mathbf{Y})=|\mathbf{X}\cap\mathbf{Y}|/|\mathbf{X}\cup\mathbf{Y}|$. For each dataset, we pick 50 queries randomly from a set of “interesting” users. A user $\mathbf{X}$ is interesting if there exist at least 40 other users with Jaccard similarity at least $0.2$ with $\mathbf{X}$.

Algorithms.

Since we put our focus on Jaccard similarity, we implemented LSH using standard MinHash (Broder, 1997) and applying the 1-bit scheme of Li and König (Li and König, 2010). The implementation takes two parameters $K$ and $L$, as discussed in Section 2.2. We set $K$ such that we expect no more than $5$ points with Jaccard similarity at most 0.1 to have the same hash value as the query. We set $L$ such that with probability at least 99%, a given point with similarity at least $r\in\{0.15,0.2,0.25,0.3\}$ is present in the $L$ buckets. The standard LSH implementation checks every bucket, stopping as soon as it finds a point with similarity at least $r$. We also consider fair LSH, which we implemented in the naïve way of collecting all points with similarity at least $r$ found in the buckets, removing duplicates, and returning one of the remaining points at random.

Objectives of the Experiments

Our experiments are tailored to answer the following questions:

1. (Q1)

How (un)fair is the output of standard LSH compared to fair LSH? 2. (Q2)

How fair is the output of an algorithm solving the approximate neighborhood version? 3. (Q3)

What is the extra cost term for solving the exact neighborhood problem?

6.1. Comparing Standard LSH and Fair LSH (Q1)

For each $r\in\{0.15,0.2,0.25,0.3\}$, we build the standard LSH data structure with the parameters mentioned above. For each of the 50 queries, we query using the standard approach and the fair approach of collecting all points and then returning a neighbor sampled uniformly at random. As result, we collect the reported neighbor. We repeat this process 26 000 times independently.

Figure 1 exemplifies plots of the output distribution obtained from these experiments. The $x$-axis represents the similarity to the query, the $y$-axis represents the 50 different queries. Each point depicts the relative frequency of a point being reported at the similarity with the given query, where frequencies are averaged over all points that have the same similarity. A fair output is produced when for each query, each associated point to this query has approximately the same relative frequency, i.e., the same size and color intensity in the plot. For the Last.FM dataset on the top, we can clearly see that standard LSH (left) is biased towards points with higher similarity. For example, the seventh query point has a near neighbor with similarity 0.6 that is clearly overrepresented. In contrast, fair LSH provides a uniform output distribution. The bottom row shows the output for the MovieLens dataset. Note that the output size is much larger for this dataset and users are much closer with respect to their similarity to the query point. Still, we see a clear gradient in the color intensity for standard LSH (left), meaning that the output is biased towards points closer to the query. Such a gradient is not visible for fair LSH (right).

From these observations, we can conclude that a straight-forward LSH implementation introduces bias on real-world datasets. Using algorithms that solve the independent sampling version of the $r$-NN problem eliminate such bias.

6.2. Fairness in the approximate version (Q2)

We turn our focus to the approximate neighborhood sampling problem as discussed in Section 1.2, which was studied in (Har-Peled and Mahabadi, 2019). In this version of the problem, the algorithm may return points in $B(\mathbf{q},cr)\setminus B(\mathbf{q},r)$ as well, which speeds up the query since it avoids additional filtering steps. As claimed in Section 1.2, it is not clear whether this notion provides fairness in the sense of equal opportunity. In the following, we will provide a concrete example that shows that this is not the case.

To this end, let us define the following dataset over the universe $\mathcal{U}=\{1,\ldots,30\}$. We let $\mathbf{X}=\{16,\ldots,30\}$, $\mathbf{Y}=\{1,\ldots,18\}$, and $\mathbf{Z}=\{1,\ldots,27\}$. Further, we let $\mathcal{M}$ contain all subsets of $\mathbf{Y}$ having at least $15$ elements (excluding $\mathbf{Y}$ itself). The dataset is the collection of $\mathbf{X},\mathbf{Y},\mathbf{Z}$ and all sets in $\mathcal{M}$. Let the query $\mathbf{Q}$ be the set $\{1,\ldots,30\}$. To build the data structure, we set $r=0.9$ and $cr=0.5$. It is easy to see that $\mathbf{Z}$ is the nearest neighbor with similarity 0.9. $\mathbf{Y}$ is the second-nearest point with similarity 0.6, but $\mathbf{X}$ is among the points with lowest similarity of 0.5. Finally, we note that each $\mathbf{x}\in\mathcal{M}$ has similarity ranging from 0.5 to $0.5\overline{6}$. Under the approximate neighborhood sampling problem, all points can be returned for the given query.

As in the previous subsection, the algorithm collects all the points found in the $L$ buckets and returns a point picked uniformly at random among those points having similarity at least 0.5. Figure 2 shows the sampling probabilities of the sets $\mathbf{X},\mathbf{Y},\mathbf{Z}$. The plot clearly shows that the notion of approximate neighborhood does not provide a sensible guarantee on the individual fairness of users. The set $\mathbf{X}$ is more than 50 times more likely than $\mathbf{Y}$ to be returned, even though $\mathbf{Y}$ is more similar to the query. This is due to the clustered neighborhood of $\mathbf{Y}$, making many other points appear at the same time in the buckets. On the other hand, $\mathbf{X}$ has no close points in its neighborhood (except $\mathbf{Z}$ and $\mathbf{Q}$).

We remark that we did not observe this influence of clustered neighborhoods on the two real-world datasets. However, it is important to notice that approximate neighborhood could introduce unintentional bias and, furthermore, can be exploited by an adversary to discriminate a given user (e.g., an adversary can create a set of objects $\mathcal{M}$ that obfuscate a given entry $\mathbf{Y}$.)

Based on this example, one could argue that the observed sampling behavior is intentional. If the goal is to find good representatives in the neighborhood of the query, then it certainly seems preferable that $\mathbf{X}$ is reported with such high probability (which is roughly the same as all points in $\mathcal{M}$ and $\mathbf{Y}$ combined). Our notion of fairness would make the output less diverse, since $\mathbf{X}$ clearly stands out from many other points in the neighborhood, but it is supposed to be treated in the very same way. Such a trade-off between diversity and fairness was also observed, for example, by Leonhardt et al. in (Leonhardt et al., 2018).

6.3. Additional cost factor for solving the exact neighborhood variant (Q3)

The running time bounds of the algorithms in Sections 3–5 have an additional running time factor $\tilde{O}(b_{S}(\mathbf{q},cr)/b_{S}(\mathbf{q},r))$, putting in relation the number of points at distance at most $cr,c\geq 1,$ (or similarity at least $cr,c\leq 1,$) to those at threshold $r$. The values $r$ and $cr$ are the distance/similarity thresholds picked when building the data structure. In general, a larger gap between $r$ and $cr$ makes the $n^{\rho}$ term in the running times smaller. However, the additive cost $\tilde{O}(b_{S}(\mathbf{q},cr)/b_{S}(\mathbf{q},r))$ can potentially be prohibitively large for worst-case datasets.

Figure 3 depicts the ratio of points with similarity at least $cr$ and $r$ for the two real-world datasets. On the Last.FM dataset, we can see that even for very large gaps, the additional cost term is reasonably small. (In particular, much smaller than the number of repetitions.) On the MovieLens dataset for $r=0.25$, we see ratios of around 300 for $c\leq 0.25$. In this case, it roughly matches the number of repetitions done for this parameter choice. In general, however, it shows that a careful inspection of dataset/query set characteristics might be necessary to find good parameter choices that balance these cost terms.

7. Conclusion

In this paper, we have investigated a possible definition of fairness in similarity search by connecting the notion of “equal opportunity” to independent range sampling. An interesting open question is to investigate the applicability of our data structures for problems like discrimination discovery (Luong et al., 2011), diversity in recommender systems (Adomavicius and Kwon, 2014), privacy preserving similarity search (Riazi et al., 2016), and estimation of kernel density (Charikar and Siminelakis, 2017). Moreover, it would be interesting to investigate techniques for providing incentives (i.e., reverse discriminations (Luong et al., 2011)) to prevent discrimination: an idea could be to merge the data structures in this paper with distance-sensitive hashing functions in (Aumüller et al., 2018), which allow to implement hashing schemes where the collision probability is an (almost) arbitrary function of the distance. Finally, the techniques presented here require a manual trade-off between the performance of the LSH part and the additional running time contribution from finding the near points among the non-far points. From a user point of view, we would much rather prefer a parameterless version of our data structure that finds the best trade-off with small overhead, as discussed in (Ahle et al., 2017) in another setting.

Acknowledgments

This work was partially supported by Investigator Grant 16582, Basic Algorithms Research Copenhagen (BARC), from the VILLUM Foundation, by the University of Padova under the SID 2018 Project, and by the Italian Ministry of Education, University and Research (MIUR), under PRIN Project n. 20174LF3T8 AHeAD.

Appendix A Sampling with a repeated query

If we repeat the same query $\mathbf{q}$ several times (and no other queries), the data structure in Section 3 always returns the same point. If we let $OUT_{i}$ denote the output at the $i$-th repetition of query $\mathbf{q}$, we have that $\textnormal{Pr}\left[OUT_{i}=\mathbf{p}|OUT_{1}=\mathbf{p}_{1}\right]$ is 1 if $\mathbf{p}=\mathbf{p}_{1}$ and 0 otherwise. We would like to extend the above data structure to get

[TABLE]

for a given query $\mathbf{q}$ and $1<i\leq{\Theta}\left(n\right)$ (i.e., there is a linear number of queries), and thus to solve the $r$-NNIS problem in the case when only one query is repeated. The main idea is to select a near neighbor $\mathbf{p}$ of $\mathbf{q}$ as in the data structure of Theorem 1 and, just before returning $\mathbf{p}$, to apply a small random perturbation to ranks for “destroying” any relevant information that can be collected by repeating the query. The perturbation is obtained by applying a random swap, similar to the one in the Fisher-Yates shuffle (Knuth, 1997): we random select a point $\mathbf{p}^{\prime}\in S$ (in fact, a suitable subset of $S$) and exchange the ranks of $\mathbf{p}$ and $\mathbf{p}^{\prime}$. In this way, we get a data structure satisfying Equation (2) with expected query time ${O}\left((n^{\rho}+b_{S}(\mathbf{q},cr)-b_{S}(\mathbf{q},r))\log^{2}n\right)$.

We remark that the rerandomization technique is only restricted to single element queries: over time all elements in the ball $B_{S}(\mathbf{q},r)$ get higher and higher ranks. This means that for another query $\mathbf{q}^{\prime}$ such that $B_{S}(\mathbf{q},r)$ and $B_{S}(\mathbf{q}^{\prime},r)$ have a non-empty intersection, the elements in $B_{S}(\mathbf{q}^{\prime},r)\setminus B_{S}(\mathbf{q},r)$ become more and more likely to be returned. The next section will provide a slightly more involved data structure that guarantees independence among queries.

We first explain why two simple adaptations of the data structure for $r$-NNS in section 3 don’t work with a repeated query. The first adaptation consists in returning the point with the $k$-th smallest rank in $S_{\mathbf{q}}=\bigcup_{i=1}^{L}S_{i,\ell_{i}(\mathbf{q})}$ where $k$ is an integer in $[1,S_{\mathbf{q}}]$ randomly and independently selected at query time. Although this approach gives Equations 2, the query time is ${O}\left(n^{\rho}b_{S}(\mathbf{q},r)+b_{S}(\mathbf{q},cr)\right)$ with constant probability, as in the trivial solution described at the beginning. Indeed, since there are point repetitions among buckets, we have to scan almost all buckets $S_{i,\ell_{i}(\mathbf{q})}$ for every $i$, getting the same asymptotic query time of the trivial LSH solution. Another approach is to random select an integer value $r$ in $[r_{m},r_{M}]$, where $r_{m}$ and $r_{M}$ are the smallest and largest ranks in $S_{\mathbf{q}}$, and then to return the point in $S_{\mathbf{q}}$ with the closest rank to $r$. However, this approach doesn’t guarantee independence among the outputs: Indeed, before the first query the initial permutation is unknown and thus all points are equally likely to be returned; subsequent queries however reveal some details on the initial distribution, conditioning subsequent queries and exposing which points are more likely to be reported. We now describe our solution.

Construction

The construction is as in the one in section 3, with the exception that points in each bucket $S_{i,j}$ are stored in a priority queue, where ranks give the priority. We assume that each queue supports the extraction of the point with minimum rank and the insertion, deletion, and update of a point given the (unique) rank.

Query

The algorithm starts as in the previous data structure by searching for the point $\mathbf{x}$ in $B_{S}(\mathbf{q},r)\cap\bigcup_{i=1}^{L}S_{i,\ell_{i}(\mathbf{q})}$ with lowest rank. However, just before returning the sampled point, we update the rank of $\mathbf{x}$ as follows. Let $r_{\mathbf{x}}$ be the rank of $\mathbf{x}$; the algorithm selects uniformly at random a value $r$ in $\{r_{\mathbf{x}},\ldots n\}$ and let $\mathbf{y}$ be the point in $S$ with rank $r$; then the algorithm swaps the rank of $\mathbf{x}$ and $\mathbf{y}$ and updates all data structures (i.e., the priority queues of buckets $S_{i,\ell_{i}(\mathbf{x})}$ and $S_{i,\ell_{i}(\mathbf{y})}$ with $1\leq i\leq L$).

Theorem 1.

With high probability $1-1/n$, the above data structure solves the $r$-NNIS problem with one single repeated query: for each query point $\mathbf{q}$ and for each point $\mathbf{p}\in S$, we have:

1. (1)

$\mathbf{p}$* is returned as near neighbor of $\mathbf{q}$ with probability $1/b_{S}(\mathbf{q},r)$.* 2. (2)

$\textnormal{Pr}\left[OUT_{i}=\mathbf{p}|OUT_{i-1}=\mathbf{p}_{i-1},\ldots OUT_{1}=\mathbf{p}_{1}\right]={1}/{b_{S}(\mathbf{q},r)}$* for each $1<i\leq n$.*

Furthermore, the data structure requires ${\Theta}\left(n^{1+\rho}\log n\right)$ space and the expected query time is

[TABLE]

Proof.

We claim that after every query $\mathbf{q}$, it is not possible to distinguish how the $B_{S}(\mathbf{q},r)$ near neighbors of $\mathbf{q}$ are distributed among the ranks $\{r_{\mathbf{x}},\ldots n\}$. Before the rank shuffle, the position of $\mathbf{x}$ is known while the positions of points in $B_{S}(\mathbf{q},r)/\{\mathbf{x}\}$ in $\{r_{\mathbf{x}}+1,\ldots n\}$ still remain unknown. After swapping $\mathbf{x}$ with a random point with rank $\{r_{\mathbf{x}},n\}$, $\mathbf{x}$ can be in each rank with probability $1/(n-r_{\mathbf{x}}+1)$ and all distributions of points in $B_{S}(\mathbf{q},r)$ in ranks $\{r_{\mathbf{x}},n\}$ are thus equally likely. As a consequence, properties 1 and 2 in the statement follow.

Before finding a $r$-near neighbor, the query algorithm finds, with high probability, ${O}\left((b_{S}(\mathbf{q},cr)-b_{S}(\mathbf{q},r)+L)\log n\right)$ points with distance larger than $r$. The final rank shuffle requires ${O}\left(L\log n\right)$ time as we need to update the at most $2L$ buckets and priority queues with points $\mathbf{x}$ and $\mathbf{y}$. The theorem follows.333We observe that if all points touched at query time are updated with the rank-swap approach, then we get ${O}\left((1+b_{S}(\mathbf{q},cr)/b_{S}(\mathbf{q},r))n^{\rho}\right)$ expected query time. However, this bound is better than the one stated in Theorem 1 only when $b_{S}(\mathbf{q},cr)={O}\left(b_{S}(\mathbf{q},r)\right)$. ∎

Appendix B A linear space near-neighbor data structure

We will split up the analysis of the data structure from Section 5 into two parts. First, we describe and analyse a query algorithm that ignores the cost of storing and evaluating the $m$ random vectors. Next, we will describe and analyze the changes necessary to obtain an efficient query method as the one described in Section 5.

B.1. Description of the Data Structure

Construction

To set up the data structure for a point set $S\subseteq\mathbb{R}^{d}$ of $n$ data points and two parameters $\beta<\alpha$, choose $m\geq 1$ random vectors $\mathbf{a}_{1},\ldots,\mathbf{a}_{m}$ where each $\mathbf{a}=(a_{1},\ldots,a_{d})\sim\mathcal{N}(0,1)^{d}$ is a vector of $d$ independent and identically distributed standard normal Gaussians. For each $i\in\{1,\ldots,m\}$, let $L_{i}$ contain all data points $\mathbf{x}\in S$ such that $\langle{\mathbf{a}_{i}},{\mathbf{x}}\rangle$ is largest among all vectors $\mathbf{a}$.

Query

For a query point $\mathbf{q}\in\mathbb{R}^{d}$ and for a choice of $\varepsilon\in(0,1)$ controlling the success probability of the query, define $f(\alpha,\varepsilon)=\sqrt{2(1-\alpha^{2})\ln(1/\varepsilon)}$. Let $\Delta_{\mathbf{q}}$ be the largest inner product of $\mathbf{q}$ over all $\mathbf{a}$. Let $L^{\prime}_{1},\ldots,L^{\prime}_{K}$ denote the lists associated with random vectors $\mathbf{a}$ satisfying $\langle{\mathbf{a}},{\mathbf{q}}\rangle\geq\alpha\Delta_{q}-f(\alpha,\varepsilon)$. Check all points in $L^{\prime}_{1},\ldots,L^{\prime}_{K}$ and report the first point $\mathbf{x}$ such that $\langle{\mathbf{q}},{\mathbf{x}}\rangle\geq\beta$. If no such point exists, report $\perp$.

The proof of the theorem below will ignore the cost of evaluating $\mathbf{a}_{1},\ldots,\mathbf{a}_{m}$. An efficient algorithm for evaluating these vectors is provided in Section B.4.

Theorem 1.

Let $-1<\beta<\alpha<1$, $\varepsilon\in(0,1)$, and $n\geq 1$. Let $\rho=\frac{(1-\alpha^{2})(1-\beta^{2})}{(1-\alpha\beta)^{2}}$. There exists $m=m(n,\alpha,\beta)$ such that the data structure described above solves the $(\alpha,\beta)$-NN problem with probability at least $1-\varepsilon$ using space $O(m+n)$ and expected query time $n^{\rho+o(1)}$.

We split the proof up into multiple steps. First, we show that for every choice of $m$, inspecting the lists associated with those random vectors $\mathbf{a}$ such that their inner product with the query point $\mathbf{q}$ is at least the given query threshold guarantees to find a close point with probability at least $1-\varepsilon$. The next step is to show that the number of far points in these lists is $n^{\rho+o(1)}$ in expectation.

B.2. Analysis of Close Points

Lemma 0.

Given $m$ and $\alpha$, let $\mathbf{q}$ and $\mathbf{x}$ such that $\langle{\mathbf{q}},{\mathbf{x}}\rangle=\alpha$. Then we find $\mathbf{x}$ with probability at least $1-\varepsilon$ in the lists associated with vectors that have inner product at least $\alpha\Delta_{\mathbf{q}}-f(\alpha,\varepsilon)$ with $\mathbf{q}$.

Proof.

By spherical symmetry (Christiani, 2017), we may assume that $\mathbf{x}=(1,0,\ldots,0)$ and $\mathbf{q}=(\alpha,\sqrt{1-\alpha^{2}},0,$ $\ldots,0)$ . The probability of finding $\mathbf{x}$ when querying the data structure for $\mathbf{q}$ can be bounded as follows from below. Let $\Delta_{\mathbf{x}}$ be the largest inner product of $\mathbf{x}$ with vectors $\mathbf{a}$ and let $\Delta_{\mathbf{q}}$ be the largest inner product of $\mathbf{q}$ with these vectors. Given these thresholds, finding $\mathbf{x}$ is then equivalent to the statement that for the vector $\mathbf{a}$ with $\langle{\mathbf{a}},{\mathbf{x}}\rangle=\Delta_{\mathbf{x}}$ we have $\langle{\mathbf{a}},{\mathbf{q}}\rangle\geq\alpha\Delta_{\mathbf{q}}-f(\alpha,\varepsilon)$. We note that $\textnormal{Pr}\left[\max\{\langle{\mathbf{a}},{\mathbf{q}}\rangle\}=\Delta\right]=1-\textnormal{Pr}\left[\forall i:\langle{\mathbf{a}_{i}},{\mathbf{q}}\rangle<\Delta\right]$.

Thus, we may lower bound the probability of finding $\mathbf{x}$ for arbitrary choices $\Delta_{\mathbf{x}}$ and $\Delta_{\mathbf{q}}$ as follows:

[TABLE]

Here, we used that $\textnormal{Pr}\left[A\cap B\cap C\right]=1-\textnormal{Pr}\left[\overline{A}\cup\overline{B}\cup\overline{C}\right]\geq\textnormal{Pr}\left[A\right]-\textnormal{Pr}\left[\overline{B}\right]-\textnormal{Pr}\left[\overline{C}\right]$. We will now obtain bounds for the three terms on the right-hand side of (B.2) separately, but we first recall the following lemma from (Szarek and Werner, 1999):

Lemma 0 ((Szarek and Werner, 1999)).

Let $Z$ be a standard normal random variable. Then, for every $t\geq 0$, we have that

[TABLE]

Bounding the first term.

Since $\mathbf{q}=(\alpha,\sqrt{1-\alpha^{2}},0,\ldots,0)$ and $\mathbf{x}=(1,0,\ldots,0)$, the condition $\langle{\mathbf{a}},{\mathbf{x}}\rangle=\Delta_{\mathbf{x}}$ means that the first component of $\mathbf{a}$ is $\Delta_{\mathbf{x}}$. Thus, we have to bound the probability that a standard normal random variable $Z$ satisfies the inequality $\alpha\Delta_{\mathbf{x}}+\sqrt{1-\alpha^{2}}Z\geq\alpha\Delta_{\mathbf{q}}-f(\alpha,\varepsilon)$. Reordering terms, we get

[TABLE]

Choose $\Delta_{\mathbf{q}}=\Delta_{\mathbf{x}}$. In this case, we bound the probability that $Z$ is larger than a negative value. By symmetry of the standard normal distribution and using Lemma 3, we may compute

[TABLE]

Bounding the second term and third term.

We first observe that

[TABLE]

Setting $\Delta_{\mathbf{x}}=\sqrt{2\log m-\log(4\kappa\pi\log(m))}$ upper bounds this term by $\text{Exp}[-\sqrt{\kappa}]$. Thus, by setting $\kappa\geq\log^{2}(1/\delta)$ the second term is upper bounded by $\delta\in(0,1)$. The same thought can be applied to the third summand of (B.2), which is only smaller because of the negative offset $f(\alpha,\varepsilon)$.

Putting everything together.

Putting the bounds obtained for all three summands together shows that we can find $\mathbf{x}$ with probability at least $1-\varepsilon^{\prime}$ by choosing $\varepsilon$ and $\delta$ such that $\varepsilon^{\prime}\geq\varepsilon+2\delta$. ∎

B.3. Analysis of Far Points

Lemma 0.

Let $-1<\beta<\alpha<1$. There exists $m=m(n,\alpha,\beta)$ such that the expected number of points $\mathbf{x}$ with $\langle{\mathbf{x}},{\mathbf{q}}\rangle\leq\beta$ in $L^{\prime}_{1},\ldots,L^{\prime}_{K}$ where $K=|\{i\mid\langle{\mathbf{a}_{i}},{\mathbf{q}}\rangle\geq\alpha\Delta_{\mathbf{q}}-f(\alpha,\varepsilon)\}|$ is $n^{\rho+o(1)}$.

Proof.

We will first focus on a single far-away point $\mathbf{x}$ with inner product at most $\beta$. Again, let $\Delta_{\mathbf{q}}$ be the largest inner product of $\mathbf{q}$. Let $\mathbf{x}$ be stored in $L_{i}$. Then we find $\mathbf{x}$ if and only if $\langle{\mathbf{a}_{i}},{\mathbf{q}}\rangle\geq\alpha\Delta_{\mathbf{q}}-f(\alpha,\varepsilon).$ By spherical symmetry, we may assume that $\mathbf{x}=(1,0,\ldots,0)$ and $\mathbf{q}=(\beta,\sqrt{1-\beta^{2}},0,\ldots,0)$.

We first derive values $t_{\mathbf{q}}$ and $t_{\mathbf{x}}$ such that, with high probability, $\Delta_{\mathbf{q}}\geq t_{\mathbf{q}}$ and $\Delta_{\mathbf{x}}\leq t_{\mathbf{x}}$. From the proof of Lemma 2, we know that

[TABLE]

Setting $t_{\mathbf{q}}=\sqrt{2\log(m/\log(n))-\log(4\pi\log(m/\log n))}$ shows that with high probability we have $\Delta_{\mathbf{q}}\geq t_{\mathbf{q}}$. Similarily, the choice $t_{\mathbf{x}}=\sqrt{2\log(m\log(n))-\log(4\pi\log(m\log n))}$ is with high probability at least $\Delta_{\mathbf{x}}$. In the following, we condition on the event that $\Delta_{\mathbf{q}}\geq t_{\mathbf{q}}$ and $\Delta_{\mathbf{x}}\leq t_{\mathbf{x}}$.

We may bound the probability of finding $\mathbf{x}$ as follows:

[TABLE]

Given that $\langle{\mathbf{a}},{\mathbf{x}}\rangle$ is $t_{\mathbf{x}}$, the condition $\langle{\mathbf{a}},{\mathbf{q}}\rangle\geq\alpha t_{\mathbf{q}}-f(\alpha,\varepsilon)$ is equivalent to the statement that for a standard normal variable $Z$ we have $Z\geq\frac{(\alpha t_{\mathbf{q}}-f(\alpha,\varepsilon)-\beta t_{\mathbf{x}})}{\sqrt{1-\beta^{2}}}$. Using Lemma 3, we have

[TABLE]

where step (1) follows from the observation that $t_{\mathbf{q}}/t_{\mathbf{x}}=1+O(1/\log\log n)$ and $f(\alpha,\varepsilon)/t_{\mathbf{x}}=O(1/\log\log n)$ if $m=\Omega(\log n)$.

Next, we want to balance this probability with the expected cost for checking all lists where the inner product with the associated vector $\mathbf{a}$ is at least $\alpha\Delta_{\mathbf{q}}-f(\alpha,\varepsilon)$. By linearity of expectation, the expected number of lists to be checked is not more than

[TABLE]

which is $m^{1-\alpha^{2}+o(1)}$ using the value of $t_{\mathbf{q}}$ set above. This motivates to set (5) equal to $m^{1-\alpha^{2}}/n$, taking into account that there are at most $n$ far-away points. Solving for $m$, we get $m=n^{\frac{1-\beta^{2}}{(1-\alpha\beta)^{2}}+o(1)}$ and this yields $m^{1-\alpha^{2}+o(1)}=n^{\rho+o(1)}$. ∎

B.4. Efficient Evaluation

The previous subsections assumed that $m$ filters can be evaluated and stored for free. However, this requires space and time $n^{(1-\beta^{2})/(1-\alpha\beta)^{2}}$, which is much higher than the work we expect from checking the points in all filters above the threshold. We solve this problem by using the tensoring approach, which can be seen as a simplified version of the general approach proposed in (Christiani, 2017).

Construction

Let $t=\lceil 1/(1-\alpha^{2})\rceil$ and assume that $m^{1/t}$ is an integer. Consider $t$ independent data structures DS1, $\ldots$, DSt, each using $m^{1/t}$ random vectors $\mathbf{a}_{i,j}$, for $i\in\{1,\ldots,t\},j\in[m^{1/t}]$. Each DSi is instantiated as described above. During preprocessing, consider each $\mathbf{x}\in S$. If $\mathbf{a}_{1,i_{1}},\ldots,\mathbf{a}_{t,i_{t}}$ are the random vectors that achieve the largest inner product with $\mathbf{x}$ in DS1, $\ldots$, DSt, map the index of $\mathbf{x}$ in $S$ to the bucket $(i_{1},\ldots,i_{t})\in[m^{1/t}]^{t}$. Use a hash table to keep track of all non-empty buckets. Since each data point in $S$ is stored exactly once, the space usage is $O(n+tm^{1/t})$.

Query

Given the query point $\mathbf{q}$, evaluate all $tm^{1/t}$ filters. For $i\in\{1,\ldots,t\}$, let $\mathcal{I}_{i}=\{j\mid\langle{\mathbf{a}_{i,j}},{\mathbf{q}}\rangle\geq\alpha\Delta_{\mathbf{q},i}-f(\alpha,\varepsilon)\}$ be the set of all indices of filters that are above the individual query threshold in DSi. Check all buckets $(i_{1},\ldots,i_{t})\in\mathcal{I}_{1}\times\dots\times\mathcal{I}_{t}$. If there is a bucket containing a close point, return it, otherwise return $\perp$.

Theorem 5.

Let $S\subseteq X$ with $|S|=n$ and $-1<\beta<\alpha<1$. The tensoring data structure solves the $(\alpha,\beta)$-NN problem in linear space and expected time $n^{\rho+o(1)}$.

Before proving the theorem, we remark that efficient evaluation comes at the price of lowering the success probability from a constant $p$ to $p^{1/(1-\alpha^{2})}$. Thus, for $\delta\in(0,1)$ repeating the construction $\ln(1/\delta)p^{1-\alpha^{2}}$ times yields a success probability of at least $1-\delta$.

Proof.

Observe that with the choice of $m$ as in the proof of Lemma 4, we can bound $m^{1/t}=n^{(1-\alpha^{2})(1-\beta^{2})/(1-\alpha\beta)^{2}+o(1)}=n^{\rho+o(1)}$. This means that preprocessing takes time $n^{1+\rho+o(1)}$. Moreover, the additional space needed for storing the $tm^{1/t}$ random vectors is $n^{\rho+o(1)}$ as well. For a given query point $\mathbf{q}$, we expect that each $\mathcal{I}_{i}$ is of size $m^{(1-\alpha^{2})/t+o(1)}$. Thus, we expect to check not more than $m^{1-\alpha^{2}+o(1)}=n^{\rho+o(1)}$ buckets in the hash table, which shows the stated claim about the expected running time.

Let $\mathbf{x}$ be a point with $\langle{\mathbf{q}},{\mathbf{x}}\rangle\geq\alpha$. The probability of finding $\mathbf{x}$ is the probability that the vector associated with $\mathbf{x}$ has inner product at least $\alpha\Delta_{\mathbf{q},i}-f(\alpha,\varepsilon)$ in DSi, for all $i\in\{1,\ldots,t\}$. This probability is $p^{t}$, where $p$ is the probability of finding $\mathbf{x}$ in a single data structure $\text{DS}_{i}$. By Theorem 1 and since $\alpha$ is a constant, this probability is constant and can be bounded from below by $1-\delta$ via a proper choice of $\varepsilon$ as discussed in the proof of Lemma 2.

Let $\mathbf{y}$ be a point with $\langle{\mathbf{q}},{\mathbf{y}}\rangle<\beta$. Using the same approach in the proof of Lemma 4, we observe that the probability of finding $\mathbf{y}$ in an individual DSi is $(1/m)^{1/t\cdot(\alpha-\beta)^{2}/(1-\beta^{2})+o(1)}$. Thus the probability of finding $\mathbf{y}$ in a bucket inspected for $\mathbf{q}$ is at most $(1/m)^{(\alpha-\beta)^{2}/(1-\beta^{2})+o(1)}$. Setting parameters as before shows that we expect at most $n^{\rho+o(1)}$ far points in buckets inspected for query $\mathbf{q}$, which completes the proof. ∎