Original: Falconn++: A Locality-sensitive Filtering Approach for Approximate Nearest Neighbor Search
Revised: Falconn++: A Locality-sensitive Filtering Approach for Approximate Nearest Neighbor Search

Original: Abstract
Revised: Abstract

Original: We present Falconn++, a novel locality-sensitive filtering approach for approximate nearest neighbor search on angular distance.
Revised: We present Falconn++, a novel locality-sensitive filtering approach for approximate nearest neighbor search on angular distance.

Original: Falconn++ can filter out potential far away points in any hash bucket before querying, which results in higher quality candidates compared to other hashing-based solutions.
Revised: Falconn++ can filter out potential far away points in any hash bucket before querying, which results in higher quality candidates compared to other hashing-based solutions.

Original: Theoretically, Falconn++ asymptotically achieves lower query time complexity than Falconn, an optimal locality-sensitive hashing scheme on angular distance.
Revised: Theoretically, Falconn++ asymptotically achieves lower query time complexity than Falconn, an optimal locality-sensitive hashing scheme on angular distance.

Original: Empirically, Falconn++ achieves higher recall-speed tradeoffs than Falconn on many real-world data sets.
Revised: Empirically, Falconn++ achieves higher recall-speed tradeoffs than Falconn on many real-world data sets.

Original: Falconn++ is also competitive with HNSW, an efficient representative of graphbased solutions on high search recall regimes
Revised: Falconn++ is also competitive with HNSW, an efficient representative of graphbased solutions on high search recall regimes

Original:  Introduction
Revised:  Introduction

Original: Nearest neighbor search (NNS) on a unit sphere is the task of, given a point set X ⊂ S d − 1 of size n and a query point q ∈ S
Revised: Nearest neighbor search (NNS) on a unit sphere is the task of, given a point set X ⊂ S d − 1 of size n and a query point q ∈ S

Original: d − 1 , finding the point p ∈
Revised: d − 1 , finding the point p ∈

Original: X
Revised: X

Original: such that p = arg min x ∈ X ∥ x − q ∥ .
Revised: such that p = arg min x ∈ X ∥ x − q ∥ .

Original: Since both data set X and query q are on a unit sphere, NNS on Euclidean distance is identical to NNS on angular distance (i.e. p = arg max x ∈ X x ⊤ q ).
Revised: Since both data set X and query q are on a unit sphere, NNS on Euclidean distance is identical to NNS on angular distance (i.e. p = arg max x ∈ X x ⊤ q ).

Original: NNS and its variant top- k NNS on angular distance are the fundamental problems in computer science, e.g. web search [11], recommender system [21], machine learning [7], and computer vision [22].
Revised: NNS and its variant top- k NNS on angular distance are the fundamental problems in computer science, e.g. web search [11], recommender system [21], machine learning [7], and computer vision [22].

Original: NNS dates back to Minsky and Papert [17], who studied the tradeoff between query time and indexing space in high dimensions.
Revised: NNS dates back to Minsky and Papert [17], who studied the tradeoff between query time and indexing space in high dimensions.

Original: Due to the “curse of dimensionality”, linear scan outperforms space/data partitioning solutions on solving exact NNS given a linear indexing space [24].
Revised: Due to the “curse of dimensionality”, linear scan outperforms space/data partitioning solutions on solving exact NNS given a linear indexing space [24].

Original: Given a polynomial indexing space n O (1) d O (1) , there is no known algorithm to solve exact NNS in truly sublinear time.
Revised: Given a polynomial indexing space n O (1) d O (1) , there is no known algorithm to solve exact NNS in truly sublinear time.

Original: If there exists such an algorithm, the Strong Exponential Time Hypothesis (SETH) [12], a fundamental conjecture in computational complexity theory, is wrong [3, 25].
Revised: If there exists such an algorithm, the Strong Exponential Time Hypothesis (SETH) [12], a fundamental conjecture in computational complexity theory, is wrong [3, 25].

Original: Due to the hardness of exact NNS, researchers study efficient solutions for approximate NNS (ANNS).
Revised: Due to the hardness of exact NNS, researchers study efficient solutions for approximate NNS (ANNS).

Original: Given an approximation factor c ′ > 1 , ANNS aims at finding the point p
Revised: Given an approximation factor c ′ > 1 , ANNS aims at finding the point p

Original: ′ ∈
Revised: ′ ∈

Original: X within distance c ′ · ∥ p − q ∥ .
Revised: X within distance c ′ · ∥ p − q ∥ .

Original: Since we can reduce ANNS to its “decision version”, called ( c, r ) -approximate near neighbor ( ( c, r ) -NN) for an approximation factor c > 1 and a radius r [10], solving ANNS boils down to ( c, r ) -NN.
Revised: Since we can reduce ANNS to its “decision version”, called ( c, r ) -approximate near neighbor ( ( c, r ) -NN) for an approximation factor c > 1 and a radius r [10], solving ANNS boils down to ( c, r ) -NN.

Original: The problem ( c, r ) -NN that asks to return any point within distance cr to q if there is a point within distance r to q is the key algorithmic component of many ANNS solvers.
Revised: The problem ( c, r ) -NN that asks to return any point within distance cr to q if there is a point within distance r to q is the key algorithmic component of many ANNS solvers.

Original: Locality-sensitive hashing (LSH) [13] is the first provable sublinear query time solution using a subquadratic indexing space for ( c, r ) -NN in high dimensions.
Revised: Locality-sensitive hashing (LSH) [13] is the first provable sublinear query time solution using a subquadratic indexing space for ( c, r ) -NN in high dimensions.

Original: In principle, LSH hashes “close” points, i.e. within radius r to q , into the same bucket with q with high probability, and hashes “far away” points, i.e. outside radius cr to q , into the same bucket with low probability.
Revised: In principle, LSH hashes “close” points, i.e. within radius r to q , into the same bucket with q with high probability, and hashes “far away” points, i.e. outside radius cr to q , into the same bucket with low probability.

Original: Given a parameter 0 < ρ < 1 , LSH answers ( c, r ) -NN in O ( dn ρ ) time and uses O (cid:0) nd + n 1+ ρ (cid:1) space.
Revised: Given a parameter 0 < ρ < 1 , LSH answers ( c, r ) -NN in O ( dn ρ ) time and uses O (cid:0) nd + n 1+ ρ (cid:1) space.

Original: Since the exponent ρ governs the complexity of LSH, it is desirable to have LSH families with the smallest ρ .
Revised: Since the exponent ρ governs the complexity of LSH, it is desirable to have LSH families with the smallest ρ .

Original: LSH families with optimal values ρ
Revised: LSH families with optimal values ρ

Original: ≈ 1 /c 2 on Euclidean distance are well studied in theory [1, 5].
Revised: ≈ 1 /c 2 on Euclidean distance are well studied in theory [1, 5].

Original: In practice, to our knowledge, only Falconn [2] with the cross-polytope LSH family asymptotically achieves ρ ≈ 1 /c 2 on the Euclidean unit sphere.
Revised: In practice, to our knowledge, only Falconn [2] with the cross-polytope LSH family asymptotically achieves ρ ≈ 1 /c 2 on the Euclidean unit sphere.

Original: Despite provable sublinear query time guarantees, the indexing space of LSH is a primary bottleneck.
Revised: Despite provable sublinear query time guarantees, the indexing space of LSH is a primary bottleneck.

Original: Since different queries require different values of r , practical LSH-based solutions often use hundreds of hash tables to guarantee the querying performance.
Revised: Since different queries require different values of r , practical LSH-based solutions often use hundreds of hash tables to guarantee the querying performance.

Original: To overcome this bottleneck, Lv et al.
Revised: To overcome this bottleneck, Lv et al.

Original: [15] propose a multi-probing trick that sequentially checks nearby buckets of the query’s bucket.
Revised: [15] propose a multi-probing trick that sequentially checks nearby buckets of the query’s bucket.

Original: This is because the hash values of the nearest neighbors of q tend to be close to the hash value of q on the hashing space [19].
Revised: This is because the hash values of the nearest neighbors of q tend to be close to the hash value of q on the hashing space [19].

Original: Therefore, multi-probe LSH achieves a similar success probability with a smaller number of hash tables than the standard LSH.
Revised: Therefore, multi-probe LSH achieves a similar success probability with a smaller number of hash tables than the standard LSH.

Original: We observe that LSH and its multi-probe schemes do not efficiently answer ANNS on high recall regimes.
Revised: We observe that LSH and its multi-probe schemes do not efficiently answer ANNS on high recall regimes.

Original: Since the distance gaps between the nearest neighbors are tiny in many real-world data sets, we need a very small approximation factor c , e.g. c = 1 . 01 .
Revised: Since the distance gaps between the nearest neighbors are tiny in many real-world data sets, we need a very small approximation factor c , e.g. c = 1 . 01 .

Original: This requirement degrades the performance of LSH-based solutions as ρ → 1 .
Revised: This requirement degrades the performance of LSH-based solutions as ρ → 1 .

Original: In this case, multi-probe LSH has to increase the number of probes and the number of candidates.
Revised: In this case, multi-probe LSH has to increase the number of probes and the number of candidates.

Original: That significantly reduces the querying performance since the probed buckets different from the query bucket tend to have more far away points.
Revised: That significantly reduces the querying performance since the probed buckets different from the query bucket tend to have more far away points.

Original: Empirically, multi-probe Falconn [2] with L = 100 hash tables on the Glove300 data set needs 4,000 probes and computes more than 0 .
Revised: Empirically, multi-probe Falconn [2] with L = 100 hash tables on the Glove300 data set needs 4,000 probes and computes more than 0 .

Original: 1 · n number of distances to achieve 90% recall.
Revised: 1 · n number of distances to achieve 90% recall.

Original: This is the rationale that
Revised: This is the rationale that

Original: LSH-based solutions are less favorable for ANNS on high recall regimes than the recent graph-based solutions [6], e.g. HNSW [16].
Revised: LSH-based solutions are less favorable for ANNS on high recall regimes than the recent graph-based solutions [6], e.g. HNSW [16].

Original: To further facilitate LSH-based solutions for ANNS, we propose a filtering mechanism that can efficiently filter out the far away points in any bucket before querying.
Revised: To further facilitate LSH-based solutions for ANNS, we propose a filtering mechanism that can efficiently filter out the far away points in any bucket before querying.

