On Closest Pair in Euclidean Metric: Monochromatic is as Hard as Bichromatic
Karthik C. S., Pasin Manurangsi

TL;DR
This paper proves tight complexity bounds for the Closest Pair problem in high-dimensional Euclidean spaces under SETH, showing it is computationally hard to solve or approximate faster than certain thresholds.
Contribution
It establishes new hardness results for the Closest Pair problem in high dimensions, connecting geometric complexity with fine-grained computational complexity assumptions.
Findings
No $O(n^{2- ext{epsilon}})$ algorithm in high dimensions under SETH.
No $O(n^{1.5- ext{epsilon}})$ approximation algorithm in high dimensions under SETH.
Construction of dense bipartite graphs with low contact dimension for hardness proofs.
Abstract
Given a set of points in , the (monochromatic) Closest Pair problem asks to find a pair of distinct points in the set that are closest in the -metric. Closest Pair is a fundamental problem in Computational Geometry and understanding its fine-grained complexity in the Euclidean metric when was raised as an open question in recent works (Abboud-Rubinstein-Williams [FOCS'17], Williams [SODA'18], David-Karthik-Laekhanukit [SoCG'18]). In this paper, we show that for every , under the Strong Exponential Time Hypothesis (SETH), for every , the following holds: No algorithm running in time can solve the Closest Pair problem in dimensions in the -metric. There exists and $c =…
Peer Reviews
No public reviews on file for this paper yet. If you reviewed it on a platform where reviews are public (OpenReview, ICLR, NeurIPS, ICML), you can paste yours below so the community can read it here.
Videos
No videos yet. Explain this paper in a talk, walkthrough, or lecture? Add one.
Taxonomy
TopicsComputational Geometry and Mesh Generation · Complexity and Algorithms in Graphs · Advanced Graph Theory Research
On Closest Pair in Euclidean Metric:
Monochromatic is as Hard as Bichromatic
Karthik C. S.
Weizmann Institute of Science
[email protected] Supported by Irit Dinur’s ERC-CoG grant 772839 and BSF grant 2014371.
Pasin Manurangsi
University of California, Berkeley
[email protected] Supported by NSF under Grants No. CCF 1655215 and CCF 1815434.
Abstract
Given a set of points in , the (monochromatic) Closest Pair problem asks to find a pair of distinct points in the set that are closest in the -metric. Closest Pair is a fundamental problem in Computational Geometry and understanding its fine-grained complexity in the Euclidean metric when was raised as an open question in recent works (Abboud-Rubinstein-Williams [FOCS’17], Williams [SODA’18], David-Karthik-Laekhanukit [SoCG’18]).
In this paper, we show that for every , under the Strong Exponential Time Hypothesis (), for every , the following holds:
- •
No algorithm running in time can solve the Closest Pair problem in dimensions in the -metric.
- •
There exists and such that no algorithm running in time can approximate Closest Pair problem to a factor of in dimensions in the -metric.
In particular, our first result is shown by establishing the computational equivalence of the bichromatic Closest Pair problem and the (monochromatic) Closest Pair problem (up to factor in the running time) for dimensions.
Additionally, under , we rule out nearly-polynomial factor approximation algorithms running in subquadratic time for the (monochromatic) Maximum Inner Product problem where we are given a set of points in -dimensional Euclidean space and are required to find a pair of distinct points in the set that maximize the inner product.
At the heart of all our proofs is the construction of a dense bipartite graph with low contact dimension, i.e., we construct a balanced bipartite graph on vertices with edges whose vertices can be realized as points in a -dimensional Euclidean space such that every pair of vertices which have an edge in the graph are at distance exactly 1 and every other pair of vertices are at distance greater than 1. This graph construction is inspired by the construction of locally dense codes introduced by Dumer-Miccancio-Sudan [IEEE Trans. Inf. Theory’03].
Contents
-
2.3 Inapproximability of Closest Pair and Maximum Inner Product
-
4 Lower Bound on Closest Pair under Orthogonal Vector Hypothesis
-
5.2.1 The Basic Gadget: Dense Bipartite Graphs with Low Contact Dimensions
-
B Covering Biclique By Isomorphic Graphs: Proof of Lemma 3.11
1 Introduction
The Closest Pair of Points problem or Closest Pair problem () is a fundamental problem in computational geometry: given points in a -dimensional metric space, find a pair of distinct points with the smallest distance between them. The Closest Pair problem for points in the Euclidean plane [SH75, BS76] stands at the origins of the systematic study of the computational complexity of geometric problems [PS85, Man89, KT05, CLRS09]. Since then, this problem has found abundant applications in geographic information systems [Hen06], clustering [Zah71, Alp10], and numerous matching problems (such as stable marriage [WTFX07]).
The trivial algorithm for examines every pair of points in the point-set and runs in time . Over the decades, there have been a series of developments on in low dimensional space for the Euclidean metric [Ben80, HNS88, KM95, SH75, BS76], leading to a deterministic -time algorithm [BS76] and a randomized -time algorithm [Rab76, KM95]. For low (i.e., constant) dimensions, these algorithms are tight as a matching lower bound of was shown by Ben-Or [Ben83] and Yao [Yao91] in the algebraic decision tree model, thus settling the complexity of in low dimensions. On other hand, for very high dimensions (i.e., ) there are subcubic algorithms [GS16, ILLP04] in the and -metrics using fast matrix multiplication algorithms [Gal14]. However, in medium dimensions, i.e., , and in various -metrics, have been a focus of study in machine learning and analysis of Big Data [Kle97], and it is surprising that, even with the tools and techniques that have been developed over many decades, when , there is no known subquadratic-time (i.e., -time) algorithm, for in any standard distance measure [Ind00, AC09, ILLP04] . The absence of such algorithms was explicitly observed as early as the late nineties by Cohen and Lewis [CL99] but there was not any explanation until recently.
David, Karthik, and Laekhanukit [DKL18] showed that for all , assuming the Strong Exponential Time Hypothesis (), for every , no algorithm running in time can solve in the -metric, even when . Their conditional lower bound was based on the conditional lower bound (again assuming ) of Alman and Williams [AW15] for the Bichromatic Closest Pair problem111We remark that is of independent interest as it’s equivalent to finding the Minimum Spanning Tree in -metric [AESW91, KLN99]. Moreover, understanding the fine-grained complexity of has lead to better understanding of the query time needed for Approximate Nearest Neighbor search problem (see Razenshteyn’s thesis [Raz17] for a survey about the problem) with polynomial preprocessing time [Rub18]. () where we are given two sets of points in a -dimensional metric space, and the goal is to find a pair of points, one from each set, with the smallest distance between them. Alman and Williams showed that for all , assuming , for every , no algorithm running in time can solve in the -dimensional -metric space. Given that [AW15] show their lower bound on for all -metrics, the lower bound on of [DKL18] feels unsatisfactory, since the -metric is arguably the most interesting metric to study on. On the other hand, the answer to the complexity of in the Euclidean metric might be on the positive side, i.e., there might exist an algorithm that performs well in the -metric because there are more tools available, e.g., Johnson-Lindenstrauss’ dimension reduction [JL84]. Thus we have the following question:
Open Question 1.1** **(Abboud-Rubinstein-Williams222Please see the erratum in [ARW17a]. [ARW17b], Williams [Wil18a], David
-Karthik-Laekhanukit [DKL18]).
Is there an algorithm running in time for some which can solve in the Euclidean metric when the points are in dimensions?
Even if the answer to the above question is negative, this does not rule out strong approximation algorithms for in the Euclidean metric, which might suffice for all applications. Indeed, we do know of subquadratic approximation algorithms for . For example, LSH based techniques can solve - (i.e., factor approximate ) in time [IM98], but cannot do much better [MNP07, OWZ14]. In a recent breakthrough, Valiant [Val15] obtained an approximation algorithm for - with runtime of . The state of the art is an -time algorithm by Alman, Chan, and Williams [ACW16]. Can the dependence on be improved indefinitely? For the case of -, assuming , Rubinstein [Rub18] answered the question in the negative. Does - also admit the same negative answer?
Open Question 1.2**.**
Is there an algorithm running in time for some which can solve - in the Euclidean metric when the points are in dimensions for every ?
Another important geometric problem is the Maximum Inner Product problem (): given points in the -dimensional Euclidean space, find a pair of distinct points with the largest inner product. This problem along with its bichromatic variant (Bichromatic Maximum Inner Product problem, denoted ) is extensively studied in literature (see [ARW17b] and references therein). Abboud, Rubinstein, and Williams [ARW17b] showed that assuming , for every , no -approximation algorithm running in time can solve when . It is a natural question to ask if their inapproximability result can be extended to :
Open Question 1.3**.**
Is there an algorithm running in time for some which can solve - in dimensions for even ?
1.1 Our Results
In this paper we address all three previously mentioned open questions. First, we almost completely resolve Open Question 1.1. In particular, we show the following.
Theorem 1.4** (Subquadratic Hardness of ; Informal, See Theorem 4.3).**
Let . Assuming , for every , no algorithm running in time can solve in the -metric, even when .
In particular we would like to emphasize that the dimension for which we show the lower bound on depends on . We would also like to remark that our lower bound holds even when the input point-set of is a subset of . Finally, we note that the centerpiece of the proof of the above theorem (and also the proofs of the other results that will be subsequently mentioned) is the construction of a dense bipartite graph with low contact dimension, i.e., we construct a balanced bipartite graph on vertices with edges whose vertices can be realized as points in a -dimensional -metric space such that every pair of vertices which have an edge in the graph are at distance exactly 1 and every other pair of vertices are at distance greater than 1. This graph construction is inspired by the construction of locally dense codes introduced by Dumer, Miccancio, and Sudan [DMS03] and uses special density properties of Reed Solomon codes. A detailed proof overview is given in Section 2.1.
Next, we improve our result in Theorem 1.4 in some aspects by showing factor inapproximability of even in dimensions, but can only rule out algorithms running in time (as opposed to Theorem 1.4 which rules out exact algorithms for running in time). More precisely, we show the following.
Theorem 1.5** (Subquadratic Hardness of gap-).**
Let . Assuming , for every , there exists and such that no algorithm running in time that can solve - in the -metric, even when .
We remark that the lower bound on approximate is an artifact of our proof strategy and that a different approach or an improvement in the state-of-the-art bound on the number of minimum weight codewords in algebraic geometric codes (which are used in our proof), will lead to the complete resolution of Open Question 1.2.
It should also be noted that the approximate version of and the dimension are closely related. Namely, using standard dimensionality reduction techniques [JL84]333In fact, since our results applies to -vectors, simply subsampling coordinates would also work. for -, one can always assume that . In other words, hardness of - immediately yields logarithmic dimensionality bound as a byproduct.
Finally, we completely answer Open Question 1.3 by showing the following inapproximability result for , matching the hardness for from [ARW17b].
Theorem 1.6** (Subquadratic Hardness of gap-).**
Assuming , for every , no algorithm running in time can solve - for any , even when .
Recently, there have been a lot of results connecting or - to other problems (see [Rub18, Che18a, Che18b, CW19]). Now such connections can be extended to as well. For example, the following conditional lower bound follows from [Rub18] for gap- in the edit distance metric and for completeness a proof is given in Appendix A.
Theorem 1.7** (Subquadratic Hardness of gap- in edit distance metric).**
Assuming , for every , there exists and such that no algorithm running in time can solve - in the edit distance metric, even when .
2 Proof Overview
In this section, we provide an overview of our proofs. For ease of presentation, we will sometimes be informal here; all notions and proofs are formalized in subsequent sections. Our overview is organized as follows. First, in Subsection 2.1, we outline our proof of running time lower bounds for exact (Theorem 1.4). Then, in Subsection 2.2, we abstract part of our reduction using error-correcting codes, and relate them back to the works on locally dense codes [DMS03, CW12, Mic14] that inspire our constructions. Finally, in Subsection 2.3, we briefly discuss how to modify the base construction (i.e. code properties) to give conditional lower bounds for approximate and (Theorems 1.5 and 1.6).
2.1 Conditional Lower Bound on Exact Closest Pair
In this subsection, we provide a proof overview of a slightly weaker version of Theorem 1.4, i.e., we show that assuming , for every , no subquadratic time algorithm can solve in the -metric when . We prove such a result by reducing in dimension to in dimension , and the subquadratic hardness for follows from the subquadratic hardness of established by [AW15]. Note that the results in this paper remain interesting even if is false, as our reduction shows that and are computationally equivalent444We can reduce an instance of to an instance of by randomly partitioning the input set of instance into two, and the optimal closest pair of points will be in different sets with probability (and this reduction can be made deterministic). (up to factor in the running time) when . The conditional lower bound on is merely a consequence of this computational equivalence. Finally, we note that a similar equivalence also holds between and .
Understanding an obstacle of [DKL18].
Our proof builds on the ideas of [DKL18] who showed that assuming , for every , no subquadratic time algorithm can solve in the -metric when . They did so by connecting the complexity of and via the contact dimension of the balanced complete bipartite graph (biclique), denoted by . We elaborate on this below.
To motivate the idea behind [DKL18], let us first consider the trivial reduction from to : given an instance of , we simply output as an instance of . This reduction fails because there is no guarantee on the distances of a pair of points both in (or both in ). That is, there could be two points such that is much smaller than the optimum of on . If we simply solve on , we might find such as the optimal pair but this does not give the answer to the original problem. In order to circumvent this issue, one needs a gadget that “stretch” pairs of points both in or both in further apart while keeping the pairs of points across and close (and preserving the optimum of on ). It turns out that this notion corresponds exactly to the contact dimension of the biclique, which we define below.
Definition 2.1** (Contact Dimension [Pac80]).**
For any graph , a mapping is said to realize (in the -metric) if for some , the following holds for every distinct vertices :
[TABLE]
The contact dimension (in the -metric) of , denoted by , is the minimum such that there exists realizing in the -metric.
In this paper, we will be mainly interested in the contact dimension of bipartite graphs. Specifically, [DKL18] only consider the contact dimension of the biclique . Notice that a realization of biclique ensures that vertices on the same side are far from each other while vertices on different sides are close to each other preserving the optimum of ; these are exactly the desired properties of a gadget outlined above. Using this, [DKL18] give a reduction from to which shows that the two are computationally equivalent whenever , as follows.
Let each of cardinality be an instance of and let be a map realizing the biclique in the -metric; we may assume w.l.o.g. that . Let be the distance between any point in and any point in (i.e., is an upper bound on the optimum of ). Let be such that for all (and this is guaranteed to exist by (2)). Moreover, let be any sufficiently large number. Consider the point-sets of cardinality each defined as
[TABLE]
where denotes the concatenation between two vectors and denotes the usual scalar-vector multiplication (i.e. scaling up by a factor of ). For brevity, we write and to denote and respectively.
We now argue that, if we can find the closest pair of points in , then we also immediately solve for . More precisely, we claim that is a bichromatic closest pair of if and only if is a closest pair of .
To see that this is the case, observe that, for cross pairs , (1) implies that the distance is exactly ; hence, among these pairs, is a closest pair iff is a bichromatic closest pair in . Notice also that, since the bichromatic closest pair in is of distance at most , the closest pair in is of distance at most .
On the other hand, for pairs both from or both from , the distance must be at least , which is more than from our choice of . As a result, these pairs cannot be a closest pair in , and this concludes the sketch of the proof.
There are a couple of details that we have glossed over here: one is that the gap cannot be too small (e.g., cannot be as small as ) and the other is that we should be able to construct efficiently. Nevertheless, these are typically not an issue.
[DKL18] show that when and that the realization can be constructed efficiently and with sufficiently large . This implies the subquadratic hardness of (by reduction from ) in the -metric for all and . However, it was known that [FM88]. Thus, they could not extend their conditional lower bound to in the Euclidean metric555Note that plugging in the bound on in the result of [DKL18] yields that assuming , no subquadratic in running time algorithm can solve when . This is not a meaningful lower bound as just the input size of when is . even when . In fact, this is a serious obstacle as it rules out many natural approaches to reduce to in a black-box manner. Elaborating, the lower bound on rules out local gadget reductions which would replace each point with a composition of that point and a gadget with a small increase in the number of dimensions, as such gadgets can be used to construct a realization of in the Euclidean metric in a low dimensional space, contradicting the lower bound on .
Overcoming the Obstacle: Beyond Biclique.
We overcome the above obstacle by considering dense bipartite graphs, instead of the biclique. More precisely, we show that there exists a balanced bipartite graph on vertices such that and is small (i.e. ). We give a construction of such a graph below but before we do so, let us briefly argue why this suffices to show that and are computationally equivalent (up to multiplicative overhead in the running time) for dimension .
Let us consider the same reduction which produces as before, but instead of using a realization of the biclique, we use a realization of . This reduction is of course incorrect: if is not an edge in , then could be large and, thus the corresponding pair of points , may not be the closest pair. Nevertheless, we are not totally hopeless: if is an edge, then we are in good shape and the reduction is correct.
With the above observation in mind, consider picking a random permutation of such that and and then initiate the above reduction with the map instead of . Note that is simply a realization of an appropriate permutation of (i.e., is isomorphic to ). Due to this, the probability that we are “lucky” and is an edge in is ; when this is the case, solving on the resulting instance would give the correct answer for the original instance. If we repeat this times, we would find the optimum of the original instance with high probability.
To recap, even when is not a biclique, we can still use it to give a reduction from to , except that the reduction produces multiple (i.e. ) instances of . We remark here that the reduction can be derandomized: we can deterministically (and efficiently) pick the permutations so that the permuted graphs covers (see Lemma 3.11). As a minor digression, we would like to draw a parallel here with a recent work of Abboud, Rubinstein, and Williams [ARW17b]. The obstacle raised in [DKL18] is about the impossibility of certain kinds of many-one gadget reductions. We overcame it by designing a reduction from to which not only increased the number of dimensions but also the number of points (by creating multiple instances of ). This technique is also utilized in [ARW17b] where they showed the impossibility of Deterministic Distributed PCPs (Theorem I.2 in [ARW17b]) but then overcame that obstacle by using an advice (which is then enumerated over resulting in multiple instances) to build Non-deterministic Distributed PCPs.
Constructing a dense bipartite graph with low contact dimension.
We now proceed to construct the desired graph . Note that any construction of a dense bipartite graph with contact dimension is non-trivial. This is because it is known that a random graph has contact dimension in the Euclidean metric with high probability [RRS89, BL05], and therefore our graph construction must be significantly better than a random graph.
Our realization of will map into a subset of . As a result, we can fix , since a realization of a graph with entries in in the Hamming-metric also realizes the same graph in every -metric for any .
Fix . We associate with where is a prime and . Let be the set of all univariate polynomials (in ) over of degree at most . We have that and associate with . Let be the set of all univariate monic polynomials (in ) over of degree , i.e.,
[TABLE]
We associate the polynomials in with the vertices in (note that ). In fact, we view the vertices in and as being uniquely labeled by polynomials in and respectively. For notational clarity, we write (resp. ) to denote the polynomial in (resp. ) that is associated to (resp. ).
For every and , we include as an edge in if and only if the polynomial (which is of degree ) has distinct roots. This completes the construction of . We have to now show the following two claims about : (i) and (ii) there is that realizes .
To show (i), let be the set of all monic polynomials of degree with distinct roots. We have that . Fix a vertex . Its degree in is exactly . This is because, for every polynomial , belongs to , and therefore . This implies the following bound on :
[TABLE]
Next, to show (ii), we construct a realization of . We note that, it is simple to translate the entries to instead of , by replacing with the -th standard basis . This would result in a realization of ; notice that the dimension of is as claimed.
We define as follows.
- •
For every , is simply the vector of evaluation of on every element in . More precisely, for every , the -th coordinate of is .
- •
Similarly, for every and , the -th coordinate of is .
We now show that is indeed a realization of ; specifically, we show that satisfies (1) and (2) with .
Consider any edge . Notice that is the number of such that . By definition of , is a polynomial with distinct roots over . Thus, as desired.
Next, consider a non-edge . Then, we know that has at most distinct roots over . Therefore, the polynomial is non-zero on at least coordinates. This implies that .
Finally, for any distinct , we have because is a non-zero polynomial of degree at most and thus can be zero over in at most locations. Similarly, for any distinct .
This completes the proof sketch for both the claims about and yields Theorem 1.4 for . Finally we remark that in the actual proof of Theorem 1.4, we will set the parameters in the above construction more carefully and achieve the bound .
2.2 Abstracting the Construction via Error-Correcting Codes
Before we move on to discuss the proofs of Theorems 1.6 and 1.5, let us give an abstraction of the construction in the previous subsection. This will allow us to easily generalize the construction for the aforemention theorems, and also to explain where our motivation behind the construction comes from in the first place.
Dense Bipartite Graph with Low Contact Dimension from Codes.
In order to construct a balanced bipartite graph on vertices with edges such that , it suffices to have a code with the following properties (for code-related definitions, see Section 3.2):
- •
of cardinality is a linear code with block length over alphabet , and minimum distance .
- •
There exists a center and such that codewords are at Hamming distance exactly from and no codeword is at distance less than from .
- •
.
We also require that and can be constructed in time but we shall ignore this requirement for the ease of exposition.
We describe below how to construct from , but first note that the construction of we saw in the previous subsubsection was just showing that Reed Solomon codes [RS60] of block length and message length over alphabet with minimum distance has the above properties. The center in that construction was the evaluation of the polynomial over , and was .
In general, to construct from , we first define a subset of cardinality as follows:
[TABLE]
We associate the vertices in with the codewords of and vertices in with the strings in . For any , let if and only if . This completes the construction of . We have to now show the following claims about : (i) and (ii) there is that realizes .
Item (i) follows rather easily from the properties of and . Let be the subset of of all codewords which are at distance exactly equal to from . From the definition of , we have . Fix . Its degree in is . This is because for every codeword we have that is a codeword in (from the linearity of ) and thus is in , and therefore .
For item (ii), consider the identity mapping that maps each string to itself. It is simple to check that realizes in the Hamming metric (with ).
Recall from the previous subsection that given that realizes in the Hamming metric, it is easy to construct that realizes in the Hamming metric with a multiplicative factor blow-up in the dimension. This completes the proof of both the claims about and gives a general way to prove Theorem 1.4 given the construction of and .
Finding Center from Another Code.
One thing that might not be clear so far is: where does the center come from? Here we provide a systematic way to produce such an , by looking at another code that contains . More precisely, let be two linear codes with the same block length and alphabet. Suppose that the distance of is , the distance of is and that . It is easy to see that, by taking to be any element of , it holds that every codeword in is at distance at least from , simply because both and the codewords of are codewords of .
Hence, we are only left to argue that there are many codewords of that is of distance exactly from . While this is not true in general, we can show by an averaging argument that this is true (for some ) if a large fraction (e.g. fraction) of codewords of has Hamming weight exactly (see Lemma 5.1).
Indeed, viewing in this light, our previous choice of center for Reed-Solomon code (i.e. evaluation of ) is not coincidental: we simply take to be another Reed-Solomon code with message length (whereas the base code is of message length ).
Comparison to Locally Dense Codes.
We end this subsection by remarking that the codes that we seek are very similar to locally dense codes [DMS03, CW12, Mic14], which is indeed our inspiration. A locally dense code is a linear code of block length and large minimum distance , admitting a ball centered at of radius666 Clearly, for the ball to contain more than a single codeword, it must be . Here we are interested in balls with radius not much bigger than that, say for some constant . and containing a large (i.e. ) number of codewords777Strictly speaking, a locally dense code also requires an auxiliary matrix used to index these codewords. However, in previous works, finding is typically not hard given the center . Hence, we ignore in our discussion here for the ease of exposition.. Such codes are non-trivial to construct and in particular all known constructions of locally dense codes are using codes that beat the Gilbert-Varshamov (GV) bound [Gil52, Var57]; in other words we need to do better than random codes to construct them. This is because (as noted in [DMS03]), for a random code (or any code that does not beat the GV bound), a random point in acting as the center contains in expectation less than one codeword in a ball of radius . Of course, this is simply an intuition and not a formal proof that a locally dense code needs to beat the GV bound, since there may be more sophisticated ways to pick a center.
Although the codes we require are similar to locally dense codes, there are differences between the two. Below we list four such differences: the first two makes it harder for us to construct our codes whereas the latter two makes it easier for us.
- •
We seek a center so that no codewords in lies at distance less than , as opposed to locally dense codes which allows codewords to be close to . This is indeed where our idea of using another code comes in, as picking from ensures us that no codeword of is too close to .
- •
Another difference is that we need the number of codewords at distance from to be very large, i.e., , whereas locally dense codes allow for much smaller number of codewords. Indeed, the deterministic constructions from [CW12, Mic14] only yield the bound of . Hence, these do not directly work for us.
- •
Locally dense codes requires to be at most for some constant , whereas we are fine with any . In fact, our Reed-Solomon code based construction above only yields which would not suffice for locally dense codes. Nevertheless, as we will see later for inapproximability of , we will also need the ratio to be a constant bounded away from 1 as well and, since we need a code with these extraordinary properties, they are very hard to find. Indeed, in this case we only manage to prove a weaker lower bound on gap-.
- •
Finally, we remark that locally dense codes are required to be efficiently constructed in time, which is part of why it is hard to find. Specifically, while [DMS03] shows that an averaging argument works for a random center, derandomizing this is a big issue and a few subsequent works are dedicated solely to this issue [CW12, Mic14]. (We also note that it remains open whether a center can be deterministically found for a variant of locally dense codes used in hardness of parameterized version of the minimum distance problem. See [BGKM18] for more details.) On the other hand, brute force search (over all codewords in ) suffices to find a center for us, as we are allowed construction time of .
2.3 Inapproximability of Closest Pair and Maximum Inner Product
In this subsection, we sketch our inapproximability results for and . Both these results use the same reduction that we had from to , except that we now need stronger properties from the gadget, i.e., the previously used notions of contact dimension does not suffice anymore. Below we sketch the required strengthening of the gadget properties and explain how to achieve them.
2.3.1 Approximate Maximum Inner Product
Observe that the gadget we construct for in Subsection 2.2 can also be written in terms of inner product as follows: there exists a dense balanced bipartite graph , a mapping such that the following holds.
- (i)
For all edges , . 2. (ii)
For all edges , . 3. (iii)
For all distinct both from or both from , .
Notice that we wrote the conditions above in a slightly different way than in previous subsections; previously in the contact dimension notation, (ii) and (iii) would be simply written together as: for all non-edge , . This change is intentional, since, to get gap in our reductions, we only need a gap between the bounds in (i) and (iii) (but not in (ii)). In particular, to get hardness of approximating , we require to be at least for some .
From our Reed-Solomon construction above, and are exactly the message length of minus one and the message length of minus one respectively. Previously, we selected these two to be and . Now to obtain the desired gap, we simply take the larger code to be a Reed-Solomon code with larger (i.e. ) message length888This approach can in fact give not just but arbitrarily large constant gap between the two cases. In the actual reduction, we take this gap to be 3 (Theorem 6.2), which makes some computations simpler..
Finally, we note that even with the above gadget, the reduction only gives a small (i.e. ) factor hardness of approximating (Theorem 6.2). To boost the gap to near polynomial, we simply tensor the vectors with themselves (see Section 6).
2.3.2 Approximate Closest Pair
Once again, recall that we have the following gadget from Subsection 2.2: there exists a dense balanced bipartite graph , a mapping such that the following holds.
- (i)
For all edges , . 2. (ii)
For all edges , . 3. (iii)
For all distinct both from or both from , .
Once again, we need an gap between the bounds in (iii) and (i), i.e., . Unfortunately, we cannot construct such codes using any of the Reed-Solomon code families. We turn to another type of codes that beat the Gilbert-Varshamov bound: Algebraic- Geometric (AG) codes. Similar to the Reed-Solomon code based construction, we take as an AG code and to be a “higher degree” AG code; getting the desired gap simply means that the distance of must be at least times the distance of .
Recall from Subsection 2.2 also that, to bound the density of , we need a lower bound on the number of minimum weight codewords of . Such bounds for AG codes are non-trivial and we turn to the bounds from [ABV01, Vlă18]. Unfortunately, this only gives with density , instead of as before. This is indeed the reason that our running time lower bound for approximate is only .
We are not aware of any result on the (asymptotic) tightness of the bounds from [ABV01, Vlă18] that we use. However, improving upon such bounds would have other consequences, such as a better bound on the kissing numbers of lattices constructed in [Vlă18]. As a result, it seems likely that more understanding of AG codes (and perhaps even new constructions) are needed in order to improve these bounds.
3 Preliminaries
In this section we define the geometric problems of interest to this paper, give an alternate proof for the conditional lower bound on bichromatic closest pair, and recall the definition of the contact dimension of a graph.
3.1 Notations, Problems and Fine-Grained Hypotheses
Distance Measures.
For any two vectors , the distance between them in the -metric is denoted by . Their distance in the -metric is denoted by , and in the -metric is denoted by , i.e., the number of coordinates on which and differ. More generally, for any two vectors in the -metric, we denote by its distance in that metric space. The -metrics that are well studied in literature are the Hamming metric (-metric), the rectilinear metric (-metric), the Euclidean metric (-metric), and the Chebyshev metric (-metric). We denote the inner product (associated with the Euclidean space) of and by . Finally, for every positive integer we define the edit metric over to be the space endowed with distance function , which is defined as the minimum number of character substitutions/insertions/deletions to transform into .
Problems.
Here we give formal definitions of Orthogonal Vectors (), Closest Pair () and Bichromatic Closest Pair () problems, and also Maximum Inner Product () and Bichromatic Maximum Inner Product () problems.
Definition 3.1** (Orthogonal Vectors Problem, ).**
In , we are given two collections of points , and the goal is to find a pair of points , such that .
Definition 3.2** (Closest Pair Problem, ).**
In in the -metric, we are given a collection of points and a positive real , and the goal is to find a pair of distinct points such that .
Definition 3.3** (Bichromatic Closest Pair Problem, ).**
In in the -metric, we are given two collections of points and a positive real , and the goal is to find a pair of points , such that .
We will also use gap versions of these problems. For any , we define - (resp. - ) in the -metric to be the problem of distinguishing between the case whether there exist distinct (resp. and ) such that and the case where for all distinct (resp. and ) we have .
Definition 3.4** (Maximum Inner Product Problem, ).**
In , we are given a collection of points and a real , and the goal is to find a pair of distinct points such that .
Definition 3.5** (Bichromatic Maximum Inner Product Problem, ).**
In , we are given two collections of points and a real , and the goal is to find a pair of points , such that .
Again we define the gap versions of these problems as follows. For any , we define - (resp. -) to be the problem of distinguishing between the case whether there exist distinct (resp. and ) such that and the case where for all distinct (resp. and ) we have .
Hypotheses.
Finally, we give formal definitions of the relevant fine-grained hypotheses (see [Wil18b] for a survey on the state-of-the-art conditional lower bounds that are known under these hypotheses).
Definition 3.6** (Strong Exponential Time Hypothesis, [IP01, IPZ01, CIP06]).**
For every , there exists such that no algorithm can solve -SAT (i.e., satisfiability on a CNF of width ) in time where is the number of variables. Moreover, this holds even when the number of clauses is at most where denotes a constant that depends only on .
Definition 3.7** (Orthogonal Vector Hypothesis, ).**
For every , no algorithm can solve in time. Moreover, this holds even when the dimension is at most where denotes a constant that depends only on .
It is known that implies [Wil05], and therefore in the rest of the paper, we base all our conditional lower bounds on .
3.2 Error-Correcting Codes
We recall here a few coding theoretic notations since all of our gadgets are based on error-correcting codes. As is standard in error-correcting codes, we will use to denote , the Hamming distance of and , for any and we further define for any and . The weight of , denoted by , is simply . For and , we use to denote the (closed) Hamming ball of radius centered at , i.e., .
An error correcting code of block length over alphabet is simply a collection of codewords . The distance of the code , denoted by , is defined as . A code is said to be linear if is a subspace of . For a linear code , its message length is defined to be the dimension of , or equivalently . We often use the notion to denote a linear code of block length , message length , and distance . The rate and relative distance of a linear code are defined as and respectively. Note also that, for a linear code , is equal to the minimum weight of a non-zero codeword of . Finally, for any code , we use to denote the number of codewords of weight .
Let us also recall the Singleton bound and the definition of maximum distance separable (MDS) codes.
Theorem 3.8** (Singleton bound [Sin64]).**
For any linear code, .
Definition 3.9** (MDS Codes).**
A linear code is said to be a maximum distance separable (MDS) code if it matches the Singleton bound, i.e., .
We note here that the above bound and notation are well-defined (or can be naturally extended) also for non-linear codes, but we will only use them in context of linear codes in this paper.
3.3 Miscellaneous Tools
Covering Biclique by Isomorphic Graphs.
A useful fact we use to derandomize our reductions is that the biclique can be covered by any dense bipartite graph with only a few graphs that are isomorphic to . To state this more formally, let us first define a few notions.
Definition 3.10**.**
For any graph and any permutation , we use to denote the graph where the vertex set is equal to and .
For brevity, we say that a permutation of vertices of a bipartite graph is side-preserving if and .
We can now state the result as follows. The proof, which proceeds via a simple set covering argument, is deferred to Appendix B.
Lemma 3.11**.**
For any bipartite graph where and , there exist side-preserving permutations where such that
[TABLE]
Moreover, such permutations can be found in time .
Translating Finite Fields Vectors to {0, 1}-Vectors.
Another simple fact which was already mentioned in the proof overview (Section 2) is that, we can embed Hamming metric on alphabet of size to Hamming metric on Boolean alphabet, with only multiplicative factor blow-up in the dimension:
Proposition 3.12**.**
For any , and alphabet such that , there exists a mapping such that, for all , we have and .
Proof.
The mapping simply replaces each coordinate that is equal to by the -th standard basis in the -dimensional space. More precisely, for , we define
[TABLE]
where denotes concatenation of vectors and denote the -th standard basis in , i.e., the vector whose -th coordinate is one and the remaining coordinates are zeroes.
It is simple to check that this satisfies the two requirements. ∎
3.4 -hardness of Exact Bichromatic Closest Pair
Alman and Williams [AW15] showed the conditional hardness (under ) of exact in every -metric even when the point-sets are over via a Turing reduction from . David, Karthik, and Laekhanukit [DKL18] gave an alternate proof of the same result where point-sets were over via a many-one reduction from . For independent interest, below we give another proof, which is both a many-one reduction and the point-sets are over .
Theorem 3.13**.**
Assuming , for every , no algorithm running in time can solve , even when the point-sets are subsets of and , for some constant (only depending on ).
Proof.
Let where be the input to an instance. We build an instance of where , , and , using functions and guaranteed by the following claim.
Claim 3.14**.**
There are functions such that for every we have:
- •
* implies .*
- •
* implies .*
For every , the point of , say is constructed from the point of , say by simply applying pointwise on each coordinate of , i.e., . Similarly we apply pointwise on each coordinate of points in . It is easy to see that there exists such that if and only if , and otherwise every pair of points in is at Hamming distance at least . ∎
Proof of Claim 3.14.
We define for all , and , where for all such that , we have if and only if and if and only if . More succinctly, and are described below as strings and the claim follows by a straight-forward calculation.
[TABLE]
[TABLE]
3.5 Contact Dimension of a Graph
The central gadget in our reduction from to is based on the contact dimension of a graph. Below we reproduce its definition from the proof overview (i.e. Definition 2.1) for convenience.
Definition 3.15** (Contact Dimension [Pac80]).**
For any graph , a mapping is said to realize (in the -metric) if for some , the following holds:
- (i)
For all , . 2. (ii)
For all , .
The contact dimension (in the -metric) of , denoted by , is the minimum such that there exists realizing in the -metric.
We may also say that -realizes if we wishes to emphasize the value of .
Note here that we may view points in as centers of spheres of radius . No two spheres overlap but they may touch, and has an edge if and only if the spheres centered at and touches.
For a summary of the bounds on for various graphs in the Euclidean metric see [Mae85, FM86, FM88, Mae91] and for a summary of the bounds on in various metrics see [DKL18]. For this paper, the following bounds are relevant.
Theorem 3.16** (Frankl-Maehara [FM88]).**
**
Theorem 3.17** (David-Karthik-Laekhanukit [DKL18]).**
**
In particular, the above two theorems are the obstacles of the approach of [DKL18] for the and Hamming metrics respectively. As discussed in the proof overview, we will overcome these barriers by constructing dense bipartite graphs with low contact dimensions in every metrics.
As discussed in Section 2.3.2, we need a generalization of contact dimension in order to show inapproximability for . This is formally defined below; it should be noted that the definition only makes sense for bipartite graphs, whereas the original contact dimension is well-defined for any graphs. Moreover, when , the notion of gap contact dimension coincides with the (non-gap) contact dimension in bipartite graphs.
Definition 3.18** (Gap Contact Dimension).**
For any bipartite graph and , a mapping is said to -gap-realize (in the -metric) if for some , the following holds:
- (i)
For all , . 2. (ii)
For all , . 3. (iii)
For all distinct both from or both from , .
The -gap contact dimension (in the -metric) of , denoted by , is the minimum such that there exists -gap-realizing in the -metric.
Again, we may say that -gap-realizes to emphasize the value of .
Finally, we define an analogous notion for inner product:
Definition 3.19** (Gap Inner Product Dimension).**
For any bipartite graph and , a mapping is said to -gap--realize if for some , the following holds:
- (i)
For all , . 2. (ii)
For all , . 3. (iii)
For all distinct both from or both from , .
The -gap inner product dimension of , denoted by , is the minimum such that there exists -gap--realizing .
We may say that -gap--realizes to emphasize the value of .
4 Lower Bound on Closest Pair under Orthogonal Vector Hypothesis
In this section, we prove the subquadratic hardness for (assuming ) using the efficient construction of a realization of a dense bipartite graph. The construction will be be formally stated below and the details will be given in Section 5.2.1. First, we define the notion of a log-dense sequence of integers:
Definition 4.1**.**
A sequence of increasing positive integers is said to be log-dense if there exists a constant such that for all .
As outlined in Section 2.1 , we use Reed-Solomon codes to construct a family of dense bipartite graphs with low contact dimensions. While the construction does not yield a graph for every number of vertices , it does yield a graph for a log-dense sequence of numbers of vertices, which turns out to be sufficient for the purpose of the reduction. More formally, we will prove the following in Section 5.2.1.
Theorem 4.2**.**
For every , there exists a log-dense sequence such that, for every , there is a bipartite graph where and , such that . Moreover, for all , a realization of can be constructed in time .
Notice that we did not specify any -metric in the notion of contact dimension above. This is intentional, because our point sets have coordinate entries in , for which the distances in the Hamming metric are equivalent (up to power of ) to distances in any -metric (). We also adopt this notational convenience below. Specifically, we will prove the following theorem which states that is hard even when the points are from ; clearly, this also implies Theorem 1.4 due to the aforementioned equivalence to other -metrics.
Theorem 4.3** (Subquadratic Hardness of -).**
Assuming , for every , there exists such that no algorithm running in time can solve in the Hamming metric even when and all points have entries.
Proof.
For any , let be the constant such that the dimension guarantee for in Theorem 4.2 is at most for . We define as .
Assume that there exists and an algorithm that can solve in time in the Hamming metric for any input of points in . We will construct an algorithm that solves any instance of in time for some constant (to be specified below), on points in dimension with coordinate entries in . Together with Theorem 3.13, this implies that is false, arriving at a contradiction.
Let denote the log-density constant (i.e. ) of the sequence from Theorem 4.2 for , and let be . The algorithm on input where with , and , works as follows:
Let be the largest number in the sequence from Theorem 4.2 with s.t. . 2. 2.
Let be the graph from Theorem 4.2 with , , and be a -realization of where . 3. 3.
We use the algorithm from Lemma 3.11 to find where such that the union of is . 4. 4.
We assume w.l.o.g.999This is without loss of generality, since if is not divisible by , we can use brute force for the remainder points. This requires only which does not affect the overall asymptotic running time of the algorithm. that is divisible by . Partition and into and each of size . For each , do the following:
- (a)
Let be an appropriate permutation of that -realizes . Label the vertices of with the points in . 2. (b)
Let , and define as
[TABLE]
where simply denotes , i.e., the concatenation of copies of . 3. (c)
Run on . If outputs YES, then output YES and terminate. 5. 5.
If none of the executions of returns YES, then output NO.
Observe that the bottleneck in the running time of the algorithm is in the executions of . The number of executions is and each execution takes time. Hence, in total the running time of the algorithm is . Now, from the log-density of the sequence from Theorem 4.2, we have . As a result, the running time of is at most as desired.
To see the correctness of the algorithm, first observe that the dimensions of vectors in are at most which is at most for any sufficiently large ; that is, the calls to are valid. Next, observe that, if is a YES instance of , there must be and such that is at most . Since covers , there must be such that . As a result, . Thus, is a YES instance for and outputs YES as desired.
Finally, assume that is a NO instance of . Consider any and . To argue that is a NO instance for , we have to show that any two points in have distance more than . To see this, let us consider two cases.
Both points are either from or from . Assume w.l.o.g. that the two points are from ; let them be and . Recall that, from the definition of -realization, . Since is an integer, we must have . As a result, the Hamming distance between the two points is at least . 2. 2.
One of the point is from and the other from . Let them be and . Since is a NO instance of , . Furthermore, from definition of -realization, we must have . Combining the two implies that the Hamming distance between and is more than .
Hence, must be a NO instance for for every and . Thus, outputs NO as desired. ∎
5 Gadget Constructions
In this section, we construct all the gadgets that are used in our reductions, including the basic gadget (Theorem 4.2) and more advanced gadgets used for and approximate version of .
5.1 Finding a Center of a Code via Another Code
At the heart of all our gadgets is the task of finding a code and a center such that there are many codewords at Hamming distance exactly equal to (for some ) from but there is no codeword in at distance less than from . The below lemma is useful in finding such an .
Lemma 5.1**.**
Let be two linear codes with the same block length and alphabet such that . Then, there exists a center such that (1) and (2) . Moreover, given , such an can be found in time.
Proof.
We show that there exists such that (2) holds. Note that (1) immediately holds, because must be a non-zero codeword of which implies that .
To show that there exists such that . We will in fact show a stronger statement: for a random , we have . Consider . Due to linearity of expectation, we have
[TABLE]
Now, since , we have . That is, . Plugging this back into the above equality, we have
[TABLE]
Thus, there must exist a center that satisfies (2) (and also (1)) as desired.
Finally, note that can be found by a brute force algorithm that tries every and check whether (2) is satisfied; this algorithm takes time. ∎
5.2 Gadgets based on Reed-Solomon Codes
In this subsection, we construct gadgets based on the Reed Solomon codes, which are defined below.
Theorem 5.2** (Reed-Solomon Codes).**
For every prime power , and every , there exists a linear code, denoted by . The generator matrix of this code can be computed in time . Moreover, for every , we have .
In order to find a good center , we use the following (well-known) bound on the number of minimum weight codewords of Reed Solomon codes (and more generally MDS codes). For a reference of this bound, see e.g. [MS77, Ch. 11, Theorem 6].
Lemma 5.3**.**
Let be any linear code that is MDS. Then, .
5.2.1 The Basic Gadget: Dense Bipartite Graphs with Low Contact Dimensions
Now we construct a dense bipartite graph with low contact dimension. A proof sketch of this construction was provided in Section 2.1 and was formally stated as Theorem 4.2.
Proof of Theorem 4.2.
Let be the -th prime number and let ; it is simple to see that the sequence is log-dense. For , consider the Reed-Solomon codes and where and . Applying Lemma 5.1 with implies that there exists a center such that
[TABLE]
where the last equality follows from the fact that .
We construct the graph and a realization as follows. Let and . can be easily realized by applying the mapping from Proposition 3.12. More precisely, let be the restriction of on . Below we argue about the density of and that is a -realization of .
- •
First, notice that is exactly .
- •
Second, notice that, for every both from or both from , we have . This implies that .
- •
Third, for every and , we have . Thus, . Hence, . Moreover, the inequality is an equality if and only if , i.e., as desired.
- •
Finally, observe that the dimension is .
As for the running time of constructing and , observe that the bottleneck is the running time needed to find the center ; according to Lemma 5.1, can be computed in , which is as desired. ∎
5.2.2 A Gadget for Maximum Inner Product
Now, we build gadgets (stated below) which will be used for proving the inapproximability of .
Theorem 5.4**.**
For every , there exists a log-dense sequence such that, for every , there is a bipartite graph where and , such that 3-. Moreover, for all , a 3-gap--realization of can be constructed in time .
Proof.
The proof here is exactly the same as the proof of Theorem 4.2, except that we will not pick , but rather pick (and accordingly).
More precisely, let be the -th prime number and let ; it is simple to see that the sequence is log-dense. For , consider the Reed-Solomon codes and where and . Similar to the proof of Theorem 4.2, applying Lemma 5.1 with implies that there exists such that
[TABLE]
We construct the graph and a realization as follows. Let and . can be easily 3-gap--realized by applying the mapping from Proposition 3.12. More precisely, let be the restriction of on . Below we argue about the density of and that is a -gap--realization of .
- •
First, notice that is exactly .
- •
Second, for every both from or both from , we have . Thus, .
- •
Third, for every and , we have . Thus, . Hence, . Moreover, the inequality is an equality if and only if , i.e., as desired.
- •
Finally, observe that the dimension is .
Once again, the running time of the construction is . ∎
5.3 Gadgets based on AG Codes
In this subsection, we construct gadgets based on algebraic geometric (AG) codes. The definitions of AG Codes are well beyond the scope of this work and we refer the readers to [Sti08, VNT07] for more thorough introductions.
Once again to find a good center, we need a bound on the number of minimum weight codewords. On this front, we use the following bound101010Note that most of the proof of this bound was from [ABV01]; [Vlă18] simply makes the bound more explicit, which is more convenience for us. from [Vlă18]. Throughout this subsection, we follow the notations from [Vlă18].
Theorem 5.5** (Theorem 4.3 of [Vlă18]).**
Let be a prime power, be a curve of genus over , let such that , and let with . Then, there exists an -positive divisor , , such that the corresponding AG Code has minimum distance and
[TABLE]
We also need the following well-known (central) fact about the parameters of AG codes.
Theorem 5.6**.**
Let be a prime power, be a curve of genus over , let such that , and let with . Then, the corresponding AG Code is a linear code over with block length , distance at least and message length .
Recall also the tower of functions of Garcia and Stichtenoth [GS96], whose parameters approach the TVZ bound. We note here that, it suffices for us to have the genus approaching and there are also other curves that satisfy this.
Theorem 5.7** ([GS96]).**
For any and any square of prime , there exists a dense sequence111111A sequence of increasing positive integers is said to be dense if there exists a constant such that for all . such that there exists a curve with genus at most where .
Plugging the bound from [Vlă18] into the above family of curves immediately yields the following:
Lemma 5.8**.**
For any and any square of prime , there exists a dense sequence such that the following holds. For any and any such that , there exists linear codes such that the following holds, where :
- •
* has message length at least and distance at least .*
- •
* has message length at least and distance exactly and*
[TABLE]
Moreover, the generator matrices of can be computed in time.
Proof.
Let be a dense sequence as in Theorem 5.7. From Theorem 5.5, there exists an -positive divisor of degree such that the corresponding code (where of size ) satisfies (3) and that its distance is ; from Theorem 5.6, its message length must also be at least . Next, let be any -positive divisor of degree such that . Let be the corresponding AG code; once again, Theorem 5.6 yields the desired bounds on its message length and distance. Finally, observe that implies that as desired.
The main bottleneck to algorithmically construct such codes lies in finding . Nevertheless, the total number of degree- -positive divisor is only . We can use brute force to enumerate all of them and check whether the corresponding code satisfies (3), which further takes time. This results in the claimed running time. ∎
Finally, we can now construct our gadgets, by an appropriate setting of parameters. In particular, and will be selected to be close to each other and to both be slightly larger than . This results in the graphs whose degrees are roughly square root of the number of vertices.
Theorem 5.9**.**
For every , there exist and a log-dense sequence such that, for every , there is a bipartite graph where and , such that -. Moreover, for all , a -gap-realization of can be constructed in time for some .
Proof.
Once again, the proof here is similar to those of Theorems 4.2 and 5.4, except that we use the (pairs of) AG codes from Lemma 5.8 instead of Reed-Solomon codes.
Let be any sufficiently large square of prime and be any sufficiently small positive real number (both to be precisely specified later).
Let be the sequence guarantee by Lemma 5.8. Let and . For convenience, we assume that and are integers121212Note that, for sufficiently large , one can take the ceilings (or floors) of the specified values to get integers with negligible affect to the calculations.. Let be the codes given by Lemma 5.8. The sequence is defined as .
Applying Lemma 5.1 to implies that there exists such that
[TABLE]
where terms above denote the terms that go to zero as and . As a result, by picking sufficiently large and sufficiently small, the term in (4) is at least .
We construct the graph and a realization as follows. Let and . can be easily realized by applying the mapping from Proposition 3.12. More precisely, let be the restriction of on . Below we argue about the density of and that is a -gap-realization of where . Note that
[TABLE]
Let us now check that and satisfy all the claimed properties:
- •
First, notice that is exactly .
- •
For any both from or both from , we have . Hence, .
- •
Next, for every and , we have . Thus, . Hence, . Moreover, the inequality is an equality if and only if , i.e., as desired.
Given , the running time of constructing is . Moreover, the running time to construct and , as given by Lemma 5.8, is
[TABLE]
where the last two inequalities are true for any sufficiently large . ∎
6 Inapproximability of Maximum Inner Product
In this section, we prove the hardness of approximating . Once again, we show a stronger version (than Theorem 1.6) where every point has Boolean coordinates, as stated below.
Theorem 6.1**.**
Assuming , for every , there is no algorithm running in time for - even for points in , for any .
The proof proceeds in two steps: first, we show hardness of approximating in low dimension but with a small () approximation factor. Second, we use tensor product operation to amplify the gap to be almost polynomial, as stated in Theorem 6.1. More specifically, in the first step, we prove the following:
Theorem 6.2**.**
Assuming , for every , there exists such that no algorithm running in time can solve - even for points in .
Note that the factor is not significant, and this can be replaced by any factor; we use this just to make the calculations more concrete. Before we move on to the proof of Theorem 6.2, let us first show how it implies Theorem 6.1.
Proof of Theorem 6.1 from Theorem 6.2.
Let be an instance of - where . For , define and . The dimension of points in is . Moreover, it is easy to check, based on the identity , that is a YES (resp. no) instance of -MIP iff is a YES (resp. NO) instance of -.
In other words, if there is an time algorithm for - in dimension, then there also exist an subquadratic time algorithm for - in dimension. Thus, Theorem 6.1 follows from Theorem 6.2. ∎
The rest of this section is devoted to proving Theorem 6.2. To do so, we consider the gap- problem.
Definition 6.3** (- problem).**
Let . In the - problem we are given two sets each of points in and an integer as input, and the goal is to distinguish between the following two cases.
- •
Completeness.* There exists such that .*
- •
Soundness.* For every we have .*
We need the below hardness result from [Rub18]. Note that the result is stated differently in [Rub18]; for how the result in [Rub18] implies the one below, see Section 3.2 of [Che18a].
Theorem 6.4** ([Rub18]).**
Assuming , for every , there is no algorithm running in time for the - problem, for any and .
Proof of Theorem 6.2.
For any , let be the constant such that the dimension of in Theorem 5.4 is at most for . We define as .
Suppose contrapositively that there exists and an algorithm that can solve - of dimension in time . We will construct an algorithm that solves - in time for some constant (to be specified below) for dimensions. Together with Theorem 6.4, this implies that is false, as desired.
Let denote the constant of the log-dense sequence from Theorem 5.4 for , and let be . The algorithm on input where works as follows:
Let be the largest number in the sequence from Theorem 5.4 with s.t. . 2. 2.
Let be the graph from Theorem 5.4 with , , and be a -gap--relization of where . 3. 3.
We use the algorithm from Lemma 3.11 to find where such that the union of is 4. 4.
We assume w.l.o.g. that is divisible by . Partition and into and each of size . For each , do the following:
- (a)
Let be an appropriate permutation of that -gap--realizes . 2. (b)
Let , and define as
[TABLE] 3. (c)
Run on . If outputs YES, then output YES and terminate. 5. 5.
If none of the executions of returns with YES, then output NO.
Observe that the bottleneck in the running time of the algorithm is in the executions of . The number of executions is and each execution takes time. Hence, in total the running time of the algorithm is . Now, from the log-density of the sequence from Theorem 5.4, we have . As a result, the running time of is at most as desired.
To see the correctness of the algorithm, first observe that the dimensions of vectors in are at most which is at most for any sufficiently large ; that is, the calls to are valid. Next, observe that, if is a YES instance of , there must be and such that is at least . Since covers , there must be such that . As a result, . Thus, is a YES instance for and outputs YES as desired.
Finally, let us assume that is a NO instance of -. Consider any and . To argue that is a NO instance for -, we have to show that any two points in have inner product less than . To see this, let us consider two cases.
The two points are either both from or both from . Assume w.l.o.g. that the two points are from ; let them be and . Recall that, from Theorem 5.4, we must have . Moreover, since , we have . Thus, we can conclude that
[TABLE]
which is less than for any sufficiently large . 2. 2.
One of the point is from and the other from . Let them be and . Since is a NO instance of -, we must have . Furthermore, from Theorem 5.4, we must have . Combining the two implies that
[TABLE]
where the second-to-last inequality holds for any sufficiently large .
Hence, must be a NO instance for - for every and . Thus, outputs NO as desired. ∎
7 Inapproximability of Closest Pair
In this section, we prove the hardness of approximating (Theorem 1.5). As usual, we reduce from the bichromatic version of the problem, and the lower bound for the bichromatic version is stated below:
Theorem 7.1** (Rubinstein [Rub18]).**
Assuming , for every there exists such that there is no algorithm running in time for - in the Hamming metric. Moreover, this holds even for instances of - when and .
Again, we prove below the inapproximability of the gap- problem for Boolean vectors. Clearly, this immediately implies Theorem 1.5.
Theorem 7.2**.**
Assuming , for every , there exists and such that there is no algorithm running in time for - in the Hamming metric for point-set in .
Proof.
Assume towards a contradiction that there exists an and an algorithm that, for every solves - of dimension in time , where is a constant that will be specified later. Let be a small constant (depending on ) that we will specify below and let be as in Theorem 7.1. We construct below an algorithm that solves - in time for any instance such that and . Together with Theorem 7.1, this implies that is false, as desired.
Let denote the constant of the log-dense sequence from Theorem 5.9 for , and let be . Let be the constant from Theorem 5.9. Select be a sufficiently small constant such that .
The algorithm on where works as follows:
Let be the largest number in the sequence from Theorem 5.9 with s.t. . 2. 2.
Let be the graph from Theorem 5.9 with , , and be a -gap-relization of where and . 3. 3.
We use the algorithm from Lemma 3.11 to find where such that the union of is 4. 4.
We assume w.l.o.g. that is divisible by . Partition and into and each of size . For each , do the following:
- (a)
Let be an appropriate permutation of that -gap-realizes . 2. (b)
Pick such that
[TABLE]
Notice that the upper and lower bounds are and they are also apart. Hence, we can pick these so that . 3. (c)
Let and define as
[TABLE] 4. (d)
Run on . If outputs YES, then output YES and terminate. 5. 5.
If none of the executions of returns with YES, then output NO.
Observe that the bottleneck in the running time of the algorithm is in the executions of . The number of executions is and each execution takes time. Hence, in total the running time of the algorithm is . Now, from the log-density of the sequence from Theorem 5.9, we have . As a result, the running time of is at most as desired.
To see the correctness of the algorithm, first observe that the dimensions of vectors in are at most which is ; that is, the calls to are valid. Next, observe that, if is a YES instance of , there must be and such that is at most . Since covers , there must be such that . As a result, . Thus, is a YES instance for and outputs YES as desired.
Finally, let us assume that is a NO instance of -. Consider any and . To argue that is a NO instance for -, we have to show that any two points in have distance more than . To see this, let us consider two cases.
Both points are either from or from . Assume w.l.o.g. that they are from ; let them be and . Recall that, from the definition of and Theorem 5.9, we must have . Thus, the Hamming distance between the two points is more than , where the inequality comes from our choice of . 2. 2.
One of the point is from and the other from . Let them be and . Since is a NO instance of -, . Moreover, from definition of , we must have . Combining the two implies that the distance between and is more than , where the inequality is once again from our choice of .
Hence, must be a NO instance for - for every and . Thus, outputs NO as desired. ∎
8 Discussion and Open Questions
It remains open to completely resolve Open Questions 1.1 and 1.2. It is still possible that our framework can be used to resolve these problems: we just need to construct gadgets with better parameters! In particular, to resolve Question 1.1, we have to improve the dimension bound in Theorem 4.2 to . For Question 1.2, we just have to improve the bound on the number of pairs in (3) of Theorem 5.9 to . Following our observation from Lemma 5.1, this motivates us to ask the following purely coding theoretic question:
Open Question 8.1**.**
For every , are there linear codes both of block length over alphabet such that the following holds:
- •
, for some .
- •
.
Apart from the aforementioned questions, Rubinstein [Rub18] pointed out an interesting obstacle, aptly dubbed the “triangle inequality barrier”, to obtain fine-grained lower bounds against 3-approximation algorithms for (see Open Question 3 in [Rub18]). In the case of , this barrier turns out to be against 2-approximation algorithms as noted in [DKL18]. We reiterate this below as an open problem to be resolved:
Open Question 8.2**.**
Can we show that assuming , for some constant , no algorithm running in time can solve 2- in any metric when the points are in dimensions?
Another interesting direction is to extend the hardness of to the -vector generalization of the problem, called -. In -, we are given a set of points and we would like to select distinct points that maximizes
[TABLE]
It is known that the -chromatic variant of - is hard to approximate (see Appendix B of [KLM18]) but this is not known to be true for - itself. Our approach seems quite compatible to tackling this problem as well; in particular, if we can construct a certain (natural) generalization of our gadget for , then we would immediately arrive at the inapproximability of - even for -entries vectors. The issue in constructing this gadget is that we are now concerned about agreements of more than two vectors, which does not correspond to error-correcting codes anymore and some additional tools are needed to argue for this more general case.
It should be noted that the hardness of approximating - for -entry vectors is equivalent to the one-sided -biclique problem [Lin18], in which a bipartite graph is given and the goal is to select vertices on the right that maximize the number of their common neighbors. The equivalence can be easily seen by viewing the coordinates as the left-hand-side vertices and the vectors as the right-hand-side vertices. The one-sided -biclique is shown to be -hard to approximate by Lin [Lin18] who also showed a lower bound of for the problem assuming . If the generalization of our gadget for - works as intended, then this lower bound can be improved to under and even under .
The one-sided -biclique is closely related to the (two-sided) -biclique problem, where we are given a bipartite graph and we wish to decide whether it contains as a subgraph. The -biclique problem was consider a major open problem in parameterized complexity (see e.g., [DF13]) until it was shown by Lin to be -hard [Lin18]. Nevertheless, the running time lower bound known is still not tight: currently, the best lower bound known for this problem is both for the exact version (under ) [Lin18] and its approximate variant (under -) [CCK*+*17]. It remains an interesting open question to close the gap between the above lower bounds and the trivial upper bound of . Progresses on the one-sided -biclique problem could lead to improved lower bounds for -biclique problem too, although several additional steps have to be taken care of.
Acknowledgements
We are grateful to Madhu Sudan for extremely helpful and informative discussion about AG codes; in particular, Madhu pointed us to [Vlă18]. We thank Bundit Laekhanukit and Or Meir for general discussions, and the Simons Institute for their wonderful work-space. Finally, we would like to thank Lijie Chen for sharing [CW19], and Orr Paradise for useful comments on an earlier draft of this manuscript.
Appendix A Lower Bound on Gap Closest Pair in Edit Distance Metric
In this section we prove Theorem 1.7. The proof is almost identical to Rubinstein’s [Rub18] proof for the -hardness of gap- in the edit distance metric and uses the following technical tool established in [Rub18].
Lemma A.1** (Rubinstein [Rub18]).**
For large enough , there is a function , where , such that for all the following holds for some constant :
[TABLE]
Moreover, for any , can be computed in time.
At a high level, picks a random -bit string uniformly and independently for every , and for every vector , replaces the coordinate by . The claims in the lemma statement follow by the known concentration bounds on the edit distance of random strings [McD89, Lue09]. This construction is further efficiently derandomized by using -wise independent strings [Kop13].
Proof of Theorem 1.7.
We show that if there exists an algorithm running in time for some that can solve - in the edit distance metric for some over point-sets in , then can be used to solve - in the Hamming metric in time over point-sets in , where . Together with Theorem 7.2, this implies that is false, as desired.
Let be an instance of - in the Hamming metric over point-sets in . It is clear131313In fact, one can design a time algorithm for in the Hamming metric, and therefore to assume , we require . from the proofs of Theorem 7.1 and Theorem 7.2 that . We now define an instance of of - in the edit distance metric as follows. Recall the function from Lemma A.1 and define the set . Notice that for every pair of distinct points , we have . In other words if we had a pair of distinct points in such that then, and suppose for all pairs of distinct points we had then , since . This completes the analysis of the completeness and soundness cases, and we can conclude that running on input solves the instance of - in the Hamming metric. ∎
Appendix B Covering Biclique By Isomorphic Graphs: Proof of Lemma 3.11
Below we prove Lemma 3.11. The proof strategy is similar to how the greedy approximation algorithms for the set cover problem are analyzed: we show that at each step, we can pick a graph isomorphic to that covers at least fraction of the remaining edges of the biclique. By doing so, we guarantee that the process ends in steps. Note however that, there are exponential number of isomorphisms and thus we cannot simply enumerate all isomorphisms to find one that covers the desired fraction of uncovered edges. Nevertheless, it is not hard to see that we can use the method of conditional expectation to find one such isomorphism in polynomial time. This is formalized below.
Lemma B.1**.**
For any two bipartite graphs and , there exists a side-preserving permutation such that
[TABLE]
Moreover, such a permutation can be found (deterministically) in time.
Proof.
Notice that, if we pick and randomly among all permutations of and respectively, then, for a fixed , the probability that belongs to is . Thus,
[TABLE]
This proves the existence part of the claim. To deterministically find such a , we use the method of conditional expectation. Suppose . The algorithm works as follows:
Let . 2. 2.
For :
- (a)
If , let . Otherwise, if , let . 2. (b)
For each , compute the conditional expectation:
[TABLE]
Let be the maximizer for the above conditional expectation. We set . 3. 3.
Output .
It is simple to see that the conditional expectation never decreases as we fill in the permutation. As a result, we must have as desired. Moreover, it is easy to see that the conditional expectation can be computed in time because, for each edge , we can compute the probability that in time. As a result, the overall running time of the algorithm is . ∎
Finally using Lemma B.1, we prove Lemma 3.11 using the strategy outlined earlier in this section.
Proof of Lemma 3.11.
We describe below an algorithm for finding . It works as follows.
Let . 2. 2.
While is non-empty, do the following:
- (a)
Let . 2. (b)
Let . 3. (c)
Use the algorithm from Lemma B.1 to find such that . 3. 3.
Output .
It is obvious that the permutations are all side-preserving permutations and that the union of over is equal to . To see that , observe that due to the guarantee of Lemma B.1, decreases by a multiplicative factor of (at most) for each permutation picked. Since the set remains non-empty after permutations are picked, we have , which implies that as desired. Finally, the bottleneck in the running time is Step 2c; we execute this step times and each execution takes time. Thus, the total running time is . ∎
The reference list from the paper itself. Each links out to its DOI / PubMed record.
- 1[ABV 01] Alexei E. Ashikhmin, Alexander Barg, and Serge G. Vladut. Linear codes with exponentially many light vectors. J. Comb. Theory, Ser. A , 96(2):396–399, 2001.
- 2[AC 09] Nir Ailon and Bernard Chazelle. The fast johnson–lindenstrauss transform and approximate nearest neighbors. SIAM J. Comput. , 39(1):302–322, 2009. Preliminary version in STOC’06.
- 3[ACW 16] Josh Alman, Timothy M. Chan, and R. Ryan Williams. Polynomial representations of threshold functions and algorithmic applications. In IEEE 57th Annual Symposium on Foundations of Computer Science, FOCS 2016, 9-11 October 2016, Hyatt Regency, New Brunswick, New Jersey, USA , pages 467–476, 2016.
- 4[AESW 91] Pankaj K. Agarwal, Herbert Edelsbrunner, Otfried Schwarzkopf, and Emo Welzl. Euclidean minimum spanning trees and bichromatic closest pairs. Discrete & Computational Geometry , 6:407–422, 1991. Preliminary version in So CG’90.
- 5[Alp 10] Ethem Alpaydin. Introduction to Machine Learning . The MIT Press, 2nd edition, 2010.
- 6[ARW 17a] Amir Abboud, Aviad Rubinstein, and Ryan Williams. Distributed PCP theorems for hardness of approximation in P. Co RR , abs/1706.06407, 2017.
- 7[ARW 17b] Amir Abboud, Aviad Rubinstein, and Ryan Williams. Distributed PCP theorems for hardness of approximation in P. In FOCS , pages 25–36, 2017.
- 8[AW 15] Josh Alman and Ryan Williams. Probabilistic polynomials and hamming nearest neighbors. In IEEE 56th Annual Symposium on Foundations of Computer Science, FOCS 2015, Berkeley, CA, USA, 17-20 October, 2015 , pages 136–150, 2015.
