Distributed PCP Theorems for Hardness of Approximation in P

TL;DR

This paper introduces a new distributed PCP model and uses it to establish nearly-tight inapproximability results for several problems in P based on SETH, advancing understanding of hardness in approximation.

Contribution

It develops a novel distributed PCP framework and derives the first SETH-based inapproximability results for specific polynomial-time problems.

Findings

No truly-subquadratic approximation algorithms under SETH

Nearly-polynomial inapproximability factors achieved

First SETH-based hardness results for these problems

Abstract

We present a new distributed model of probabilistically checkable proofs (PCP). A satisfying assignment $x \in \{0,1\}^n$ to a CNF formula $\varphi$ is shared between two parties, where Alice knows $x_1, \dots, x_{n/2}$, Bob knows $x_{n/2+1},\dots,x_n$, and both parties know $\varphi$. The goal is to have Alice and Bob jointly write a PCP that $x$ satisfies $\varphi$, while exchanging little or no information. Unfortunately, this model as-is does not allow for nontrivial query complexity. Instead, we focus on a non-deterministic variant, where the players are helped by Merlin, a third party who knows all of $x$. Using our framework, we obtain, for the first time, PCP-like reductions from the Strong Exponential Time Hypothesis (SETH) to approximation problems in P. In particular, under SETH we show that there are no truly-subquadratic approximation algorithms for Bichromatic Maximum Inner Product over {0,1}-vectors, Bichromatic LCS Closest Pair over permutations, Approximate Regular Expression Matching, and Diameter in Product Metric. All our inapproximability factors are nearly-tight. In particular, for the first two problems we obtain nearly-polynomial factors of $2^{(\log n)^{1-o(1)}}$; only $(1+o(1))$-factor lower bounds (under SETH) were known before.

Equations

$$\phi \triangleq \underset{i=1}{\overset{n/2}{\bigwedge }}\left(\neg {\alpha }_i\vee \neg {\beta }_i\right).$$

$$\Delta\Big{(}(x_{1},\ldots,x_{k}),(y_{1},\ldots,y_{k})\Big{)}\triangleq f\Big{(}\Delta_{1}(x_{1},y_{1}),\ldots,\Delta_{k}(x_{k},y_{k})\Big{)}.$$

$$\displaystyle\Delta_{2,\infty}(x,y)\triangleq\sqrt{\sum_{i=1}^{d_{2}}\left(\max_{j=2}^{d_{\infty}}\left\{\Big{|}x_{i,j}-y_{i,j}\Big{|}\right\}\right)^{2}}.$$

$$\forall i\in \left[\frac{n}{T}\right]\Phi (i)=0$$

$$\Phi (i)=\sum _{t=1}^T{\Psi }_{\alpha ,t}(i)\cdot {\Psi }_{\beta ,t}(i).$$

$${a^{\alpha ,\mu }}_{\ell ,{b^{\beta }}_{\ell }}=1.$$

$$s\left(a,b\right)\triangleq \underset{\ell \in L}{\mathrm{Pr}}\left[\underset{k\in K}{\bigvee }\left(a_{\ell ,k}=b_{\ell }\right)\right].$$