Original: Our proposed mechanism is also locality-sensitive in the sense that far away points will be filtered out with high probability and close points will be pruned with low probability.
Revised: Our proposed mechanism is also locality-sensitive in the sense that far away points will be filtered out with high probability and close points will be pruned with low probability.

Original: Therefore, we can safely remove far away points while building the index to improve the query time and reduce the indexing space simultaneously.
Revised: Therefore, we can safely remove far away points while building the index to improve the query time and reduce the indexing space simultaneously.

Original: This feature significantly increases the performance of multi-probe LSH since it dramatically reduces the number of distance computations while preserving the search recall.
Revised: This feature significantly increases the performance of multi-probe LSH since it dramatically reduces the number of distance computations while preserving the search recall.

Original: We implement the proposed filtering mechanism for angular distance based on the asymptotic property of the concomitant of extreme order statistics [9, 20].
Revised: We implement the proposed filtering mechanism for angular distance based on the asymptotic property of the concomitant of extreme order statistics [9, 20].

Original: Similar to Falconn [2], our approach utilizes many random projection vectors and only considers specific vectors r i that are closest or furthest to the query q .
Revised: Similar to Falconn [2], our approach utilizes many random projection vectors and only considers specific vectors r i that are closest or furthest to the query q .

Original: The key difference is that we use the random projection value x ⊤ r i to estimate x ⊤ q by leveraging the asymptotic behavior of these projection values.
Revised: The key difference is that we use the random projection value x ⊤ r i to estimate x ⊤ q by leveraging the asymptotic behavior of these projection values.

Original: This feature makes our filtering mechanism locality-sensitive .
Revised: This feature makes our filtering mechanism locality-sensitive .

Original: Theoretically, our proposed locality-sensitive filtering (LSF) scheme, named Falconn++ , asymptotically achieves smaller ρ , a parameter governing the query time complexity, than Falconn.
Revised: Theoretically, our proposed locality-sensitive filtering (LSF) scheme, named Falconn++ , asymptotically achieves smaller ρ , a parameter governing the query time complexity, than Falconn.

Original: Empirically,
Revised: Empirically,

Original: Falconn++ with a new add-on that applies multi-probing on both querying and indexing phases achieves significantly higher recall-speed tradeoffs than Falconn on many real-world data sets.
Revised: Falconn++ with a new add-on that applies multi-probing on both querying and indexing phases achieves significantly higher recall-speed tradeoffs than Falconn on many real-world data sets.

Original: We further innovate Falconn++ with several heuristics that make it competitive with HNSW [16], a recent efficient graph-based solution for ANNS on high recall regimes.
Revised: We further innovate Falconn++ with several heuristics that make it competitive with HNSW [16], a recent efficient graph-based solution for ANNS on high recall regimes.

Original:  Preliminary 2.1 Locality-sensitive hashing (LSH)
Revised:  Preliminary 2.1 Locality-sensitive hashing (LSH)

Original: Since 1998, LSH [13] has emerged as an algorithmic primitive of ANNS in high dimensions.
Revised: Since 1998, LSH [13] has emerged as an algorithmic primitive of ANNS in high dimensions.

Original: LSH provably guarantees a sublinear query time for ANNS by solving the ( c, r ) -NN over ˜ O
Revised: LSH provably guarantees a sublinear query time for ANNS by solving the ( c, r ) -NN over ˜ O

Original: (log n ) different radii.
Revised: (log n ) different radii.

Original: Given a distance function dist ( · , · ) , the LSH definition is as follows.
Revised: Given a distance function dist ( · , · ) , the LSH definition is as follows.

Original: Definition 1 (LSH) .
Revised: Definition 1 (LSH) .

Original: For positive reals r , c , p 1 , p 2 , and 0 < p 2 < p 1 ≤ 1 , c > 1 , a family of functions
Revised: For positive reals r , c , p 1 , p 2 , and 0 < p 2 < p 1 ≤ 1 , c > 1 , a family of functions

Original: H is ( r, cr, p 1 , p 2 ) -sensitive
Revised: H is ( r, cr, p 1 , p 2 ) -sensitive

Original: if for uniformly chosen h ∈ H and all x , y , q ∈ R d :
Revised: if for uniformly chosen h ∈ H and all x , y , q ∈ R d :

Original: • If dist ( x , q ) ≤ r , then Pr [ h ( x ) = h ( q )] ≥ p 1 ; •
Revised: • If dist ( x , q ) ≤ r , then Pr [ h ( x ) = h ( q )] ≥ p 1 ; •

Original: If dist ( y , q ) ≥ cr , then Pr [ h ( y ) = h ( q )] ≤ p 2 .
Revised: If dist ( y , q ) ≥ cr , then Pr [ h ( y ) = h ( q )] ≤ p 2 .

Original: To simplify notations, we call x as a “close” point if dist ( x , q ) ≤ r and y as “far away” point if dist ( y , q ) ≥ cr .
Revised: To simplify notations, we call x as a “close” point if dist ( x , q ) ≤ r and y as “far away” point if dist ( y , q ) ≥ cr .

Original: To minimize the collision probability of far away points, we combine l = O (log n ) different LSH functions together to form a new ( r, cr, p l 1 , p l 2 ) -sensitive LSH family, and set p l 2 = 1 /n .
Revised: To minimize the collision probability of far away points, we combine l = O (log n ) different LSH functions together to form a new ( r, cr, p l 1 , p l 2 ) -sensitive LSH family, and set p l 2 = 1 /n .

Original: Since the combination also decreases the collision probability of close points from p 1 to p l 1 , we need r
Revised: Since the combination also decreases the collision probability of close points from p 1 to p l 1 , we need r

Original: − r 2 .
Revised: − r 2 .

Original: 1 r c=1.
Revised: 1 r c=1.

Original: Falconn++
Revised: Falconn++

Original: Falconn 1.
Revised: Falconn 1.

Original: 1.4 c cr=0.
Revised: 1.4 c cr=0.

Original: Falconn++
Revised: Falconn++

Original: Falconn
Revised: Falconn

Original: L = O (cid:0) 1 /p l 1 (cid:1) hash tables to ensure that we can find a close point with a constant probability.
Revised: L = O (cid:0) 1 /p l 1 (cid:1) hash tables to ensure that we can find a close point with a constant probability.

Original: Given the setting p l 2 = 1 /n and denote by ρ = ln(1 /p 1 ) / ln(1 /p 2 ) , LSH needs L = O ( n ρ ) tables and compute O ( n ρ ) distances in O ( dn ρ ) time to answer ( c, r ) -NN with a constant probability.
Revised: Given the setting p l 2 = 1 /n and denote by ρ = ln(1 /p 1 ) / ln(1 /p 2 ) , LSH needs L = O ( n ρ ) tables and compute O ( n ρ ) distances in O ( dn ρ ) time to answer ( c, r ) -NN with a constant probability.

Original: The exponent ρ governing the complexity of an ( r, cr, p 1 , p 2 ) -sensitive LSH algorithm depends on the distance function and c .
Revised: The exponent ρ governing the complexity of an ( r, cr, p 1 , p 2 ) -sensitive LSH algorithm depends on the distance function and c .

Original: O’Donnell et al.
Revised: O’Donnell et al.

Original: [18] show that ρ ≥ 1 /c 2 − o (1) on Euclidean distance given p 2 ≥ 1 /n .
Revised: [18] show that ρ ≥ 1 /c 2 − o (1) on Euclidean distance given p 2 ≥ 1 /n .

Original: However, it is difficult to implement the LSH families with optimal ρ in practice.
Revised: However, it is difficult to implement the LSH families with optimal ρ in practice.

Original: 2.2 Falconn: An optimal LSH on angular distance
Revised: 2.2 Falconn: An optimal LSH on angular distance

Original: Andoni et al.
Revised: Andoni et al.

Original: [2] introduce Falconn that uses a cross-polytope LSH family on angular distance (i.e. cosine similarity).
Revised: [2] introduce Falconn that uses a cross-polytope LSH family on angular distance (i.e. cosine similarity).

Original: Given D random vectors r i ∈ R d ,
Revised: Given D random vectors r i ∈ R d ,

Original: i ∈
Revised: i ∈

Original: [ D ] whose coordinates are randomly selected from the standard normal distribution N (0 , 1) , and sgn ( · ) is the sign function, the crosspolytope LSH family uses the index of the random vector as the hash value.
Revised: [ D ] whose coordinates are randomly selected from the standard normal distribution N (0 , 1) , and sgn ( · ) is the sign function, the crosspolytope LSH family uses the index of the random vector as the hash value.

Original: In particular, w.l.o.g. we assume that r 1 = arg max r i | q ⊤ r i | , then h ( q ) is calculated as follows:
Revised: In particular, w.l.o.g. we assume that r 1 = arg max r i | q ⊤ r i | , then h ( q ) is calculated as follows:

Original: [Equation]
Revised: [Equation]

Original: A geometric intuition of Falconn is that h ( q ) =
Revised: A geometric intuition of Falconn is that h ( q ) =

Original: r 1 (or h ( q ) = − r 1 ) indicates that q is closest (or furthest) to the random vector r 1 among D random vectors, as shown in Figure 1a.
Revised: r 1 (or h ( q ) = − r 1 ) indicates that q is closest (or furthest) to the random vector r 1 among D random vectors, as shown in Figure 1a.

Original: Falconn uses D random vectors r i to partition the sphere into 2 D wedges centered by the 2 D random vectors ±
Revised: Falconn uses D random vectors r i to partition the sphere into 2 D wedges centered by the 2 D random vectors ±

Original: r i .
Revised: r i .

Original: If x and q are similar, they tend to be closest or furthest to the same random vector, and hence are hashed into the same wedge corresponding to that random vector.
Revised: If x and q are similar, they tend to be closest or furthest to the same random vector, and hence are hashed into the same wedge corresponding to that random vector.

Original: The following lemma states the asymptotic collision probability between two points x , q when D is sufficiently large.
Revised: The following lemma states the asymptotic collision probability between two points x , q when D is sufficiently large.

Original: Lemma 1.
Revised: Lemma 1.

