Almost Optimal Time Lower Bound for Approximating Parameterized Clique, CSP, and More, under ETH
Abstract
The Parameterized Inapproximability Hypothesis (PIH), which is an analog of the PCP theorem in parameterized complexity, asserts that, there is a constant such that for any computable function , no -time algorithm can, on input a -variable CSP instance with domain size , find an assignment satisfying fraction of the constraints. A recent work by Guruswami, Lin, Ren, Sun, and Wu (STOC’24) established PIH under the Exponential Time Hypothesis (ETH).
In this work, we improve the quantitative aspects of PIH and prove (under ETH) that approximating sparse parameterized CSPs within a constant factor requires time. This immediately implies that, assuming ETH, finding a -clique in an -vertex graph with a -clique requires time. We also prove almost optimal time lower bounds for approximating -ExactCover and Max -Coverage.
Our proof follows the blueprint of the previous work to identify a "vector-structured" ETH-hard CSP whose satisfiability can be checked via an appropriate form of "parallel" PCP. Using further ideas in the reduction, we guarantee additional structures for constraints in the CSP. We then leverage this to design a parallel PCP of almost linear size based on Reed-Muller codes and derandomized low degree testing.
1 Introduction
One of the goals of complexity theory is to pinpoint the asymptotically optimal time (or other resource) needed to solve basic computational problems or classes of problems. The theory of NP-completeness attacks this at a coarse level, but modern complexity theory also has tools to give more fine-grained information on computational complexity.
A common setting for fine-grained understanding of computational hardness is considering parameterized problems. Under this setting, each instance is attached with an additional parameter indicating some specific quantities (e.g., the optimum or the treewidth). We treat as some super constant that is much smaller than the instance size and consider the existence or absence of algorithms with running time depends both on and (e.g., with running time , or ). The hardness of parameterized problems is studied under the realm of parameterized complexity theory [17]. It is a central challenge to figure out the minimal time (depending on both and ) to solve prototypical parameterized problems.
A representative example is the -Clique problem parameterized by the optimum , which is one of the most fundamental problems in parameterized complexity theory: given an -vertex graph as input, determine if it has a clique of size . The naive brute force algorithm takes roughly time. Using fast matrix multiplication, there are better algorithms that take time, where is the matrix multiplication exponent. On the hardness side, it is known that no algorithm can decide -Clique within running time , for any computable function , under the widely-considered Exponential Time Hypothesis (ETH) [14], which states that algorithms cannot solve 3SAT formulas on variables within running time . The optimal running time for -clique is therefore pinpointed to be , assuming ETH.
Can one design a faster algorithm if one settles for approximating -Clique? For example, what if we only want to find a clique of size in a graph that is promised to have a -clique.111This can also be formulated as a “gap” decision problem of distinguishing graphs with a -clique from those which do not even have a -clique.
It was shown that such an approximation to -Clique still requires the tightest time [11], under the very strong assumption Gap-ETH. The Gap-ETH postulates an exponential time lower bound of approximating Max 3-SAT within a constant ratio. The constant gap baked into the assumption is then transformed into a constant gap for approximating -Clique. Though Gap-ETH has been proved under particular strengthening of ETH (smooth version of ETH) [5], a theoretically more satisfactory result is to obtain the hardness of approximating -Clique under the original ETH. Under ETH, weaker time lower bounds were known for constant-factor approximations of -Clique: in [31], which was later improved to in [32, 13] and in [33].222There is another line of work on improving the inapproximability factor of -Clique under the minimal hypothesis W[1]FPT: constant factor in [31], and the improved in [28, 13]. However, all these approaches cannot obtain lower bounds better than due to the coding theoretic barriers [30].
However, this paper significantly improves this lower bound, assuming only the original ETH.
Theorem 1.1.
Assume ETH. For any constant and any computable function , any algorithm that approximates -Clique within an ratio must take runtime .
To prove the theorem above, we follow a similar idea of proving the NP-hardness of approximating cliques, which relies on the NP-hardness of constant approximating CSP (a.k.a., the PCP theorem) and a subsequent FGLSS reduction [18]. In the parameterized setting, we can apply an analogous reduction.
-
•
We first establish a near-optimal lower bound for approximating (sparse) “parameterized CSPs” with variables, constraints, an alphabet of size , and some constant inapproximability factor.
-
•
Then Theorem 1.1 follows immediately by the FGLSS reduction [18] and an expander-based gap-amplification procedure [3, 32].
The first step is equivalent to establishing a quantitative version of the Parameterized Inapproximability Hypothesis (PIH) [34], which plays the role of the PCP theorem in the parameterized complexity theory. The first quantitative version of PIH was established under Gap-ETH [11], with the lower bound . A recent improvement proved PIH under ETH [21], with a weaker lower bound . However, both results are too weak to establish Theorem 1.1. In this paper, we make a significant quantitative improvement to the reduction in [21], obtaining our main theorem stated below.
Theorem 1.2 (Informal version of Theorem 4.1).
Assume ETH. For some constant , for any computable function , every algorithm that takes as input a satisfiable parameterized 2CSP instance with variables, constraints and size- alphabet finds an assignment satisfying fraction of the constraints, must take time.
Combining with the parallel repetition in projection games [38], we can immediately boost the soundness to any constant with lower bound .
Corollary 1.3.
Assume ETH. For any computable function and any constant , every algorithm that takes as input a satisfiable parameterized 2CSP instance with variables, constraints and size- alphabet finds an assignment satisfying fraction of the constraints, must take time.
By the discussion above, Theorem 1.1 follows immediately by combining Theorem 1.2, the FGLSS reduction, and the expander-based gap-amplification procedure [3, 32]. Moreover, using Theorem 1.2 as the foundation, we can obtain, via reductions, strong inapproximability results for other fundamental parameterized problems. Below, we list two application highlights and refer interested readers to [21] for more detailed discussions.
Application Highlight: -ExactCover
-ExactCover (a.k.a., -UniqueSetCover) is one of the canonical problems in the parameterized world. It is a weaker version of the -SetCover problem. For the -approximation version of -ExactCover with , denoted by -ExactCover, the instance consists of a universe and a collection of subsets of , with a goal to distinguish the following two cases.
-
•
There exists disjoint subsets from whose union equals the whole universe .
-
•
The union of any subsets of is a proper subset of .
Here, the parameter is the optimum . We remark that the additional disjointness requirement in the completeness part makes -ExactCover an excellent intermediate problem for proving the hardness of other problems [2, 35].
On the algorithmic side, the -ExactCover has a brute-force -time algorithm. However, no -time algorithms are known. Thus, it is natural to consider whether we can establish a matching lower bound. Our work almost establishes a lower bound for -ExactCover, under ETH, for some constant . Previously, this was only known under the Gap-ETH assumption [35].
Theorem 1.4.
Assume ETH. There exists some constant , such that for any computable function , any algorithm deciding -ExactCover must take runtime .
To prove the theorem above, We note that the previous work [22] achieves a parameter-preserving reduction from PIH to -ExactCover for any constant , by imitating the beautiful reduction of Feige [16].333In fact, a weaker variant of PIH, named Average Baby PIH over rectangular constraints, suffices.
Therefore, Theorem 1.4 follows by combining the reduction of [22] with our Theorem 1.2. Applying Corollary 1.3, we can boost the ratio to any constant with lower bound .
Proposition 1.5.
Assume ETH. For any constant and computable function , any algorithm deciding -ExactCover must take runtime .
Application Highlight: Max -Coverage
The Max -Coverage is the maximization variant of the -SetCover problem. For the -approximation version of Max -Coverage with , denoted by Max -Coverage, the instances are the same as -ExactCover above, but the goal changes to distinguish the following two case:
-
•
There exists subsets from whose union equals .
-
•
Any subsets from has the union size at most .
Max -Coverage has been widely studied in previous literature. There exists a simple greedy algorithm solving Max -Coverage within polynomial runtime [23].
On the hardness side, a celebrated result of Feige [16] showed the NP-hardness of Max -Coverage for any , thus proving a tight inapproximability result.
In the parameterized world, one can solve Max -Coverage in time by brute force enumeration. On the other hand, Cohen-Addad, Gupta, Kumar, Lee, and Li [10] showed that assuming Gap-ETH, Max -Coverage requires runtime. Manurangsi [35] further improved this lower bound to the tightest under Gap-ETH.
Our work implies an almost-optimal time lower bound for Max -Coverage under ETH for some constant .
Theorem 1.6.
Assume ETH. There exists some constant , such that for any computable function , any algorithm deciding Max -Coverage must take runtime .
Theorem 1.6 follows from our Theorem 1.2 and the analysis in [35, Sections 9.1 and 9.2] that accomplishes a gap-preserving reduction from -CSP to Max -Coverage. Applying Corollary 1.3, we can boost the ratio to the tightest with lower bound .
Proposition 1.7.
Assume ETH. for any constant and computable function , there exists a constant , any algorithm deciding Max -Coverage must take runtime .
New PCP Characterizations
An interesting byproduct of Theorem 1.2 is a new PCP theorem for 3SAT as follows.
Theorem 1.8 (Informal Version of Theorem 4.2).
For any parameter , 3SAT has a constant-query PCP verifier with alphabet size , runtime , and random coins, which has perfect completeness and soundness .
Theorem 1.8 generalizes the classic PCP theorem and gives a smooth trade-off between the proof length and the alphabet size, connecting parameterized complexity and the classical complexity theory.
Paper Organization
In Section 2, we provide an overview for our proof of Theorem 1.2 and discuss future works. In Section 3, we formalize necessary notation and concepts. The formal structure for proving Theorem 1.2 is presented in Section 4, with most technical statements deferred to other sections: the reduction from ETH-hard problems to special vector-valued CSPs is provided in Section 5, and the PCPP verifier for a helper language is constructed in Section 6. In Appendix A, we give details of derandomized parallel low degree tests which is a key component for the PCPP construction.
2 Technical Overview
In this part, we provide general ideas of proving Theorem 1.2. Due to the equivalence between the existence of PCP systems and the inapproximability of constraint satisfaction problems [15, 1], Theorem 1.8 directly follows from Theorem 1.2.
We follow the spirit of [21] to prove Theorem 1.2. The proof framework is as follows.
-
•
First, we reduce an ETH-hard problem to a CSP problem with specific structures.
-
•
Then, leveraging the special structures, we construct a probabilistic checkable proof of proximity (PCPP) verifier to check whether the encoding of some given solution satisfies all constraints. Theorem 1.2 follows by converting the PCP verifier into CSP instances [1, 15].
For the first step, [21] reduces 3SAT to vector-valued CSPs (VecCSPs for short), whose variables take values in a vector space . In addition, each constraint is either a coordinate-wise parallel constraint or a linear constraint.
-
•
A parallel constraint (over variables and ) is defined by a sub-constraint and a subset of coordinate . It checks whether for every coordinate .
-
•
A linear constraint enforces that two vector-valued variables satisfy a linear equation specified by a matrix , i.e., .
Then, in the second step, [21] encodes the solution by parallel Walsh-Hadamard code and constructs a PCPP verifier with double-exponential proof length, resulting in an lower bound for -Gap -Variable CSP.
2.1 More Refined Vector Structure
Unfortunately, the vector structure used in [21] is far from being enough for obtaining an almost-optimal lower bound due to the following reasons.
-
•
For parallel constraints, VecCSP sets up the sub-constraints over a subset of the coordinates. There might be (where is the number of parallel constraints) different sub-CSP instances over all coordinates, each of which requires an individual PCPP verifier. To simultaneously check the satisfiability of all these sub-instances, they tuple these verifiers into a giant verifier, resulting in an exponential blowup of the proof length. Hence, an almost linear proof size is impossible.
-
•
For linear constraints, VecCSP defined in [21] allow them to be over arbitrary pairs of variables. They introduce auxiliary variables for all pairs of variables and their corresponding linear constraints to check such unstructured constraints. The number of auxiliary variables is , where are the numbers of variables and linear constraints, respectively. This means that the proof length is at least quadratic, making an almost linear proof size impossible.
-
•
Furthermore, the VecCSP instance in [21] has parameters , which is a starting point with already a quantitative loss for any subsequent constructions.
The analysis above urges us to mine more vector structures and devise new reductions with smaller parameter blowups. In this work, we further engineer VecCSP and obtain special vector-valued CSPs (SVecCSP for short) with three more features.
-
•
First, SVecCSP partitions the variables into two disjoint parts .
-
•
Second, for parallel constraints, SVecCSP sets up the sub-constraint on all coordinates, which implies a unified sub-CSP instance among all coordinates. As a result, we avoid the tuple procedure, enabling a highly succinct proof.
-
•
Third, for linear constraints, SVecCSP only sets up linear constraints over and , with the same index . After encoding and by the parallel Reed-Muller code, we can leverage this alignment and introduce auxiliary proofs, which is also a codeword of the parallel Reed-Mulle code, to check the validity of linear constraints efficiently, with an almost-linear blowup.
In addition, to decrease the parameter blowup, we apply the reduction in [36, 29] to obtain ETH-hard sparse parameterized CSP instances. Then, we imitate the reduction in [21] to obtain a sparse VecCSP instance with , which ultimately reduces to SVecCSP, with an almost optimal lower bound, by properly duplicating variables and relocating constraints.
2.2 Applying The Parallel Reed-Muller Code
After establishing the almost optimal runtime lower bound for SVecCSP, we need to design a PCPP verifier certifying the encoding of a given assignment satisfies all constraints. However, the previous work [21] designs a PCPP verifier that requires a proof with a double-exponential length, which is far from obtaining Theorem 1.2.
This paper applies the parallel Reed-Muller (RM) encoding with an almost-linear codeword length. Recall that the variables in the SVecCSP instance are divided into two disjoint parts , the input proof of the PCPP verifier consists of and , which are supposed to be the parallel RM encoding of the assignment over and respectively. The verification procedure is demonstrated as follows.
First, to ensure that and are indeed codewords of the parallel RM code, we apply parallel low degree testing. The standard low degree testing causes a quadratic blowup in the proof length. To ensure an almost-linear proof length, we use the parallel version of the derandomized low degree testing [9] (Appendix A).
Second, we check whether satisfies all parallel constraints. Since a unified sub-CSP instance exists among all coordinates, as long as we have constructed a PCPP verifier for this sub-CSP, we can simulate it in parallel to check all coordinates at the same time, with no blowup in the proof length (as opposed to an exponential blowup in [21]). Our sub-CSP has an alphabet of constant size. Thus, we can apply the existing approach (see, e.g., [8, Theorem 3.3]) in a black box way to construct an almost-linear PCPP verifier for all parallel constraints in our sub-CSP.
Finally, we check whether satisfies all linear constraints. Recall that SVecCSP only sets up linear constraints over and , with the same index . Denote as the matrix for the index , i.e., the -th linear constraint is . We introduce an auxiliary proof , satisfying
where is the parallel RM encoding for matrices . Then, all systematic parts of , i.e., the codeword entries corresponding to for , should be . The key observation is that if and are codewords of parallel RM code, then so does . Hence, we can apply parallel derandomized low degree testing for and apply another PCPP, as in the parallel part, to check whether all systematic parts of are . Finally, we check whether satisfies the equation above by simply querying a random index, for which the soundness and completeness are guaranteed by Schwartz-Zippel lemma [40]. In this way, we have a highly efficient PCPP verifier that checks all linear constraints with an almost linear proof length.
The overall PCPP verifier is the combination of the verifiers for parallel constraints and for linear constraints. A more detailed framework of our proof is in Section 4.
2.3 Future Works
Our work gives almost optimal time lower bounds for the approximation version of many canonical parameterized problems under ETH, including -Clique, -ExactCover, -Variable CSPs, and Max -Coverage.
Technically, we prove the almost optimal time lower bound for constant-gap -Variable CSPs. Using this result as the cornerstone, we obtain the inapproximability for other problems by existing reductions. One open question is whether almost optimal time lower bounds for other problems also follow from this result, e.g., -Balanced Biclique [11, 20].
The second question is to obtain the (actual) optimal time lower bounds for constant-gap -Variable CSPs. This problem can be seen as the parameterized extension of the long-standing linear-size PCP conjecture [7]. In the non-parameterized world, the state-of-the-art PCP theorem with the shortest proof length is due to [15] with quasilinear proof length. It is also interesting if this optimal bound (i.e., the parameterized extension of the linear-size PCP conjecture) can be established assuming the existence of linear-size PCP.
For more interesting directions, please refer to [21].
3 Preliminaries
For a positive integer , we use to denote the set . We use to denote the logarithm with base . For a prime power where is a prime and is an integer, we use to denote the finite field of order and characteristic .
For an event , is defined the indicator function, which equals if happens and otherwise. For a finite set , we use to denote a uniformly random element from .
For disjoint sets and , we use to denote their union while emphasizing .
Asymptotics
Throughout the paper, we use to hide absolute constants that do not depend on any other parameter. We also use to denote some implicit polynomial in terms of the parameters within, e.g., is upper bounded by for some absolute constant .
3.1 Constraint Satisfaction Problem
In this paper, we only focus on constraint satisfaction problems (CSPs) of arity two. Formally, a CSP instance is a quadruple , where:
-
•
is for the set of variables.
-
•
is for the set of constraints. Each constraint connects two distinct variables .
The constraint graph is the undirected graph on vertices with edges . Note that we allow multiple constraints between the same pair of variables; thus, the constraint graph may have parallel edges.
-
•
is for the alphabet of each variable in . For convenience, we sometimes have different alphabets for different variables, and we will view them as a subset of a grand alphabet with some natural embedding.
-
•
is the set of constraint validity functions. Given a constraint , the function checks whether the constraint between and is satisfied.
We use to denote the size of a CSP instance .
Assignment and Satisfiability Value
An assignment is a function that assigns each variable a value in the alphabet. We use
to denote the satisfiability value for an assignment . The satisfiability value for is . We say that an assignment is a solution if , and is satisfiable iff has a solution. When the context is clear, we omit in the description of a constraint, i.e., stands for .
Boolean Circuits
Throughout the paper, we consider standard Boolean circuits with AND/OR gate of fan-in two and fan-out two, and NOT gate with fan-out two.
Exponential Time Hypothesis (ETH)
Exponential Time Hypothesis (ETH), first proposed by Impagliazzo and Paturi [24], is a famous strengthening of the hypothesis and that has since found numerous applications in modern complexity theory, especially in fine-grained complexity.
The ETH postulates that the general 3SAT problem has no sub-exponential algorithm. In this paper, we use the ETH-based hardness of the 4-Regular 3-Coloring problem.
Definition 3.1 (4-Regular 3-Coloring).
A 2CSP instance is an instance of 4-Regular 3-Coloring if (1) , (2) the constraint graph is -regular, and (3) each checks whether the two endpoints of are assigned with different colors from , where has size three and is fixed in advance.
We remark that usually 3-Coloring is defined directly with a ternary alphabet . Here for simplicity of later reductions, we assume the alphabet is . This is without loss of generality since the coloring constraint is also upgraded to check additionally whether the colors are from .
Theorem 3.2 (ETH Lower Bound for 4-Regular 3-Coloring [12]).
Assuming ETH, no algorithm can decide 4-Regular 3-Coloring in time.
3.2 Parameterized Complexity Theory
In parameterized complexity theory, we consider a promise language equipped with a computable function , which returns a parameter for every input instance . We use to denote a parameterized language. We think of as a growing parameter that is much smaller than the instance size .
A parameterized promise language is fixed parameter tractable (FPT) if there is an algorithm such that for every input , it decides whether in time for some computable function .
An FPT reduction from to is an algorithm which, on every input outputs another instance such that:
-
•
Completeness. If , then .
-
•
Soundness. If , then .
-
•
FPT. There exist universal computable functions and such that and the runtime of is bounded by .
We refer to [17] for the backgrounds on fixed parameter tractability and FPT reductions.
-Gap -Variable CSP
We mainly focus on the gap version of the parameterized CSP problem. Formally, an -Gap -Variable CSP problem is the following parameterized promise language .
-
•
consists of all CSPs with .
-
•
consists of all CSPs with .
-
•
equals the number of variables in .
In other words, we need to decide whether a given CSP instance with variables satisfies or .
Parameterized Inapproximability Hypothesis (PIH)
Parameterized Inapproximability Hypothesis (PIH) is a folklore conjecture generalizing the celebrated PCP theorem to the parameterized complexity. It was first rigorously formulated in [34]. Below, we present a slight reformulation, asserting fixed parameter intractability (rather than -hardness specifically) of gap CSP.
Hypothesis 3.3 (PIH).
For an absolute constant , no FPT algorithm can decide -Gap -Variable CSP.
3.3 Parallel Reed-Muller Code
Word
We say is a word (a.k.a., vector) with alphabet if is a string of finite length and each entry is an element from ; and contains all words with alphabet . Assume has length . For each , we use to denote the sub-string of on entries in . When is a singleton set, we simply use to denote . For a word over a vector alphabet , for each entry and , we define as the -th coordinate of . We define as , which is a word over .
Let be another word. We use to denote the concatenation of and . If is also of length , we define as their relative Hamming distance. For a set of words, if holds for every , we say is -far from ; otherwise we say is -close to . In particular, if , then is -far from . Below, we recall the notion of error correcting codes.
Definition 3.4 (Error Correcting Code (ECC)).
An error correcting code is the image of the encoding map with message length and codeword length . We say that the ECC has a relative distance if holds for any distinct . We use to denote the relative distance of the image map of and use to denote the codewords of .
Reed-Muller Code
We use the parallel Reed-Muller (RM) code to construct PCPPs. This parallel operation is called interleaving in coding theory. Below, we present the formal definition.
For an -variate parallel-output function , we denote as its single-output components, i.e., We say is of parallel degree- if are degree- polynomials, where a polynomial is degree- if all monomials with (total) degree larger than have zero coefficients.
If and , by a dimension argument, there exist distinct points (a.k.a., interpolation set) whose values can uniquely determine the polynomial of parallel degree .
Definition 3.5 (Parallel RM Code).
Assume and . Let be the set above. The -parallel RM code is the image of the following encoding map:
where for each , the encoding is the truth table of over the whole space .
In addition, is the systematic part of the parallel RM encoding, which can be read off directly: for each , equals the entry indexed by in the codeword.
By Schwartz-Zippel lemma444Schwartz-Zippel lemma is usually stated only for single-output polynomials, but it naturally generalizes to the parallel case., the relative distance of -parallel RM code is
Furthermore, there is an efficient codeword testing procedure (Theorem 3.6) for , the proof of which is in Appendix A.
Theorem 3.6 (Codeword Testing).
Assume and . Let be the set of univariate degree- polynomials over . There exists an efficient verifier with the following properties.
-
•
The input of is , where is supposed to be a codeword of and is the auxiliary proof.
-
•
tosses unbiased coins and makes queries on .
-
•
If , then there exists some such that always accepts.
-
•
If is -far from , then for any .
Given a Boolean circuit , we say a word parallel satisfies iff holds for every coordinate .
Extracting from the verifier in Theorem 3.6, we obtain a circuit of small size that describes the codeword testing procedure, the proof of which is also in Appendix A.
Theorem 3.7.
Assume and . There exists a Boolean circuit of size for , where we encode as , such that is codeword of iff parallel satisfies .
3.4 Pair Language and Probabilistic Checkable Proof of Proximity
We will perform various satisfiability testing for assignments of Boolean circuits where both are given as input. This motivates the notion of pair language, where the input is naturally divided into two parts corresponding to circuits and assignments respectively.
Pair Language
Formally, is a pair language over the alphabet and if all words of are in the form where . For each , we define as the restriction of on .
Probabilistic checkable proof of proximity (PCPP)
PCPP provides robust testing of satisfiability for pair languages.
Definition 3.8 (PCPP).
Given a pair language with alphabet , a -PCPP verifier takes as input a pair of words and an auxiliary proof with alphabet , such that:
-
(T1)
The verifier reads all bits of , tosses at most many unbiased coins, makes at most queries on and , and then decides to accept or reject within runtime .
We use to denote the query positions on under randomness , and use to indicate the behavior (i.e., accept or reject) of under randomness and query answer .
-
(T2)
If , then there exists some such that always accepts.
-
(T3)
If is -far from , then rejects with probability at least for every .
We say is a -PCP verifier if it is a -PCPP verifier.
Remark 3.9 (Proof Length).
We can always upper bound by , for which reason we do not put an additional parameter in Definition 3.8.
From PCPP to CSP
PCPPs are tightly connected with CSPs. The following standard reduction establishes the connection.
Definition 3.10 (From PCPP to CSP).
Given a -PCPP verifier for the pair language . We define a CSP instance , where and , by the following steps:
-
•
First, we treat each position of (resp., ) as a single variable in and (resp., ) with alphabet (resp., ). Note that and by Remark 3.9.
-
•
Then, for each choice of random coins , let be the set of query positions over under randomness ; and we add a variable to whose alphabet is , i.e., all possible configurations of the query result. Note that .
-
•
Finally, we add constraints between and every query position . The constraint checks whether is an accepting configuration, and the assignment of the position is consistent with the assignment of .
By construction, the completeness and soundness are preserved up to a factor of under this reduction, where the loss comes from splitting queries into consistency checks. In addition, the reduction from to is an FPT reduction.
Fact 3.11.
The reduction described in Definition 3.10 is an FPT reduction. Recall that is a -PCPP verifier for the pair language over the alphabet . We have the following properties for :
-
•
Alphabet. The alphabet of is .
-
•
Parameter Blowup. The number of varialbes . The number of constraints .
-
•
Completeness. If , then there exists a solution of assigning to .
-
•
Soundness. If is -far from , then any assignment assigning to satisfies at most fraction of the constraints in . Note that if , then .
Circuit Value Problem (CktVal)
CktVal is a standard pair language widely used in the classical PCP theorems (see e.g., [8]). It directly checks if a binary string is a solution to a Boolean circuit.
Definition 3.12 (CktVal).
CktVal is a pair language over consisting of all words in the form of , where is a Boolean predicate with input bits and is a binary string that satisfies . We define the input length to be the size of plus .
We quote the following almost-linear PCPP result for CktVal, which follows from [8, Theorem 3.3] by setting to be a constant sufficiently large.
Theorem 3.13 (PCPP for CktVal, [8]).
There exists an absolute constant such that CktVal has
an -PCPP verifier , |
where is the input length of CktVal.
Remark 3.14.
In the parallel setting, we want to check if a circuit is satisfied on different inputs . Note that according to the Definition 3.8, given and an auxiliary proof for every , the PCPP reads the whole and then queries and . In other words, the query locations depend only on . So, when applied in parallel, the PCPP queries the same locations for different .
4 Proof of the Main Theorems
This section is devoted to giving a landscape of the proof of Theorem 1.2 and Theorem 1.8. To depict a clear picture, we relegate the proof of technical lemmas in subsequent sections. Below, we first present the formal statement of Theorem 1.2 and Theorem 1.8.
Theorem 4.1 (Formal Version of Theorem 1.2).
Assume ETH. Then for some constant and any computable function , no algorithm can take as input a 2CSP instance with variables, constraints and alphabet , distinguish between the following two cases in time:
-
•
is satisfiable;
-
•
any assignment satisfies at most fraction of the constraints in .
Theorem 4.2 (Formal Version of Theorem 1.8).
For any integer sufficiently large, 3SAT has a constant-query PCP verifier of alphabet size , runtime , and random coins, which has perfect completeness and soundness .
The proof of Theorem 4.1 follows a similar idea in the previous work [21].
-
•
First, we reduce from 4-Regular 3-Coloring, which has the lower bound under ETH, to a CSP with specific vector structures, termed as the special vector-valued CSP (SVecCSP for short). This step is somewhat similar to the previous approach [21], in the sense that both approaches engineer non-parameterized CSP problems into parameterized CSPs with vector structure. However, the vector structure in [21] is not enough for obtaining the almost-optimal lower bound for -Variable CSP. This paper obtains a much more refined structure.
-
•
Second, we design a PCPP verifier for SVecCSPs. To obtain an almost-optimal lower bound, we encode the solution of SVecCSPs via Reed-Muller code with an almost-linear blowup. Below, we present the details of our proof.
4.1 Reduction from 4-Regular 3-Coloring to SVecCSP
In this section, we define special vector-valued CSP (SVecCSP for short). The notion of vector-valued CSPs was first defined in [21], and here we consider a better-structured variant.
Definition 4.3 (SVecCSP).
A CSP instance is an SVecCSP if the following properties hold.
-
(S1)
.
-
(S2)
is a -dimensional vector space over a finite field with .
-
(S3)
For each constraint where and are two variables in , there is a sub-constraint such that checks on all coordinates, i.e.,
-
(S4)
. For each , there exists a matrix and a constraint check if , i.e.,
The following theorem establishes the hardness of SVecCSP.
Theorem 4.4.
There is a reduction algorithm that holds the following. Given as input an integer and an -variable 4-Regular 3-Coloring instance , it produces an SVecCSP instance where:
-
(R1)
Variables and Constraints. and .
-
(R2)
Runtime. The reduction runs in time .
-
(R3)
Alphabet. where .
-
(R4)
Satisfiability. is satisfiable iff is satisfiable.
We defer the proof of Theorem 4.4 to Section 5. Compared with vector-valued CSPs (VecCSP) used in the previous work [21, Definition 3.3], SVecCSP offers more structural properties.
-
•
For parallel constraints, the previous work [21] sets up the sub-constraint over a subset of the coordinates. By construction, there might be different sub-CSP instances over all coordinates. Each of the sub-CSPs requires an individual PCPP verifier. To simultaneously check the satisfiability of all these sub-instances, they tuple these verifiers into a giant verifier, resulting in an exponential blowup of the proof length. Hence, an almost-linear size of proof is impossible.
In contrast, SVecCSP sets up the sub-constraint on all coordinates, which implies a unified sub-CSP instance among all coordinates. As a result, we avoid the tuple procedure, enabling a highly succinct proof.
-
•
For linear constraints, VecCSP defined in [21] allow them to be over arbitrary pairs of variables. They introduce auxiliary variables for all pairs of variables and their corresponding linear constraints to check such unstructured constraints. The number of auxiliary variables is , which means that the proof length is at least quadratic, making an almost linear size of proof impossible.
However, SVecCSP only sets up linear constraints over and , with the same index . After encoding and by the parallel Reed-Muller code, we can leverage this alignment and introduce auxiliary proofs, which is also a codeword of the parallel Reed-Mulle code, to check the validity of linear constraints efficiently, with an almost-linear blowup.
Though SVecCSP has a more refined structure than VecCSP, we can obtain it from VecCSP by properly duplicating variables and relocating constraints. However, the VecCSP instance in [21] has parameters , which are too large to obtain Theorem 4.4. To get around this, we combine results from [36, 29] and the reduction in [21] to obtain a sparse VecCSP instance with , which ultimately leads to Theorem 4.4.
4.2 Reduction from SVecCSPs to -Gap -Variable CSPs
With the ETH-hardness of SVecCSP by Theorem 4.4, the remaining work is to reduce SVecCSP to -Gap -Variable CSP. To this end, we follow the same idea of previous works [4, 21].
-
(L1)
First, we encode the solution using an error correcting code.
-
(L2)
Then, we design a constant-query PCPP verifier to check whether the given proof is the codeword of some solution with the aid of auxiliary proofs.
-
(L3)
Finally, we obtain Theorem 4.1 by converting the PCPP verifier into an instance of -Gap -Variable CSP by Fact 3.11.
Remark 4.5.
In our actual construction of Item (L2), parallel constraints and linear constraints will be processed separately, building on a (supposedly) same solution. Hence we need to encode the solution using error correcting codes in Item (L1) and design PCPP verifier (instead of PCP verifier) for Item (L2) on top of the shared encoding of the solution.
For the first step (Item (L1)), we need error correcting codes with almost-linear length blowup. In detail, we choose the parallel Reed-Muller code (see Definition 3.5) with suitable choice of parameters. This motivates us to define the following pair language SVecCSP Satisfiability (SVSat).
Definition 4.6 (SVSat).
-SVSat is a pair language consisting of where:
-
•
is an SVecCSP instance. We require that and is a subfield of .
-
•
are codewords of . Suppose and for some . Define assignment by
We further require that is a solution of , which implicitly demands for .
Remark 4.7.
Since , the index in defining is at most the length of and thus is well defined in Definition 4.6. The parameters come from the parameters of the parallel Reed-Muller code.
In this pair language, is the starting SVecCSP instance in our reduction, and serves as the encoding of a solution. We have the following connection between -SVSat and the satisfiability of SVecCSP.
Fact 4.8.
Let be an SVecCSP instance. Assume and is a subfield of . Then, is satisfiable iff there exists such that -SVSat.
Remark 4.9 (Encoding Choice).
One may wonder the necessity for encoding and separately, as opposed to encoding them jointly as . This is due to the bipartite structure of the linear constraints (see Item (S4)) that we will need to ensure proximity for the encoding on both and . This will be clear in Item (T3) and Lemma 4.23.
For the second step (Item (L2)), we need to construct a PCPP verifier for -SVSat. Formally, we construct a PCPP verifier with the following parameters.
Theorem 4.10.
Assume and . Then for any , -SVSat has
and -PCPP verifier , |
where is the number of constraints in -SVSat and .
Fix some supposed to be in -SVSat. We use to denote the assignment recovered (if succeeded) from and . Our goal is to verify whether is the solution of . To this end, we will handle parallel and linear constraints in Subsection 4.2.1 and Subsection 4.2.3 separately, then combine them together in Subsection 4.2.3 to prove Theorem 4.10.
4.2.1 Verification of Parallel Constraints
We first consider verifying whether satisfies all parallel constraints by probing the indices of . Since is a systematic code (Definition 3.5), we can recover the value of an index in the assignment directly from probing an index of . In addition, recall that parallel constraints set up the same sub-constraints over all coordinates (Item (S3)), we can build up a unified Boolean circuit that checks whether the systematic part of and satisfies the sub-constraints in a single coordinate. In detail, the circuit is defined as follows.
Definition 4.11 (The Circuit ).
Let be words of length over alphabet555For ease of presentation, the circuit’s input is described as alphabet . We take the trivial conversion from an element of into a binary string of length . . Assume are codewords of . The circuit executes the following.
-
•
recovers the messages from the systematic part of respectively.
-
•
After that, checks whether the assignment specified by has the correct subfield entries and satisfies all constraints in the part of , at the single-coordinate level. Specifically, is the assignment of defined by
For every , checks whether ; and for every constraint , checks whether .
The size of circuit is bounded by .
Double Test Problem (DoubleTest)
In light of Definition 4.11, satisfies all parallel constraints iff are correct codewords and for each . This motivates us to consider the following pair language DoubleTest related to CktVal.
Definition 4.12 (DoubleTest).
Assume . -DoubleTest is a pair language over consisting of where
-
•
is a Boolean circuit with input bits and are codewords of ;
-
•
if we view as , parallel satisfies .
We define the input length to be the size of plus . Note that the dimension is reflected on the alphabet, not on the length.
In short, DoubleTest extends CktVal by allowing the assignment to have more dimensions (i.e., ), allowing the assignment to be partitioned into two parts (i.e., ), and assuming each part is encoded by parallel RM code.
Given Definition 4.12 and Definition 4.11, we have the following statement. Note that the assumption that are codewords of in Definition 4.11 is guaranteed in Definition 4.12.
Fact 4.13.
Parallel constraints in are satisfied iff -DoubleTest.
Thus, to verify that satisfies all parallel constraints, if suffices to construct a PCPP verifier for DoubleTest. The verifier is formally stated as follows and will be proved in Section 6.
Theorem 4.14 (PCPP for DoubleTest).
Assume and . For any , -DoubleTest has
an -PCPP verifer , |
where is the input length of -DoubleTest and .
4.2.2 Verification of Linear Constraints
We then turn to verifying whether satisfies all linear constraints . Recall from Item (S4) that all linear constraints are set up between and , with the constraint that . By defining auxiliary variables , it suffices to check whether for every .
Thus, we add the auxiliary proof , which is supposed to fulfill the following condition
(1) |
where is the parallel RM encoding of . Here we extend Definition 3.5 for matrix values: the value of is for and is for . Equivalently, for each matrix coordinate , is the RM encoding of . We remark that entries of can be efficiently computed on the fly by demand and are not included as a proof for the PCPP verifier.
Based on the discussion above, we obtain the following fact.
Fact 4.15.
Linear constraints in are satisfied iff are codewords of and the systematic part of , defined by Equation 1, are all .
Recall that being correct codewords are guaranteed by the analysis of parallel constraints above. Hence we focus on testing the systematic part of , which amount to parallel satisfying the following circuit.
Definition 4.16 (The Circuit ).
The circuit receives as input a word of length over alphabet . It checks if holds for all , where we recall that from Definition 3.5.
The size of the circuit is bounded by .
We will use a variant of DoubleTest, denoted SingleTest, on and . But before that, we give a degree bound for .
Claim 4.17.
If are codewords of , then the defined by Equation 1 is a codeword of .
Proof.
Expanding the matrix multiplication, for each coordinate , we have
where is the -th entry of . Since are truth tables of degree- polynomials, is the truth table of a degree- polynomial, which means . ∎
Single Test Problem (SingleTest)
At this point, checking Fact 4.15 can be safely handled by the following SingleTest with proper degree conditions.
Definition 4.18 (SingleTest).
Assume . -SingleTest is a pair language over consisting of where
-
•
is a Boolean circuit with input bits and is a codeword of ;
-
•
if we view as , parallel satisfies .
We define the input length to be the size of plus .
In comparison, SingleTest simply removes the second table from DoubleTest. Combining Claim 4.17 and Fact 4.15, we have the following result.
Fact 4.19.
Linear constraints in are satisfied iff are codewords of , satisfies Equation 1, and -SingleTest.
Analogous to Theorem 4.14, we also have an efficient PCPP verifier for SingleTest as follows, which will also be proved in Section 6.
Theorem 4.20 (PCPP for SingleTest).
Assume and . For any , -SingleTest has
an -PCPP verifer , |
where is the input length of -SingleTest and .
Finally, we briefly sketch how to check if satisfies Equation 1, as needed in Fact 4.19. This will be done by randomly picking an index and checking whether Equation 1 holds on that . The soundness will be analyzed by Schwartz-Zippel Lemma. This will be formalized in Subsection 4.2.3.
4.2.3 The Whole Construction and Analysis
Based on the above discussion, we are now ready to construct the PCPP verifier for SVSat. We invoke Theorem 4.14 to obtain PCPP verifiers and for -DoubleTest and -SingleTest respectively.
Recall that the input of -SVSat is . The auxiliary proof consists of , , and , where
-
•
is supposed to be a codeword in and for all ;
-
•
is supposed to be the auxiliary proof to convince that belongs to the pair language -DoubleTest.
-
•
is supposed to be the auxiliary proof to convince that belongs to the pair language -SingleTest.
The verifier performs one of the following three tests with equal probability.
-
(T1)
Feed the pair of words and the auxiliary proof into . Reject if rejects.
-
(T2)
Feed the pair of words and the auxiliary proof into . Reject if rejects.
-
(T3)
Generate a random point , reject if .
At this point, we are ready to analyze the PCPP verifier . In particular, Theorem 4.10 follows from the combination of the following Lemma 4.21, Lemma 4.22, and Lemma 4.23.
Lemma 4.21 (Parameters).
Assume and . Then tosses
unbiased coins and makes queries. The alphabet of the auxiliary proof is where .
Proof.
By Theorem 4.14 and Theorem 4.20, both and make constant queries. Also in Item (T3), makes 3 queries on . Thus makes total queries.
By Definitions 4.16 and 4.11, the input lengths of and in Item (T1) and Item (T2) are
respectively. Putting this into Theorem 4.14 and Theorem 4.20, the number of unbiased coins used in and is
In Item (T3), tosses coins. Since only executes one of the three tests, the randomness is bounded by their maximum.
The auxiliary proofs have alphabet by Theorem 4.14 and Theorem 4.20. The alphabet of is , which can also be embedded into the larger . ∎
Lemma 4.22 (Completeness).
Assume and . Suppose , and the assignment given by and (recall Definition 4.6) is a solution to . Then there exist which accepts with probability .
Proof.
By Definition 4.11, parallel satisfies the circuit . Thus -DoubleTest by Fact 4.13. Hence there exists an auxiliary proof which makes accepts with probability 1. Item (T1) therefore always passes.
For each , define . By Claim 4.17, . Let be the messages encodes respectively. Note that satisfies the linear constraints in , i.e., for all . Hence all , we have
where are the distinct points defining the encoding of parallel RM code (see Definition 3.5). Therefore, parallel satisfies . By Fact 4.19, there exists an auxiliary proof , which makes accepts with probability 1, and Item (T2) always passes.
Finally Item (T3) always passes due to the definition of . This completes the proof. ∎
Lemma 4.23 (Soundness).
Assume and . Let be arbitrary. If is -far from satisfying, i.e., -far from the restriction of -SVSat on , then rejects with probability .
Proof.
Let be a large constant, the specific value of which depends on the hidden constants in Theorem 4.14 and Theorem 4.20. By modifying the hidden constant in here and noticing that -far implies -far for any , we safely assume .
Fix arbitrary that is -far from satisfying. Assume that rejects with probability at most , since otherwise the statement already holds. Then each of the tests Item (T1), Item (T2), and Item (T3) reject with probability at most . By choosing sufficiently large and according to soundness guarantee of and in Theorem 4.14 and Theorem 4.20, we know
-
1.
is -close to , which is a pair of codewords of that parallel satisfies .
Since have the same length, this alse implies that is -close to and is -close to .
-
2.
is -close to , which is a codeword of that parallel satisfies .
We aim to show that -SVSat, which contradicts to the assumption that is -far from satisfying and completes the proof.
Let , , be the messages of respectively. It now suffices to prove the assignment given by
satisfies all constraints in .
By Item 1 and Fact 4.13, satisfies all constraints in . To analyze constraints in , we first prove that in accordance with Equation 1. Assume this is false for some entry , i.e.,
(2) |
Note that are all of parallel degree- and is of parallel degree-. Then by Schwartz-Zippel lemma, Equation 2 actually happens for at least fraction of points . Now recall the test in Item (T3), which checks precisely the above for a random with replaced by . By Items 1 and 2 and a union bound, with probability at least , on this random we have and Equation 2 happens, which makes Item (T3) reject. By our assumption on and with sufficiently large, this rejection probability is at least and contradicts to our assumption on the rejection probability of Item (T3). In short, Equation 2 can never happen.
4.3 Putting Everything Together
Now, we are ready to prove the main theorems.
Proof of Theorem 4.1.
We start with an arbitrary -variable 4-Regular 3-Coloring instance , which prohibits algorithms of runtime in the worst case by Theorem 3.2 assuming ETH. By Theorem 4.4, we obtain an SVecCSP instance in time which preserves the satisfiability of . In addition, and .
Let and be integers to be chosen later satisfying
(3) |
Let be a field of characteristic two which contains as a subfield and satisfies
(4) |
By Fact 4.8, is satisfiable iff there exists such that -SVSat. Then we construct the PCPP verifier for -SVSat from Theorem 4.10 with to obtain a PCP verifier (recall Definition 3.8) for the satisfiability of .
The query complexity, completeness, alphabet, and randomness of follow from those of in Theorem 4.10; and the soundness of is the (unspecified) constant soundness parameter by setting in Theorem 4.10. In particular,
and
Then we apply Fact 3.11 and obtain a 2CSP instance preserving the satisfiability of (and thus ) where
-
•
the size of the alphabet of is
-
•
the number of variables in is at most
-
•
the number of constraints in is a constant multiple of the number of variables in .
Finally we optimize the choice of . Assume is a perfect square and is sufficiently large and set
Then
which is consistent with Equation 3. We also have
which is consistent with Equation 4. Moreover, has alphabet size and the number of variables as follows.
where can be furthered simplified to
Since has no -time algorithm by assumption, has the lower bound -time for any computable function as claimed.
∎
The PCP statement Theorem 4.2 follows directly from the proof above.
Proof of Theorem 4.2.
From any instance of 3SAT, there is a linear-size reduction to an instance of 4-Regular 3-Coloring [36]. Therefore we only need to construct the desired PCP for 4-Regular 3-Coloring. This follows directly from the verifier in the proof of Theorem 4.1. In particular, we stick to the parameter choice there and obtain a PCP verifier with alphabet size
and randomness
The implicit constant soundness of can be boosted to by a constant number of randomness-efficient query repetitions (see e.g., [8, Lemma 2.11]). ∎
5 From 4-Regular 3-Coloring to SVecCSP
The goal of this section is to reduce 4-Regular 3-Coloring, which is known to be ETH-hard Theorem 3.2, to SVecCSP.
Theorem (Theorem 4.4 Restated).
There is a reduction algorithm such that the following holds. Given as input an integer and an -variable 4-Regular 3-Coloring instance , it produces an SVecCSP instance where:
-
(R1)
Variables and Constraints. and .
-
(R2)
Runtime. The reduction runs in time .
-
(R3)
Alphabet. where .
-
(R4)
Satisfiability. is satisfiable iff is satisfiable.
The reduction starts by grouping vertices into supernodes, which take vector values. Then the constraints between supernodes correspond to (possibly multiple) constraints in the original instance. To make sure the new instance has small size, we need a grouping method (Lemma 5.1) that produces as few supernodes and constraints as possible. Then we make duplicates of variables and rearrangements of their coordinates to make sure parallel constraints are scattered properly (Proposition 5.4). Finally we make more duplicates to ensure that linear constraints form a matching and parallel constraints are applied on all coordinates (Proposition 5.5).
5.1 From 4-Regular 3-Coloring to VecCSP
The following Lemma 5.1 serves the purpose of the grouping method and can be seen as a parameterized version of the sparsification lemma [24, 25] in classical computation complexity.
Lemma 5.1 ([36, 29]).
There is an algorithm such that the following holds. takes as input a 2CSP instance and an integer , outputs a 2CSP instance in time where and , such that is satisfiable iff is satisfiable. In addition, the constraint graph of is a 3-regular graph.
In the actual construction, each corresponds to a subset of size and takes values in as assignments to variables in . For each , the constraint is the conjunction of the following:
-
1.
equality constraints on common variables of and ;
-
2.
constraints across666The construction in [29] ensures that each original constraint is covered by some new constraint in the sense that . This means that we only need to check the cross constraints in and omit the ones purely inside or inside . and in .
Remark 5.2.
Note that since the constraint graph of is 3-regular, the total number of constraints in is linear in . In addition, only incurs an extra blowup over the information theoretic limit . This is crucial for us to get almost tight hardness. Indeed, naive approaches (e.g., the reduction in [21]) will incur a polynomial loss. We also remark that it is an open problem whether the extra can be further removed, which, if true, implies a precise parameterized analog of the sparsification lemma and has many applications. See [36] for detailed discussions.
Given Lemma 5.1, we first obtain a vector-valued CSP (VecCSP) instance (Proposition 5.4), which we will soon convert into SVecCSP (Proposition 5.5).
Definition 5.3 (VecCSP, [21]).
A CSP instance is a VecCSP if the following properties hold.
-
•
is a -dimensional vector space over a finite field with .
-
•
For each constraint where and are two variables in , the constraint validity function is classified as one of the following cases:
-
–
Linear. There exists a matrix such that
-
–
Parallel. There exists a sub-constraint and a subset of coordinates such that checks for every coordinate in , i.e.,
-
–
-
•
Each variable is related to at most one parallel constraint.
Note that SVecCSP, the special case of VecCSP we use, additionally enforces linear constraints to be a matching and enforces parallel constraints to operate on all coordinates (i.e., ).
Proposition 5.4 (VecCSP Intermediate Instance).
There is a reduction algorithm such that the following holds. Given as input an integer and an -variable 4-regular 3-Coloring instance , it produces an VecCSP instance where:
-
•
Variables and Constraints. and .
-
•
Runtime. The reduction runs in time .
-
•
Alphabet. where .
-
•
Satisfiability. is satisfiable iff is satisfiable.
Proof.
We first plug the 4-Regular 3-Coloring instance from Theorem 3.2 into Lemma 5.1 and obtain a 2CSP instance . By the construction in Lemma 5.1, each corresponds to a set of variables in . We fix an arbitrary order in and use to denote the -th variable in . From the fact that is 4-regular and the construction in Lemma 5.1, the produced 2CSP instance has the following properties:
- •
-
•
the constraint graph of is -regular;
-
•
, , , and the runtime is ;
-
•
is satisfiable iff is satisfiable.