$${a^{\alpha ,\mu }}_{\ell ,k}\triangleq \{\begin{array}{ll}k& \text{if aα,μℓ,k=1}\\ \perp & \text{if aα,μℓ,k=0}\end{array}.$$

$$|a\cap b|=|L|\cdot s(a^{\prime },b^{\prime }).$$

$$N^{1-x}\cdot (n^c+N\cdot n^{1-\epsilon })=N^{1+x(c-1)}+N^{2-\epsilon x}$$

$${\gamma }_1$$

$${\alpha }_0$$

$${\beta }_0$$

$$x(u)\triangleq {◯}_{i=1}^d{\pi }^u(u_i).$$

$$\displaystyle LCS\big{(}x(u),x(v)\big{)}$$

$$=(u\cdot v)|{\Sigma }_i|+(d-u\cdot v)O(\sqrt{|{\Sigma }_i|}\log N).$$

$${\pi }_p(i,j)\triangleq (j,i+p(j)).$$

$${\pi }_p^{-1}(j,k)\triangleq (k-p(j),j).$$

$${\pi }_p(i,j)=(j,i+p(j))=(j,i^{\prime }+q(j))={\pi }_q(i^{\prime },j).$$

$$LCS({\pi }_p,{\pi }_q)=O(|\mathcal{F}|\cdot d)=O(\sqrt{|{\Sigma }_i|}\cdot \log N).$$

$$\widetilde{x_{\ell }}:=\widetilde{x_{\ell ,1}}|\widetilde{x_{\ell ,2}}|\cdots |\widetilde{x_{\ell ,K}}$$

$$\widetilde{x(a)}:=\widetilde{x_1}\circ \cdots \circ \widetilde{x_L}$$

$$\tilde{x}:=\widetilde{x(a^1)}|\widetilde{x(a^2)}|\cdots |\widetilde{x(a^N)}.$$

$$\underset{x\in \widetilde{x(a)}}{\min }H(x,y(b))=\sum _{\ell =1}^L\left(1-\underset{k\in [K]}{\max }(a_{\ell ,k}=b_{\ell })\right)=L-\sum _{\ell =1}^L\underset{k\in [K]}{\bigvee }(a_{\ell ,k}=b_{\ell })$$

$$L(\widetilde{x(a)})=\left\{x=a_{1,k_1}\cdots a_{L,k_L}\mid k_1,\dots ,k_L\in [K]\right\}$$

$$\underset{x\in \tilde{x}}{\min }H(x,y(b))=\underset{a\in A}{\min }\left(L-\sum _{\ell =1}^L\underset{k\in [K]}{\bigvee }(a_{\ell ,k}=b_{\ell })\right)=L-\underset{a\in A}{\max }L\cdot s(a,b)$$

$$\displaystyle\Delta_{2,\infty}(x,y)\triangleq\sqrt{\sum_{i=1}^{d_{2}}\left(\max_{j=2}^{d_{\infty}}\left\{\Big{|}x_{i,j}-y_{i,j}\Big{|}\right\}\right)^{2}}.$$

$$x(a)\triangleq {◯}_{\ell \in L}{◯}_{\sigma \in \Sigma }\underset{k\in K}{\bigvee }[a_{\ell ,k}=\sigma ].$$

$$y(b)\triangleq -{◯}_{\ell \in L}{◯}_{\sigma \in \Sigma }[b_{\ell }=\sigma ].$$

$$\Delta_{2,\infty}\big{(}x(a),y(b)\big{)}=(1+s(a,b))\cdot\ell.$$

Full text

Using our framework, we obtain, for the first time, PCP-like reductions from the Strong Exponential Time Hypothesis (SETH) to approximation problems in ¶. In particular, under SETH we show that there are no truly-subquadratic approximation algorithms for Bichromatic Maximum Inner Product over $\{0,1\}$-vectors, Bichromatic LCS Closest Pair over permutations, Approximate Regular Expression Matching, and Diameter in Product Metric. All our inapproximability factors are nearly-tight. In particular, for the first two problems we obtain nearly-polynomial factors of $2^{(\log n)^{1-o(1)}}$; only $(1+o(1))$-factor lower bounds (under SETH) were known before.

1 Introduction

Fine-Grained Complexity classifies the time complexity of fundamental problems under popular conjectures, the most productive of which has been the Strong Exponential Time Hypothesis111SETH is a pessimistic version of ¶$\neq$ \NP, stating that for every $\varepsilon>0$ there is a $k$ such that $k$-SAT cannot be solved in $O((2-\varepsilon)^{n})$ time. (SETH). The list of “SETH-Hard” problems is long, including central problems in pattern matching and bioinformatics [AWW14, BI15, BI16], graph algorithms [RV13, GIKW17], dynamic data structures [AV14], parameterized complexity and exact algorithms [PW10, LMS11, CDL*+*16], computational geometry [Bri14], time-series analysis [ABV15, BK15], and even economics [MPS16] (a longer list can be found in [Wil15]).

For most problems in the above references, there are natural and meaningful approximate versions, and for most of them the time complexity is wide open (a notable exception is [RV13]). Perhaps the most important and challenging open question in the field of Fine-Grained Complexity is whether a framework for hardness of approximation in ¶ is possible. To appreciate the gaps in our knowledge regarding inapproximability, consider the following fundamental problem from the realms of similarity search and statistics, of finding the most correlated pair in a dataset.

Definition 1.1** **(The Bichromatic222See the end of this section for a discussion of “bichromatic” vs “monochromatic” closest pair problems.

Max Inner Product Problem (Max-IP)).

Given two sets $A,B$, each of $N$ binary vectors in $\{0,1\}^{d}$, return a pair $(a,b)\in A\times B$ that maximizes the inner product $a\cdot b$.

Thinking of the vectors as subsets of $[d]$, this Max-IP problem asks to find the pair with largest overlap, a natural similarity measure. A naïve algorithm solves the problem in $O(N^{2}d)$ time, and one of the most-cited fine-grained results is a SETH lower bound for this problem. Assuming SETH, we cannot solve Max-IP (exactly) in $N^{2-\varepsilon}\cdot 2^{o(d)}$ time, for any $\varepsilon>0$ [Wil05].

This lower bound is hardly pleasing when one of the most vibrant areas of Algorithms333In SODA’17, two entire sessions were dedicated to algorithms for similarity search. is concerned with designing approximate but near-linear time solutions for such similarity search problems. For example, the original motivation of the celebrated MinHash algorithm was to solve the indexing version of this problem [Bro97, BGMZ97], and one of the first implementations was at the core of the AltaVista search engine. The problem has important applications all across Computer Science, most notably in Machine Learning, databases, and information retrieval, e.g. [IM98, AI06, RR*+*07, RG12, SL14, AINR14, AIL*+*15, AR15, NS15, SL15, Val15, AW15, KKK16, APRS16, TG16, CP16, Chr17].

Max-IP seems to be more challenging than closely related problems where similarity is defined as small Euclidean distance rather than large inner product. For the latter, we can get near-linear $O(N^{1+\varepsilon})$ time algorithms, for all $\varepsilon>0$, at the cost of some constant $f(\varepsilon)$ error that depends on $\varepsilon$ [IM98, AI06, AINR14, AR15]. In contrast, for Max-IP, even for a moderately subquadratic running time of $O(N^{2-\varepsilon})$, all known algorithms suffer from polynomial $N^{g(\varepsilon)}$ approximation factors.

Meanwhile, the SETH lower bound for Max-IP was only slightly improved by Ahle, Pagh, Razenshteyn, and Silvestri [APRS16] to rule out $1+o(1)$ approximations, leaving a huge gap between the not-even-$1.001$ lower bound and the polynomial upper bound.

Open Question 1**.**

Is there an $O(N^{1+\varepsilon})$-time algorithm for computing an $f(\varepsilon)$-approximation to Bichromatic Max Inner Product over binary vectors?

This is just one of the many significant open questions that highlight our inability to prove hardness of approximation in ¶, and pour cold water on the excitement from the successes of Fine-Grained Complexity. It is natural to try to adapt tools from the \NP-Hardness-of-approximation framework (namely, the celebrated PCP Theorem) to ¶. Unfortunately, when starting from SETH, almost everything in the existing theory of PCPs breaks down. Whether PCP-like theorems for Fine-Grained Complexity are possible, and what they could look like, are fascinating open questions.

Our main result is the first SETH-based PCP-like theorem, from which several strong hardness of approximation in ¶ results follow. We identify a canonical problem that is hard to approximate, and further gadget-reductions allow us to prove SETH-based inapproximability results for basic problems such as Subset Queries, Closest Pair under the Longest Common Subsequence similarity measure, and Furthest Pair (Diameter) in product metrics. In particular, assuming SETH, we negatively resolve Open Question 1 in a very strong way, proving an almost tight lower bound for Max-IP.

1.1 PCP-like Theorems for Fine-Grained Complexity

The following meta-structure is common to most SETH-based reductions: given a CNF $\varphi$, construct $N=O\left(2^{\frac{n}{2}}\right)$ gadgets, one for each assignment to the first/last $n/2$ variables, and embed those gadgets into some problem $A$. The embedding is designed so that if $A$ can be solved in $O\left(N^{2-\varepsilon}\right)=O\left(2^{\left(1-\frac{\varepsilon}{2}\right)n}\right)$ time, a satisfying assignment for $\varphi$ can be efficiently recovered from the solution, contradicting SETH.

The most obvious barrier to proving fine-grained hardness of approximation is the lack of an appropriate PCP theorem. Given a 3-SAT formula $\varphi$, testing that an assignment $x\in\left\{0,1\right\}^{n}$ satisfies $\varphi$ requires reading all $n$ bits of $x$. The PCP Theorem [AS98, ALM*+*98], shows how to transform $x\in\left\{0,1\right\}^{n}$ into a PCP (probabilistically checkable proof) $\pi=\pi\left(\varphi,x\right)$, which can be tested by a probabilistic verifier who only reads a few bits from $\pi$. This is the starting point for almost all proofs of \NP-hardness of approximation. The main obstacle in using PCPs for fine-grained hardness of approximation is that all known PCPs incur a blowup in the size proof: $\pi\left(\varphi,x\right)$ requires $n^{\prime}\gg n$ bits. The most efficient known PCP, due to Dinur [Din07], incurs a polylogarithmic blowup ($n^{\prime}=n\cdot\polylog(n)$), and obtaining a PCP with a constant blowup is a major open problem (e.g. [BKK*+*16, Din16]). However, note that even if we had a fantastic PCP with only $n^{\prime}=10n$, a reduction of size $N^{\prime}=2^{\frac{n^{\prime}}{2}}=2^{5n}$ does not imply any hardness at all. Our goal is to overcome this barrier:

Open Question 2**.**

Is there a PCP-like theorem for fine-grained complexity?

Distributed PCPs

Our starting point is that of error-correcting codes, a fundamental building block of PCPs. Suppose that Alice and Bob want to encode a message $m=\left(\alpha;\beta\right)\in\left\{0,1\right\}^{n}$ in a distributed fashion. Neither Alice nor Bob knows the entire message: Alice knows the first half ($\alpha\in\left\{0,1\right\}^{\frac{n}{2}}$), and Bob knows the second half ($\beta\in\left\{0,1\right\}^{\frac{n}{2}}$). Alice can locally compute an encoding $E^{\prime}\left(\alpha\right)$ of her half, and Bob locally computes an encoding $E^{\prime}\left(\beta\right)$ of his. Then the concatenation of Alice’s and Bob’s strings, $E\left(m\right)=\left(E^{\prime}\left(\alpha\right);E^{\prime}\left(\beta\right)\right)$, is an error-correcting encoding of $m$.

Now let us return to distributed PCPs. Alice and Bob share a $k$-SAT formula444In the formulation of SETH, $k$ is a “sufficiently large constant”(see Section 2 for definition). However, for the purposes of our discussion here it suffices to think of $k=3$. $\varphi$. Alice has an assignment $\alpha\in\left\{0,1\right\}^{\frac{n}{2}}$ to the first half of the variables, and Bob has an assignment $\beta\in\left\{0,1\right\}^{\frac{n}{2}}$ to the second half. We want a protocol where Alice locally computes a string $\pi^{\prime}\left(\alpha\right)\in\left\{0,1\right\}^{n^{\prime}}$, Bob locally computes $\pi^{\prime}\left(\beta\right)\in\left\{0,1\right\}^{n^{\prime}}$, and together $\pi\left(\alpha;\beta\right)=\left(\pi^{\prime}\left(\alpha\right),\pi^{\prime}\left(\beta\right)\right)$ is a valid probabilistically checkable proof that $x=\left(\alpha,\beta\right)$ satisfies $\varphi$. That is, a probabilistic verifier can read a constant number of bits from $\left(\pi^{\prime}\left(\alpha\right),\pi^{\prime}\left(\beta\right)\right)$ and decide (with success probability at least $2/3$) whether $\left(\alpha,\beta\right)$ satisfies $\varphi$.

It is significant to note that if distributed PCPs can be constructed, then very strong reductions for fine-grained hardness of approximation follow, completely overcoming the barrier for fine-grained PCPs outlined above. The reason is that we can still construct $N=O\left(2^{\frac{n}{2}}\right)$ gadgets, one for each half assignment $\alpha,\beta\in\left\{0,1\right\}^{\frac{n}{2}}$, where the gadget for $\alpha$ also encodes $\pi^{\prime}\left(\alpha\right)$. The blowup of the PCP only affects the size of each gadget, which is negligible compared to the number of gadgets. In fact, this technique would be so powerful, that we could reduce SETH to problems like approximate $\ell_{2}$-Nearest Neighbor, where the existing sub-quadratic approximation algorithms (e.g. [AR15]) would falsify SETH!

Alas, distributed PCPs are unconditionally impossible (even for $2$-SAT) by a simple reduction from Set Disjointness:

Theorem 1.2** (Reingold [Rei17]; informal).**

Distributed PCPs are impossible.

Proof (sketch).

Consider the 2-SAT formula

[TABLE]

This $\varphi$ is satisfied by assignment $\left(\alpha;\beta\right)$ iff the vectors $\alpha,\beta\in\left\{0,1\right\}^{\frac{n}{2}}$ are disjoint. If a PCP verifier can decide whether $\left(\alpha;\beta\right)$ satisfies $\varphi$ by a constant number of queries to $\left(\pi^{\prime}\left(\alpha\right),\pi^{\prime}\left(\beta\right)\right)$, then Alice and Bob can simulate the PCP verifier to decide whether their vectors are disjoint, while communicating only a constant number of bits (the values read by the PCP verifier). This contradicts the randomized communication complexity lower bounds of $\Omega(n)$ for set disjointness [KS92, Raz92, BJKS04]. ∎

Note that the proof shows that even distributed PCPs with $o(n)$ queries are impossible.

Distributed and non-deterministic PCPs

As noted above, set disjointness is very hard for randomized communication, and hard even for non-deterministic communication [KKN95]. But Aaronson and Wigderson [AW09] showed that set disjointness does have $\tilde{O}\left(\sqrt{n}\right)$ Merlin-Arthur ($\MA$) communication complexity. In particular, they construct a simple protocol where the standard Bob and an untrusted Merlin (who can see both sets of Alice and Bob) each send Alice a message of length $\tilde{O}\left(\sqrt{n}\right)$. If the sets are disjoint, Merlin can convince Alice to accept; if they are not, Alice will reject with high probability regardless of Merlin’s message.

Our second main insight in this paper is this: for problems where the reduction from SETH allows for an efficient OR gadget, we can enumerate over all possible messages from Merlin and Bob555In fact, enumerating over Merlin’s possible messages turns out to be easy to implement in the reductions; the main bottleneck is the communication with Bob.. Thus we incur only a subexponential blowup666Subexponential in $n$ (the number of $k$-SAT variables), which implies subpolynomial in $N\approx 2^{n/2}$. in the reduction size, while overcoming the communication barrier. Indeed, the construction in our PCP-like theorem (Theorem 4.1) can be interpreted as implementing a variant of Aaronson and Wigderson’s $\MA$ communication protocol. The resulting PCP construction is distributed (in the sense described above) and non-deterministic (in the sense that Alice receives sublinear advice from Merlin).

It can be instructive to view our distributed PCP model as a 4-party (computationally-efficient) communication problem. Merlin wants to convince Alice, Bob, and Veronica (the verifier) that Alice and Bob jointly hold a satisfying assignment to a publicly-known formula. Merlin sees everything except the outcome of random coin tosses, but he can only send $o(n)$ bits to only Alice. Alice and Bob each know half of the (allegedly) satisfying assignment, and each of them must (deterministically) send a (possibly longer) message to Veronica. Finally, Veronica tosses coins and is restricted to reading only $o(n)$ bits from Alice’s and Bob’s messages, after which she must output Accept/Reject.

Patrascu and Williams [PW10] asked whether it is possible to use Aaronson and Wigderson’s $\MA$ protocol for Set Disjointness to obtain better algorithms for satisfiability. Taking an optimistic twist, our results in this paper may suggest this is indeed possible: if any of several important and simple problems admit efficient approximation algorithms, then faster algorithms for (exact) satisfiability may be obtained via Aaronson and Wigderson’s $\MA$ protocol.

1.2 Our results

Our distributed and non-deterministic PCP theorem is formalized as Theorem 4.1. Since our main interest is proving hardness-of-approximation results, in Section 5 we abstract the prover-verifier formulation by reducing our PCP to an Orthogonal-Vectors-like problem which we call PCP-Vectors. The hardness of PCP-Vectors is formalized as Theorem 5.2. PCP-Vectors turns out to be an excellent starting point for many results, yielding easy reductions for fundamental problems and giving essentially tight inapproximability bounds. Let us exhibit what we think are the most interesting ones.

Bichromatic Max Inner Product

Our first application is a strong resolution of Open Question 1, under SETH. Not only is an $O(1)$-factor approximation impossible in $O(N^{1+\varepsilon})$ time, but we must pay a near-polynomial $2^{(\log{N})^{1-o(1)}}$ approximation factor if we do not spend nearly-quadratic $N^{2-o(1)}$ time! (See Theorem 1.3 below.)

As we mentioned earlier, when viewing the $\{0,1\}^{d}$ vectors as subsets of $[d]$, Max-IP corresponds to maximizing the size of the intersection. In fact our hardness of approximation result holds even in a seemingly easier special case of Max-IP which has received extensive attention: the Subset Query problem [RPNK00, MGM03, AAK10, GG10], which is known to be equivalent to the classical Partial Match problem. The first non-trivial algorithms for this problem appeared in Ronald Rivest’s PhD thesis [Riv74, Riv76]. Since our goal is to prove lower bounds, we consider its offline or batch version (and the lower bound will transfer to the data structure version):

Given a collection of (text) sets $T_{1},\ldots,T_{N}\subseteq[d]$ and a collection of (pattern) sets $P_{1},\ldots,P_{N}\subseteq[d]$, is there a set $P_{i}$ that is contained in a set $T_{j}$?

In the $c$-approximate case, we want to distinguish between the case of exact containment, and the case where no $T_{j}$ can cover more than a $c$-fraction of any $P_{i}$. We show that even in this very simple problem, we must pay a $2^{(\log{N})^{1-o(1)}}$ approximation factor if it is to be solved in truly-subquadratic time. Hardness of approximation for Max-IP follows as a simple corollary of the following stronger statement:

Theorem 1.3**.**

Assuming SETH, for any $\varepsilon>0$, given two collections $A,B$, each of $N$ subsets of a universe $[m]$, where $m=N^{o(1)}$ and all subsets $b\in B$ have size $k$, no $O(N^{2-\varepsilon})$ time algorithm can distinguish between the cases:

Completeness

there exist $a\in A,b\in B$ such that $b\subseteq a$; and

Soundness

for every $a\in A,b\in B$ we have $|a\cap b|\leq k/2^{(\log{N})^{1-o(1)}}$.

Improving our lower bound even to some $N^{\varepsilon}$ factor (for a universal constant $\varepsilon>0$) would refute SETH via the known Max-IP algorithms (see e.g. [APRS16]). Using an idea of [WW10], it is not hard to show that Theorem 1.3 also applies to the harder (but more useful) search version widely known as MIPS.

Corollary 1.4**.**

Assuming SETH, for all $\varepsilon>0$, no algorithm can preprocess a set of $N$ vectors $p_{1},\ldots,p_{N}\in D\subseteq\{0,1\}^{m}$ in polynomial time, and subsequently given a query vector $q\in\{0,1\}^{m}$ can distinguish in $O(N^{1-\varepsilon})$ time between the cases:

Completeness

there exist $p_{i}\in D$ such that $\langle p_{i},q\rangle\geq s$; and

Soundness

for every $p_{i}\in D$, $\langle p_{i},q\rangle\leq s/2^{(\log{N})^{1-o(1)}}$,

even when $m=N^{o(1)}$ and the similarity threshold $s\in[m]$ is fixed for all queries.

Except for the $(1+o(1))$-factor lower bound [APRS16] which transfers to MIPS as well, the only lower bounds known were either for specific techniques [MNP07, ACP08, OWZ14, AIL*+*15], or were in the cell-probe model but only ruled out extremely efficient queries [AIP06, PTW08, PTW10, KP12, AV15, ALRW17].

An important version of Max-IP is when the vectors are in $\{-1,1\}^{d}$ rather than $\{0,1\}^{d}$. This version is closely related to other famous problems such as the light bulb problem and the problem of learning parity with noise (see the reductions in [Val15]). Negative coordinates often imply trivial results for multiplicative hardness of approximation: it is possible to shift a tiny gap of $k$ vs. $k+1$ to a large multiplicative gap of [math] vs $1$ by adding $k$ coordinates with $-1$ contribution. In the natural version where we search for a pair with maximum inner product in absolute value, this trick does not quite work. Still, Ahle et al. [APRS16] exploit such cancellations to get a strong hardness of approximation result using an interesting application of Chebychev embeddings. The authors had expected that a different approach must be taken to prove constant factor hardness for the $\{0,1\}$ case. Interestingly, since it is easy to reduce $\{0,1\}$ to $\{-1,1\}$, our reduction also improves their lower bound for the $\{-1,1\}$ case from $2^{\tilde{\Omega}(\sqrt{\log{N}})}$ to the almost-tight $2^{(\log{N})^{1-o(1)}}$ (see Corollary 6.1). This also implies an $N^{1-o(1)}$-time lower bound for queries in the indexing version of the problem.

Longest Common Subsequence Closest Pair

Efficient approximation algorithms have the potential for major impact in sequence alignment problems, the standard similarity measure between genomes and biological data. One of the most cited scientific papers of all time studies BLAST, a heuristic algorithm for sequence alignment that often returns grossly sub-optimal solutions777Note that many of its sixty-thousand citations are by other algorithms achieving better results (on certain datasets). but always runs in near-linear time, in contrast to the best-known worst-case quadratic-time algorithms. For theoreticians, to get the most insight into these similarity measures, it is common to think of them as Longest Common Subsequence (LCS) or Edit Distance. The Bichromatic LCS Closest Pair problem is:

Given a (data) set $N$ strings and a (query) set of $N$ strings, all of which have length $m\ll N$, find a pair, one from each set, that have the maximum length common subsequence (noncontiguous).

The search version and the Edit Distance version are defined analogously. Good algorithms for these problems would be highly relevant for bioinformatics.

A series of breakthroughs [LMS98, Ind04, BYJKK04, BES06, OR07, AKO10, AO12] led to “good” approximation algorithms for Edit Distance. While most of these papers focus on the more basic problem of approximating the Edit Distance of two given strings (see Open Question 4), they use techniques such as metric embeddings that can solve the Edit Distance Closest Pair problem in near-linear time with a $2^{O(\sqrt{\log{m}\log\log{m}})}$ approximation [OR07]. Meanwhile, both the basic LCS problem on two strings and the LCS Closest Pair resisted all these attacks, and to our knowledge, no non-trivial algorithms are known. On the complexity side, only a $(1+o(1))$-approximation factor lower bound is known for Bichromatic LCS Closest Pair [ABV15, BK15, AB17], and getting a $1.001$ approximation in near-linear time is not known to have any consequences. For algorithms that only use metric embeddings there are nearly logarithmic lower bounds for Edit-Distance Closest Pair, but even under such restrictions the gaps are large [ADG*+*03, SU04, KN05, AK07, AJP10].

Perhaps our most surprising result is a separation between these two classical similarity measures. Although there is no formal equivalence between the two, they have appeared to have the same complexity no matter what the model and setting are. We prove that LCS Closest Pair is much harder to approximate than Edit Distance.

Theorem 1.5**.**

Assuming SETH, there is no $\left({2^{(\log{N})^{1-o(1)}}}\right)$-approximation algorithm for Bichromatic LCS Closest Pair on two sets of $N$ permutations of length $m=N^{o(1)}$ in time $O\left(N^{2-\varepsilon}\right)$, for all $\varepsilon>0$.

Notice that our theorem holds even under the restriction that the sequences are permutations. This is significant: in the “global” version of the problem where we want to compute the LCS between two long strings of length $n$, one can get the exact solution in near-linear time if the strings are permutations (the problem becomes the famous Longest Increasing Subsequence), while on arbitrary strings there is an $N^{2-o(1)}$ time lower bound from SETH. The special case of permutations has received considerable attention due to connections to preference lists, applications to biology, and also as a test-case for various techniques. In 2001, Cormode, Muthukrishnan, and Sahinalp [CMS01] gave an $O(\log{m})$-Approximate Nearest Neighbor data structure for Edit Distance on permutations with $N^{o(1)}$ time queries (improved to $O(\log\log{m})$ in [AIK09]), and raised the question of getting similar results for LCS Approximate Nearest Neighbor. Our result gives a strong negative answer under SETH, showing that Bichromatic LCS Closest Pair suffers from near-polynomial approximation factors when the query time is truly sublinear.

Regular Expression Matching

Given two sets of strings of length $m$, a simple hashing-based approach lets us decide in near-linear time if there is a pair of Hamming distance [math] (equal strings), or whether all pairs have distance at least $1$. A harder version of this problem, which appears in many important applications, is when one of the sets of strings is described by a regular expression:

Given a regular expression $R$ of size $N$ and a set $S$ of $N$ strings of length $m$, can we distinguish between the case that some string in $S$ is matched by $R$, and the case that every string in $S$ is far in Hamming distance888In our hard instances, all the strings in $\operatorname*{L}(R)$ will be of length $m$, so Hamming distance is well defined. from every string in $\operatorname*{L}(R)$ (the language defined by $R$)?

This is a basic approximate version of the classical regular expression matching problem that has been attacked from various angles throughout five decades, e.g. [Tho68, MM89, Mye92, WMM95, KM95, MOG98, Nav04, BR13, BT09, BI16, BGL16]. Surprisingly, we show that this problem is essentially as hard as it gets: even if there is an exact match, it is hard to find any pair with Hamming distance $(1-\varepsilon)\cdot m$, for any $\varepsilon>0$. For the case of binary alphabets, we show that even if an exact match exists (a pair of distance [math]), it is hard to find a pair of distance $(\frac{1}{2}-\varepsilon)\cdot m$, for any $\varepsilon>0$. Our lower bounds also rule out interesting algorithms for the harder setting of Nearest-Neighbor queries: Preprocess a regular expression so that given a string, we can find a string in the language of the expression that is approximately-the-closest one to our query string. The formal statement and definitions of regular expressions are given in Section 8.

Theorem 1.6** (informal).**

Assuming SETH, no $O(N^{2-\varepsilon})$-time algorithm can, given a regular expression $R$ of size $N$ and a set $S$ of $N$ strings of length $m=N^{o(1)}$, distinguish between the two cases:

Completeness

some string in $S$ is in $\operatorname*{L}(R)$; and

Soundness

all strings in $S$ have Hamming distance $(1-o(1))\cdot m$ (or, $(\frac{1}{2}-o(1))\cdot m$ if the alphabet is binary) from all strings in $\operatorname*{L}(R)$.

Diameter in Product Metrics

The diameter (or furthest pair) problem has been well-studied in a variety of metrics (e.g. graph metrics [ACIM99, RV13, CLR*+*14]). There is a trivial $2$-approximation in near-linear time (return the largest distance from an arbitrary point), and for arbitrary metrics (to which we get query access) there is a lower bound stating that a quadratic number of queries is required to get a $(2-\delta)$-approximation [Ind99]. For $\ell_{2}$-metric, there is a sequence of improved subquadratic-time approximation algorithms [EK89, FP02, BOR04, Ind00, GIV01, Ind03]. The natural generalization to the $\ell_{p}$-metric for arbitrary $p$ is, to the best of our knowledge, wide open.

While we come short of resolving the complexity of approximating the diameter for $\ell_{p}$-metrics, we prove a tight inapproximability result for the slightly more general problem for the product of $\ell_{p}$ metrics. Given a collection of metric spaces $M_{i}=\langle X_{i},\Delta_{i}\rangle$, their $f$-product metric is defined as

[TABLE]

In particular, we are concerned with the $\ell_{2}$-product of $\ell_{\infty}$-spaces, whose metric is defined as:

[TABLE]

(This is a special case of the more general $\Delta_{2,\infty,1}(\cdot,\cdot)$ product metric, studied by [AIK09].)

Product metrics (or cascaded norms) are useful for aggregating different types of data [Ind98, Ind02, CM05, JW09]. They also received significant attention from the algorithms community because they allow rich embeddings, yet are amenable to algorithmic techniques (e.g. [Ind02, Ind03, Ind04, AIK09, AJP10, AO12]).

Theorem 1.7** (Diameter).**

Assuming SETH, there are no $(2-\delta)$-approximation algorithms for Product-Metric Diameter in time $O\left(N^{2-\varepsilon}\right)$, for any constants $\varepsilon,\delta>0$.

1.3 Related work

For all the problems we consider, SETH lower bounds for the exact version are known. See [Wil05, AW15] for the Max-IP and Subset Queries problems, [AWW14, ABV15, BK15, AHWW16] for Bichromatic LCS Closest Pair, [BI16, BGL16] for Regular Expression Matching, and [Wil05] for Metric Diameter. Also, [Wil18] recently proved SETH lower bounds for the related problems of exact $\ell_{2}$ Diamater and Bichromatic Closest Pair over short vectors ($d=\poly\log\log(N)$).

Prior to our work, some hardness of approximation results were known using more problem-specific techniques. For example, distinguishing whether the diameter of a graph on $O(n)$ edges is $2$ or at least $3$ in truly-subquadratic time refutes SETH [RV13], which implies hardness for $(3/2-\varepsilon)$ approximations. (This is somewhat analogous to the $\NP$-hardness of distinguishing $3$-colorable graphs from graphs requiring at least $4$ colors, immediately giving hardness of approximation for the chromatic number.) In most cases, however, this fortunate situation does not occur. The only prior SETH-based hardness of approximation results proved with more approximation-oriented techniques are by Ahle et al. [APRS16] for Max-IP via clever embeddings of the vectors. As discussed above, for the case of $\{0,1\}$-valued vectors, their inapproximability factor is still only $1+o(1)$.

[AB17] show that, under certain complexity assumptions, deterministic algorithms cannot approximate the Longest Common Subsequence (LCS) of two strings to within $1+o(1)$ in truly-subquadratic time. They tackle a completely orthogonal obstacle to proving SETH-based hardness of approximation: for problems like LCS with two long strings, the quality of approximation depends on the fraction of assignments that satisfy a SAT instance. There is a trivial algorithm for approximating this fraction: sample assignments uniformly at random. See further discussion on Open Question 4.

Recent works by Williams [Wil16] (refuting the \MA-variant of SETH) and Ball et al. [BRSV17] also utilize low-degree polynomials in the context of SETH and related conjectures. Their polynomials are quite different from ours: they sum over many possible assignments, and are hard to evaluate (in contrast, the polynomials used in the proof of our Theorem 3.1 correspond to a single assignment, and they are trivial to evaluate).

The main technical barrier to hardness of approximation in ¶ is the blowup incurred by standard PCP constructions; in particular, we overcome it with distributed constructions. There is also a known construction of PCP with linear blowup for large (but sublinear) query complexity [BKK*+*16] with non-uniform verifiers; note however that merely obtaining linear blowup is not small enough for our purposes. Different models of “non-traditional” PCPs, such as interactive PCPs [KR08] and interactive oracle proofs (IOP) [BCS16, RRR16] have been considered and found “positive” applications in cryptography (e.g. [GKR15, GIMS10, BCS16]). In particular, [BCG*+*16] obtain a linear-size IOP. It is an open question whether these interactive variants can imply interesting hardness of approximation results [BCG*+*16]. (And it would be very interesting if our distributed PCPs have any cryptographic applications!)

After the first version of this paper became public, it was brought to our attention that the term ”distributed PCP” has been used before in a different context by Drucker [Dru10]. In the simplest variant of Drucker’s model, Alice and Bob want to compute $f(\alpha,\beta)$ with minimal communication. They receive a PCP that allegedly proves that $f(\alpha,\beta)=1$; Alice and Bob each query the PCP at two random locations and independently decide whether to accept or reject the PCP. As with the interactive variants of PCP, we don’t know of any implications of Drucker’s work for hardness of approximation, but we think that this is a fascinating research direction.

1.4 Discussion

In addition to resolving the fine-grained approximation complexity of several fundamental problems, our work opens a hope to understanding more basic questions in this area. We list a few that seem to represent some of the most fundamental challenges, as well as exciting applications.

Bichromatic LCS Closest Pair Problem over $\{0,1\}$

The Bichromatic LCS Closest Pair Problem is most interesting in two regimes: permutations (which, by definition, require a large alphabet); and small alphabet, most notably $\{0,1\}$. For the regime of permutations, we obtain nearly-polynomial hardness of approximation. For small alphabet $\Sigma$, per contra, there is a trivial $1/|\Sigma|$-approximation algorithm in near-linear time: pick a random $\sigma\in\Sigma$, and restrict all strings to their $\sigma$-subset. Are there better approximation algorithms?

Our current hardness techniques are limited because this problem does not admit an approximation preserving OR-gadget for a large OR. In particular the $1/|\Sigma|$-approximation algorithm outlined above implies that we cannot combine much more than $|\Sigma|$ substrings in a clever way and expect the LCS to correspond to just one substring.

Open Question 3**.**

Is there a $1.1$-approximation for the Bichromatic LCS Closest Pair Problem on binary inputs running in $O(n^{2-\varepsilon})$ time, for some $\varepsilon>0$?

LCS Problem (with two strings)

Gadgets constructed in a fashion similar to our proof of Theorem 1.5 can be combined together (along with some additional gadgets) into two long strings $A,B$ of length $m$, in a way that yields a reduction from SETH to computing the longest common subsequence (LCS) of $(A,B)$, ruling out exact algorithms in $O(m^{2-\varepsilon})$ [ABV15, BK15]. However, in the instances output by this reduction, approximating the value of the LCS reduces to approximating the fraction of assignments that satisfy the original formula; it is easy to obtain a good additive approximation by sampling random assignments. The recent work of [AB17] mentioned above, uses complexity assumptions on deterministic algorithms to tackle this issue, but their ideas do not seem to generalize to randomized algorithms.

Open Question 4**.**

Is there a $1.1$-approximation for LCS running in $O(n^{2-\varepsilon})$ time, for some $\varepsilon>0$? (Open for all alphabet sizes.)

Dynamic Maximum Matching

A holy grail in dynamic graph algorithms is to maintain a $(1+\varepsilon)$-approximation for the Maximum Matching in a dynamically changing graph, while only spending amortized $n^{o(1)}$ time on each update. Despite a lot of attention in the past few years  [GP13, NS16, BHI14, BGS15, BS15, BHI16, BS16, PS16, BHN16, Sol16], current algorithms are far from achieving this goal: one can obtain a $(1+\varepsilon)$-approximation by spending $\Omega(\sqrt{m})$ time per update, or one can get an $2$-approximation with $\tilde{O}(1)$ time updates.

For exact algorithms, we know that $n^{o(1)}$ update times are impossible under popular conjectures [P1̌0, AV14, KPP16, HKNS15, Dah16], such as $3$-SUM999The $3$-SUM Conjecture, from the pioneering work of [GO95], states that we cannot find three numbers that sum to zero in a list of $n$ integers in $O(n^{2-\varepsilon})$ time, for some $\varepsilon>0$., Triangle Detection101010The conjecture that no algorithm can find a triangle in a graph on $m$ edges in $O(m^{4/3-\varepsilon})$ time, for some $\varepsilon>0$, or even just that $O(m^{1+o(1)})$ algorithms are impossible [AV14]. and the related Online Matrix Vector Multiplication111111The conjecture that given a Boolean $n\times n$ matrix $M$ and a sequence of $n$ vectors $v_{1},\ldots,v_{n}\in\{0,1\}^{n}$ we cannot compute the $n$ products $M\cdot x_{i}$ in an online fashion (output $Mx_{i}$ before seeing $x_{i+1}$) in a total of $O(n^{3-\varepsilon})$ time [HKNS15]. See [LW17] for a recent upper bound.. From the viewpoint of PCP’s, this question is particularly intriguing since it seems to require hardness amplification for one of these other conjectures. Unlike all the previously mentioned problems, even the exact case of dynamic matching is not known to be SETH-hard.

Open Question 5**.**

Can one maintain an $(1+\varepsilon)$-approximate maximum matching dynamically, with $n^{o(1)}$ amortized update time?

New frameworks for hardness of approximation

More fundamental than resolving any particular problem, our main contribution is a conceptually new framework for proving hardness of approximation for problems in ¶ via distributed PCPs. In particular, we were able to resolve several open problems while relying on simple algebrization techniques from early days of PCPs (e.g. [LFKN92] and reference therein). It is plausible that our results can be improved by importing into our framework more advanced techniques from decades of work on PCPs — starting with verifier composition [AS98], parallel repetition [Raz98], Fourier analysis [Hås01], etc.

Hardness from other sublinear communication protocols for Set Disjointness

A key to our results is an \MA protocol for Set Disjointness with sublinear communication, which trades off between the size of Merlin’s message and the size of Alice and Bob’s messages. There are other non-standard communication models where Set Disjointness enjoys a sublinear communication protocol, for example quantum communication121212Note that due to Grover’s algorithm, SETH is false for quantum computational complexity; but it is also false for \MA [Wil16], which doesn’t prevent us from using the \MA communication protocol in an interesting way. [BCW98].

Open Question 6**.**

Can other communication models inspire new reductions (or algorithms) for standard computational complexity?

Hardness of approximation from new models of PCPs

This is the most open-ended question. Formulating a clean conjecture about distributed PCPs was extremely useful for understanding the limitations and possibilities of our framework — even though our original conjecture turned out to be false.

Open Question 7**.**

Formulate a simple and plausible PCP-like conjecture that resolves any of the open questions mentioned in this section.

Bichromatic vs Monochromatic Closest Pair

Essentially all known SETH-based hardness results for variants of closest pair, including the ones in this paper (Theorems 1.3 and 1.5), hold for the so called “bichromatic” variant: the input to the algorithm is two sets $A,B$, and the goal is to find the closest pair $(a,b)\in A\times B$. Indeed, this is the most interesting variant because it implies hardness for the corresponding data structure variants (as in Corollary 1.4). Surprisingly, this understanding of bichromatic closest pair problems does not seem to translate to the corresponding “monochromatic” variants, where the input to the algorithm is a single set $U$, and the goal is to find the closest pair $u,v\in U$ ($u\neq v$). In an earlier version of this paper we had mistakenly claimed that our techniques here can also shed light on this problem, but this turned out to be incorrect (see also Erratum in Section 10). Understanding the complexity of exact and approximate monochromatic closest pair problems for many metrics remains an interesting open question; see e.g. [DKL16, Wil18] for further discussion.

2 Preliminaries

The Strong Exponential Time Hypothesis

SETH was suggested by Impagliazzo and Paturi [CIP06, IP01] as a possible explanation for the lack of improved algorithms for $k$-SAT: Given a $k$-CNF formula (each clause has $k$ literals) on $n$ variables, decide if it is satisfiable. Known algorithms have an upper bound of the form $O(2^{(1-c/k)n})$, where $c$ is some constant, which makes them go to $2^{n}$ as $k$ grows. The conjecture is that this is inevitable.

Conjecture 2.1** (SETH).**

For any $\varepsilon>0$ there exists $k\geq 3$ such that $k$-SAT on $n$ variables cannot be solved in time $O(2^{(1-\varepsilon)n})$.

Sparsification Lemma

An important tool for working with SETH is the Sparsification Lemma of Impagliazzo, Paturi, and Zane [IPZ01], which implies the following.

Lemma 2.2** (Follows from Sparsification Lemma [IPZ01]).**

If there is an $\varepsilon>0$ such that for all $k\geq 3$ we can solve $k$-SAT on $n$ variables and $c_{k,\varepsilon}\cdot n$ clauses in $O(2^{(1-\varepsilon)n})$ time, then SETH is false.

Notation

We use $[n]$ to denote the set $\{1,\dots,n\}$, and $x_{-n}$ to denote the vector $(x_{1},\dots,x_{n-1})$.

3 \MA Communication Complexity

In this section we prove a \MA (Merlin-Arthur) style communication protocol for Set Disjointness with sublinear communication and near-polynomial soundness. Our protocol is similar to the protocol from [AW09], but optimizes different parameters (in particular, we obtain very low soundness).

Theorem 3.1**.**

For $T\leq n$, there exists a computationally efficient \MA-protocol for Set Disjointness in which:

Merlin sends Alice $O(n\log{n}/T)$ bits; 2. 2.

Alice and Bob jointly toss $\log_{2}n+O(1)$ coins; 3. 3.

Bob sends Alice $O(T\log{n})$ bits. 4. 4.

Alice returns Accept or Reject.

If the sets are disjoint, there is a message from Merlin such that Alice always accepts; otherwise (if the sets have a non-empty intersection or Merlin sends the wrong message), Alice rejects with probability $\geq\frac{1}{2}$.

Proof.

Arithmetization

Assume without loss of generality that T divides $n$. Let $q$ be a prime number with $4n\leq q\leq 8n$, and let $\mathbb{F}_{q}$ denote the prime field of size $q$. We identify $[\frac{n}{T}]\times[T]$ with the universe $[n]$ over which Alice and Bob want to compute Set Disjointness.

Alice’s input can now be represented as $T$ functions $\psi_{\alpha,t}:[\frac{n}{T}]\rightarrow\left\{0,1\right\}$ as follows: $\psi_{\alpha,t}(i)\triangleq 1$ if and only if the element corresponding to $(i,t)$ is in Alice’s set. Define $\psi_{\beta,t}$ analogously. Notice that their sets are disjoint if and only if $\psi_{\alpha,t}(i)\psi_{\beta,t}(i)=0$ for all $i,t\in[\frac{n}{T}]\times[T]$.

Extend each $\psi_{\alpha,t},\psi_{\beta,t}$ to polynomials $\Psi_{\alpha,t},\Psi_{\beta,t}:\mathbb{F}_{q}\rightarrow\mathbb{F}_{q}$ of degree at most $\frac{n}{T}-1$ in every variable. Notice that the polynomials $\Psi_{t}(i)\triangleq\Psi_{\alpha,t}(i)\cdot\Psi_{\beta,t}(i)$ have degree at most $2(\frac{n}{T}-1)$. The same degree bound also holds for the sum of those polynomials, $\Psi\triangleq\sum_{t=1}^{T}\Psi_{t}$. Notice that the sets are disjoint if and only if $\Psi_{t}(i)=0$ for all $i,t\in[\frac{n}{T}]\times[T]$. Similarly131313Here we use the fact that $\mathbb{F}_{q}$ has a large characteristic, and $\Psi_{t}(i)\in\left\{0,1\right\}$ for all $i,t\in[\frac{n}{T}]\times[T]$; so the summation (in $\mathbb{F}_{q}$) of $T$ zeros and ones is equal to zero if and only if there are no ones., the sets are disjoint if and only if $\Psi(i)=0$ for all $i\in[\frac{n}{T}]$.

The protocol

We begin with a succinct formal description of the protocol, and provide more details below.

Merlin sends Alice $\Phi$ which is allegedly equal to the marginal sums polynomial $\Psi$. 2. 2.

Alice and Bob jointly draw $i\in\mathbb{F}_{q}$ uniformly at random. 3. 3.

Bob sends Alice $\Psi_{\beta,t}(i)$ for every $t\in[T]$. 4. 4.

Alice accepts if and only if both of the following hold:

[TABLE]

Recall that Merlin knows both $\Psi_{\alpha,t}$ and $\Psi_{\beta,t}$. In the first step of the protocol, Merlin sends Alice a polynomial $\Phi$ which is allegedly equal to $\Psi$. Notice that $\Psi$ is a (univariate) polynomial of degree at most $2(\frac{n}{T}-1)$; thus it can be uniquely specified by $2\frac{n}{T}-1$ coefficients in $\mathbb{F}_{q}$. Since each coefficient only requires $\log_{2}{|\mathbb{F}_{q}|}=\log_{2}n+O(1)$ bits, the bound on Merlin’s message follows.

In the second step of the protocol Alice and Bob draw $i\in\mathbb{F}_{q}$ uniformly at random. In the third step of the protocol, Bob sends Alice the values of $\Psi_{\beta,\cdot}(i)$. In particular sending $T$ values in $\mathbb{F}_{q}$ requires $O(T\log{n})$ bits.

Analysis

Completeness

If the sets are disjoint, Merlin can send the true $\Psi$, and Alice always accepts.

Soundness

If the sets are not disjoint, Merlin must send a different low degree polynomial (since (2) is false for $\Psi$). By the Schwartz-Zippel Lemma, since $\Psi$ and $\Phi$ have degree less than $2\frac{n}{T}\leq\frac{q}{2}$, if they are distinct they must differ on at least half of $\mathbb{F}_{q}$. Hence, (3) is false with probability $\geq\frac{1}{2}$. (The same holds if the sets are disjoint but Merlin sends the wrong $\Phi$.)

∎

In the following corollary we amplify the soundness of the communication protocol, to obtain stronger computational hardness results.

Corollary 3.2**.**

There exists a computationally efficient \MA-protocol for Set Disjointness s.t.:

Merlin sends Alice $o(n)$ bits; 2. 2.

Alice and Bob jointly toss $o(n)$ coins; 3. 3.

Bob sends Alice $o(n)$ bits. 4. 4.

Alice returns Accept or Reject.

If the sets are disjoint, there is a unique message from Merlin such that Alice always accepts; otherwise (if the sets have a non-empty intersection or Merlin sends the wrong message), Alice rejects with probability $\geq 1-1/2^{n^{1-o(1)}}$.

Proof.

Let $T$ be a small super-logarithmic function of $n$, e.g. $T=\log^{2}n$. Repeat the protocol from Theorem 3.1 $R=\frac{n}{T^{2}}$ times to amplify the soundness. Notice that since Merlin sends her message before the random coins are tossed, it suffices to only repeat steps 2-4. Thus Merlin still sends $O(\frac{n}{T}\cdot\log{n})=o(n)$ bits, Alice and Bob toss a total of $O(R\cdot\log n)=o(n)$ coins, and Bob sends a total of $O(R\cdot T\cdot\log{n})=o(n)$ bits. ∎

Remark 3.3**.**

An alternative way to obtain Corollary 3.2 is via a “white-box” modification of the protocol from Theorem 3.1: all the polynomials remain the same, but we consider their evaluation over an extension field $\mathbb{F}_{q^{R}}$. Note that Merlin’s message (polynomial) remains the same as the coefficients are still in $\mathbb{F}_{q}$, but Bob’s message is now $R$-times longer (as in the proof of Corollary 3.2).

4 A distributed and non-deterministic PCP theorem

In this section we prove our distributed, non-deterministic PCP theorem.

Theorem 4.1** (Distributed, Non-deterministic PCP Theorem).**

Let $\varphi$ be a Boolean CNF formula with $n$ variables and $m=O(n)$ clauses. There is a non-interactive protocol where:

• •

Alice, given the CNF $\varphi$, partial assignment $\alpha\in\{0,1\}^{n/2}$, and advice $\mu\in\{0,1\}^{o(n)}$, outputs a string $a^{\alpha,\mu}\in\{0,1\}^{2^{o(n)}}$.

• •

Bob, given $\varphi$ and partial assignment $\beta\in\{0,1\}^{n/2}$, outputs a string $b^{\beta}\in\{0,1\}^{2^{o(n)}}$.

• •

The verifier, given input $\varphi$, tosses $o(n)$ coins, non-adaptively reads $o(n)$ bits from $b^{\beta}$, and adaptively reads one bit from $a^{\alpha,\mu}$; finally, the verifier returns Accept or Reject.

If the combined assignment $(\alpha,\beta)$ satisfies $\varphi$, there exists advice $\mu^{*}$ such that the verifier always accepts. Otherwise (in particular, if $\varphi$ is unsatisfiable), for every $\mu$, the verifier rejects with probability $\geq 1-1/2^{n^{1-o(1)}}$.

Proof.

For any partial assignments $\alpha,\beta\in\left\{0,1\right\}^{n/2}$, we consider the induced sets $S_{\alpha},T_{\beta}\subseteq[m]$, where $j\in S_{\alpha}$ iff none of the literals in the $j^{th}$ clause receive a positive assignment from $\alpha$ (i.e. each literal is either set to false, or not specified by the partial assignment). Define $T_{\beta}$ analogously. Notice that the joint assignment $(\alpha,\beta)$ satisfies $\varphi$ iff the corresponding sets are disjoint. The construction below implements the \MA communication protocol for Set Disjointness from Corollary 3.2 with inputs $S_{\alpha},T_{\beta}$.

Constructing the PCP

Bob’s PCP is simply a list of all messages that he could send on the \MA communication protocol, depending on the random coin tosses. Formally, let $L$ enumerate over the outcomes of Alice and Bob’s coin tosses in the protocol ($|L|\leq 2^{o(n)}$). For each $\ell\in L$, we let ${b^{\beta}}_{\ell}$ be the message Bob sends on input $T_{\beta}$ and randomness $\ell$.

Alice’s PCP is longer: she writes, for each possible outcome of the coin tosses, a list of all messages from Bob that she is willing to accept. Formally, let $K$ enumerate over all possible Bob’s messages (in particular, $|K|=2^{o(n)}$). For each $k\in K$, if Alice accepts given message $\mu$ from Merlin, randomness $\ell$, and message $k$ from Bob, we set ${a^{\alpha,\mu}}_{\ell,k}\triangleq 1$. Otherwise (if Alice rejects), we set ${a^{\alpha,\mu}}_{\ell,k}\triangleq 0$.

The verifier chooses $\ell\in L$ at random, reads ${b^{\beta}}_{\ell}$ and then ${a^{\alpha,\mu}}_{\ell,{b^{\beta}}_{\ell}}$ (i.e. accesses ${a^{\alpha,\mu}}_{\ell,\cdot}$ at index ${b^{\beta}}_{\ell}$). The verifier accepts iff

[TABLE]

Analysis

Observe that for each $\ell$, we have that ${a^{\alpha,\mu}}_{\ell,{b^{\beta}}_{\ell}}=1$ iff and Alice accepts (given Alice and Bob’s respective inputs, Merlin’s message $\mu$, randomness $\ell$, and Bob’s message ${b^{\beta}}_{\ell}$). Therefore, the probability that the PCP verifier accepts is exactly equal to the probability that Alice accepts in the \MA communication protocol. ∎

5 PCP-Vectors

In this section we introduce an intermediate problem which we call PCP Vectors. The purpose of introducing this problem is to abstract out the prover-verifier formulation before proving hardness of approximation in ¶, very much like $\NP$-hardness of approximation reductions start from gap-3-SAT or Label Cover.

Definition 5.1** (PCP-Vectors).**

The input to this problem consists of two sets of vectors $A\subset\Sigma^{L\times K}$ and $B\subset\Sigma^{L}$, The goal is to find vectors $a\in A$ and $b\in B$ that maximize

[TABLE]

Theorem 5.2**.**

Let $\varepsilon>0$ be any constant, and let $\left(A,B\right)$ be an instance of PCP-Vectors with $N$ vectors and parameters $|L|,|K|,|\Sigma|=N^{o\left(1\right)}$. Then, assuming SETH, $O\left(N^{2-\varepsilon}\right)$-time algorithms cannot distinguish between:

Completeness

there exist $a^{*},b^{*}$ such that $s\left(a^{*},b^{*}\right)=1$; and

Soundness

for every $a\in A,b\in B$, we have $s\left(a,b\right)\leq 1/2^{(\log N)^{1-o(1)}}$.

Proof.

Let $\varphi$ be a CNF formula with $n$ variables and $m$ clauses (without loss of generality $m=\Theta\left(n\right)$ by the Sparsification Lemma [IPZ01]). Let $B$ be the sets of vectors generated by Bob in the distributed, non-deterministic PCP from Theorem 4.1, where we think of each substring ${b^{\beta}}_{\ell}\in\{0,1\}^{o(n)}$ as a single symbol in $\Sigma$. Similarly, let $\widehat{A}$ be the set of vectors generated by Alice. For each $\alpha,\mu$, we modify $\widehat{a}^{\alpha,\mu}$ as follows:

[TABLE]

By definition, $s\left({a^{\alpha,\mu}}_{\ell,k},{b^{\beta}}_{\ell}\right)$ is exactly equal to the probability that the verifier accepts. ∎

6 Max Inner Product and Subset Queries

In this section, we present our first application of our PCP-Theorem by giving an extremely simple reduction from our PCP-Vectors problem to the Bichromatic Max Inner Product problem (and its special case, the Subset Query problem) from Section 1.

Proof.

(of Theorem 1.3) Given an instance $A^{\prime},B^{\prime}$ of PCP-Vectors as in Theorem 5.2 with parameters $|L|,|K|,|\Sigma|=N^{o(1)}$ we map each vector $a^{\prime}\in A^{\prime}\subseteq\Sigma^{L\times K}$ to a subset $a$ of $U=L\times\Sigma$ in the following natural way. For all $\ell\in[L],k\in[K]$ and $\sigma\in\Sigma$ we set add $(\ell,\sigma)$ to $a$ iff there is a $k\in K$ such that $a^{\prime}_{\ell,k}=\sigma$. We map the vectors $b^{\prime}\in B$ to a subset $b$ of $U$ by adding the element $(\ell,\sigma)$ to $b$ iff $b^{\prime}_{\ell}=\sigma$. Note that the universe has size $d=|L|\cdot|\Sigma|=N^{o(1)}$ and the sets $b$ have size $|L|$.

The completeness and soundness follow from the fact that for any two vectors $a^{\prime}\in A^{\prime},b^{\prime}\in B^{\prime}$:

[TABLE]

∎

6.1 MIPS

Next, we show the corollary for the search version of the problem known as MIPS. This reduction from the (offline) closest pair problem to the (online) nearest neighbor problem is generic and works for all the problems we discuss in this paper. The proof is based on a well-known technique [WW10], but might be surprising when seen for the first time.

Proof.

(of Corollary 1.4) Assume we have a data structure as in the statement, and we will show how to solve Bichromatic Max Inner Product instances on $2N$ vectors as in Theorem 1.3, refuting SETH. Let $c$ be such that $O(n^{c})$ is an upper bound on the (polynomial) preprocessing time of the data structure. Set $x=1/2c$ and note that it is small but constant. We partition the set $B$ of vectors into $t=N^{1-x}$ buckets of size $N^{x}$ each $B_{1},\dots,B_{t}$. For each bucket $B_{i}$ for $i\in[t]$ we use our data structure to do the following:

Preprocess the $n=N^{x}$ vectors in $B_{i}$. 2. 2.

For each of our $N$ vectors $a\in A$, ask the query to see if $a$ is close to any vector in $B_{i}$.

Observe that after these $t$ checks are performed, we are guaranteed to find the high-inner product pair, if it exists. The total runtime is $N^{1-x}$ times the time for each stage:

[TABLE]

which is $O(N^{2-\varepsilon^{\prime}})$ for some constant $\varepsilon^{\prime}>0$, refuting SETH. ∎

6.2 Maximum Inner Product over $\{-1,1\}$

We shall now prove that our results extend to the variant of Bichromatic Max Inner Product where the vectors are in $\{-1,1\}^{d}$ and the goal is to maximize the absolute value of the inner product.

Corollary 6.1**.**

Assuming SETH, the following holds for every constant $\varepsilon>0$. Given two sets of vectors $A,B\in\{-1,1\}^{d}$, where $|A|=|B|=N$, and $d=N^{o(1)}$, any $O(N^{2-\varepsilon})$ time algorithm for computing $\max_{\begin{subarray}{c}a\in A\\ b\in B\end{subarray}}|a\cdot b|$ must have approximation factor at least $2^{(\log{N})^{1-o(1)}}$.

Proof.

Starting with a hard $(A^{\prime},B^{\prime})$ instance of Bichromatic Max Inner Product over $\{0,1\}^{d/4}$, we construct $(A,B)$ as follows. Consider the following three vectors in $\{-1,1\}^{4}$:

[TABLE]

Notice that $\gamma_{1}\cdot\gamma_{1}=4$, but $\alpha_{0}\cdot\gamma_{1}=\gamma_{1}\cdot\beta_{0}=\alpha_{0}\cdot\beta_{0}=0$.

We replace each entry in each vector in $A^{\prime},B^{\prime}$ with one of $\gamma_{1},\alpha_{0},\beta_{0}$ as follows: all $1$’s are replaced by $\gamma_{1}$, all [math]’s in $A$-vectors are replaced by $\alpha_{0}$, and all [math]’s in $B$-vectors are replaced by $\beta_{0}$. For vectors $a^{\prime}\in A^{\prime},b^{\prime}\in B^{\prime}$, let $a,b\in\{-1,1\}^{d}$ denote the new vectors that result from the reduction. Observe that now $a\cdot b=4a^{\prime}\cdot b^{\prime}$. ∎

7 Permutation LCS

In this section, we prove that closest pair under the Longest Common Subsequence (LCS) similarity measure cannot be solved in truly subquadratic time, even when allowed near-polynomial approximation factors, and even when the input strings are restricted to be permutations. As a direct corollary, we show that approximate nearest neighbor queries under LCS cannot be computed efficiently: one must spend time proportional to the number of strings in the database.

Definition 7.1** (Bichromatic LCS Closest Pair Problem).**

Given two sets of strings $X,Y\subseteq\Sigma^{m}$ over an alphabet $\Sigma$, the goal is to find a pair $x\in X,y\in Y$ that maximize $LCS(x,y)$.

If the optimal solution to the LCS Closest Pair problem is $OPT$, a $c$-approximation algorithm is allowed to return any value $L$ such that $OPT/c\leq L\leq OPT$, corresponding to a pair of strings that are $c$-away from the closest pair.

The rest of this section is dedicated to the proof of Theorem 1.5 from the Introduction.

Proof.

(of Theorem 1.5)

We reduce from Max-IP to Bichromatic LCS Closest Pair over permutations. Specifically, for each vector $u\in A\cup B\subseteq\{0,1\}^{m}$ in the Max-IP instance and each index $i\in[m]$, we encode $u_{i}$ as a permutation $\pi^{u}(u_{i})$ over sub-alphabet $\Sigma_{i}$ (where $\Sigma_{i}$ is unique to the index $i$ and independent of the vector $u$). Our encoding (shown below) has the following guarantee: if $u_{i}=v_{i}=1$, then LCS\big{(}\pi^{u}(u_{i}),\pi^{v}(v_{i})\big{)}=|\Sigma_{i}|, and otherwise LCS\big{(}\pi^{u}(u_{i}),\pi^{v}(v_{i})\big{)}=O(\sqrt{|\Sigma_{i}|}\log{N}).

Observe that this suffices to prove our theorem for sufficiently large $|\Sigma_{i}|$. The strings in our Bichromatic LCS Closest Pair instance will be simply the concatenation of all the sub-permutations:

[TABLE]

Notice that those strings are indeed permutations. Furthermore, because the sub-permutations use disjoint alphabets, we have:

[TABLE]

When setting $|\Sigma_{i}|=2^{(\log N)^{1-o(1)}}d\log N$, the first term in (5) dominates the second one, and the reduction from Max-IP follows.

7.0.1 Embedding bits as permutations

We need $N+1$ different permutations over each $\Sigma_{i}$: the [math]-bits of different vectors should be embedded into very far strings (in LCS “distance”), but we use the same embedding for all the $1$-bits. First, observe that we could simply use $N+1$ random permutations; with high probability every pair will have LCS at most $O(\sqrt{|\Sigma_{i}|}\log N)$. Below, we show how to match this bound with a simple deterministic construction.

We assume w.l.o.g. that $|\Sigma_{i}|$ is a square of a prime. Let ${\cal F}$ be the prime field of cardinality $|{\cal F}|=\sqrt{|\Sigma_{i}|}$. We consider permutations over ${\cal F}^{2}$, sorted by the lexicographic order. For every polynomial $p:{\cal F}\rightarrow{\cal F}$ of degree $\leq\log{N}$, we construct a permutation $\pi_{p}:{\cal F}^{2}\rightarrow{\cal F}^{2}$ as follows:

[TABLE]

To see that those are indeed permutations, notice that we can invert them:

[TABLE]

Note also that we now have more than enough ($|{\cal F}|^{\log N}\gg N$) different permutations.

Let us argue that these permutations are indeed far in (in LCS “distance”). Fix a pair of polynomials $p,q$, and consider the LCS of the corresponding permutations. Suppose that for some $i,i^{\prime},j$, we matched

[TABLE]

Then, for this particular choice of $i,i^{\prime}$ the above equality holds for only $d$ distinct $j\in T$. Thus, we can add at most $d$ elements to the LCS until we increase either $i$ or $i^{\prime}$. Since each of those increases only $|{\cal F}|$ times, we have that

[TABLE]

∎

8 Regular Expressions

In this section we prove hardness for a much simpler metric, the Hamming Distance between strings, but where one of the sets is defined by a regular expression. Our result is essentially the strongest possible negative result explaining why there are no non-trivial algorithms for our problem.

A regular expression is defined over some alphabet $\Sigma$ and some additional operations such as $\{|,\circ,*,+\}$. Our results will hold even in the restricted setting where we only allow the operations $|$ and $\circ$ (OR and concatenation), and so we will restrict the attention to this setting. The simplest definition is recursive: If $e_{1},e_{2}$ are two regular expressions, and $\sigma\in\Sigma$ is a letter, then:

• •

$e=\sigma$ is a regular expression, and its language is $\operatorname*{L}(e)=\{\sigma\}$.

• •

$e=e_{1}|e_{2}$ is a regular expression, and $\operatorname*{L}(e)=\operatorname*{L}(e_{1})\cup\operatorname*{L}(e_{2})$.

• •

$e=e_{1}\circ e_{2}$ is a regular expression, and $\operatorname*{L}(e)=\{x=x_{1}\circ x_{2}\mid x_{1}\in\operatorname*{L}(e_{1})\text{ and }x_{2}\in\operatorname*{L}(e_{2})\}$.

As is popular, we will assume that regular expressions are given as strings over $\Sigma\cup\{|,\circ\}$, and the length of the regular expression is just the length of this string. We will often omit the concatenation notation so that $e_{1}e_{2}$ represents $e_{1}\circ e_{2}$ (when clear from context). Our reductions will produce regular expressions whose language will only contain strings of a fixed length $M$, which will be natural in the context of our Closest Pair problem. Recall that the Hamming distance of two strings $x,y$ of length $m$ is $H(x,y):=m-\sum_{i=1}^{m}(x[i]=y[i])$.

Definition 8.1** (RegExp Closest Pair Problem).**

Given a set of $n$ strings $Y\subseteq\Sigma^{m}$ of length $m$ over an alphabet $\Sigma$, and a regular expression $\tilde{x}$ of length $N$ whose language $\operatorname*{L}(\tilde{x})\subseteq\Sigma^{m}$ contains strings of length $m$, the goal is to find a pair of strings $x\in\operatorname*{L}(\tilde{x}),y\in Y$ with minimum Hamming distance $H(x,y)$.

The main result of this section proves a hardness result for this problem which holds even for instances with perfect completeness: even if an exact match exists, it is hard to find any pair with Hamming distance $O(m^{1-\varepsilon})$, for any $\varepsilon>0$. This is essentially as strong as possible, since a factor $m$ approximation is trivial (return any string). For the case of binary alphabets, we show that even if an exact match exists (pair of distance [math]), it is hard to find a pair of distance $(1/2-\varepsilon)\cdot m$, for any $\varepsilon>0$.

Theorem 8.2**.**

Let $\varepsilon>0$ be any constant, and let $\left(\tilde{x},Y,\Sigma\right)$ be an instance of RegExp Closest Pair with $|Y|=n$ strings and parameters $m,|\Sigma|=n^{o(1)}$, and $N=n^{1+o(1)}$. Then, assuming SETH, $O\left(n^{2-\varepsilon}\right)$-time algorithms cannot distinguish between:

Completeness

there exist $x\in\operatorname*{L}(\tilde{x}),y\in Y$ such that $H(x,y)=0$; and

Soundness

for every $x\in\operatorname*{L}(\tilde{x}),y\in Y$, $H(x,y)=m\cdot(1-\frac{1}{2^{(\log{n})^{1-o(1)}}})$.

Furthermore, if we restrict to binary alphabets $|\Sigma|=2$, then for all $\delta>0$, assuming SETH, $O\left(n^{2-\varepsilon}\right)$-time algorithms cannot distinguish between:

Completeness

there exist $x\in\operatorname*{L}(\tilde{x}),y\in Y$ such that $H(x,y)=0$; and

Soundness

for every $x\in\operatorname*{L}(\tilde{x}),y\in Y$, $H(x,y)=(1/2-\delta)\cdot m$.

Proof.

We start with the simpler case of large alphabets. The reduction essentially translates the PCP-Vectors problem into the language of regular expressions. Given an instance of PCP-Vectors as in Theorem 5.2 with $N$ vectors and parameters $d_{A},K,|\Sigma|=N^{o\left(1\right)}$, and $d_{B}=L=O(\log{N})$, we construct an instance of RegExp Closest Pair Problem as follows. Our alphabet will be the same $\Sigma$, and we will map each vector $b\in B$ into a string $y(b)\in Y$ in the obvious way: for all $\ell\in[L]$ $y(b)[\ell]:=b_{\ell}$. Note that we have $n=N$ strings in $Y$ and their length is $m=L=O(\log{N})$, and the alphabet has size $n^{o(1)}$. The vectors in $A$ will be encoded with the regular expression $\tilde{x}$. First, for all $\ell\in[L],k\in[K]$ we define the subexpression $\widetilde{x_{\ell,k}}$ to be the single letter $a_{\ell,k}\in\Sigma$. Then, for all $\ell\in[L]$ we define the subexpression $\widetilde{x_{\ell}}$ as the OR of all the $\widetilde{x_{\ell,k}}$ strings:

[TABLE]

Then, we concatenate all the $\widetilde{x_{\ell}}$ gadgets into the expression

[TABLE]

which encodes a vector $a\in A$. Finally, the final regular expression $\widetilde{x}$ is the OR of all these gadgets:

[TABLE]

Note that the length of the expression is $N^{\prime}=O(NLK)=n^{1+o(1)}$.

To see the correctness of the reduction, first observe that for all $a\in A,b\in B$ we have that:

[TABLE]

Which follows since the language of $\widetilde{x}$ can be expressed as:

[TABLE]

It follows that for all $b\in B$:

[TABLE]

Completeness.

if there is a pair $a\in A,b\in B$ with $s(a,b)=1$, then for $y(b)\in B$ we have that $\min_{x\ \in\ \widetilde{x}}H(x,y(b))=0$.

Soundness.

if for all pairs $a\in A,b\in B$ $s(a,b)=\frac{1}{2^{(\log{n})^{1-o(1)}}}$ then for all strings $y\in Y$ and $x\in\widetilde{x}$ we have that $H(x,y)=L\cdot\left(1-\frac{1}{2^{(\log{n})^{1-o(1)}}}\right)$.

Binary Alphabets.

To get a reduction to strings over a binary alphabet, we simply replace each letter in $\Sigma$ with a codeword from a code with large Hamming distance between any pair of codewords. Let $\delta>0$ be an arbitrary small constant, and let $d=\polylog({|\Sigma|})$. We consider an error correcting code $e:\Sigma\to\{0,1\}^{d}$ with constant rate and relative distance $(1/2-\delta)$; i.e. for any distinct $\sigma,\sigma^{\prime}\in\Sigma$ we have that $H(e(\sigma),e(\sigma^{\prime}))\geq(1/2-\delta)\cdot d$ (e.g. a random code or the concatenation of Reed Solomon and Hadamard codes [AB09, Chapter 17.5.3]). We map each symbol $\sigma\in\Sigma$ in any of our strings $y\in Y$ or in the regular expression $\widetilde{x}$ into the string $e(\sigma)$. For any two strings $x,y\in\Sigma^{L}$ let $x^{\prime},y^{\prime}\in\{0,1\}^{Ld}$ be the strings after this replacement, and observe that $H(x^{\prime},y^{\prime})\geq H(x,y)\cdot(1/2-\delta)\cdot d$, and moreover, if $H(x,y)=0$, then $H(x^{\prime},y^{\prime})=0$. The completeness and soundness follow, and note that the lengths of the strings and the expression grow by a negligible $n^{o(1)}$ factor. ∎**

9 Product metric diameter

Definition 9.1** (Product-Metric Diameter).**

The input to this problem consists of a set of vectors $X\subset\mathbb{R}^{d_{2}\times d_{\infty}}$.

The goal is to find two vectors $x,y\in X$ that maximize

[TABLE]

Theorem 9.2**.**

Assuming SETH, there are no $(2-\delta)$-approximation algorithms for Product-Metric Diameter in time $O\left(N^{2-\varepsilon}\right)$, for any constants $\varepsilon,\delta>0$.

Proof.

We reduce from PCP-Vectors over alphabet $\Sigma=N^{o(1)}$.

For every vector $a\in A\subset\Sigma^{L\times K}$, we construct a binary vector $x(a)\in\{0,1\}^{L\times\Sigma}$ by setting:

[TABLE]

Similarly, for each $b\in B\subset\Sigma^{L}$, construct a binary vector $y(b)\in\{-1,0\}^{L\times\Sigma}$ by setting:

[TABLE]

For any pair $x(a),y(b)$ and $\ell\in L$, we have that the $\infty$-norm distance between $x(a)_{\ell,\cdot}$ and $y(b)_{\ell,\cdot}$ is $2$ if there is some $k$ such that $a_{\ell,k}=b_{\ell}$, and $1$ otherwise. Therefore, summing over $\ell\in L$ we have that

[TABLE]

In particular, if $(A,B)$ is a yes case of PCP-Vectors, there are $x(a^{*}),y(b^{*})$ such that \Delta_{2,\infty}\big{(}x(a^{*}),y(b^{*})\big{)}=2\ell; given a no instance, \Delta_{2,\infty}\big{(}x(a),y(b)\big{)}=(1+o(1))\ell for any $x(a),y(b)$.

Finally, observe that any two $x$-vectors have $\Delta_{2,\infty}$-distance at most $\ell$ since all the entries have the same sign; similarly for any two $y$-vectors.

∎

10 Erratum

In a previous version of this paper, we erroneously claimed hardness of approximation results on symmetric, or “monochromatic” variants of PCP-Vectors and Max-IP, as well as exact hardness for Closest Pair problems in Hamming, Manhattan, and Euclidean metrics. We later discovered a mistake in that part of the proof. Unfortunately, it was too late to update the extended abstract that will appear in the proceedings of FOCS 2017 [ARW17].

Acknowledgements

We thank Karthik C.S., Alessandro Chiesa, Søren Dahlgaard, Piotr Indyk, Rasmus Pagh, Ilya Razenshteyn, Omer Reingold, Nick Spooner, Virginia Vassilevska Williams, Ameya Velingker, and anonymous reviewers for helpful discussions and suggestions.

This work was done in part at the Simons Institute for the Theory of Computing. We are also grateful to the organizers of Dagstuhl Seminar 16451 for a special collaboration opportunity.