Original: [2, Theorem 1]
Revised: [2, Theorem 1]

Original: Given two points x , q ∈ S d − 1 such that ∥ x − q ∥ =
Revised: Given two points x , q ∈ S d − 1 such that ∥ x − q ∥ =

Original: r
Revised: r

Original: where 0 < r < 2 .
Revised: where 0 < r < 2 .

Original: Then, we have
Revised: Then, we have

Original: [Equation]
Revised: [Equation]

Original: Given a small c , Equation 2 indicates that Falconn has an optimal exponent ρ ≈
Revised: Given a small c , Equation 2 indicates that Falconn has an optimal exponent ρ ≈

Original: [Equation]
Revised: [Equation]

Original: 1 ≈ 1 /c 2 .
Revised: 1 ≈ 1 /c 2 .

Original: Multi-probe Falconn.
Revised: Multi-probe Falconn.

Original: To reduce the number of hash tables L , multi-probe Falconn considers the next closest or furthest random vectors to generate the probing sequence in a hash table.
Revised: To reduce the number of hash tables L , multi-probe Falconn considers the next closest or furthest random vectors to generate the probing sequence in a hash table.

Original: For example, in Figure 1a, since q is next closest to − r 2 , the bucket corresponding to the blue wedge will be the next probe.
Revised: For example, in Figure 1a, since q is next closest to − r 2 , the bucket corresponding to the blue wedge will be the next probe.

Original: Given a fixed total number of query probes qProbes for a query, ranking the buckets across L tables is challenging.
Revised: Given a fixed total number of query probes qProbes for a query, ranking the buckets across L tables is challenging.

Original: Falconn heuristically uses the distance between the projection values of q on random vectors to construct the probing sequence.
Revised: Falconn heuristically uses the distance between the projection values of q on random vectors to construct the probing sequence.

Original: For example, in the table corresponding to Figure 1a, the ranking score of the blue wedge for probing is | q ⊤ r 1 | − | q ⊤ r 2 | .
Revised: For example, in the table corresponding to Figure 1a, the ranking score of the blue wedge for probing is | q ⊤ r 1 | − | q ⊤ r 2 | .

Original: Even though multi-probe Falconn can significantly reduce the number of hash tables, it demands a significantly large qProbes and candidate sizes to solve ANN on high recall regimes due to the small distance gaps among nearest neighbors.
Revised: Even though multi-probe Falconn can significantly reduce the number of hash tables, it demands a significantly large qProbes and candidate sizes to solve ANN on high recall regimes due to the small distance gaps among nearest neighbors.

Original: 3 CEOs: An optimal
Revised: 3 CEOs: An optimal

Original: dimensionality reduction
Revised: dimensionality reduction

Original: on
Revised: on

Original: unit
Revised: unit

Original: sphere
Revised: sphere

Original: Pham proposes CEOs [20], an optimal dimensionality reduction for ANN on angular distance.
Revised: Pham proposes CEOs [20], an optimal dimensionality reduction for ANN on angular distance.

Original: While
Revised: While

Original: CEOs shares the same spirit that utilizes random projections as Falconn, it is a similarity estimation technique rather than hashing.
Revised: CEOs shares the same spirit that utilizes random projections as Falconn, it is a similarity estimation technique rather than hashing.

Original: In particular, CEOs randomly projects X and q onto D Gaussian random vectors and considers the projection values on specific random vectors that are closest or furthest to q , e.g. arg max r i | q ⊤ r i | .
Revised: In particular, CEOs randomly projects X and q onto D Gaussian random vectors and considers the projection values on specific random vectors that are closest or furthest to q , e.g. arg max r i | q ⊤ r i | .

Original: Asymptotically, given a sufficiently large D , the following lemma states the projection values on a few specific random vectors preserve the inner product.
Revised: Asymptotically, given a sufficiently large D , the following lemma states the projection values on a few specific random vectors preserve the inner product.

Original: Lemma 2.
Revised: Lemma 2.

Original: [20] Given two points x , q ∈ S d − 1 and significantly large D random vectors r i , w.l.o.g we assume that r 1 = arg max r i | q ⊤ r i | .
Revised: [20] Given two points x , q ∈ S d − 1 and significantly large D random vectors r i , w.l.o.g we assume that r 1 = arg max r i | q ⊤ r i | .

Original: Then, we have
Revised: Then, we have

Original: [Equation]
Revised: [Equation]

Original: Among D random vectors, if r 1 is closest or furthest to q , the projection values of all points in X preserve their inner product order in expectation.
Revised: Among D random vectors, if r 1 is closest or furthest to q , the projection values of all points in X preserve their inner product order in expectation.

Original: In Figure 1a, since q is closest to r 1 , the order of projection values onto r 1 , e.g. x ⊤ r 1 > z ⊤ r 1 , preserves the inner product order, e.g. x ⊤ q > z ⊤ q .
Revised: In Figure 1a, since q is closest to r 1 , the order of projection values onto r 1 , e.g. x ⊤ r 1 > z ⊤ r 1 , preserves the inner product order, e.g. x ⊤ q > z ⊤ q .

Original: Importantly, given a constant s 0 > 0 , Lemma 2 also holds for the top- s 0 closest vectors and top- sfurthest random vectors to q due to the asymptotic property of extreme normal order statistics [9].
Revised: Importantly, given a constant s 0 > 0 , Lemma 2 also holds for the top- s 0 closest vectors and top- sfurthest random vectors to q due to the asymptotic property of extreme normal order statistics [9].

Original: For example, in Figure 1a, we can see that the inner product order is also preserved on − r 1 , − r 2 .
Revised: For example, in Figure 1a, we can see that the inner product order is also preserved on − r 1 , − r 2 .

Original: Connection to Falconn.
Revised: Connection to Falconn.

Original: From Equations 1 and 3, we can see that Falconn uses the top-1 closest or furthest random vector (i.e. r 1 ) as the hash value of q while CEOs uses the projection values over this random vector as inner product estimates.
Revised: From Equations 1 and 3, we can see that Falconn uses the top-1 closest or furthest random vector (i.e. r 1 ) as the hash value of q while CEOs uses the projection values over this random vector as inner product estimates.

Original: Furthermore, the multi-probe Falconn likely probes buckets corresponding to the 2 s 0 random vectors closest or furthest to q .
Revised: Furthermore, the multi-probe Falconn likely probes buckets corresponding to the 2 s 0 random vectors closest or furthest to q .

Original: Since the inner product order is well preserved on the projections onto these 2 s 0 vectors, thanks to the CEOs property, we can keep a small fraction of number of points with the largest projection values in Falconn’s buckets.
Revised: Since the inner product order is well preserved on the projections onto these 2 s 0 vectors, thanks to the CEOs property, we can keep a small fraction of number of points with the largest projection values in Falconn’s buckets.

Original: This filtering approach will significantly save the indexing space and improve the query time while maintaining the same recall as multi-probe Falconn.
Revised: This filtering approach will significantly save the indexing space and improve the query time while maintaining the same recall as multi-probe Falconn.

Original: The next section will theoretically analyze this approach and describe its practical implementation.
Revised: The next section will theoretically analyze this approach and describe its practical implementation.

Original:  Falconn++: A locality-sensitive filtering approach 3.1 A locality-sensitive filtering (LSF)
Revised:  Falconn++: A locality-sensitive filtering approach 3.1 A locality-sensitive filtering (LSF)

Original: Let 0 <
Revised: Let 0 <

Original: q 2 < q 1 ≤ 1 , we define an LSF mechanism that can keep in any bucket h ( q ) any close point x with probability at least q 1 and any far away point y with probability at most q 2 as follows.
Revised: q 2 < q 1 ≤ 1 , we define an LSF mechanism that can keep in any bucket h ( q ) any close point x with probability at least q 1 and any far away point y with probability at most q 2 as follows.

Original: Definition 2 (LSF) .
Revised: Definition 2 (LSF) .

Original: For positive reals r , c , q 1 , q 2 , and 0 < q 2 < q 1 ≤ 1 , c > 1 , given x , y in the bucket h ( q ) where h is randomly chosen from a LSH family, an LSF mechanism is a filter that have the following properties:
Revised: For positive reals r , c , q 1 , q 2 , and 0 < q 2 < q 1 ≤ 1 , c > 1 , given x , y in the bucket h ( q ) where h is randomly chosen from a LSH family, an LSF mechanism is a filter that have the following properties:

Original: • If dist ( x , q ) ≤ r , then Pr [ x is not filtered ] ≥ q 1 ; • If dist ( y , q ) ≥ cr , then Pr [ y is not filtered ] ≤ q 2 .
Revised: • If dist ( x , q ) ≤ r , then Pr [ x is not filtered ] ≥ q 1 ; • If dist ( y , q ) ≥ cr , then Pr [ y is not filtered ] ≤ q 2 .

Original: Applying the LSF mechanism on each bucket of the hash table constructed by any ( r, cr, p 1 , p 2 ) - sensitive LSH, the new collision probabilities among x , y , q after hashing and filtering are:
Revised: Applying the LSF mechanism on each bucket of the hash table constructed by any ( r, cr, p 1 , p 2 ) - sensitive LSH, the new collision probabilities among x , y , q after hashing and filtering are:

Original: Pr [ h ( x ) = h ( q ) , x is not filtered ] ≥ q 1 p 1 , Pr [ h ( y ) =
Revised: Pr [ h ( x ) = h ( q ) , x is not filtered ] ≥ q 1 p 1 , Pr [ h ( y ) =

Original: h ( q ) , y is not filtered ] ≤ q 2 p 2 .
Revised: h ( q ) , y is not filtered ] ≤ q 2 p 2 .

Original: Assume that LSF has the property ln (1 /q 1 ) / ln
Revised: Assume that LSF has the property ln (1 /q 1 ) / ln

Original: (1 /q 2 ) ≤ ρ , applying hashing and filtering, we can solve ( c, r ) -NN with the new exponent ρ ′ ≤ ρ .
Revised: (1 /q 2 ) ≤ ρ , applying hashing and filtering, we can solve ( c, r ) -NN with the new exponent ρ ′ ≤ ρ .

Original: Benefits of LSF.
Revised: Benefits of LSF.