Thus, we duplicate each into constant many copies, and distribute the sub-constraints in onto different copies. This produces another 2CSP instance where
-
•
for each , the constraint has exactly one type of sub-constraint (i.e., equality or coloring), which forms a partial (non-parallel) matching across the coordinates (i.e., ) of ;
(Note that the consistency checks among duplicates will be added later.)
-
•
each variable in is related to exactly one constraint;
-
•
and .
The above procedure is efficient: we only need to perform matching decompositions for each separately for equality checks and coloring checks.
Before adding the consistency checks among duplicates, we first permute coordinates of each variable in to parallelize the partial matchings. This is possible since each variable in is related to exactly one constraint in . For a fixed , let be the duplicates of . After the permutation, we add linear constraints between and for to check whether they are consistent (i.e., the correct permuted copies of each other). See Figure 1 for a streamlined presentation.
The construction of the VecCSP instance is completed after the permutation and adding the consistency checks among duplicated. The satisfiability is naturally preserved, , and . In terms of Definition 5.3, the consistency checks are linear constraints and the constraints in after permutation are parallel constraints. ∎
5.2 From VecCSP to SVecCSP
Given Proposition 5.4, Theorem 4.4 follows directly by the following general reduction from VecCSP to SVecCSP.
Proposition 5.5 (VecCSP to SVecCSP).
There is a reduction algorithm such that the following holds. Given as input a VecCSP instance , it produces an SVecCSP instance where:
-
•
Variables and Constraints. and .
-
•
Runtime. The reduction runs in time .
-
•
Satisfiability. is satisfiable iff is satisfiable.
Proof.
Now that we get a VecCSP instance , we show how to modify it to to obtain an SVecCSP instance that satisfies properties Item (S3) and Item (S4). The construction consists of two steps and see Figure 2 for a streamlined presentation.
To satisfy Item (S3), we split each variable in into a parallel variable and a linear variable in for parallel and linear constraints separately. Then we construct the constraints in .
-
•
For each linear constraint , we add the same linear constraint on in .
-
•
For each parallel constraint with sub-constraint and subset of coordinates , we add a parallel constraint on in , which has applied on all coordinates.
-
•
We need to additionally check in the partial equality between and only on the subset of coordinates . Since each variable is related to at most one parallel constraint as guaranteed in Definition 5.3, this additional check is well-defined.
This check can be written as , where is a matrix which projects on coordinates inside and zeroing out coordinates outside . To have the matrix only on one side, we introduce an additional variable in , and add two linear constraints and to .
We first show that the above construction preserves the satisfiability as follows.
-
•
Given a solution for the original , assign to and , which satisfies all linear constraints in . Then assign to on the subset of coordinates, which satisfies all the partial equality checks in . Finally, assign arbitrary solution777Technically it is possible that is not satisfiable. If , then we can simply replace by any satisfiable sub-constraint. If otherwise , then the original is not satisfiable and is also not satisfiable. Therefore the construction still works. of to on coordinates outside , which satisfies all the parallel constraints in .
-
•
Given a solution of , assign to every in , which satisfies all linear constraints in . Since satisfies the parallel constraint in for all coordinates and the partial equality check guarantees consistency between and on the coordinates , the corresponding parallel constraints in are satisfied as well.
Moreover, the variable set has size and the constraint set has size .
Now we construct from to satisfy Item (S4). The final variable set of will be , which is constructed along with the constraint set as follows.
-
•
Initialize as disjoint copies of and initialize . For a variable , we denote as its -copy and -copy in , respectively.
-
•
For each , we add an equality, which is a linear constraint with the identity matrix, in between and .
Note that this is consistent with Item (S4).
-
•
Then for each parallel constraint , we add the same constraint in on the -copies of and .
-
•
Finally for each linear constraint888In particular, can be or or . that checks , we add new variables to and to . Then we impose a linear constraint between them in , which is consistent with Item (S4). We further add two equality constraints, which are identified as parallel constraints in , between and , as well as between and .
The construction of preserves the satisfiability of as all the duplicates in of variables in are connected by identity constraints. Moreover, and as desired. ∎

6 PCPP for Multi-Test Problem
In this section we prove Theorem 4.14 for DoubleTest and Theorem 4.20 for SingleTest. For convenience, we define the following multi-test problem (MultiTest) which generalizes DoubleTest and SingleTest in a straightforward fashion.
Definition 6.1 (MultiTest).
Assume . -MultiTest is a pair language over consisting of all words in the form of , where
-
•
is a Boolean circuit with input bits and are codewords of ;
-
•
if we view as , parallel satisfies .
We define the input length to be the size of plus .
By setting or , we immediately obtain -SingleTest or -DoubleTest. Hence Theorem 4.20 and Theorem 4.14 follows directly from the following result for MultiTest.
Theorem 6.2 (PCPP for MultiTest).
Assume and . Assume is a positive integer. Then for any , -MultiTest has
an -PCPP verifer , |
where is the input length of -MultiTest and .
Proof sketch
Let be an input for -MultiTest. Our goal is to check whether is -close to some MultiTest, i.e., the restriction of the pair language MultiTest on . In other words, the following two conditions hold:
-
(C1)
for each , is the truth table of a polynomial of parallel degree ;
-
(C2)
, viewed as a word in , parallel satisfies the Boolean circuit .
To guarantee Item (C1), we use the PCPP verifier from the codeword testing of (see Theorem 3.6). Given satisfying Item (C1), we aim to test that it also satisfies Item (C2). That is, for each fixed , satisfies the Boolean circuit .
To this end, we will use the PCPP verifier of CktVal (see Theorem 3.13). This alone, however, is not sufficient as cannot rule out the case that changing fraction of entries in satisfying the circuit . To fix this issue, we have to exploit the fact that each is supposed to be the truth table of a degree- polynomial, which, by Schwartz-Zippel lemma and the fact that is a constant, forbids such attacks. As a result, we need to incorporate the codeword testing circuit (see Theorem 3.7) to enforce the low degree condition.
Unfortunately, this still does not work due to a subtle alphabet mismatch: the codeword testing works over but Item (C2) needs to flat as . Therefore, the distance guaranteed by the low degree condition can be dilated by a worst-case factor of after converting to , for which reason the mentioned attack can still be carried out. To address this issue, we employ a standard approach to lift the conversion of via error correcting codes [8, 4, 15]. More formally, after flattening as , we take it through an error correcting code with constant rate and distance, which produces a codeword in and, more importantly, has constant relative distance against other codewords.
In summary, to handle Item (C2), we need to use to check the validity of the combination of (1) the original circuit , (2) the codeword testing procedure, and (3) the error correcting lifting. This is parallel for each coordinate and is presented in Subsection 6.1. Then in Subsection 6.2, we put together the argument for Item (C1) and prove Theorem 6.2.
Remark 6.3.
One may wonder the necessity of using a separate codeword testing for Item (C1), as we anyway need to use it for Item (C2). The difference lies in the proximity: the former uses Theorem 3.6 which guarantees the parallel proximity (i.e., including all the dimensions ), whereas the latter uses Theorem 3.7 which only implies coordinate-wise proximity (i.e., individually for each coordinate ).
Without the former, we can only get an final proximity via a union bound. Upgrading the latter needs to generalize the construction of to the parallel setting, which arguably requires more work. Hence we stick to our current presentation for simplicity.
6.1 Single-Coordinate Checking Circuit
As sketched above, we construct another Boolean circuit for Item (C2), which augments the original circuit with an alphabet lifting via error correcting code and a low-degree check. Later, this single-coordinate checking circuit will be applied in parallel for every coordinate.
Lifted Flattening of
We will use the following standard error correcting code to achieve such an alphabet lifting.
Proposition 6.4 (Binary ECC with Constant Rate and Distance [27]).
For every , there exists an efficiently computable error correcting code with the encoding map of relative distance .
Let to be composed with the natural flattening of into . Let be the corresponding decoding function.
Later putting back into the construction of , we will apply to every entry of for every coordinate . For convenience, we define the parallel encoding map as
(5) |
where we view as a function and the index points to the lifted flattening of the -th entry of . Given the definition of , the lifted flattening of can be simply represented as .
The Construction of
Given the lifted flattening of alphabet, we now present the construction. The circuit takes as input where each is supposed to be for some . Note that will be , rolling over all coordinates . The circuit check the following three things in order:
-
(S1)
Check if each is a codeword of and, if so, compute each and view it as a binary string via the standard flattening of .
This requires to decode a total number of words in , which can be has circuit size .
-
(S2)
Check if each satisfies from Theorem 3.7, i.e., is the truth table of a degree- polynomial.
This has size by Theorem 3.7.
-
(S3)
Check whether satisfies the original circuit .
This has size precisely the size of .
Now we list properties of .
Fact 6.5 (Satisfiability).
If satisfies the circuit , then satisfies the circuit .
Fact 6.6 (Size).
Recall from Definition 6.1 that is the input length of -MultiTest, which equals the size of plus . The size of the circuit is at most and the input of has length .
Claim 6.7 (Distance).
If passes Items (S1) and (S2) but not Item (S3), then it is -far from solutions of .
Proof.
Let be an arbitrary solution of , which means it passes Items (S1), (S2) and (S3). Let be the decoding outcome from Item (S1). Then there exists such that . Since they both pass Item (S2), and , viewed as an element from , correspond to truth tables of distinct degree- polynomials. Hence by Schwartz-Zippel lemma and our assumption on . Recall from Equation 5 that applies entrywise. Since and , we now have by Proposition 6.4. Since , we have
as desired. ∎
6.2 Combining Codeword Testing
Now we are ready to combine the codeword testing for Item (C1) and the single-coordinate checking circuit for Item (C2) to prove Theorem 6.2.
Proof of Theorem 6.2.
The auxiliary proof for consists of two parts.
-
•
The first part is . Each has alphabet and is constructed by Theorem 3.6, which is supposed to be the auxillary proof for codeword testing of on .
-
•
The second part is denoted by , which has the alphabet naturally embedded into . For each coordinate , is constructed by Theorem 3.13 for to check if satisfies the circuit .
Testing Procedure of
Now we describe the testing procedure. executes one of the following two tests with equal probability.
-
•
For each , invokes to run the codeword testing for on . This checks whether .
-
•
parallel simulates to test if satisfies for all coordinates .
In detail, for each coordinate , tosses random coins as does, and probes entries of if needed. Whenever needs to probe some bit of , queries the corresponding entry (i.e., the index in Equation 5) of , performs the lifted flattening of for that entry, and obtains the desired bit.
We emphasize that the randomness used to simulate is the same for all coordinates. Therefore, the queries by are simulated in parallel for all coordinates , as the query locations are uniquely determined by the randomness.
Parameters of
Since is a constant and both have constant queries (see Theorem 3.6 and Theorem 3.13), makes constant queries.
Recall that the input length equals the size of plus . By Theorem 3.6, the first part tosses
coins, where we used the assumption on . By Theorem 3.13 and Fact 6.6, the second part tosses
coins. Since we only execute one of them, the number of random coins is the maximum of the above two as desired.
Completeness and Soundness
The completeness is straightforward by the completeness of (see Theorem 3.6) and (see Theorem 3.13) and the construction of (see Subsection 6.1). We focus on the soundness analysis: assuming that is -far from MultiTest (i.e., we do not have Items (C1) and (C2)), rejects with probability . By modifying the hidden constant in and noticing that -far implies -far for any , we additionally assume .
Assume towards contradiction that the above soundness statement is false. We first show that each is close to being parallel degree-. This comes from the following Fact 6.8, which can be deduced directly from Theorem 3.6.
Fact 6.8.
If for some , is -far from , then rejects with probability .
Now we assume each is -close to some , which corresponds to Item (C1). Next, we show parallel satisfies , which corresponds to Item (C2). By Fact 6.5, it suffices to show for each coordinate that satisfies , which is precisely the following Claim 6.9.
Claim 6.9.
For each coordinate , satisfies Items (S1), (S2) and (S3).
Given Claim 6.9, we arrive at a contradiction and complete the soundness analysis. ∎
Finally we prove Claim 6.9.
Proof of Claim 6.9.
Note that Item (S1) is already satisfied. Since each , each is the truth table of a degree- polynomial, which means Item (S2) is also satisfied. If Item (S3) is false for some , then by Claim 6.7, is -far from any solution of . Observe that
(since is relative distance) | ||||
(by the choice of ) |
Since , we know that is -far from solutions of . By Theorem 3.13, this means , which executes with half probability, rejects with probability . Recall that we assumed that does not reject with probability , which is a contradiction. Thus Item (S3) should also be satisfied and this completes the proof of Claim 6.9. ∎
Acknowledgement
We thank Eli Ben-Sasson for clarifying questions regarding [9] and thank Karthik C.S. for pointing out the application to Max -Coverage (Theorem 1.6).
References
- AB [09] Sanjeev Arora and Boaz Barak. Computational Complexity: A Modern Approach. Cambridge University Press, USA, 1st edition, 2009.
- ABSS [97] Sanjeev Arora, László Babai, Jacques Stern, and Z. Sweedyk. The hardness of approximate optima in lattices, codes, and systems of linear equations. J. Comput. Syst. Sci., 54(2):317–331, 1997.
- AFWZ [95] Noga Alon, Uriel Feige, Avi Wigderson, and David Zuckerman. Derandomized graph products. Comput. Complex., 5(1):60–75, 1995.
- ALM+ [01] Sanjeev Arora, Carsten Lund, Rajeev Motwani, Madhu Sudan, and Mario Szegedy. Proof verification and the hardness of approximation problems. Journal of the ACM (JACM), 45:501–555, 09 2001.
- App [17] Benny Applebaum. Exponentially-hard gap-csp and local prg via local hardcore functions. In 2017 IEEE 58th Annual Symposium on Foundations of Computer Science (FOCS), pages 836–847, 2017.
- AR [94] Noga Alon and Yuval Roichman. Random Cayley graphs and expanders. Random Structures & Algorithms, 5(2):271–284, 1994.
- BEKP [13] Edouard Bonnet, Bruno Escoffier, Eun Jung Kim, and Vangelis Th. Paschos. On subexponential and fpt-time inapproximability. In Gregory Gutin and Stefan Szeider, editors, Parameterized and Exact Computation, pages 54–65, Cham, 2013. Springer International Publishing.
- BGH+ [06] Eli Ben-Sasson, Oded Goldreich, Prahladh Harsha, Madhu Sudan, and Salil Vadhan. Robust PCPs of proximity, shorter PCPs, and applications to coding. SIAM Journal on Computing, 36(4):889–974, 2006.
- BSSVW [03] Eli Ben-Sasson, Madhu Sudan, Salil Vadhan, and Avi Wigderson. Randomness-efficient low degree tests and short pcps via epsilon-biased sets. In Proceedings of the Thirty-Fifth Annual ACM Symposium on Theory of Computing, STOC ’03, page 612–621, New York, NY, USA, 2003. Association for Computing Machinery.
- CAGK+ [19] Vincent Cohen-Addad, Anupam Gupta, Amit Kumar, Euiwoong Lee, and Jason Li. Tight FPT Approximations for k-Median and k-Means. In Christel Baier, Ioannis Chatzigiannakis, Paola Flocchini, and Stefano Leonardi, editors, 46th International Colloquium on Automata, Languages, and Programming (ICALP 2019), volume 132 of Leibniz International Proceedings in Informatics (LIPIcs), pages 42:1–42:14, Dagstuhl, Germany, 2019. Schloss Dagstuhl – Leibniz-Zentrum für Informatik.
- CCK+ [17] Parinya Chalermsook, Marek Cygan, Guy Kortsarz, Bundit Laekhanukit, Pasin Manurangsi, Danupon Nanongkai, and Luca Trevisan. From gap-ETH to FPT-inapproximability: Clique, dominating set, and more. In Chris Umans, editor, 58th IEEE Annual Symposium on Foundations of Computer Science, FOCS 2017, Berkeley, CA, USA, October 15-17, 2017, pages 743–754. IEEE Computer Society, 2017.
- CFG+ [16] Marek Cygan, Fedor V. Fomin, Alexander Golovnev, Alexander S. Kulikov, Ivan Mihajlin, Jakub Pachocki, and Arkadiusz Socala. Tight bounds for graph homomorphism and subgraph isomorphism. In Robert Krauthgamer, editor, Proceedings of the Twenty-Seventh Annual ACM-SIAM Symposium on Discrete Algorithms, SODA 2016, Arlington, VA, USA, January 10-12, 2016, pages 1643–1649. SIAM, 2016.
- CFLL [23] Yijia Chen, Yi Feng, Bundit Laekhanukit, and Yanlin Liu. Simple combinatorial construction of the k-lower bound for approximating the parameterized k-clique. CoRR, abs/2304.07516, 2023.
- CHKX [06] Jianer Chen, Xiuzhen Huang, Iyad A. Kanj, and Ge Xia. Strong computational lower bounds via parameterized complexity. J. Comput. Syst. Sci., 72(8):1346–1367, 2006.
- Din [07] Irit Dinur. The PCP theorem by gap amplification. J. ACM, 54(3):12–es, jun 2007.
- Fei [98] Uriel Feige. A threshold of for approximating set cover. Journal of the ACM (JACM), 45(4):634–652, 1998.
- FG [06] Jörg Flum and Martin Grohe. Parameterized Complexity Theory. Texts in Theoretical Computer Science. An EATCS Series. Springer, 2006.
- FGL+ [96] Uriel Feige, Shafi Goldwasser, László Lovász, Shmuel Safra, and Mario Szegedy. Interactive proofs and the hardness of approximating cliques. J. ACM, 43(2):268–292, 1996.
- FS [95] Katalin Friedl and Madhu Sudan. Some improvements to total degree tests. In Proceedings Third Israel Symposium on the Theory of Computing and Systems, pages 190–198. IEEE, 1995.
- FSLM [20] Andreas Emil Feldmann, Karthik C. S., Euiwoong Lee, and Pasin Manurangsi. A survey on approximation in parameterized complexity: Hardness and algorithms. Algorithms, 13(6), 2020.
- GLR+ [23] Venkatesan Guruswami, Bingkai Lin, Xuandi Ren, Yican Sun, and Kewen Wu. Parameterized inapproximability hypothesis under ETH. CoRR, abs/2311.16587, 2023.
- GRS [23] Venkatesan Guruswami, Xuandi Ren, and Sai Sandeep. Baby PIH: Parameterized inapproximability of Min CSP. arXiv preprint arXiv:2310.16344, 2023.
- Hoc [97] Dorit S. Hochbaum. Approximation algorithms for NP-hard problems. SIGACT News, 28(2):40–52, jun 1997.
- IP [01] Russell Impagliazzo and Ramamohan Paturi. On the complexity of k-SAT. Journal of Computer and System Sciences, 62:367–375, 2001.
- IPZ [01] Russell Impagliazzo, Ramamohan Paturi, and Francis Zane. Which problems have strongly exponential complexity? Journal of Computer and System Sciences, 63(4):512–530, 2001.
- JM [21] Akhil Jalan and Dana Moshkovitz. Near-optimal Cayley expanders for abelian groups. In 41st IARCS Annual Conference on Foundations of Software Technology and Theoretical Computer Science, 2021.
- Jus [72] Jørn Justesen. Class of constructive asymptotically good algebraic codes. IEEE Trans. Inf. Theory, 18:652–656, 1972.
- KK [22] Karthik C. S. and Subhash Khot. Almost polynomial factor inapproximability for parameterized k-clique. In Shachar Lovett, editor, 37th Computational Complexity Conference, CCC 2022, July 20-23, 2022, Philadelphia, PA, USA, volume 234 of LIPIcs, pages 6:1–6:21. Schloss Dagstuhl - Leibniz-Zentrum für Informatik, 2022.
- KMPS [23] Karthik C. S., Dániel Marx, Marcin Pilipczuk, and Uéverton S. Souza. Conditional lower bounds for sparse parameterized 2-CSP: A streamlined proof. CoRR, abs/2311.05913, 2023.
- KT [00] Jonathan Katz and Luca Trevisan. On the efficiency of local decoding procedures for error-correcting codes. In Proceedings of the Thirty-Second Annual ACM Symposium on Theory of Computing, STOC ’00, page 80–86, New York, NY, USA, 2000. Association for Computing Machinery.
- Lin [21] Bingkai Lin. Constant approximating -clique is W[1]-hard. In Samir Khuller and Virginia Vassilevska Williams, editors, STOC ’21: 53rd Annual ACM SIGACT Symposium on Theory of Computing, Virtual Event, Italy, June 21-25, 2021, pages 1749–1756. ACM, 2021.
- LRSW [22] Bingkai Lin, Xuandi Ren, Yican Sun, and Xiuhan Wang. On lower bounds of approximating parameterized k-clique. In Mikolaj Bojanczyk, Emanuela Merelli, and David P. Woodruff, editors, 49th International Colloquium on Automata, Languages, and Programming, ICALP 2022, July 4-8, 2022, Paris, France, volume 229 of LIPIcs, pages 90:1–90:18. Schloss Dagstuhl - Leibniz-Zentrum für Informatik, 2022.
- LRSW [23] Bingkai Lin, Xuandi Ren, Yican Sun, and Xiuhan Wang. Improved hardness of approximating k-clique under ETH. In 64th IEEE Annual Symposium on Foundations of Computer Science, FOCS 2023, Santa Cruz, CA, USA, November 6-9, 2023, pages 285–306. IEEE, 2023.
- LRSZ [20] Daniel Lokshtanov, M. S. Ramanujan, Saket Saurabh, and Meirav Zehavi. Parameterized complexity and approximability of directed odd cycle transversal. In Shuchi Chawla, editor, Proceedings of the 2020 ACM-SIAM Symposium on Discrete Algorithms, SODA 2020, Salt Lake City, UT, USA, January 5-8, 2020, pages 2181–2200. SIAM, 2020.
- Man [20] Pasin Manurangsi. Tight running time lower bounds for strong inapproximability of maximum -coverage, unique set cover and related problems (via -wise agreement testing theorem). In Proceedings of the Fourteenth Annual ACM-SIAM Symposium on Discrete Algorithms, pages 62–81. SIAM, 2020.
- Mar [10] Dániel Marx. Can you beat treewidth? Theory Comput., 6(1):85–112, 2010.
- PS [94] Alexander Polishchuk and Daniel A Spielman. Nearly-linear size holographic proofs. In Proceedings of the twenty-sixth annual ACM symposium on Theory of computing, pages 194–203, 1994.
- Rao [11] Anup Rao. Parallel repetition in projection games and a concentration bound. SIAM Journal on Computing, 40(6):1871–1891, 2011.
- RS [96] Ronitt Rubinfeld and Madhu Sudan. Robust characterizations of polynomials with applications to program testing. SIAM Journal on Computing, 25(2):252–271, 1996.
- Sch [80] J. T. Schwartz. Fast probabilistic algorithms for verification of polynomial identities. J. ACM, 27(4):701–717, oct 1980.
Appendix A Derandomized Parallel Low Degree Test
In this section, we design a derandomized parallel low degree test to prove Theorem 3.6 and Theorem 3.7. This is obtained by combining the derandomized low degree test [9, Theorem 4.1] with the parallel low degree test [33, Lemma 7.7], where the latter builds on [19]. While the combination is standard, we decide to expand the proof sketch in [9] to a full proof for completeness.
Theorem (Theorem 3.6 Restated).
Assume and . Let be the set of univariate degree- polynomials over . There exists an efficient verifier with the following properties.
-
•
The input of is , where is supposed to be a codeword of and is the auxiliary proof.
-
•
tosses unbiased coins and makes queries on .
-
•
If , then there exists some such that always accepts.
-
•
If is -far from , then for any .
Theorem (Theorem 3.7 Restated).
Assume and . There exists a Boolean circuit of size for , where we encode as , such that is codeword of iff parallel satisfies .
A.1 Extra Notation
We first set up some necessary notation.
Parallel Low Degree Polynoimal
We first recall the notion of parallel polynomial from Section 3. Let be a finite field. For a parallel-output function , we denote as its single-output components, i.e., . We aim to test if are consistent with degree- polynomials on a large common set of inputs. Formally, we say is -close to parallel degree- iff is -close to ; and we say is parallel degree- if .
A simple union bound shows that if each is -close to degree- (e.g., from the standard low degree test), then is -close to parallel degree-. However for our purposes, such a loss is not affordable since is typically large. Therefore we need to open-box the specific low degree test and show that it implies consistency on common fraction of inputs simultaneously for all .
Parallel Low Degree Test
For , the line crossing in direction is the set
Note that if then , otherwise has points. Let be the set of lines in . For a parallel function and any , we use to denote the restriction of on the line .
Let be the set of univariate parallel degree- polynomials, i.e.,
The standard low degree test [39], translated to the parallel setting [33], is given oracle access to and , which later tests their consistency999The term consistency has been called correlated agreement, e.g., in recent literature of proximity gaps for RS codes and related literature in FRI protocol/SNARKs.. For each line , we denote as its parallel line polynomial, which we interpret as a univariate parallel degree- polynomial mapping elements in to . Thus for a line and a point , is well defined. We say agrees with on if .
For each and , we use to denote the restriction of on each line to its closest parallel degree- polynomial. That is, for each line , we set to be the parallel degree- polynomial closest to , where we break tie arbitrarily. Note that we will always assume the degree to be tested is , and thus we omit in defining for simplicity.
In the completeness case (i.e., is indeed parallel degree-), we can pick which is also parallel degree-. The parallel low degree test explores the reverse direction: independently select and accept iff , i.e., agrees with the parallel line polynomial on point . The parallel low degree test [33] shows that if accepts with probability , then is -close to parallel degree-. Note that this bound does not depend on .
Derandomized Parallel Low Degree Test
Now we introduce the derandomized version of the parallel low degree test. Following [9], this simply replaces the uniformly random direction by a pseudorandom for a much smaller set . Hence the number of randomness drops from to .
Definition A.1 (Derandomized Parallel Low Degree Test).
Let and .101010Technically, only needs to be defined on lines whose directions are in . We choose to assume is defined over all lines for simplicity. The derandomized parallel low degree test is executed as follows: independently select and , then accept iff .
Later the set is chosen to be a -biased set as in [9].
Definition A.2 (-Biased Set).
is a -biased set iff
-
•
is symmetric, i.e., if then ;111111In some literature this symmetric assumption is not imposed. The parameter in that case is comparable with the one here by a multiplicative factor of .
-
•
holds for any non-trivial homomorphism121212This homomorphism is usually referred as character. It is trivial if it maps everything to . An illustrative example is when and is a parity function. , where is the multiplicative group of -th unit root and is the characteristic of .
In a graph theoretical reformulation, is -biased iff the graph is an (undirected) expander graph with expansion factor , where the vertex set of is and is connected iff (see e.g., [26]). For our purposes, we quote the following results derived directly from the expanding property of biased sets.
Lemma A.3 ([9, Lemma 4.3]).
Suppose is -biased. Then for any of density and any , we have
Finally we remark that -biased sets exist for [6] and efficient explicit constructions of sizes are also obtained.
Fact A.4 (See e.g., [26]).
For any finite field , positive integer , and parameter , a -biased set of size can be constructed efficiently in time .
Augmented Derandomized Parallel Low Degree Test
Unfortunately the derandomized parallel low degree test is not sufficient to guarantee the exact quantitative degree condition, as the directions have fairly limited possibilities. More concretely, even if succeeds with probability , it is not guaranteed that is parallel degree-. To compensate the missing directions, we need to augment Definition A.1 with an additional test that checks the consistency of and on a purely random direction from the origin [9].
Definition A.5 (Augmented Derandomized Parallel Low Degree Test).
Let and . The augmented derandomized parallel low degree test is executed as follows: with equal probability we perform one of the following two tests:
-
•
Independently select and , then accept iff .
-
•
Select , then accept iff .
The first test in is simply , for which we will later show that it guarantees that is close to parallel degree-. Then the second test allows us to further bring the degree down to .
A.2 Codeword Testing
Theorem 3.6 and Theorem 3.7 follow directly from the following result, combined with the explicit constructions for biased sets.
Theorem A.6.
Assume , , and . Let be a -biased set. If
then is -close to parallel degree-.
Proof of Theorem 3.6.
We first note that and are satisfied assuming the conditions on in Theorem 3.6, thus is well defined.
Then we instantiate Theorem A.6 with and the -biased set by Fact A.4. The construction of is efficient in time and has size . Then we define as where and is defined to be the entries of that can be possibly queried. Recall Definition A.5. Then we have
In addition, by merging the randomness of the two tests in , tosses
total coins. The completeness is obvious and the soundness follows from Theorem A.6. ∎
Proof of Theorem 3.7.
Now we turn to Theorem 3.7. By Theorem 3.6, it suffices to implement purely on . In addition, since and by Definition A.5, it performs the same check in parallel for each coordinate . This means that we only need to instantiate for a single coordinate (or equivalently, think of ) to design the circuit .
To get rid of the extra proof , we simply set . Then, whenever we need information about entries in (i.e., a line polynomial), we can probe the entries along the line in to compute it. We remark that this is inefficient in terms of the query complexity, but it is still efficient in terms of the circuit complexity.
Now we describe the construction of for a fixed coordinate . Based on the coin toss of , it checks the consistency of an -valued point (i.e., or ) with an evaluation point (i.e., or ) of a degree- line polynomial over (i.e., or ). To implement it as a circuit, we take the conjunction of all the sub-circuit outcome from coin toss possibilities, where each sub-circuit performs the following computation.
-
•
It first interpolates the line polynomial using entries of along the line, and checks if this line polynomial is degree-.
This can be efficiently done with gates.
-
•
Then it evaluates the value of the desired point of the line polynomial, and checks if it is the same as the one directly obtained from .
This also requires gates only.
The correctness of follows directly from Theorem 3.6 and our choice of . Since the number of coin toss possibilities is , by our assumption on , the size of is as claimed. ∎
To prove the statement about , we need to analyze first, which guarantees a weaker degree bound.
Theorem A.7.
Assume , , and . Let be a -biased set. If
then is -close to parallel degree-.
Assuming Theorem A.7, we conclude the proof of Theorem A.6.
Proof of Theorem A.6.
First we assume since otherwise and the statement trivially holds. Recall Definition A.5 that executes with probability . Hence must accept with probability at least . By Theorem A.7, this means that is -close to a parallel degree- polynomial . It suffices to show that is acutally parallel degree-.
Assume towards contradiction that is not parallel degree-. Now we consider the second half of , which checks if for . Then we have
(6) |
To analyze Equation 6, we consider the following quantity:
(7) |
On the one hand, conditioned on , we have and being uniform in . Therefore we can relate Equation 6 with Equation 7:
(8) |
On the other hand, conditioned on , is a univariate parallel degree- polynomial in . Let be the parallel degree of . Then the coefficient of in is a non-zero parallel degree- polynomial. By Schwartz–Zippel lemma, it vanishes on at most fraction of choices of . For each that the top coefficient of does not vanish, by Schwartz–Zippel lemma, agrees with on at most choices of since is parallel degree- and . This means
Equation 7 | ||||
(since ) |
Combining this with Equation 8 and Equation 6, we have
where we used the fact that and . Since this is half of the actual , it means
which is a contradiction.
In conclusion, must be parallel degree-. ∎
Our Theorem A.7 is the parallel version of [9, Theorem 4.1]. Its proof follows from iteratively applying the following lemma, which is the parallel version of [9, Lemma 4.4].
Lemma A.8.
Assume . Let be a -biased set and of size . Let . If
then for any , there exists and with the following properties:
-
1.
.
-
2.
.
-
3.
.
Assuming Lemma A.8, we first conclude Theorem A.7.
Proof of Theorem A.7.
First we assume since otherwise and the statement trivially holds. Next, we can also assume without loss of generality that . This is because, for each possible131313A line is possible in if its direction lies in . line , conditioned on this line checks a uniformly random point whether . Since is parallel degree-, the success probability maximized when .
We will repeatedly apply Lemma A.8 to bring the soundness gap down to , at which point it is actually zero by granularity. Then we use the following characterization of parallel low degree polynomials similar to [39] to arrive at an actual parallel degree- polynomial.
Theorem A.9.
Let be a -biased set and of size . Then is parallel degree- if is parallel degree- for every .
Lemma A.8 will be proved in Subsection A.4. Now we focus on reducing the soundness gap.
The Case
In this case, we first perform a pre-processing round to bring down the soundness gap. By Lemma A.8 with and , we have and with the following property:
-
1.
, since .
-
2.
.
-
3.
, since and .
Now define
For each , we apply Lemma A.8 on and obtain . To show the correctness of this process, we verify by induction on that the conditions in Lemma A.8 are satisfied, i.e.,141414In Lemma A.8 we only require . Here we strengthen it for convenience of Theorem A.9.
(9) |
where we omit since it holds by the definition of .
The base case is valid by Item 1 and Item 3. For the inductive cases , we first observe that the first condition in Equation 9 follows from the following calculation:
(by Lemma A.8) | ||||
(by Lemma A.8 iteratively) | ||||
(by Item 1) | ||||
(since ) |
The second condition in Equation 9 follows from last round of Lemma A.8, which establishes that
Let . Then the above analysis shows
Since samples and then perform a deterministic check whether , its accepting probability is an integer multiple of . Therefore, we actually have , which means that is parallel degree- on for all . By Theorem A.9, this means that is parallel degree-. In addition, its distance from the original is
(by Item 2) | ||||
(by Lemma A.8) | ||||
(since ) |
The Case
In this case, the analysis is even simpler as we do not need pre-processing. Let and . Define
We also apply Lemma A.8 for each on to obtain . The conditions in Lemma A.8 along this process can be verified in the similar fashion. Here we only highlight the difference: for the second condition, we have
and for the third condition, we have
Then similarly, we set and obtain as a parallel degree- polynomial. Moreover, we have
(since and by Lemma A.8) | ||||
which completes the proof. ∎
A.3 One Round of Correction
Lemma (Lemma A.8 Restated).
Assume . Let be a -biased set and of size . Let . If
then for any , there exists and with the following properties:
-
1.
.
-
2.
.
-
3.
.
Proof.
Let be the set of directions such that for at least fraction of , agrees with the parallel line polynomial on . That is,
(10) |
Then
(by assumption) | ||||
(by Definition A.1) | ||||
(by Equation 10) |
which implies Item 1 by rearranging.
To construct , for each we define to be the most common value of over where we break tie arbitrarily. Now we verify Item 2. Let
By the definition of , we know that holds for any . Hence Item 2 reduces to showing as follows:
(by Markov’s inequality) | ||||
(since ) | ||||
(by assumption) | ||||
(by Item 1) |
To prove Item 3, we first get rid of . For a fixed and each , let be the set of directions such that . Denote , which is defined to be the most common value of over . Thus for any . As a result, we have
(since ’s form a partition of ) | ||||
(since for all ) | ||||
Now taking the negation and the expectation over random , we have
(11) |
To upper bound Equation 11, we will use bivariate testing theorems [37] similar to [33, 19]. The idea is, as sketched in [9], to use Lemma A.3 to show the following claim.
Claim A.10.
With probability at least
over , we have
-
(a)
.
-
(b)
.
-
(c)
.
-
(d)
.
Claim A.10 intuitively says that is almost parallel degree- along the line (Item (a)), the line (Item (b)), and the plane spanned by (Items (c) and (d)). For simplicity, define
(12) |
Given Claim A.10 and Equation 11, it suffices to show
(13) |
Observe that is a parallel bivariate polynomial. Recall that is the restriction of on each line of its closest parallel degree- polynomial. Thus for each fixed , is parallel degree- in the variable . Let be the single-output components of . Then for each and in , the variable has degree at most and the variable has degree at most . We say is of parallel degree for shorthand. Similarly, is of parallel degree .
Combining Items (c) and (d), we have
(14) |
We will use the following lemma to zero out the inconsistent entries of and .
Lemma A.11 ([37, Lemma 3]).
Let be arbitrary. There exists a non-zero bivariate polynomial of degree such that for all .
By setting to be the set of with , we have by Equation 14. Thus by Lemma A.11, there is a non-zero bivariate polynomial of degree at most such that holds for all . Note that and are polynomials with outputs and has single output. The product produces a vector of length with entries of scaled by ; same for .
Then we use the following lemma to show that and are close to a parallel bivariate polynomial of parallel degree .
Lemma A.12 ([37, Lemma 8]).
Let be bivariate polynomials of degree and respectively. Assume . Assume further there exist distinct such that divides for all , and distinct such that divides for all . Then divides , i.e., there exists a bivariate polynomial of degree such that holds for all .
Fix an arbitrary . For each , define , which also equals since . Since is non-zero and has degree , there are at least many distinct such that is an univariate polynomial not identically zero, for which divides ; same for and . By Lemma A.12 with and , there exists a bivariate polynomial with parallel degree such that holds for all , where we used the fact that implies .151515If , then ; otherwise .
Let be the parallel-output bivariate polynomial with single-output components obtained above. Then holds as long as is not identically zero, which has at least possibilities out of total choices off . Recall Item (a). For at least fraction of ’s, we have . Note that the distance between any two distinct (parallel) degree- polynomial is at least , which is at least since . In addition, is parallel degree-. Thus is the closest parallel degree- polynomial of , i.e., holds for all where we recall Equation 12. In particular, this means .
Similarly, using Item (b), we can show , which verifies Equation 13 and thus Item 3, and completes the proof of Lemma A.8. ∎
Finally it remains to prove Claim A.10.
Proof of Claim A.10.
We show that each item holds with probability at least , and then Claim A.10 follows from a union bound.
We first consider Item (a) and the analysis for Item (b) is almost identical. For each , define
Then for any fixed , we have by Equation 10, and, moreover,
(since and by assumption) | ||||
(since ) | ||||
(by assumption and Item 1) | ||||
(by Lemma A.3) | ||||
(since ) |
By taking the expectation over , Item (a) holds with the desired probability.
Now we consider Item (c) and the analysis for Item (d) is almost identical. For each , define
(15) |
For each , we have
(by Markov’s inequality) | ||||
(since ) | ||||
(16) |
and
(17) |
where we use the following reasoning for the last inequality: if the event inside bracket does not happen, then
(by Equation 15) |
Then similar to the analysis for Item (a), we continue upper bounding Equation 17 as follows:
RHS of Equation 17 | ||||
(by Equation 16 and ) | ||||
(since and ) | ||||
(by Lemma A.3 and Equation 16) |
Therefore Item (c) holds with the desired probabilit by taking the expectation over . ∎
A.4 Derandomized Characterizations of Parallel Low Degree Polynomials
In this part, we extend the characterization of low degree polynomials in [39] to the derandomized setting, where we only consider lines with directions generated by a (large subset of) small-biased set.
We use superscript to denote vector and matrix transpose. For two vectors , we use to denote their inner product which equals (or ).
Theorem (Theorem A.9 Restated).
Let be a -biased set and of size . Then is parallel degree- if is parallel degree- for every .
Proof.
Assume without loss of generality that , since we can apply the analysis individually for each single-output component .
We first prove that has the full rank . Assume towards contradiction that has rank at most . Then there exists a non-zero vector such that holds for all . In light of Definition A.2, we construct a non-trivial homomorphism to derive a contradiction, where is the characteristic of . Let be a non-trivial (group) homomorphism, where we view as an additive group. We define for each that
which is a non-trivial homomorphism since is a non-trivial homomorphism and . Note that for all , we have
Thus
(since ) |
which contradicts Definition A.2.
Now we fix a set of linearly independent directions . Then we can interpolate using degree- polynomials for . For concreteness, we apply the invertible linear transform on such that map to axis parallel directions , where . Let be the polynomial after this transform, which shares the same degree with since the transform is invertible and linear. Since are all degree-, we know that is degree- along the axis parallel lines. Then by polynomial interpolation (see e.g., [39, Lemma 28]), has degree at most , which in turn means that has degree at most as claimed. ∎