Original: Given the condition ln (1 /q 1 ) / ln (1 /q 2 ) ≤ ρ of LSF, combining filtering and hashing mechanisms leads to a faster LSH-based ( c, r ) -NN solver since ρ ′ ≤ ρ .
Revised: Given the condition ln (1 /q 1 ) / ln (1 /q 2 ) ≤ ρ of LSF, combining filtering and hashing mechanisms leads to a faster LSH-based ( c, r ) -NN solver since ρ ′ ≤ ρ .

Original: We note that the number of required tables is now O (1 /q 1 p 1 ) whereas the standard LSH only needs O (1 /p 1 ) .
Revised: We note that the number of required tables is now O (1 /q 1 p 1 ) whereas the standard LSH only needs O (1 /p 1 ) .

Original: Since the number of close points is often much smaller than the number of far away points in real-world data sets, an LSF table contains substantially less than nq 1 points in practice.
Revised: Since the number of close points is often much smaller than the number of far away points in real-world data sets, an LSF table contains substantially less than nq 1 points in practice.

Original: Therefore, the combination of LSF and LSH improves both query time and indexing space compared to LSH.
Revised: Therefore, the combination of LSF and LSH improves both query time and indexing space compared to LSH.

Original: Challenges.
Revised: Challenges.

Original: The challenge is how to design an LSF mechanism with ln (1 /q 1 ) / ln (1 /q 2 ) ≤ 1 /csince Falconn has an asymptotically optimal ρ ≈ 1 /c 2 .
Revised: The challenge is how to design an LSF mechanism with ln (1 /q 1 ) / ln (1 /q 2 ) ≤ 1 /csince Falconn has an asymptotically optimal ρ ≈ 1 /c 2 .

Original: If this condition does not hold, the LSF mechanism will increase the exponent ρ and degrade the querying performance.
Revised: If this condition does not hold, the LSF mechanism will increase the exponent ρ and degrade the querying performance.

Original: For example, randomly discarding a point in a bucket will increase ρ .
Revised: For example, randomly discarding a point in a bucket will increase ρ .

Original: Next, we will instantiate the LSF mechanism based on the CEOs property, which leads to an evolution of Falconn for angular distance.
Revised: Next, we will instantiate the LSF mechanism based on the CEOs property, which leads to an evolution of Falconn for angular distance.

Original: 3.2 LSF with CEOs
Revised: 3.2 LSF with CEOs

Original: Given sufficiently large D random vectors r i , w.l.o.g.
Revised: Given sufficiently large D random vectors r i , w.l.o.g.

Original: we assume h ( q ) =
Revised: we assume h ( q ) =

Original: r 1 = arg max r i q ⊤ r i .
Revised: r 1 = arg max r i q ⊤ r i .

Original: We denote by random variables X
Revised: We denote by random variables X

Original: =
Revised: =

Original: x ⊤ r 1 , Y =
Revised: x ⊤ r 1 , Y =

Original: y ⊤ r 1 corresponding to x , y in the bucket h ( q ) .
Revised: y ⊤ r 1 corresponding to x , y in the bucket h ( q ) .

Original: From
Revised: From

Original: Lemma 2 we have X ∼ N (cid:16)
Revised: Lemma 2 we have X ∼ N (cid:16)

Original: [Equation]
Revised: [Equation]

Original: Exploiting this property, we propose the filtering mechanism as follows:
Revised: Exploiting this property, we propose the filtering mechanism as follows:

Original: Given a threshold t = (1 − r 2 / 2) √ 2 ln D , in each bucket, we keep any point x if x ⊤ r 1 ≥ t and discard any point y if y ⊤ r 1 < t .
Revised: Given a threshold t = (1 − r 2 / 2) √ 2 ln D , in each bucket, we keep any point x if x ⊤ r 1 ≥ t and discard any point y if y ⊤ r 1 < t .

Original: The following theorem shows that our mechanism is locality-sensitive.
Revised: The following theorem shows that our mechanism is locality-sensitive.

Original: Theorem 1.
Revised: Theorem 1.

Original: Given sufficiently large D random vectors and c > 1 , the proposed filtering mechanism asymptotically has the following properties:
Revised: Given sufficiently large D random vectors and c > 1 , the proposed filtering mechanism asymptotically has the following properties:

Original: • If ∥ x − q ∥ ≤ r , then Pr [ x is not filtered ] ≥ q 1 = 1 / 2 ; • If ∥ y − q ∥ ≥ cr , then Pr [ y is not filtered ] ≤ q 2 = 1 γ √ 2 π exp( − γ 2 / 2) <
Revised: • If ∥ x − q ∥ ≤ r , then Pr [ x is not filtered ] ≥ q 1 = 1 / 2 ; • If ∥ y − q ∥ ≥ cr , then Pr [ y is not filtered ] ≤ q 2 = 1 γ √ 2 π exp( − γ 2 / 2) <

Original: q 1 where γ = cr (1 − 1 /c 2 ) √ 4 − c 2 r 2 · √ 2 ln D .
Revised: q 1 where γ = cr (1 − 1 /c 2 ) √ 4 − c 2 r 2 · √ 2 ln D .

Original: The proof uses a classical tail bound on normal variables X, Y over t (see the supplementary materials for details).
Revised: The proof uses a classical tail bound on normal variables X, Y over t (see the supplementary materials for details).

Original: Given a sufficiently large D , we can make ln (1 /q 1 ) / ln
Revised: Given a sufficiently large D , we can make ln (1 /q 1 ) / ln

Original: (1 /q 2 ) arbitrarily smaller than 1 /c 2 .
Revised: (1 /q 2 ) arbitrarily smaller than 1 /c 2 .

Original: Hence, the proposed LSF mechanism can be used to improve Falconn for ANNS.
Revised: Hence, the proposed LSF mechanism can be used to improve Falconn for ANNS.

Original: 3.3 Falconn++: A locality-sensitive filtering approach
Revised: 3.3 Falconn++: A locality-sensitive filtering approach

Original: Falconn++ is an essential combination between the proposed LSF and the cross-polytope LSH of
Revised: Falconn++ is an essential combination between the proposed LSF and the cross-polytope LSH of

Original: Falconn using sufficiently large D random vectors.
Revised: Falconn using sufficiently large D random vectors.

Original: For each bucket, we simply filter out potential far away points if its projection value is smaller than t =
Revised: For each bucket, we simply filter out potential far away points if its projection value is smaller than t =

Original: (1 − r 2 / 2) √ 2 ln D .
Revised: (1 − r 2 / 2) √ 2 ln D .

Original: From Theorem 1, we have: ln (1 /q 1 ) =
Revised: From Theorem 1, we have: ln (1 /q 1 ) =

Original: ln 2 and ln (1 /q 2 ) =ln
Revised: ln 2 and ln (1 /q 2 ) =

Original: [Equation] √ 2 π ) + ln γ + γ 2 / 2 , where γ = cr (1 − 1 /c 2 ) √ 4 − c 2 r 2 · √ 2 ln D .
Revised: ln ( √ 2 π ) + ln γ + γ 2 / 2 , where γ = cr (1 − 1 /c 2 ) √ 4 − c 2 r 2 · √ 2 ln D .

Original: For a large D , we have ln (1 /q 2 )
Revised: For a large D , we have ln (1 /q 2 )

Original: ≈ γ 2 / 

Revised: ≈ γ 2 /

Original: = (1 − 1 /c 2 ) 2 4 /c 2 r 2 − 1 · ln D .
Revised: = (1 − 1 /c 2 ) 2 4 /c 2 r 2 − 1 · ln D .

Original: The new exponent ρ ′ of Falconn++ on answering ( c, r ) -NN is strictly smaller than the exponent ρ of Falconn since
Revised: The new exponent ρ ′ of Falconn++ on answering ( c, r ) -NN is strictly smaller than the exponent ρ of Falconn since

Original: [Equation]
Revised: [Equation]

Original: For a small c , ρ ≈ 1 /c 2 and ρ ′ ≈ 1 / (2 c 2 − 2 + 1 /c 2 ) .
Revised: For a small c , ρ ≈ 1 /c 2 and ρ ′ ≈ 1 / (2 c 2 − 2 + 1 /c 2 ) .

Original: Figure 1b shows a clear gap between ρ ′ compared to ρ on various settings of r and c .
Revised: Figure 1b shows a clear gap between ρ ′ compared to ρ on various settings of r and c .

Original: Discussion on the lower bounds.
Revised: Discussion on the lower bounds.

Original: For a positive integer l ≥ 1 , the lower bound ρ ≥ 1 /c 2 − o (1) [18, Theorem 4.1] for data-independent ( r, cr, p 1 , p 2 ) -sensitive LSH families on Euclidean space requires pl 2 = 1 /n to yield an O (cid:0)dn + n 1+ ρ (cid:1) space and O ( dn ρ ) time.
Revised: The lower bound ρ ≥ 1 /c 2 − o (1) [18, Theorem 4.1] for dataindependent ( r, cr, p 1 , p 2 ) -sensitive LSH families on Euclidean space requires p 2 = 1 /n to yield an O (cid:0) n 1+ ρ (cid:1) space and O ( n ρ ) distance computations.

Original: Setting ( p 2 q 2) l = 1 /n , we have: 
Revised: Given the setting p 2 q 2 = 1 /n , we have: (cid:18) (1 − 1 /

Original: [Equation]
Revised: [Equation]

Original: To ensure Falconn++ has an O (cid:16) dn ρ ′ (cid:17) query time, we need D
Revised: To ensure Falconn++ has an O (cid:16) dn ρ ′ (cid:17) query time, we need D

Original: = O (cid:16)
Revised: = O (cid:16)

Original: n ρ ′ (cid:17). We set 4 /r 2 − 1 ≤ l , and hence r ≥2 / √ 1 + l .
Revised: n ρ ′ (cid:17) , and hence r ≥ √ 2 .

Original: We emphasize that the theoretical improvement of Falconn++ over the lower bound is only in a certain range of r .
Revised: We emphasize that the theoretical improvement of Falconn++ over the lower bound is only in a certain range of r .

Original: Following the same line of argument, one can show that this condition is also necessary for Falconn to yield an O ( dn ρ ) query time.
Revised: Note that this condition is also necessary for Falconn. Since nearest neighbors tend to be orthogonal, i.e. r ≈ √ 2 , in high dimensions, and distance computation often dominates hash evaluation, we can use a significantly large D to boost the practical performance of Falconn variants.

Original: Connection to recent LSF frameworks.
Revised: Connection to recent LSF frameworks.

Original: Our proposed LSF mechanism combined with Falconn can be seen as a practical instance of the asymmetric LSF frameworks recently studied in theory [4, 8].
Revised: Our proposed LSF mechanism combined with Falconn can be seen as a practical instance of the asymmetric LSF frameworks recently studied in theory [4, 8].

Original: These frameworks use different filtering conditions on the data and query points to govern the spacetime tradeoff of ANNS.
Revised: These frameworks use different filtering conditions on the data and query points to govern the spacetime tradeoff of ANNS.

Original: In particular, given two thresholds t u , t q , over the random choice of r i , the r i iProbes largest
Revised: In particular, given two thresholds t u , t q , over the random choice of r i , the r i iProbes largest

Original: LSF frameworks study the probability where both x and q pass the filter corresponding to r i , i.e.
Revised: LSF frameworks study the probability where both x and q pass the filter corresponding to r i , i.e.

Original: Pr (cid:2) x ⊤ r i ≥ t u , q ⊤ r i ≥ t q (cid:3) .
Revised: Pr (cid:2) x ⊤ r i ≥ t u , q ⊤ r i ≥ t q (cid:3) .

Original: Indeed, Falconn++ can be seen as a specific design of the asymmetric
Revised: Indeed, Falconn++ can be seen as a specific design of the asymmetric

Original: LSF framework where we utilize cross-polytope LSH to implement the filtering condition for queries and the asymptotic property of CEOs to implement the filtering condition for data points.
Revised: LSF framework where we utilize cross-polytope LSH to implement the filtering condition for queries and the asymptotic property of CEOs to implement the filtering condition for data points.

Original: We believe that our approach is much simpler in terms of theoretical analysis and practical implementation.
Revised: We believe that our approach is much simpler in terms of theoretical analysis and practical implementation.

Original: Empirically, we observe that Falconn++ with practical add-ons provides higher search recall than the corresponding instantiation of the theoretical LSF frameworks.
Revised: Empirically, we observe that Falconn++ with practical add-ons provides higher search recall than the corresponding instantiation of the theoretical LSF frameworks.

Original: 3.4 Practical implementation and add-ons of Falconn++
Revised: 3.4 Practical implementation and add-ons of Falconn++

Original: In the previous section, we prove that there exists a threshold t so that Falconn++ runs faster and uses less indexing space on answering ( c, r ) -NN than Falconn.
Revised: In the previous section, we prove that there exists a threshold t so that Falconn++ runs faster and uses less indexing space on answering ( c, r ) -NN than Falconn.

Original: Since the nearest neighbor distance is different from different queries in practice, it is difficult to find an optimal t for all queries.
Revised: Since the nearest neighbor distance is different from different queries in practice, it is difficult to find an optimal t for all queries.

Original: We simplify the process of selecting t by introducing a scaling factor 0 < α < 1 to control the fraction of number of points in a bucket.
Revised: We simplify the process of selecting t by introducing a scaling factor 0 < α < 1 to control the fraction of number of points in a bucket.

Original: In particular, for any bucket of size B corresponding to the random vector r
Revised: In particular, for any bucket of size B corresponding to the random vector r

Original: i , we keep only the top- ( αB ) points x where | x ⊤ r i | is largest.
Revised: i , we keep only the top- ( αB ) points x where | x ⊤ r i | is largest.

Original: Hence, the total number of points in one hash table is scaled to αn .
Revised: Hence, the total number of points in one hash table is scaled to αn .

Original: Selecting an α fraction of points in a bucket is similar to selecting different values of t on different density areas.
Revised: Selecting an α fraction of points in a bucket is similar to selecting different values of t on different density areas.

Original: In particular, we tend to use a larger t for large buckets covering dense areas, and a smaller t for small buckets covering sparse areas.
Revised: In particular, we tend to use a larger t for large buckets covering dense areas, and a smaller t for small buckets covering sparse areas.

Original: This simple scheme can be seen as a data-dependent
Revised: This simple scheme can be seen as a data-dependent

Original: LSF without any training phase.
Revised: LSF without any training phase.

Original: Multi-probing for indexing:
Revised: Multi-probing for indexing:

Original: A new add-on.
Revised: A new add-on.

Original: We note that multi-probing is motivated by the observation that randomly perturbing q generates many perturbed objects that tend to be close to q and to be hashed into the same bucket with q ’s nearest neighbors [19].
Revised: We note that multi-probing is motivated by the observation that randomly perturbing q generates many perturbed objects that tend to be close to q and to be hashed into the same bucket with q ’s nearest neighbors [19].

Original: This observation is also true in the reverse case where we perturb q ’s nearest neighbors to form new perturbed objects that tend to be hashed into the q ’s bucket.
Revised: This observation is also true in the reverse case where we perturb q ’s nearest neighbors to form new perturbed objects that tend to be hashed into the q ’s bucket.

Original: Hence, multi-probing can be used for indexing where we hash one point into multiple buckets.
Revised: Hence, multi-probing can be used for indexing where we hash one point into multiple buckets.

Original: However, the downside of this approach is an increase of the table size from n to iProbes · n points where iProbes ≥ 1 is the number of indexing probes for one data point.
Revised: However, the downside of this approach is an increase of the table size from n to iProbes · n points where iProbes ≥ 1 is the number of indexing probes for one data point.

Original: Therefore, multi-probing for indexing has not been used in practice.
Revised: Therefore, multi-probing for indexing has not been used in practice.

Original: We note that the key feature of Falconn++ is the capacity to rank and filter out the points in any bucket based on their projection values to govern the space complexity.
Revised: We note that the key feature of Falconn++ is the capacity to rank and filter out the points in any bucket based on their projection values to govern the space complexity.

Original: Given this mechanism,
Revised: Given this mechanism,

Original: Falconn++ can utilize multi-probe indexing to improve the query performance without increasing the indexing space.
Revised: Falconn++ can utilize multi-probe indexing to improve the query performance without increasing the indexing space.

Original: Particularly, after executing D random projections, we add x into the iProbes buckets corresponding to the top- iProbes random vector r i closest or furthest to x , as shown in
Revised: Particularly, after executing D random projections, we add x into the iProbes buckets corresponding to the top- iProbes random vector r i closest or furthest to x , as shown in

Original: Algorithm 1.
Revised: Algorithm 1.

Original: Since we further scale each bucket by iProbes times, the number of points in a table is still αn .
Revised: Since we further scale each bucket by iProbes times, the number of points in a table is still αn .

Original: Empirically, a large iProbes does not improve the performance of Falconn++ since we likely keep points closest to the random vector r i .
Revised: Empirically, a large iProbes does not improve the performance of Falconn++ since we likely keep points closest to the random vector r i .

Original: When q is not close enough to r i , we will get all false positive candidates.
Revised: When q is not close enough to r i , we will get all false positive candidates.

Original: Multi-probing for querying:
Revised: Multi-probing for querying:

Original: A new criteria.
Revised: A new criteria.

Original: Among D random vectors, the CEOs property asymptotically holds for the 2 s 0 closest and furthest random vectors to q for a constant s 0 > 0 .
Revised: Among D random vectors, the CEOs property asymptotically holds for the 2 s 0 closest and furthest random vectors to q for a constant s 0 > 0 .

Original: Hence, Falconn++ can probe up to 2 s 0 buckets on each table.
Revised: Hence, Falconn++ can probe up to 2 s 0 buckets on each table.

Original: Unlike Falconn, we rank the probing sequences based on | q ⊤ r i | where r i is the random vector corresponding to the probing bucket.
Revised: Unlike Falconn, we rank the probing sequences based on | q ⊤ r i | where r i is the random vector corresponding to the probing bucket.

Original: New heuristics makes Falconn++ more efficient.
Revised: New heuristics makes Falconn++ more efficient.

Original: Besides the Structured Spinners [2] that exploit the fast Hadamard transform (FHT) to simulate Gaussian random projections in O ( D log D ) time, we propose other heuristics to improve the performance of Falconn++.
Revised: Besides the Structured Spinners [2] that exploit the fast Hadamard transform (FHT) to simulate Gaussian random projections in O ( D log D ) time, we propose other heuristics to improve the performance of Falconn++.

Original: [Figure]
Revised: [Figure]

Original: (1) Centering the data points.
Revised: (1) Centering the data points.

Original: We observe that when the data set distribution is skewed on a specific area of the sphere, Falconn variants do not perform well.
Revised: We observe that when the data set distribution is skewed on a specific area of the sphere, Falconn variants do not perform well.

Original: This is because most data points will be hashed into a few buckets.
Revised: This is because most data points will be hashed into a few buckets.

Original: To handle this issue, we center the data set before building the index.
Revised: To handle this issue, we center the data set before building the index.

Original: Denote by c = (cid:80) i x i /n the center of X , we map x i (cid:55)→ x ′ i
Revised: Denote by c = (cid:80) i x i /n the center of X , we map x i (cid:55)→ x ′ i

Original: = x i − c .
Revised: = x i − c .

Original: This mapping can diverge X to the whole sphere and hence increases the performance of Falconn variants.
Revised: This mapping can diverge X to the whole sphere and hence increases the performance of Falconn variants.

Original: We note that after centering, arg max x ∈ X x ⊤ q = arg max x ′ ∈ X x ′⊤ q .
Revised: We note that after centering, arg max x ∈ X x ⊤ q = arg max x ′ ∈ X x ′⊤ q .

Original: Although ∥ x ′ i ∥ ̸ = 1 , it does not affect the performance of Falconn++ since the CEOs property holds for the general inner product [20].
Revised: Although ∥ x ′ i ∥ ̸ = 1 , it does not affect the performance of Falconn++ since the CEOs property holds for the general inner product [20].

Original: (2) Limit scaling.
Revised: (2) Limit scaling.

Original: We observe that we do not need to scale small buckets since they might already contain high quality candidates.
Revised: We observe that we do not need to scale small buckets since they might already contain high quality candidates.

Original: While we are scaling the bucket size on Line 6, Algorithm 1, we keep max ( k, αB/iProbes ) points.
Revised: While we are scaling the bucket size on Line 6, Algorithm 1, we keep max ( k, αB/iProbes ) points.

Original: Note that this trick will increase space usage in practice.
Revised: Note that this trick will increase space usage in practice.

Original: However, it achieves a better recall-speed tradeoff given the same space complexity configuration.
Revised: However, it achieves a better recall-speed tradeoff given the same space complexity configuration.

Original:  Experiment
Revised:  Experiment

Original: We implement Falconn and Falconn++ in C++ and compile with g++ -O3 -std
Revised: We implement Falconn and Falconn++ in C++ and compile with g++ -O3 -std

Original: =c++17 -fopenmp -march
Revised: =c++17 -fopenmp -march

Original: =native .
Revised: =native .

Original: We conduct experiments on Ubuntu 20.04.4 with an AMD Ryzen Threadripper 3970X CPU 2.2 MHz, 128GB of RAM using 64 threads.
Revised: We conduct experiments on Ubuntu 20.04.4 with an AMD Ryzen Threadripper 3970X CPU 2.2 MHz, 128GB of RAM using 64 threads.

Original: We present empirical evaluations on top- k
Revised: We present empirical evaluations on top- k

Original: NNS to verify our claims, including:
Revised: NNS to verify our claims, including:

Original: • Falconn++ with multi-probe indexing and querying provides higher search recall-speed tradeoffs than FalconnLib 1 given the same amount of indexing space.
Revised: • Falconn++ with multi-probe indexing and querying provides higher search recall-speed tradeoffs than FalconnLib 1 given the same amount of indexing space.

Original: • Falconn++ builds index faster and achieves competitive recall-speed tradeoffs compared to HNSW, 2 a recent efficient graph-based solution for ANNS on high search recall regimes.
Revised: • Falconn++ builds index faster and achieves competitive recall-speed tradeoffs compared to HNSW, 2 a recent efficient graph-based solution for ANNS on high search recall regimes.

Original: We set k = 20 for all experiments.
Revised: We set k = 20 for all experiments.

Original: We use the average number of queries per second and Recall @ 20 to measure recall-speed tradeoffs.
Revised: We use the average number of queries per second and Recall @ 20 to measure recall-speed tradeoffs.

Original: A better solution will give the recall-speed curve towards the top right corner.
Revised: A better solution will give the recall-speed curve towards the top right corner.

Original: We conduct experiments on three popular data sets, including Glove200 ( n = 1 , 183 , 514 , d = 200 ), Glove300 ( n = 2 , 196 , 017 , d = 300 ), and NYTimes ( n = 290 , 000 , d = 256 ).
Revised: We conduct experiments on three popular data sets, including Glove200 ( n = 1 , 183 , 514 , d = 200 ), Glove300 ( n = 2 , 196 , 017 , d = 300 ), and NYTimes ( n = 290 , 000 , d = 256 ).

Original: We extract 1000 points to form the query set.
Revised: We extract 1000 points to form the query set.

Original: All results are the average of 5 runs of the algorithms.
Revised: All results are the average of 5 runs of the algorithms.

Original: A note on our implementation ( https://github.com/NinhPham/FalconnLSF ).
Revised: A note on our implementation ( https://github.com/NinhPham/FalconnLSF ).

Original: Our implementation uses std::vector to store hash tables and the Eigen library 3 for SIMD vectorization.
Revised: Our implementation uses std::vector to store hash tables and the Eigen library 3 for SIMD vectorization.

Original: We use boost::dynamic_bitset to remove duplicated candidates.
Revised: We use boost::dynamic_bitset to remove duplicated candidates.

Original: For multi-threading, we add #pragma omp parallel directive on the for loop over 1000 queries.
Revised: For multi-threading, we add #pragma omp parallel directive on the for loop over 1000 queries.

Original: Compared to the released FalconnLib and HnswLib, our implementation is rather straightforward and lacks many optimized routines, such as prefetching instructions, optimized multi-threading primitives, and other hardware-specific optimizations.
Revised: Compared to the released FalconnLib and HnswLib, our implementation is rather straightforward and lacks many optimized routines, such as prefetching instructions, optimized multi-threading primitives, and other hardware-specific optimizations.

Original: Given the same configuration, our Falconn’s indexing time is 3 times slower than
Revised: Given the same configuration, our Falconn’s indexing time is 3 times slower than

Original: FalconnLib.
Revised: FalconnLib.

Original: Though Falconn++ still provides higher search-recall tradeoffs than these two highly optimized libraries, we believe there are rooms to engineer Falconn++ for further improvements.
Revised: Though Falconn++ still provides higher search-recall tradeoffs than these two highly optimized libraries, we believe there are rooms to engineer Falconn++ for further improvements.

Original: Falconn++ and FalconnLib parameter settings.
Revised: Falconn++ and FalconnLib parameter settings.

Original: FalconnLib uses the number of bits to control the number of buckets in a hash table, which implicitly governs the number of concatenating hash functions l .
Revised: FalconnLib uses the number of bits to control the number of buckets in a hash table, which implicitly governs the number of concatenating hash functions l .

Original: In the experiment, our Falconn and Falconn++ use l = 2 and explicitly set the number of buckets via the number of random projections D .
Revised: In the experiment, our Falconn and Falconn++ use l = 2 and explicitly set the number of buckets via the number of random projections D .

Original: Since each hash function returns 2 D different hash
Revised: Since each hash function returns 2 D different hash

Original: [Figure]
Revised: [Figure]

Original: values, Falconn++ has 4 D 2 buckets on a hash table.
Revised: values, Falconn++ has 4 D 2 buckets on a hash table.

Original: For example, on Glove200 where d = 200 , the setting D = 256 = 2 8 of Falconn++ leads to the suggested configuration of FalconnLib using 18 bits.
Revised: For example, on Glove200 where d = 200 , the setting D = 256 = 2 8 of Falconn++ leads to the suggested configuration of FalconnLib using 18 bits.

Original: Regarding the indexing space, both Falconn++ and Falconn use roughly the same memory footprint to contain the same number of points in a hash table.
Revised: Regarding the indexing space, both Falconn++ and Falconn use roughly the same memory footprint to contain the same number of points in a hash table.

Original: 4.1 An ablation study on Glove 
Revised: 4.1 An ablation study on Glove

Original: This subsection measures the performance of our implemented Falconn++ and Falconn.
Revised: This subsection measures the performance of our implemented Falconn++ and Falconn.

Original: We show the advantage of functionalities of Falconn++, including multi-probe indexing and proposed heuristics for improving the recall-time tradeoff.
Revised: We show the advantage of functionalities of Falconn++, including multi-probe indexing and proposed heuristics for improving the recall-time tradeoff.

Original: We conduct the experiments on Glove200 using 64 threads.
Revised: We conduct the experiments on Glove200 using 64 threads.

Original: Both Falconn variants use D = 256 .
Revised: Both Falconn variants use D = 256 .

Original: To have the same indexing space, Falconn uses L hash tables and Falconn++ uses L/α where α is a scaling factor.
Revised: To have the same indexing space, Falconn uses L hash tables and Falconn++ uses L/α where α is a scaling factor.

Original: Falconn++ with index probing iProbes uses
Revised: Falconn++ with index probing iProbes uses

Original: L/ ( α · iProbes ) .
Revised: L/ ( α · iProbes ) .

Original: Note that Falconn is Falconn++ with iProbes
Revised: Note that Falconn is Falconn++ with iProbes

Original: = 1 , α = 1 .
Revised: = 1 , α = 1 .

Original: Falconn++ with multi-probing.
Revised: Falconn++ with multi-probing.

Original: Figure 2 shows the recall-time tradeoffs of Falconn++ with various settings of L and α such that the total number of points in all tables is αnL .
Revised: Figure 2 shows the recall-time tradeoffs of Falconn++ with various settings of L and α such that the total number of points in all tables is αnL .

Original: Falconn uses qProbes = {1000, ..., 10000} and Falconn++ uses qProbes/α to have a similar number of candidates.
Revised: Falconn uses qProbes = {1000, ..., 10000} and Falconn++ uses qProbes/α to have a similar number of candidates.

Original: Without index probing, i.e. iProbes = 1 , Figure 2a shows that Falconn++ has lower query time than
Revised: Without index probing, i.e. iProbes = 1 , Figure 2a shows that Falconn++ has lower query time than

Original: Falconn given the same recall rate.
Revised: Falconn given the same recall rate.

Original: Falconn++ achieves better recall-time tradeoffs when α is smaller.
Revised: Falconn++ achieves better recall-time tradeoffs when α is smaller.

Original: Figure 2b explains the superiority of Falconn++.
Revised: Figure 2b explains the superiority of Falconn++.

Original: Given qProbes/α probes, α = 0 .
Revised: Given qProbes/α probes, α = 0 .

Original: 1 leads to the smallest candidate sizes for the same recall though Falconn++’s indexing time is increased by 1 /α .
Revised: 1 leads to the smallest candidate sizes for the same recall though Falconn++’s indexing time is increased by 1 /α .

Original: With the index probing, Falconn++ with L = 500 , α = 0 .
Revised: With the index probing, Falconn++ with L = 500 , α = 0 .

Original: 1 improves the performance with iProbes = 3 in Figure 2c.
Revised: 1 improves the performance with iProbes = 3 in Figure 2c.

Original: Larger iProbes values are not helpful since Falconn++ tends to keep points closest or furthest to the random vectors only.
Revised: Larger iProbes values are not helpful since Falconn++ tends to keep points closest or furthest to the random vectors only.

Original: Falconn++ with new heuristics.
Revised: Falconn++ with new heuristics.

Original: Figure 3 shows the performance of Falconn++ with the centering and limit scaling heuristics.
Revised: Figure 3 shows the performance of Falconn++ with the centering and limit scaling heuristics.

Original: Given L = 500 , α = 0 . 1 , iProbes = 3 , the limit scaling that keeps max ( k, αB/iProbes ) points in any bucket increases the number of points in a table from 0 .
Revised: Given L = 500 , α = 0 . 1 , iProbes = 3 , the limit scaling that keeps max ( k, αB/iProbes ) points in any bucket increases the number of points in a table from 0 .

Original: 1 n to 2 .
Revised: 1 n to 2 .

Original: 42 n points.
Revised: 42 n points.

Original: This is because many empty or small buckets tend to contain more points (up to k = 20 ) with index probing.
Revised: This is because many empty or small buckets tend to contain more points (up to k = 20 ) with index probing.

Original: However, such an increased number of points in a table pay off.
Revised: However, such an increased number of points in a table pay off.

Original: Each bucket has sufficient high quality candidates and hence we do not need a large qProbes to get high recalls.
Revised: Each bucket has sufficient high quality candidates and hence we do not need a large qProbes to get high recalls.

Original: In this case, one hash table of Falconn++ can be seen as a “merged version” of 3 hash tables of Falconn.
Revised: In this case, one hash table of Falconn++ can be seen as a “merged version” of 3 hash tables of Falconn.

Original: Figure 3a shows the recall-speed comparison between Falconn++ with centering and limit scaling heuristics and Falconn variants given the same 2 .
Revised: Figure 3a shows the recall-speed comparison between Falconn++ with centering and limit scaling heuristics and Falconn variants given the same 2 .

Original: 42 · nL points in the index.
Revised: 42 · nL points in the index.

Original: Though Falconn with the centering heuristic achieves higher tradeoffs than standard Falconn, both of them with L =tables are inferior to Falconn++.
Revised: Though Falconn with the centering heuristic achieves higher tradeoffs than standard Falconn, both of them with L =tables are inferior to Falconn++.

Original: Figure 3b shows that the centering heuristic provides better candidates as Falconn++ and centering Falconn use a similar number of inner product computations to achieve the same recall.
Revised: Figure 3b shows that the centering heuristic provides better candidates as Falconn++ and centering Falconn use a similar number of inner product computations to achieve the same recall.

Original: Figure 3c shows the query time breakdown components.
Revised: Figure 3c shows the query time breakdown components.

Original: Since Falconn++ uses less L and qProbes , it has less hashing and probing time and hence less total query time compared to the centering Falconn given the same 95% recall ratio.
Revised: Since Falconn++ uses less L and qProbes , it has less hashing and probing time and hence less total query time compared to the centering Falconn given the same 95% recall ratio.

Original: Falconn++ parameter settings.
Revised: Falconn++ parameter settings.

Original: Falconn++ has several parameters, including L , D , iProbes , α , qProbes .
Revised: Falconn++ has several parameters, including L , D , iProbes , α , qProbes .

Original: Since increasing iProbes will degrade the performance (see Figure 2c), we need iProbes large enough to ensure that each bucket has approximately k candidates.
Revised: Since increasing iProbes will degrade the performance (see Figure 2c), we need iProbes large enough to ensure that each bucket has approximately k candidates.

Original: Note that Falconn++ uses 2 LSH functions and hence has 4 D 2 buckets.
Revised: Note that Falconn++ uses 2 LSH functions and hence has 4 D 2 buckets.

Original: With index probing, we expect the number
Revised: With index probing, we expect the number

Original: [Figure]
Revised: [Figure]

Original: # Q ue r i e s pe r
Revised: # Q ue r i e s pe r

Original: [Figure]
Revised: [Figure]

Original: e c
Revised: e c

Original: [Figure]
Revised: [Figure]

Original: FalconnLib 0.
Revised: FalconnLib 0.

Original: [Figure] [Figure]
Revised: [Figure] [Figure]

Original: # Q ue r i e s
Revised: # Q ue r i e s

Original: [Figure]
Revised: [Figure]

Original: FalconnLib
Revised: FalconnLib

Original: [Figure] [Figure]
Revised: [Figure] [Figure]

Original: [Figure] [Figure]
Revised: [Figure] [Figure]

Original: of points in a table, i.e. n · iProbes , will be distributed uniformly into 4 D 2 buckets and each bucket has n · iProbes/ 4 D 2 points in expectation.
Revised: of points in a table, i.e. n · iProbes , will be distributed uniformly into 4 D 2 buckets and each bucket has n · iProbes/ 4 D 2 points in expectation.

Original: We heuristically select iProbes and D such that k ≈ n · iProbes/ 4 D 2 .
Revised: We heuristically select iProbes and D such that k ≈ n · iProbes/ 4 D 2 .

Original: For instance, on Glove200: n = 1 M , D = 256 , k = 20 , the choice of iProbes = 3 , D = 256 leads to 1 M · 3 / 2 18 = 2 4 = 16 <
Revised: For instance, on Glove200: n = 1 M , D = 256 , k = 20 , the choice of iProbes = 3 , D = 256 leads to 1 M · 3 / 2 18 = 2 4 = 16 <

Original: k = 20 points in a bucket in expectation.
Revised: k = 20 points in a bucket in expectation.

Original: L and α depend on the available memory footprint, and qProbes depends on the required recall ratio.
Revised: L and α depend on the available memory footprint, and qProbes depends on the required recall ratio.

Original: 4.2 Comparison between Falconn++ and FalconnLib
Revised: 4.2 Comparison between Falconn++ and FalconnLib

Original: This subsection compares our implemented Falconn++ with the released FalconnLib [2] given the same number of points in the index.
Revised: This subsection compares our implemented Falconn++ with the released FalconnLib [2] given the same number of points in the index.

Original: Since FalconnLib does not support multi-threading for querying,
Revised: Since FalconnLib does not support multi-threading for querying,

Original: Falconn++ uses 1 thread for a sake of comparison.
Revised: Falconn++ uses 1 thread for a sake of comparison.

Original: Falconn++ uses L = 50 , α = 0 .
Revised: Falconn++ uses L = 50 , α = 0 .

Original: 1 , iProbes = 10 on NYTimes, L = 500 , α = 0 .
Revised: 1 , iProbes = 10 on NYTimes, L = 500 , α = 0 .

Original: 1 , iProbes = 1 on
Revised: 1 , iProbes = 1 on

Original: Glove300, and L = 500 , α = 0 .
Revised: Glove300, and L = 500 , α = 0 .

Original: 1 , iProbes = 3 on Glove200.
Revised: 1 , iProbes = 3 on Glove200.

Original: iProbes are set based on the above heuristic.
Revised: iProbes are set based on the above heuristic.

Original: For each data set, FalconnLib uses the corresponding scaled tables L = { 200 , 50 , 1210 } , respectively, to ensure the same space usage.
Revised: For each data set, FalconnLib uses the corresponding scaled tables L = { 200 , 50 , 1210 } , respectively, to ensure the same space usage.

Original: We observe that FalconnLib needs { 16 , 18 , 18 } bits for the corresponding data sets to yield the highest performance.
Revised: We observe that FalconnLib needs { 16 , 18 , 18 } bits for the corresponding data sets to yield the highest performance.

Original: For Falconn++, we set
Revised: For Falconn++, we set

Original: D = { 128 , 256 , 256 } accordingly.
Revised: D = { 128 , 256 , 256 } accordingly.

Original: For all approaches, we select qProbes = { 1000 , . . .
Revised: For all approaches, we select qProbes = { 1000 , . . .

Original: Figure 4 shows the recall-speed comparison between Falconn++ and FalconnLib on these 3 data sets.
Revised: Figure 4 shows the recall-speed comparison between Falconn++ and FalconnLib on these 3 data sets.

Original: Since the center c ≈ 0 on NYTimes, the centering trick is not necessary.
Revised: Since the center c ≈ 0 on NYTimes, the centering trick is not necessary.

Original: Instead, we plot our own implemented Falconn, which has lower recall-speed tradeoffs than FalconnLib.
Revised: Instead, we plot our own implemented Falconn, which has lower recall-speed tradeoffs than FalconnLib.

Original: This again shows that our implementation is not well-optimized.
Revised: This again shows that our implementation is not well-optimized.

Original: Nevertheless, Falconn++ shows superior performance compared to FalconnLib on the 3 data sets.
Revised: Nevertheless, Falconn++ shows superior performance compared to FalconnLib on the 3 data sets.

Original: The significant improvement is from Glove300 and
Revised: The significant improvement is from Glove300 and

Original: Glove200 where Falconn++ gains substantial advantages from better quality candidates and less number of query probes.
Revised: Glove200 where Falconn++ gains substantial advantages from better quality candidates and less number of query probes.

Original: 4.3 Comparison between Falconn++ and HNSW on high search recall regimes
Revised: 4.3 Comparison between Falconn++ and HNSW on high search recall regimes

Original: This subsection compares Falconn++ with the released HnswLib [16], and Faiss-Hnsw [14], highly optimized libraries for ANNS using 64 threads.
Revised: This subsection compares Falconn++ with the released HnswLib [16], and Faiss-Hnsw [14], highly optimized libraries for ANNS using 64 threads.

Original: HNSW has two parameters to control the indexing space and time, including ef _ index and M .
Revised: HNSW has two parameters to control the indexing space and time, including ef _ index and M .

Original: We set ef _ index = 200 and use M = { 1024 , 512 , 512 } for NYTimes, Glove300, and Glove200, respectively, to achieve high recalls with fast query time.
Revised: We set ef _ index = 200 and use M = { 1024 , 512 , 512 } for NYTimes, Glove300, and Glove200, respectively, to achieve high recalls with fast query time.

Original: Falconn++ uses L = 500 , α = 0 .
Revised: Falconn++ uses L = 500 , α = 0 .

Original: 01 , iProbes = 10 on NYTimes, L = 900 , α = 0 .
Revised: 01 , iProbes = 10 on NYTimes, L = 900 , α = 0 .

Original: iProbes =on Glove300, L = 350 , α = 0 .
Revised: iProbes =on Glove300, L = 350 , α = 0 .

Original: 01 , iProbes = 3 on Glove200 to have the same space as HNSW.
Revised: 01 , iProbes = 3 on Glove200 to have the same space as HNSW.

Original: Figure 5 shows the recall-speed tradeoffs of Falconn++ and HNSW libraries using 1 and 64 threads on NYTimes and Glove200.
Revised: Figure 5 shows the recall-speed tradeoffs of Falconn++ and HNSW libraries using 1 and 64 threads on NYTimes and Glove200.

Original: Falconn++ uses qProbes = { 1000 , . . .
Revised: Falconn++ uses qProbes = { 1000 , . . .

Original: and HNSW sets ef _ query =
Revised: and HNSW sets ef _ query =

Original: Though Falconn++ is not competitive with HnswLib, it outperforms
Revised: Though Falconn++ is not competitive with HnswLib, it outperforms

Original: Faiss-Hnsw with 1 thread at the recall of 97%.
Revised: Faiss-Hnsw with 1 thread at the recall of 97%.

Original: With 64 threads, Falconn++ surpasses both HnswLib and Faiss-Hnsw from recall ratios of 0.97 and 0.94, respectively, on both data sets.
Revised: With 64 threads, Falconn++ surpasses both HnswLib and Faiss-Hnsw from recall ratios of 0.97 and 0.94, respectively, on both data sets.

Original: We observe that the speedup of Falconn++ comes from its simplicity and scalability on multithreading CPUs.
Revised: We observe that the speedup of Falconn++ comes from its simplicity and scalability on multithreading CPUs.

Original: Table 1 shows that Falconn++ achieves higher threading scales than both HnswLib and Faiss-Hnsw when increasing the number of threads on NYTimes and Glove200.
Revised: Table 1 shows that Falconn++ achieves higher threading scales than both HnswLib and Faiss-Hnsw when increasing the number of threads on NYTimes and Glove200.

Original: Both HNSW libraries suffer sufficiently suboptimal scales when the number of threads is larger than 16.
Revised: Both HNSW libraries suffer sufficiently suboptimal scales when the number of threads is larger than 16.

Original: Figure 6 shows the recall-speed comparison between Falconn++, HnswLib, and brute force with the above parameter settings.
Revised: Figure 6 shows the recall-speed comparison between Falconn++, HnswLib, and brute force with the above parameter settings.

Original: Falconn++ provides higher recall-speed tradeoffs than HnswLib when
Revised: Falconn++ provides higher recall-speed tradeoffs than HnswLib when

Original: [Figure] [Figure]
Revised: [Figure] [Figure]

Original: the recall is at least 97% on the 3 data sets.
Revised: the recall is at least 97% on the 3 data sets.

Original: Regarding the indexing space, they use nearly the same amount of RAM, as shown in Table 2.
Revised: Regarding the indexing space, they use nearly the same amount of RAM, as shown in Table 2.

Original: However, Falconn++ builds indexes at least 5 times faster than
Revised: However, Falconn++ builds indexes at least 5 times faster than

Original: HNSW and hence can be better for streaming ANNS applications [23].
Revised: HNSW and hence can be better for streaming ANNS applications [23].

Original: Due to the space limit, we present the comparison of recall-speed tradeoffs between Falconn++, the theoretical LSF frameworks, and other competitive ANNS solvers in the supplementary materials.
Revised: Due to the space limit, we present the comparison of recall-speed tradeoffs between Falconn++, the theoretical LSF frameworks, and other competitive ANNS solvers in the supplementary materials.

Original:  Conclusion
Revised:  Conclusion

Original: We present Falconn++, a practical locality-sensitive filtering scheme for ANNS on angular distance.
Revised: We present Falconn++, a practical locality-sensitive filtering scheme for ANNS on angular distance.

Original: Theoretically, Falconn++ asymptotically has lower query time complexity than Falconn, an optimal
Revised: Theoretically, Falconn++ asymptotically has lower query time complexity than Falconn, an optimal

Original: LSH scheme.
Revised: LSH scheme.

Original: Though our implementation of Falconn++ lacks many optimized routines, Falconn++ with several heuristic add-ons gives higher recall-speed tradeoffs than Falconn.
Revised: Though our implementation of Falconn++ lacks many optimized routines, Falconn++ with several heuristic add-ons gives higher recall-speed tradeoffs than Falconn.

Original: It is also competitive with HNSW, an efficient representative of graph-based solutions on high search recall regimes.
Revised: It is also competitive with HNSW, an efficient representative of graph-based solutions on high search recall regimes.

Original: [Table] [Table]
Revised: [Table] [Table]

Original: Checklist
Revised: Checklist

Original: For all authors... (a) Do the main claims made in the abstract and introduction accurately reflect the paper’s contributions and scope?
Revised: For all authors... (a) Do the main claims made in the abstract and introduction accurately reflect the paper’s contributions and scope?

Original: [Yes] See Section 3 for theoretical results and Section 5 for empirical results.
Revised: [Yes] See Section 3 for theoretical results and Section 5 for empirical results.

Original: (b) Did you describe the limitations of your work?
Revised: (b) Did you describe the limitations of your work?

Original: [Yes] Currently, our implementaion of Falconn++ is not optimized compared to other competitors, especially HNSW.
Revised: [Yes] Currently, our implementaion of Falconn++ is not optimized compared to other competitors, especially HNSW.

Original: We plan to integrate our work into the released FalconnLib to utilize its optimized routines.
Revised: We plan to integrate our work into the released FalconnLib to utilize its optimized routines.

Original: Another issue is the increase of indexing time of Falconn++.
Revised: Another issue is the increase of indexing time of Falconn++.

Original: However, it just takes a few minutes to build the index compared to a half of hour of HNSW on Glove300.
Revised: However, it just takes a few minutes to build the index compared to a half of hour of HNSW on Glove300.

Original: (c) Did you discuss any potential negative societal impacts of your work?
Revised: (c) Did you discuss any potential negative societal impacts of your work?

Original: [N/A] (d) Have you read the ethics review guidelines and ensured that your paper conforms to them?
Revised: [N/A] (d) Have you read the ethics review guidelines and ensured that your paper conforms to them?

Original: [Yes] 2.
Revised: [Yes] 2.

Original: If you are including theoretical results... (a) Did you state the full set of assumptions of all theoretical results?
Revised: If you are including theoretical results... (a) Did you state the full set of assumptions of all theoretical results?

Original: [Yes] The asymptotic results of both Falconn and Falconn++ require a sufficiently large D random vectors.
Revised: [Yes] The asymptotic results of both Falconn and Falconn++ require a sufficiently large D random vectors.

Original: Indeed, Falconn++ built on the CEOs property that requires D → ∞ .
Revised: Indeed, Falconn++ built on the CEOs property that requires D → ∞ .

Original: Nevertheless, we observe that D > 100 works very well in practice.
Revised: Nevertheless, we observe that D > 100 works very well in practice.

Original: (b) Did you include complete proofs of all theoretical results?
Revised: (b) Did you include complete proofs of all theoretical results?

Original: [Yes] Please see the supplementary material for the detailed proof of the main theorem.
Revised: [Yes] Please see the supplementary material for the detailed proof of the main theorem.

Original: If you ran experiments... (a) Did you include the code, data, and instructions needed to reproduce the main experimental results (either in the supplemental material or as a URL)?
Revised: If you ran experiments... (a) Did you include the code, data, and instructions needed to reproduce the main experimental results (either in the supplemental material or as a URL)?

Original: [Yes] Please see the supplementary material.
Revised: [Yes] Please see the supplementary material.

Original: (b) Did you specify all the training details (e.g., data splits, hyperparameters, how they were chosen)?
Revised: (b) Did you specify all the training details (e.g., data splits, hyperparameters, how they were chosen)?

Original: [No] We do not use any training phase.
Revised: [No] We do not use any training phase.

Original: (c) Did you report error bars (e.g., with respect to the random seed after running experiments multiple times)?
Revised: (c) Did you report error bars (e.g., with respect to the random seed after running experiments multiple times)?

Original: [No] The recall-speed deviations of studied algorithms are very tiny.
Revised: [No] The recall-speed deviations of studied algorithms are very tiny.

Original: Hence, we do not report them.
Revised: Hence, we do not report them.

Original: (d) Did you include the total amount of compute and the type of resources used (e.g., type of GPUs, internal cluster, or cloud provider)?
Revised: (d) Did you include the total amount of compute and the type of resources used (e.g., type of GPUs, internal cluster, or cloud provider)?

Original: [Yes] Please see Section 4. 4.
Revised: [Yes] Please see Section 4. 4.

Original: If you are using existing assets (e.g., code, data, models) or curating/releasing new assets... (a) If your work uses existing assets, did you cite the creators?
Revised: If you are using existing assets (e.g., code, data, models) or curating/releasing new assets... (a) If your work uses existing assets, did you cite the creators?

Original: [Yes] We used the released FalconnLib and HnswLib, and public data sets.
Revised: [Yes] We used the released FalconnLib and HnswLib, and public data sets.

Original: (b) Did you mention the license of the assets?
Revised: (b) Did you mention the license of the assets?

Original: [N/A] (c) Did you include any new assets either in the supplemental material or as a URL?
Revised: [N/A] (c) Did you include any new assets either in the supplemental material or as a URL?

Original: [Yes] Falconn++ implementation is at https://github.com/NinhPham/FalconnLSF .
Revised: [Yes] Falconn++ implementation is at https://github.com/NinhPham/FalconnLSF .

Original: (d) Did you discuss whether and how consent was obtained from people whose data you’re using/curating?
Revised: (d) Did you discuss whether and how consent was obtained from people whose data you’re using/curating?

Original: [N/A]
Revised: [N/A]

Original: (e) Did you discuss whether the data you are using/curating contains personally identifiable information or offensive content?
Revised: (e) Did you discuss whether the data you are using/curating contains personally identifiable information or offensive content?

Original: [N/A] 5.
Revised: [N/A] 5.

Original: If you used crowdsourcing or conducted research with human subjects... (a) Did you include the full text of instructions given to participants and screenshots, if applicable?
Revised: If you used crowdsourcing or conducted research with human subjects... (a) Did you include the full text of instructions given to participants and screenshots, if applicable?

Original: [N/A] (b) Did you describe any potential participant risks, with links to Institutional Review Board (IRB) approvals, if applicable?
Revised: [N/A] (b) Did you describe any potential participant risks, with links to Institutional Review Board (IRB) approvals, if applicable?

Original: [N/A] (c) Did you include the estimated hourly wage paid to participants and the total amount spent on participant compensation?
Revised: [N/A] (c) Did you include the estimated hourly wage paid to participants and the total amount spent on participant compensation?

Original: [N/A]
Revised: [N/A]