Abstract 1 Introduction 2 Proof Overview 3 Preliminaries 4 From Planted CSPs to Noisy 𝒌-XOR 5 Solving Noisy 𝒌-XOR References

Solving Random Planted CSPs Below the nk/2 Threshold

Arpon Basu ORCID Princeton University, NJ, USA    Jun-Ting Hsieh ORCID MIT, Cambridge, MA, USA    Andrew D. Lin ORCID Princeton University, NJ, USA    Peter Manohar ORCID The Institute for Advanced Study, Princeton, NJ, USA
Abstract

We present a family of algorithms to solve random planted instances of any k-ary Boolean constraint satisfaction problem (CSP). A randomly planted instance of a Boolean CSP is generated by (1) choosing an arbitrary planted assignment x, and then (2) sampling constraints from a particular “planting distribution” designed so that x will satisfy every constraint. Given an n variable instance of a k-ary Boolean CSP with m constraints, our algorithm runs in time nO() for a choice of a parameter , and succeeds in outputting a satisfying assignment if mO(n)(n/)k21logn. This generalizes the poly(n)-time algorithm of [17], the case of =O(1), to larger runtimes, and matches the constraint number vs. runtime trade-off established for refuting random CSPs by [34].

Our algorithm is conceptually different from the recent algorithm of [23], which gave a poly(n)-time algorithm to solve semirandom CSPs with mO~(nk2) constraints by exploiting conditions that allow a basic SDP to recover the planted assignment x exactly. Instead, we forego certificates of uniqueness and recover x in two steps: we first use a degree-O() Sum-of-Squares SDP to find some x^ that is o(1)-close to x, and then we use a second rounding procedure to recover x from x^.

Keywords and phrases:
Random CSPs, Sparse Learning Parity with Noise
Category:
Track A: Algorithms, Complexity and Games
Funding:
Arpon Basu: This material is based upon work supported by the Moskewicz Venture Forward Graduate Fellowship and NSF CAREER Award #2047933.
Jun-Ting Hsieh: This material is based upon work supported by NSF CAREER Award #2047933.
Andrew D. Lin: This material is based upon work supported by Princeton AI Lab Seed Grant.
Peter Manohar: This material is based upon work supported by NSF Grant No. DMS-1926686
Copyright and License:
[Uncaptioned image] © Arpon Basu, Jun-Ting Hsieh, Andrew D. Lin, and Peter Manohar; licensed under Creative Commons License CC-BY 4.0
2012 ACM Subject Classification:
Mathematics of computing Probabilistic algorithms
Related Version:
Full Version: https://arxiv.org/abs/2507.10833
Editors:
Sayan Bhattacharya, Danupon Nanongkai, Michael Benedikt, and Gabriele Puppis

1 Introduction

Constraint satisfaction problems (CSPs) such as k-SAT are a foundational class of computational problems that are notoriously hard in the worst case. After several decades, results on hardness of approximation show that, assuming 𝖯𝖭𝖯, no polynomial-time algorithm can perform much better than a naive algorithm that simply returns a random assignment when the instance is sparse: namely, it has m=O(n) constraints where n is the number of variables [25]. While there are efficient algorithms for “maximally dense” instances with mΩ(nk) constraints [6], it is not possible to outperform a random assignment if the instance has m=o(nk) constraints [20], assuming the Exponential-Time Hypothesis (ETH) [28]. More generally, under ETH, it is not possible for an algorithm running in time 2nδ to outperform a random assignment if the instance has m=o(nkδ) constraints [20].

Given such strong hardness results, it is natural to study the average-case search problem of solving random CSPs, where it might be possible to design substantially better algorithms than in the worst case. Although a fully random CSP (i.e., each constraint is drawn uniformly at random from all possible constraints) with mn constraints is unsatisfiable with high probability, one can define fairly natural models of random planted CSPs, where the instance is sampled from a “highly random” distribution but is still guaranteed to have a particular satisfying assignment x.111Intuitively, one should view this distribution as first choosing an assignment x to be the planted assignment, and then drawing m constraints at random conditioned on each one being satisfied by x. As it turns out, using such a naive process actually makes recovering x rather straightforward; e.g., in the case of k-SAT, the aforementioned distribution will have the negation signs associated to any variable i[n] be biased towards the sign of xi, and thus a simple majority “poll” for each variable reveals the value of x with high probability. Because of this, one has to choose the random constraints a bit more carefully. See Definition 2 for the formal definition of the model. This task of solving a random planted CSP has received much attention in prior works [10, 29, 12, 14, 17], with the work of [17] giving an algorithm that runs in time poly(n) and succeeds in solving the random planted CSP if mO~(nk/2), which is far lower than the m=o(nk1) threshold for which 2n1o(1)-time hardness is known under ETH [20]. Besides hoping to understand the complexity of CSPs better, many of these works were also motivated by the connection to Goldreich’s pseudorandom generator [22], the security of which boils down to distinguishing a random planted CSP from a fully random CSP. For example, the work of [17] implies that one can efficiently invert Goldreich’s PRG if the PRG is k-local and has stretch larger than O~(nk/2).

In addition to the above average-case search problem, there is another fairly natural average-case problem for CSPs that has also received a lot of attention: refutation. In this problem, one is given a fully random CSP (which is unsatisfiable with high probability) and the algorithmic goal is to find a certificate of unsatisfiability. The refutation problem has received considerable attention over the past two decades [21, 15, 3, 8, 34], culminating in the work of [34], which gives an algorithm that, for a choice of a parameter , runs in nO() time and succeeds in refuting a random CSP with high probability provided that it has at least mO~(n)(n/)k/21 constraints. That is, they establish a trade-off between the runtime and number of constraints required for refutation: as the “runtime exponent” varies from O(1) to n, the number of constraints required varies from O~(nk/2) to O~(n). In particular, for the choice of =O(1), this algorithm runs in poly(n) time and succeeds in refuting a random instance if it has at least mO~(nk/2) constraints, the same threshold as in [17]. This runtime vs. number of constraints trade-off established by [34] is conjectured to be optimal, with evidence coming in the form of lower bounds against restricted computational models such as the Sum-of-Squares (SoS) SDP hierarchy [16, 11, 33, 32, 7, 30, 18].

In light of the runtime vs. number of constraints trade-off established by [34] for the refutation problem, one may wonder if it is possible to get an algorithm with similar performance for the search problem, i.e., for random planted CSPs. While there has been a flurry of recent work on understanding refutation and search for the “harder” semirandom and smoothed CSPs [1, 24, 27, 23], there is still no known algorithm for solving random planted CSPs at the same runtime vs. number of constraints trade-off established by [34] for the refutation problem – in time nO() with O~(n)(n/)k/21 constraints. While there has been some recent work on designing superpolynomial-time algorithms by [13], the runtime vs. number of constraints trade-off obtained is far from the conjectured optimal one.222For example, the algorithm of [13] always requires at least Ω(n2) constraints, regardless of the runtime.

1.1 Our results

As our main result, we give, for any choice of a parameter , an algorithm running in time nO() that succeeds in outputting a satisfying assignment to a random planted k-ary CSP with high probability provided that the CSP has at least mO~(n)(n/)k/21 constraints. That is, we resolve the aforementioned gap and give an algorithm with the “correct” trade-off matching the trade-off that is known for the refutation case. Similar to [17], we can also achieve a much better dependence on m by replacing k with r in the above expression in the case that the k-ary CSP has “complexity” r rather than k.

Before we formally state our results, we will first formally define the random planted CSP model, as done in [17].

Definition 1 (k-ary Boolean CSPs).

A CSP instance Ψ with a k-ary predicate P:{1,1}k{0,1} is a set of m constraints on variables x1,,xn of the form

P(𝗇𝖾𝗀(C)1xi1,𝗇𝖾𝗀(C)2xi2,,𝗇𝖾𝗀(C)kxik)=1,

where C=(i1,,ik)[n]k ranges over a collection of scopes333We additionally allow to be a multiset, i.e., that multiple clauses can contain the same ordered tuple of variables. (a.k.a. clause structure) of k-tuples of n variables and 𝗇𝖾𝗀(C){1,1}k are “literal negations”, one for each C in . We let valΨ(x) denote the fraction of constraints satisfied by an assignment x{1,1}n, and we define the value of Ψ, val(Ψ), to be maxx{1,1}nvalΨ(x).

Definition 2 (Random planted k-ary Boolean CSPs).

Let P:{1,1}k{0,1} be a predicate. We say that a distribution 𝒬 over {1,1}k is a planting distribution for P if Pry𝒬[P(y)=1]=1.

We say that an instance Ψ with predicate P is a random planted instance with planting distribution 𝒬 if it is sampled from a distribution Ψ(x,m,𝒬) where

  1. (1)

    The planted assignment x{1,1}n is arbitrary;

  2. (2)

    the scopes [n]k is a multiset of size m sampled by choosing m elements of [n]k uniformly at random with replacement;

  3. (3)

    for each C=(i1,,ik), the literal negations 𝗇𝖾𝗀(C) are sampled by 𝗇𝖾𝗀(C)𝒬(𝗇𝖾𝗀(C)(xi1,,xik)), where “” denotes the element-wise product of two vectors. That is, Pr[𝗇𝖾𝗀(C)=y]=𝒬(y(xi1,,xik)) for each y{1,1}k. Then, add the constraint

    P(𝗇𝖾𝗀(C)1xi1,𝗇𝖾𝗀(C)2xi2,,𝗇𝖾𝗀(C)kxik)=1

    to the instance Ψ.

Because 𝒬 is supported only on satisfying assignments to P, it follows that if ΨΨ(x,m,𝒬), then x satisfies Ψ with probability 1.

Before we state our main theorem, we define the notion of distribution complexity, as defined in [17].

Definition 3 (Distribution Complexity).

Let P:{1,1}k{0,1} be a predicate, and let 𝒬:{1,1}k[0,1] be a planting distribution supported on P1(1). The distribution complexity of 𝒬 is defined to be the smallest integer r1 for which there exists a set S[k] of size r such that |𝒬^(S)|4k,444The definition in [17] differs slightly here and only requires that |𝒬^(S)|>0. This is because they implicitly assume that 𝒬 is constant with respect to n, so that if |𝒬^(S)|>0 and k=O(1), then |𝒬^(S)|Ω(1). We do not make this assumption on 𝒬. where for any set T[k], the Fourier coefficient 𝒬^(T) is defined as 𝒬^(T):=2ky{1,1}k𝒬(y)jTyj. In case maxS[k]|𝒬^(S)|<4k, set the distribution complexity of 𝒬 to be r=1.

Note that if P is a non-trivial predicate, i.e. P1(1){1,1}k, then supp(𝒬){1,1}k since supp(𝒬)P1(1), and thus one can show (see Proposition 18) that

maxS[k]|𝒬^(S)|4k.

We now state our main theorem, which gives an algorithm to solve a random planted CSP.

Theorem 4.

Let m,n be positive integers, and let 2kclogn for some small enough constant c>0. Let be a parameter such that 2kn/8. There is an algorithm that takes as input a k-ary Boolean CSP Ψ and in time nO() outputs an assignment x{1,1}n with the following guarantee: if ΨΨ(x,m,𝒬) where 𝒬 is a planting distribution with distribution complexity r and

mm0:=2O(k)nlognmax{(n)r21,1},

then with probability 11/poly(n) over the draw of the random CSP instance Ψ, it holds that the output x of the algorithm is a satisfying assignment to Ψ. Furthermore, the algorithm can output a list of 2k+2 assignments such that at least one of them is x.

We note that in Theorem 4, the first term in the maximum is larger unless r=1.

Theorem 4 fills the remaining gap in our knowledge for the search problem of solving random planted CSPs by giving an algorithm with “[34]-like” guarantees, i.e., an algorithm that matches the conjectured “correct” trade-off between runtime and number of constraints. We note that there is a similar gap in our knowledge for the case of semirandom CSPs, a model where the scopes are additionally allowed to be worst-case. For semirandom CSPs, the works of [1, 24, 27] give a “[34]-like” refutation algorithm, and the work of [23] gives a poly(n)-time algorithm to solve semirandom planted CSPs with O~(nk/2) constraints. However, no “[34]-like” search algorithm is known, and we leave this problem as an intriguing open question for future work. As the semirandom case is only harder than the random case handled in Theorem 4, Theorem 4 is a necessary first step towards obtaining an algorithm for the semirandom case.

Theorem 4 differs slightly from [17], which gives an algorithm to recover x exactly (up to a global sign), rather than output a short list of candidate assignments, of which one is guaranteed to be x and thus a satisfying one. This is because the order of quantifiers in the result of [17] is different: they allow their algorithm to depend on 𝒬, i.e., it “knows” the planting distribution 𝒬 in advance. If we make the same assumption, then our algorithm does not need to output a list of candidate assignments, and can instead also recover x exactly (up to a global sign) as well.

In Theorem 4, we assume that 𝒬 is a planting distribution so that it is supported only on satisfying assignments to P. However, if we assume that it only outputs a satisfying assignment to P with probability, say, 1δ for a constant δ, so that valΨ(x)1δo(1) with high probability for ΨΨ(x,m,𝒬),555valΨ(x) is 1δ in expectation, and by a Chernoff bound is at least 1δo(1) with high probability. then the algorithm still succeeds in outputting an assignment that is “just as good” as x, i.e., it has value at least 1δo(1) as well.

Theorem 4 additionally gives an algorithm to invert Goldreich’s PRG [22] and its related variants [4] in time nO() when the stretch of the PRG is at least 2O(k)n(n)k21logn and k is the “locality” of the PRG.

Noisy 𝒌-XOR / 𝒌-sparse LPN

We prove Theorem 4 using the reduction of [17, 23] to the special case of “noisy k-XOR”, also referred to as k-sparse Learning Parity with Noise (LPN). This problem was first introduced in [2], and has found many applications in cryptography such as, e.g., [5]. Below, we define the “search” or “learning” variant of the problem.

Definition 5 (Noisy k-XOR / k-sparse LPN instance).

We define the distribution 𝖫𝖯𝖭k(x,m,ε) over k-XOR instances as follows:

  1. (1)

    We sample by choosing m tuples C[n]k with replacement;

  2. (2)

    For each C, we set the “right-hand side” of the equation to be bC=iCxi with probability 1/2+ε and bC=iCxi with probability 1/2ε, independently.

We thus obtain a family of equations {iCxi=bC}C over {1,1}n, which we refer to as (,{bC}C). We also refer to equations where bC=iCxi as corrupted or noisy.

The key technical component of the proof of Theorem 4 is the following theorem, which gives a new algorithm to recover the planted assignment x from a noisy k-XOR instance.

Theorem 6 (Algorithm for Noisy k-XOR).

Let m,n be positive integers and let 1ko(n1/4). Let be a parameter such that 2kn/8. There is an algorithm that takes as input a k-XOR instance and in time nO() outputs an assignment x{1,1}n with the following guarantee: if the input (,{bC}C) is drawn from 𝖫𝖯𝖭k(x,m,ε), where ε(0,12] is such that ε2/kΩ(n1/2) and

mm0:=2O(k)nlognmax{1ε11(n)k21,1ε2}, (1)

then with probability 11/poly(n) over the draw of (,{bC}C), it holds that the output x satisfies x=x if k is odd, and either x=x or x=x if k is even.

We note that as in Theorem 4, the first term in Equation 1 is larger unless k=1.

Theorem 6 gives a new algorithm for the search (a.k.a. “learning”) variant of k-sparse LPN problem in the “high noise regime” where the noise is 1/2ε. To the best of our knowledge, prior algorithms in this high noise regime were either for the distinguishing variant of the problem [3, 34, 24, 27], the search problem in the polynomial-time regime [17, 23], or are far from obtaining the conjectured optimal “runtime vs. constraints” trade-off [13].

Unlike in Theorem 4, in Theorem 6 our algorithm recovers the planted assignment x exactly: when k is odd, it outputs x, and when k is even, it outputs one of ±x, which is the best possible since 𝖫𝖯𝖭k(x,m,ε) and 𝖫𝖯𝖭k(x,m,ε) are identical distributions. The reason we do not recover x exactly in Theorem 4 is because the reduction from the general CSP case in Theorem 4 to the noisy k-XOR case in Theorem 6 produces 2k+12 candidate noisy t-XOR instances for 1tk, and then each noisy t-XOR instance outputs at most 2 candidates for x because of the global sign. If we use the convention of [17] and allow the algorithm in Theorem 4 to “know” the planting distribution 𝒬 in advance, then it “knows” which noisy t-XOR instance it should use to recover x, which allows it to recover x exactly (up to a global sign) as done in [17].

2 Proof Overview

In this section, we give an overview of the proofs of our two main theorems, Theorems 4 and 6. As Theorem 4 follows from Theorem 6 combined with the standard reduction from case of general CSPs to k-XOR [17, 23], we will focus on Theorem 6 in this section, which is the case of noisy k-XOR.

To begin, in Section 2.1 we will briefly recall the overall approach of [23] and explain why it fails to generalize to the case of super-constant . Then, in Section 2.2 we will explain our approach and how it avoids the previous technical barrier.

2.1 Certificates of uniqueness: the algorithm of [23]

The key idea in the algorithm of [23] is to understand conditions under which a simple SDP is able to recover the planted assignment x exactly. For simplicity, let us briefly explain how this works for the case of 2-XOR, before explaining how this generalizes to larger k.

For the case of noisy 2-XOR, we are given equations of the form xixj=bij, where bij is equal to xixj with probability 1/2+ε. We can represent the pairs {i,j} for which we are given equations as a graph G, and we can view it as having a signed adjacency matrix A, where Ai,j=bij if there is an equation for the pair {i,j}, and otherwise Ai,j=0. The argument of [23] shows that if the (unsigned) graph G is an expander with spectral gap λ666That is, λ is the second smallest eigenvalue of the normalized Laplacian of G, where the smallest eigenvalue of the normalized Laplacian is always 0. and mnlognpoly(1/λ), then with high probability over the noise, the basic SDP is able to certify that x is (up to a sign) the unique globally optimal assignment. This implies that the basic SDP, which computes the matrix Xn×n that maximizes {i,j}GXijbij subject to the conditions X0 and the diagonal of X is all 1’s, has an optimal solution of X=x(x), and from this one can easily recover x up to a sign. This is the best possible when k is even, as the sign of x does not matter. Finally, as G is random in the case of noisy 2-XOR, it is also an expander, and this finishes the proof.

If k is even but larger than 2, a similar idea still works. One can form the matrix A indexed by sets S of size k/2, where A(S,T)=bST if ST=C is a constraint with right-hand side bC. Since the hypergraph is random, this underlying graph is again an expander, and so a similar proof then shows that if mO~(N)=O~(nk/2) where N=(nk/2) is the number of vertices in the new graph, then one can recover iCxi for each C[n] of size k. From this, one immediately can recover x up to a global sign as well.

The barrier to the approach of [23]: weak expansion of Kikuchi graphs

The above argument shows how to give an algorithm for the “polynomial-time case” of =O(1). Let us now explain why this approach fails when becomes super-constant. For general , the natural graph to consider is the “level Kikuchi graph” of [35], which is defined below.

Definition 7.

Let k/2n be an integer, and let be a collection of subsets of n of size exactly k. The Kikuchi graph G(,) is defined as follows. The vertices of the graph are the subsets S[n] of size exactly , and there is an edge (S,T) if the symmetric difference of S and T is equal to some C.

The Kikuchi graph in Definition 7 was originally introduced by [35] to give a simplified proof of the results of [34], and has since been very influential in extending algorithms for average-case k-XOR instances to the superpolynomial-time and semirandom settings (see [24, 27]). In light of this, one might expect to be able to simply use this graph to extend the algorithm of [23] to prove Theorem 6. However, there is an immediate issue one encounters, which is that the Kikuchi graph is not a good expander when is super-constant. Even if we let be the “complete” hypergraph, i.e., it contains all sets C of size k, then the Kikuchi graph is simply a Johnson graph. The eigenvalues and eigenvectors of the Johnson graph are well-understood (see [35, Lemma A.3]), and in this setting of parameters we will have spectral gap λ1/. Now, because the constraint threshold of [23] loses a poly(1/λ) factor, this means that if we rely on expansion here, the resulting constraint threshold we obtain will be m0poly() instead of m0, where m0=O~(n)(n)k21 is the “correct” threshold. When =O(1) as in the case of [23], this extra poly() factor is irrelevant and one obtains a threshold of O~(nk/2), but in the more general setting of Theorem 6, this is a significant loss. Furthermore, we do not see a way to overcome this barrier, as the complete hypergraph is in some sense the “best case scenario” for the algorithm.

2.2 A two part rounding procedure: our approach

The problem in the aforementioned approach arises because we are trying to find an algorithm that recovers x in “one shot” by certifying that x is the globally optimal assignment. Instead, to prove Theorem 6, we will depart from this framework and find x in two steps. In the first step, we will be content with finding an assignment x^ that is o(1)-close to x in normalized Hamming distance. Then, we will explain how, given x^, we can then round it to recover x exactly.

Finding an approximate solution

Our algorithm for finding an approximate solution uses the Sum-of-Squares hierarchy; we refer the reader to Section 3.1 for the relevant background. As notation, we will let denote the hypergraph of the noisy k-XOR instance. We will think of each right-hand side bC as being sampled via a two step process. First, with probability 2ε, we set bC=xC, and otherwise we set bC=σC, where σC is a Rademacher random variable, i.e., it is uniform over {1,1}. We let 2ε denote the set of C’s where the sampling procedure sets bC=xC in the first step, so that for C2ε, we have bC=σC where σC is a Rademacher random variable.

In our proof, we argue the following. Suppose that with high probability over the draw of the noisy k-XOR instance, there are degree-O() Sum-of-Squares proofs that certify:

  1. (1)

    (Lemma 24) For all x{1,1}n, |𝔼C2ε[iCxi]1nk(i=1nxi)k|o(1) ;

  2. (2)

    (Fact 15) For all x{1,1}n, |𝔼C2ε[σCiCxi]|o(ε), where the σC’s are Rademacher random variables.

Assuming that degree-O() SoS can certify the above two inequalities, we can complete the proof. By a Chernoff bound, we have that |2ε|2εm, where m=||. Let 𝔼~μ denote the degree-O() pseudoexpectation we find by maximizing the polynomial ψ(x)=CbCiCxi subject to the constraints xi2=1 for all i[n]. We have ψ(x)2ε(1o(1))m (in expectation over the noisy k-XOR instance, ψ(x)=2εm, and then it is 2ε(1o(1))m with high probability), and so we must have 𝔼~μ[ψ(x)]2ε(1o(1))m. We can then split ψ(x) as

ψ(x)=C2εbCiCxi(I)+C2εbCiCxi(II).

Let ψ1(x) denote the first term and ψ2(x) denote the second term. For each C2ε, we have bC=σC. Therefore, by Item (2), degree-O() SoS can certify that ψ2(x)o(εm) for all x{1,1}n, which implies that 𝔼~μ[ψ2(x)]o(εm). For the first term, we have that bC=iCxi for all C2ε, and so by Item (1), it follows that |𝔼~μ[12εmψ1(x)]𝔼~μ[1nk(i=1nxixi)k]|o(1).

Combining, we have shown that

𝔼~μ[1nkx,xk] 12εm𝔼~μ[ψ1(x)]o(1)=12εm𝔼~μ[ψ(x)ψ2(x)]o(1)
12εm(2ε(1o(1))mo(εm))o(1)1o(1).

Hence, 𝔼~μ[1nkx,xk] is very close to 1. From this, we would like to recover an assignment x^ that is o(1)-close in relative Hamming distance to x. In the case of odd k, we do this by proving a generalization of [26, Lemma A.5] (see Fact 14), which shows that we can round by taking x^i=sgn(𝔼~μ[xi]). The case of even k is slightly more complicated, as 𝔼~μ[xi] may be 0 for all i because x and x are equally valid planted assignments. We show that almost all of the rows of the matrix 𝔼~μ[x2]n×n must be highly correlated with x (see Lemma 20), and from this we can extract a single x^{1,1}n that is o(1)-close to one of x, x.

It remains to justify why degree-O() SoS can certify Items (1) and (2) above. Item (2) is equivalent to requiring that the algorithm of [34, 35, 24, 27] for refuting random k-XOR can be “captured” by degree-O() SoS, which is indeed true (see Fact 15). Item (1) is a bit tricker to argue, but it turns out that we can reduce Item (1) to the case of Item (2) by using a symmetrization argument: we can replace 1nk(i=1nxi)k with 𝔼C[iCxi], where is a random hypergraph with the same distribution as 2ε and then view the random process of placing C in 2ε or as assigning a Rademacher random variable σC to each C. Item (2) is captured by Lemma 24, a proof of which can be found in the full-version of the paper.

As we can solve a degree-O() SoS program in time nO(), it follows that in nO() time we can approximately recover x by finding an assignment x^{1,1}n that is o(1)-close to x.

Rounding an approximate solution to an exact solution

It remains to show how to round x^ to exactly recover x. We will do this by using nlogn “fresh” constraints. That is, we divide the original m constraints into two sets, and we use the first set to obtain x^, and the second set to round x^ to get x.

By “shifting” all equations by x^, we can equivalently view this rounding task as recovering a planted assignment y from a noisy k-XOR instance with nlogn constraints under the assumption that y has at most o(n) entries that are 1. This is because x^x, where x is the original assignment and denotes the element-wise product of vectors, has at most o(n) entries that are 1.

Let us now look at all constraints that contain some fixed i[n]. By concentration, we should expect to have about logn of these constraints for each choice of i, and moreover each constraint, after removing the chosen index i, is distributed as a random set of size k1. We can now make the following observation. Because y has only o(n) entries that are 1, a random set of size k1 should typically avoid all j’s where yj=1. Therefore, a typical constraint C{i} where |C|=k1 will have jCyj=1, and so it will have bC=yijCyj=yi when the constraint is not noisy. Because all but a o(1)-fraction of such constraints are typical, by taking a majority vote we can recover each yi exactly with high probability, and therefore recover the planted assignment y.

The idea underpinning the above rounding procedure is simple: if y is a very biased assignment, then a typical constraint contains only indices j where yj=1, and so if we look at all constraints containing a certain index i, then the right-hand sides of these equations will be biased towards yi, and this is simple to detect. We note that a similar idea was employed in the work of [12], which gave an algorithm to break Goldreich’s PRG under the condition that the predicate has “distribution complexity” r2 (Definition 3).

3 Preliminaries

We lay down some preliminaries we’ll use throughout the paper. The proofs of the statements used without proof can be found in the full version of the paper.

For any xn and any S[n], define xS:=iSxi. For any two vectors x,yn, we define the correlation of x,y to be corr(x,y):=x,y/x2y2.

For any z, define

sgn(z):={1if z0,1otherwise.

For any vector xn, define sgn(x){±1}n to be the entrywise application of sgn() to x.

The following proposition shows that if xn is correlated with x{1,1}n, then sgn(x) is also correlated with x.

Proposition 8.

Let xn be a non-zero vector, and let x{1,1}n be such that corr(x,x)1δ. Then corr(sgn(x),x)14δ.

We define a k-uniform hypergraph to be a collection of tuples of size k. We also allow our hypergraphs to have repeated hyperedges, i.e., they can be multisets.

At times, it will be convenient to have notation to denote ordered tuples of length k where the entries in the tuple are distinct. Towards this end, for any set V, we define V(k):={xVk:All entries of x are distinct}. That is, [n]k is the set of tuples of length k, and [n](k) is the set of tuples of length k where all entries are distinct.

We state the following result to pass from tuples in [n]k to tuples with distinct entries:

Proposition 9.

Let k2. Then |[n]k[n](k)|/nkk2/n. In particular, if is a collection of m u.a.r. samples from [n]k, then |[n](k)|/||2k2/n with probability 1exp(Ω(mk2/n)).

We generate a random hypergraph with m hyperedges on the vertex set V by sampling m hyperedges from Vk uniformly at random.

We will also need the following concentration inequality.

Fact 10 (McDiarmid’s Inequality, [31]).

Let f:Ωm be a function such that for any i[m], and any ω1,,ωmΩ,ωiΩ, we have that |f(ω1,,ωi,,ωm)f(ω1,,ωi,,ωm)|ci for some real numbers c1,,cm0. Then if X1,,XmΩ are independent, then

Pr(|f(X1,,Xm)𝔼[f(X1,,Xm)]|ε)2exp(2ε2i[m]ci2).

3.1 Background on the Sum-of-Squares hierarchy

We recall some basic facts about SoS (see [19, 9] for further details). Define [x1,,xn]t to be the set of polynomials in [x1,,xn] of degree t.

Definition 11 (Pseudo-expectations over the hypercube).

For any d2, a degree d pseudo-expectation 𝔼~ over {1,1}n is a linear functional 𝔼~:[x1,,xn]d satisfying the following properties:

  1. 1.

    (Normalization) 𝔼~[1]=1,

  2. 2.

    (Booleanity) 𝔼~[fxi2]=𝔼~[f] for all i[n],f[x1,,xn]d2,

  3. 3.

    (Positivity) 𝔼~[f2]0 for all f[x1,,xn]d/2.

Finally, denote by 𝖲𝗈𝖲d (𝖲𝗈𝖲d) the set of all degree d (d) pseudo-expectations over {1,1}n.

We will make a slight abuse of terminology and use the phrase “pseudo-expectation” to mean a pseudo-expectation over {1,1}n.

Suppose we have a function f:{1,1}n, and suppose the function attains its maximum on A{1,1}n. It is easy to verify that the expectation operator associated to any probability distribution supported on A is also a degree-d pseudo-expectation for all 2dn. In particular, maxx{1,1}nf(x)sup𝔼~𝖲𝗈𝖲d𝔼~[f] for all 2dn. We also note the following elementary facts about pseudo-distributions on the hypercube:

Fact 12.

Let 𝔼~ be a pseudo-expectation of degree 2 on the hypercube. Then:

  1. (1)

    For all i[n], 𝔼~[xi]21. In general, if 𝔼~ is a pseudo-expectation of degree d, and if f[x1,,xn]d/2, then 𝔼~[f]2𝔼~[f2]. In particular, for any S[n], we have |𝔼~[xS]|1.

  2. (2)

    For all f[x1,,xn]d2, we have 𝔼~[fx22]=i𝔼~[fxi2]=i𝔼~[f]=n𝔼~[f].

The SoS algorithm can compute all moments up to degree d of some pseudo-expectation in sup𝔼~𝖲𝗈𝖲d𝔼~[f] in nO(d) time:

Fact 13 (SoS Algorithm (Corollary 3.40 in [19])).

Let f=f(x1,,xn) be a polynomial of degree t with rational coefficients such that each coefficient has poly(n) bit complexity. Then for any dt, there exists an algorithm which on inputting f and d runs in time nO(d) and outputs {αS}S([n]d), where |αS𝔼~μ[xS]|4n for all S([n]d), and 𝔼~μargmax𝔼~𝖲𝗈𝖲d𝔼~[f]. In particular in nO(d) time one can compute α:=𝔼~μ[f] such that α satisfies β+2nαβ, where β:=maxx{1,1}nf(x).

We also state a generalization of [26, Lemma A.5] which we need for “rounding/decoding” an approximately correct solution.

Fact 14.

Let k2 be any integer. Let 𝔼~ be a degree (k+2) pseudo-expectation on the hypercube such that 𝔼~[x,xk]nk(1δ), for some x{1,1}n,δ(0,1). Then:

  1. (1)

    If k is odd, then 𝔼~[x,x]n(12δ),

  2. (2)

    If k is even, then 𝔼~[x,x2]n2(12δ).

A proof of this fact can be found in the full-version of the paper.

3.2 Sum-of-Squares refutation of 𝒌-XOR

We now define the canonical degree d SoS relaxation associated to a system of equations: For any hypergraph , and any equation system {xC=bC}C, write ψ(x):=𝔼C[bCxC]=1||CbCxC. The canonical degree d SoS relaxation associated to ψ (and hence to the system of equations) is argmax𝔼~𝖲𝗈𝖲d𝔼~[ψ(x)]. By Fact 13, we can calculate any moment (up to degree d) of this relaxation in nO(d) time.

We crucially need the following theorem for refuting k-XOR systems due to Hsieh, Kothari, and Mohanty ([27, Theorem 4.1]):

Fact 15 (Refuting k-XOR Systems).

Let k, and let be a parameter such that 2kn/8. Let [n](k) be any hypergraph such that

||m0:=2O(k)(n)k/21nlognδ4,

where δ(0,1/2) is an arbitrary parameter. Consider the polynomial

ψ(x):=𝔼C[σCxC],

where {σC}C are i.i.d. uniform {1,1}-valued random variables. Then with probability 11/poly(n) over the draw of {σC}C, for every pseudo-expectation 𝔼~ of degree 2, we have |𝔼~[ψ(x)]|δ.

 Remark 16.

A few remarks are due:

  1. (1)

    [27] treats hypergraphs as collections of subsets of [n]. But note that any [n](k) can be treated as a k-uniform hypergraph in the sense of [27] by simply flattening tuples into sets.

  2. (2)

    The formal statement in [27, Theorem 4.1] does not state that their algorithm is “captured” by degree-2 Sum-of-Squares in the above sense. However, their algorithm goes via showing an upper bound on the spectral norm of a certain level Kikuchi matrix (Definition 7), and it is straightforward to see that this reasoning is captured by a degree 2 Sum-of-Squares proof.

In this paper, it will be more convenient to work in the case where is a subsample of [n]k, rather than [n](k). Because of this, we prove the following corollary using Proposition 9, which is essentially just Fact 15 with this other distribution.

Corollary 17.

Let be a collection of m u.a.r. samples from 𝒦:=[n]k. Let {σC}C be i.i.d Rademacher random variables. If 2kn/8 is such that

m2O(k)δ4(n)k/21nlogn

for some δ(0,1/2), then for any pseudo-expectation 𝔼~ of degree 2, we have, with probability 11/poly(n) over the randomness of and {σC}C,

|𝔼~[𝔼CσCxC]|δ+2k2n.

A proof of this fact can be found in the full-version of the paper.

3.3 CSP to 𝒌-XOR reduction

We describe the CSP to XOR reduction we use to reduce solving random CSPs to solving random XOR systems, which has appeared in prior work [17, 23].

Fix a positive integer m, an assignment x{1,1}n, a predicate P:{1,1}k{0,1}, and a planting distribution 𝒬 for P. Sample ΨΨ(x,m,𝒬). For any S[k], define ψ(S,+) as the set of equations

ψ(S,+):={jSxij=jS𝗇𝖾𝗀(C)j}C=(i1,,ik),

and define ψ(S,) similarly as

ψ(S,):={jSxij=jS𝗇𝖾𝗀(C)j}C=(i1,,ik).

Finally, for any distribution 𝒬:{1,1}k[0,1], and any S[k], define the Fourier coefficient

𝒬^(S):=12ky{1,1}k𝒬(y)jSyj.

We now claim that if 𝒬 does not have full-support (which will be the case when P is a non-trivial predicate, i.e. P1(1){1,1}k), then it has a non-trivially large non-zero Fourier coefficient. A proof of this fact can be found in the full-version of this paper.

Proposition 18.

Let 𝒬 be a probability distribution on {1,1}k such that supp(𝒬){1,1}k. Then maxS[k]|𝒬^(S)|>4k.

With the above notation, we will use the following reduction from CSPs to k-XOR from [23]:

Fact 19 (Claim 4.2, [23]).

Let ΨΨ(x,m,𝒬) for some planting distribution 𝒬 for a nontrivial predicate P. Then, for all non-empty S[k], ψ(S,+) is distributed as 𝖫𝖯𝖭|S|(x,m,2k1𝒬^(S)) and ψ(S,) is distributed as 𝖫𝖯𝖭|S|(x,m,2k1𝒬^(S)).

Furthermore, if the hypergraph of Ψ is , then the underlying hypergraph of ψ(S,±) is |S:={C|S:C}, where for any C=(i1,,ik)[n]k and S[k], we define C|S:=(ij:jS).

4 From Planted CSPs to Noisy 𝒌-XOR

In this section, we present our algorithm for solving random planted CSPs and prove its guarantees (Theorem 4) using our algorithm for noisy k-XOR (Theorem 6) as a subroutine. We first prove Theorem 4, using Theorem 6.

Proof of Theorem 4 from Theorem 6.

We shall show that the following algorithm satisfies all the required properties.

Algorithm 1 Solving Random Planted CSPs.


Input:

A CSP predicate P:{1,1}k{0,1}, a CSP system Ψ={P(xi1,,xik)=1}C=(i1,,ik), where [n]k, and a parameter 2kn/8.

Output:

A vector x{1,1}n.

Operation:

  1. (1)

    If P(y)=1 for all y{1,1}k, then return x:=𝟏.

  2. (2)

    Initialize 𝒱:=.

  3. (3)

    For S[k], For {+,}:

    1. (a)

      Run the algorithm of Theorem 6 (Algorithm 2) on input (ψ(S,),) to obtain output x{1,1}n. Add x,x to 𝒱.

  4. (4)

    For every v𝒱, check if v satisfies Ψ. Return the first satisfying assignment found.

  5. (5)

    If no satisfying assignment is found in the previous line, return 𝟏.

If P(y)=1 for all y{1,1}k, then the CSP instance is trivially satisfiable, and the algorithm may return any vector, say 𝟏.

Thus assume P1(1){1,1}k, and thus supp(𝒬){1,1}k. Let S[k] be the smallest non-empty set such that |𝒬^(S)|4k (such a set exists due to Proposition 18). Write r=|S|, and note that r is the distribution complexity of 𝒬.

Now, enumerate all non-empty S[k], and for each S guess if 𝒬^(S) is >0,=0 or <0. For each S where we guessed 𝒬^(S)>0 (resp. <0), construct the instance ψ:=ψ(S,+) (resp. ψ:=ψ(S,)), run Algorithm 2 on ψ and note down its output.

Consequently, we obtain a list of 4(2k1)<2k+2 outputs from the above procedure for 2k1 different non-empty subsets of [k], 2 possible signs of each Fourier coefficient, and another factor of 2 to include the negation of each output when k is even.

Now, note that since is a collection of m u.a.r. samples from [n]k, |S is a collection of m u.a.r. samples from [n]|S|=[n]r. Consequently, when we guess the sign of 𝒬^(S) correctly, running Algorithm 2 on ψ(S,sgn(𝒬^(S)))𝖫𝖯𝖭r(x,m,ε), where ε2k14k2O(k), yields a vector x{±x} with probability 11/poly(n), by Fact 19 and Theorem 6. Consequently, with probability 11/poly(n), 𝒱, which is a list of size 2k+2, contains x, which is a satisfying assignment for Ψ, as desired.

Finally, the algorithm described above takes O(2k)nO()=nO() time to run, as 2k.

5 Solving Noisy 𝒌-XOR

In this section, we prove Theorem 6, which is our algorithm to solve noisy k-XOR instances, or equivalently k-sparse LPN. As explained in Section 2, the algorithm of Theorem 6 proceeds in two steps. First, we will recover an approximate solution x^ is that is close to x, and then we will round x^ to recover x (up to a global sign). The two steps are captured by the following two lemmas below, which we will prove in Sections 5.1 and 5.2, respectively.

Lemma 20 (Finding an approximate solution).

Let m,n be positive integers, and let 2ko(n1/4). Let be a parameter such that 2kn/8. There is an algorithm that takes as input a k-XOR instance (,{bC}C) and in time nO() outputs an assignment x^{1,1}n with the following guarantee. Suppose that (,{bC}C)𝖫𝖯𝖭k(x,m,ε), where ε(0,12] and

m2O(k)ε6δ5(n)k/21nlogn (2)

for some δ(0,1/2), such that εδΩ(n1/2) for some large enough constant in the Ω(). Then with probability at least 11/poly(n), it holds that

  1. (1)

    If k is odd, then corr(x^,x)1δ;

  2. (2)

    If k is even, then either corr(x^,x)1δ or corr(x^,x)1δ.

Lemma 21 (Rounding an approximate solution to an exact solution).

Let m,n be positive integers and let 2ko(n). There is an algorithm that takes as input a k-XOR instance (,{bC}C) along with an assignment x^{1,1}n, and in time poly(m,n) outputs an assignment x~{1,1}n with the following guarantee. If (,{bC}C)𝖫𝖯𝖭k(x,m,ε) where corr(x~,x)1δ (if k is odd) or |corr(x~,x)|1δ (if k is even) for some δ such that δεk, and if mΩ(ε2nlogn), then with probability 11/poly(n) over the draw of the noisy k-XOR instance, the output x~ satisfies x~=x (if k is odd) or x~{x,x} (if k is even).

We now prove Theorem 6 from Lemmas 20 and 21.

Proof of Theorem 6 from Lemmas 20 and 21.

We shall show that the following algorithm satisfies all the required properties:

Algorithm 2 Recovering x from Noisy XOR system.


Input:

A system of k-XOR equations (,{bC}C), where [n]k, and a parameter 2kn/8.

Output:

A vector x{1,1}n.

Operation:

  1. (1)

    If k2:

    1. (a)

      Split into two parts =12 with |1|=||/2,|2|=||/2.

    2. (b)

      Run the algorithm of Lemma 20 (Algorithm 3) on input (1,{bC}C1), and let x^ denote the output.

    3. (c)

      Run the algorithm of Lemma 21 (Algorithm 4) on input (x^,2,{bC}C2), and let x~ denote the output. Return x~.

  2. (2)

    Else if k=1:

    1. (a)

      For every i[n], collect all equations of the form {xi=bij}, and return x{1,1}n, where xi:=majority({bij}).

First assume k2, and write δ:=ε/k. Split into two parts =12 with |1|=m/2,|2|=m/2. Note that |2|Ω(ε2nlogn). We now make cases:

  1. (1)

    𝒌 odd: In this case, applying Lemma 20 in Step (1b), with probability 11/poly(n) we obtain x^{1,1}n with corr(x^,x)1δ=1ε/k. Now, note that the distribution of {1,{bC}C1} (which includes the randomness of 1 and the randomness of {bC}) is independent of {2,{bC}C2}. Since x~ is completely determined by {1,{bC}C1}, x~ is independent of {2,{bC}C2}. Consequently, we can apply Lemma 21 to recover x with probability 11/poly(n), as desired.

  2. (2)

    𝒌 even: In this case, applying Lemma 20 in Step (1b), with probability 11/poly(n) we obtain x^{1,1}n such that |corr(x^,x)|1δ. Again, by the same argument as in Item (1), we have that x~ is independent of {2,{bC}C2}. Consequently, we can apply Lemma 21 to recover x up to a sign with probability 11/poly(n), as desired.

Observe that for k2, the runtime of the algorithm is nO()+poly(m,n)nO(), using the runtime bounds in Lemmas 20 and 21.

Finally, suppose k=1. Note that for any i[n], the expected multiplicity of (i) in is ||/n. Consequently, by Chernoff + union bound, with probability 11/poly(n), for every i[n], we have Ω(ε2logn) equations of the form {xi=bij}. Furthermore, bij=xi with probability 1/2+ε, and consequently, majority({bij})=xi with probability 1exp(Ω(ε2(ε2logn)))11/poly(n), and the theorem follows by a union bound over all i[n].

 Remark 22.

A few remarks are due:

  1. (1)

    Note that Algorithm 2 doesn’t assume knowledge of ε. Algorithm 2 only assumes knowledge of , which should be viewed as a proxy for the amount of runtime we have available. Given , if ε is large enough (as dictated by Equation 1), then we recover x successfully.

  2. (2)

    By [27, Remark 2], for even k, we can actually take m0:=2O(k)(n)k/21nlognδ2, as opposed to the δ4 dependence right now in Fact 15. Tracking the dependence of δ throughout the proof of Theorem 6, for even k, we can take

    m0:=2O(k)ε7(n)k/21nlogn,

    in Equation 1, instead of the ε11 dependence.

5.1 Finding an approximate solution: proof of Lemma 20

In this subsection, we prove Lemma 20. We do this by showing that the algorithm below has the required guarantees.

Algorithm 3 Recovering x from Noisy XOR system.


Input:

A system of equations (,{bC}C) and a parameter 2kn/8.

Output:

A vector x{1,1}n.

Operation:

  1. (1)

    If k is odd:

    1. (i)

      Compute x:=𝔼~μ[x], where 𝔼~μargmax𝔼~𝖲𝗈𝖲2𝔼~[CbCxC].

    2. (ii)

      Output x^:=sgn(x).

  2. (2)

    Else if k is even:

    1. (i)

      Compute X:=𝔼~μ[x2]n×n, where 𝔼~μargmax𝔼~𝖲𝗈𝖲2𝔼~[CbCxC].

    2. (ii)

      For each row X(i) of X, compute x^(i):=sgn(X(i)).

    3. (iii)

      For each i,j[n], compute |corr(x^(i),x^(j))|. For each i[n], let δi be such that |corr(x^(i),x^(j))|1δi for at least 0.99n choices of j[n]. Let i[n] be a minimizer of δi. Output x^(i).

We start by showing that the canonical degree 2 SoS program recovers a vector which is strongly correlated with x.

Observe that in Step (1i) or Step (2i), Algorithm 3 first finds a pseudoexpectation which maximizes 𝔼~[CbCxC]. We show that for such a pseudodistribution, 𝔼~[CbCxC] is close to 𝔼~[x,xk] (when we normalize appropriately) with high probability over the choice of a random XOR instance, which we use to bound the correlation.

Lemma 23.

Let 2ko(n1/4), and let (,{bC}C)𝖫𝖯𝖭k(x,m,ε), where ε(0,12]. Let be a parameter such that 2kn/8, and suppose

m2O(k)εδ5(n)k/21nlogn, (3)

where δ(0,1/2) is a parameter. Then with probability 11/poly(n) over the draw of and {xC=bC}C, we have that for any pseudo-expectation 𝔼~ of degree 2,

𝔼~[ψ(x)2εnkx,xk]δ+O(1n),

where ψ(x):=𝔼C[bCxC].

Proof.

Consider the random variable

X:={σwith probability 12ε,1with probability 2ε,

where σ is a Rademacher random variable, i.e. it takes values ±1 with equal probability. Note that Pr(X=1)=1Pr(X=1)=12+ε, and thus bC is distributed as XxC. Consequently, we can write
𝔼~[CbCxC2εmnkx,xk]=𝔼~[C2ε(xx)C2εmnkx,xk](I)+𝔼~[C2εσC(xx)C](II), (4)

where 2ε is a 2ε-sample of , i.e. every element of is included in 2ε independently with probability 2ε. We now bound the above terms one by one:

Bounding term (𝐈).

Write m:=|2ε|. Note that 𝔼[m]=2εm, and by a Chernoff bound,

m2εm[1±O(1n)] (5)

with probability 1exp(Ω(εm/n))1exp(Ω(logn))11/poly(n), since εm2O(k)nk2lognk212O(k)nlogn, since n. Equivalently, m2O(k)δ5nk2lognk21 with probability 11/poly(n).

To finish bounding this term, we will need the following lemma, which intuitively shows that degree-2 Sum-of-Squares can certify that a random hypergraph with a sufficient number of samples is a good approximation of the complete hypergraph.

Lemma 24.

Let be a collection of m u.a.r. samples from 𝒦:=[n]k, where 2ko(n1/4). Let δ(0,1/2) be an arbitrary parameter. Then for any pseudo-expectation 𝔼~ of degree 2, where

n82k,k212O(k)nk2mlognδ4,

we have, with probability 11/poly(n) over the draw of ,

𝔼~[𝔼C[xC]𝔼C𝒦[xC]]δ+O(1n).

We now use Lemma 24 to finish bounding term (I).

Since 2ε is distributed as a collection of m u.a.r. samples of 𝒦, by Lemma 24, for any 𝔼~𝖲𝗈𝖲2, we have that
𝔼~[𝔼C2ε[yC]𝔼C𝒦[yC]]δ+O(1n)𝔼~[C2εyCm𝔼C𝒦yC](δ+O(1n))m,

where y:=xx.777Note that technically Lemma 24 is stated in terms of x, but since it works for all pseudo-distributions of degree 2, by translating we can put y instead of x. Now note that

𝔼C𝒦[yC]=𝔼C𝒦[(xx)C]=1nkC[n]k(xx)C=1nkx,xk. (6)

Consequently,

(δ+O(1n))m 𝔼~[C2εyCm𝔼C𝒦yC]
=𝔼~[C2εyC2εmnkx,xk]+(2εmmnk)𝔼~x,xk
𝔼~[C2εyC2εmnkx,xk](δ+O(1n))m+|m2εm||𝔼~x,xknk|. (7)

Now, by Equation 6, we have 𝔼~[x,xk]nk=𝔼~[𝔼C𝒦[yC]]=𝔼C𝒦[𝔼~[xC]]. By Fact 12, 𝔼~[xC][1,1] for all C𝒦, and thus 𝔼C𝒦𝔼~[xC][1,1]|𝔼~[x,xk]nk|1. Also, by Equation 5, |m2εm|O(m/n). Putting all this together in Equation 7, we obtain that

𝔼~[C2εyC2εmnkx,xk]m(δ+O(1n)+O(1n))m(δ+O(1n)).
Bounding term (𝐈𝐈).

Write m′′:=|2ε|. Here we make two cases:

  1. (1)

    m′′δm: In this case, 𝔼~[C2εσC(xx)C]=C2εσC𝔼~[(xx)C]m′′δm.

  2. (2)

    m′′>δm: Note that m′′>δm2O(k)εδ4nk2lognk212O(k)δ4nk2lognk21. Also note that 2ε is a collection of m′′ u.a.r. samples from 𝒦:=[n]k. Consequently, by Corollary 17, for any 𝔼~𝖲𝗈𝖲2, we have 𝔼~C2εσCxCm′′(δ+2k2n)m(δ+2k2n).

Combining the above terms together, we can say that for any 𝔼~𝖲𝗈𝖲2, we have

𝔼~[C2εσCxC]m(δ+2k2n)m(δ+O(n1/2)),

where the last inequality follows since ko(n1/4). Finally, putting everything together in Equation 4, we obtain that

𝔼~[CbCxC2εmnkx,xk]m(δ+O(1n))+m(δ+O(1n))
m(2δ+O(1n)),

and we absorb the 2 in front of the δ in the 2O(k) term in Equation 3. We can now prove the main lemma.

Proof of Lemma 20.

Write ν:=εδ. Note that m2O(k)εν5(n)k/21nlogn.

Let 𝔼~μargmax𝔼~𝖲𝗈𝖲2ψ(x) be any pseudo-distribution maximizing ψ(x):=𝔼C[bCxC]. By Lemma 23,

𝔼~μ[ψ(x)2εnkx,xk]ν+O(1n)2ν𝔼~μ[ψ(x)]2εnk𝔼~μx,xk+2ν,

where we can write ν+O(n1/2)2ν since ν=εδΩ(n1/2).

Now, consider the probability distribution which places all its mass on x. By Definition 11, the expectation operator associated to this distribution is a valid degree 2 pseudo-distribution over {1,1}n. Furthermore, the expectation of ψ(x) under this distribution is ψ(x). Consequently, 𝔼~μψ(x)ψ(x), and thus

2εnk𝔼~μx,xk+2ν ψ(x)=𝔼C[bCxC]()2ε(1O(1n)) (8)
1nk𝔼~μx,xk 1νεO(1n)=:1ξ, (9)

where () follows with probability 11/poly(n) by a Chernoff bound. Note that ξ=ν/ε+O(n1/2)=δ+O(n1/2)=O(δ), since δεδΩ(n1/2).

We now make cases based on whether k is odd or even:

  1. (1)

    k is odd: In this case, Fact 14 implies that 𝔼~μ[x,x]n(1ξ)𝔼~μ[x],xn(12ξ). Write z:=𝔼~μ[x]. Then note that z22=i𝔼~μ[xi]2Fact 12n. Consequently, corr(z,x)=|z,x|/z2x2z,x/n12ξ. Now, by Fact 13, the vector x we compute (in Item 1i of Algorithm 2) is very close to its “idealized value” z, i.e. xz12n. Since 2ξΩ(n1/2)2n, 2ξ+O(2n)O(ξ)O(δ). Now, by Proposition 8, it follows that for x^:=sgn(x), we have that corr(x^,x)1O(δ), which finishes the proof in this case.

  2. (2)

    k is even: In this case, Fact 14 implies that 𝔼~μ[x,x2]n2(12ξ). Now, note that x,x2=x2,x2, and thus 𝔼~μ[x2],x2n2(12ξ). Write Z:=𝔼~μ[x2], where Z is to be viewed as a n×n matrix. Then note that Z,x2=i[n]z(i),xixn2(12ξ), where z(i) is the ith row of Z. Also note that z(i)22=j𝔼~μ[xixj]2Fact 12j𝔼~μ[xi2xj2]=n, and thus

    i[n]|corr(z(i),x)| =i[n]|z(i),x|z(i)2x2=i[n]|z(i),xix|z(i)2n
    1ni[n]|z(i),xix|1n|i[n]z(i),xix|n(12ξ).

    On the other hand, i[n]|corr(z(i),x)|n, since corr(z(i),x)[1,1] for each i[n]. Consequently, by an averaging argument, we must have that for 0.99n indices i[n], |corr(z(i),x)|1200ξ.

    As before, if X(i) is the vector we compute (in Item 2ii of Algorithm 3), then X(i)z(i)12n, and thus for 0.99n indices i[n], we have |corr(X(i),x)|1O(ξ)1O(δ), and we can absorb the constant in O() into the lower bound for m, as usual.

    Now, let x^(i)=sgn(X(i)) for each i. By Proposition 8, we have that |corr(x^(i),x)|1O(δ) for at least 0.99n indices i[n]. Call these indices the “good” indices. We now observe that the i chosen in Item 2iii must be such that |corr(x^(i),x)|1O(δ). Indeed, for any choice of one of the “good” 0.99n indices i, we must have that |corr(x^(i),x^(j)|1O(δ) for every other good j, i.e., δi=O(δ). Therefore, for the particular i chosen in Item 2iii, it follows that |corr(x^(i),x^(j)|1O(δ) for some good index j, there are 0.99n good indices. We thus conclude by triangle inequality that |corr(x^(i),x)|1O(δ), which finishes the proof.

5.2 Rounding approximate solutions: proof of Lemma 21

In this subsection, we prove Lemma 21.

Proof.

Since ||=Ω(ε2nlogn), and since |[n]k[n](k)|/nkO(k2/n)=o(1) (see Proposition 9), if we write :=[n](k), with probability 1exp(Ω(n)) we have ||Ω(ε2nlogn). Note that all tuples in have distinct entries. For every i[n], write i:={C{i}:iC}. Note that the is may have repeated hyperedges. Also for any Ti, denote by (T,i) the tuple in that T was obtained from. Since the hyperedges of are independent uniform samples from [n](k), the hyperedges of i are independent uniform samples from ([n]{i})(k1).

Consider the following algorithm:

Algorithm 4 Exact Recovery from an Approximately Correct Solution.


Input:

A k-XOR instance (,{bC}C), and a vector x~{1,1}n.

Output:

A vector x{1,1}n.

Operation:

  1. (1)

    For every i[n], compute Si:={b(T,i)x~T:Ti}, which is a multiset over {1,1}. Here i:={C{i}:iC[n](k)}.

  2. (2)

    Output x{1,1}n, where

    xi:={1if |Si|/2 entries of Si are 1,1otherwise.

It is easy to see that the above algorithm runs in poly(m,n) time. We will argue that if k is odd, then x=x with probability 11/poly(n), and if k is even, then x{x,x} with probability 11/poly(n).

Let us first consider the case where corr(x^,x)1δ (for both odd and even k). It suffices to show that xixi with probability O(n2) for all i[n], as then we are done by a union bound over all i[n].

Write B:={i[n]:x~ixi}. Note that x~,x=n2|B|, and thus |B|δn/2. We call Ti good if it satisfies the following conditions:

  1. (1)

    TB=,

  2. (2)

    b(T,i)=x(T,i).

Note that if Ti is good, then b(T,i)x~T=x(T,i)x~T=x(T,i)xT=xi. Consequently, xixi if <|Si|/2=|i|/2 elements of i are good.

Since x~ is independent of and all is, we see that the probability that any given element of i does not intersect B is
i=1k1n|B|ini(n|B|knk)k1(1δ2kn1kn)k11(k1)δ2(1kn)1kδ21ε2,

where we recall i contains independent uniformly random tuples from ([n]{i})(k1), and k11k/nk for large enough n. Since the noise in the equations {xC=bC}C is independent of the randomness in sampling , the probability that any given element of i is good is

(1ε2)(12+ε)12+ε4.

Now, by a Chernoff bound, |i|12n||=Ω(ε2logn) with probability

1exp(Ω(||/n))=1exp(Ω(ε2logn))11/poly(n).

By another Chernoff bound, the probability that 12 fraction of i is good is

1exp(Ω(ε2|i|))1exp(Ω(logn))11/poly(n),

as desired.

It remains to handle the case when k is even and corr(x^,x)1δ. Let us make the following simple observation: since k is even, the distributions 𝖫𝖯𝖭k(x,m,ε) and 𝖫𝖯𝖭k(x,m,ε) are identical. Hence, we can follow the above analysis using x as the planted assignment since corr(x^,x)1δ, and the aforementioned argument implies that we recover x with probability at least 11/poly(n), which finishes the proof.

References

  • [1] Jackson Abascal, Venkatesan Guruswami, and Pravesh K. Kothari. Strongly refuting all semi-random Boolean CSPs. In Proceedings of the 2021 ACM-SIAM Symposium on Discrete Algorithms, SODA 2021, Virtual Conference, January 10 - 13, 2021, pages 454–472. SIAM, 2021. doi:10.1137/1.9781611976465.28.
  • [2] Michael Alekhnovich. More on average case vs approximation complexity. In 44th Annual IEEE Symposium on Foundations of Computer Science, 11-14 October 2003, Cambridge, MA, USA. IEEE, 2003.
  • [3] Sarah R. Allen, Ryan O’Donnell, and David Witmer. How to Refute a Random CSP. In IEEE 56th Annual Symposium on Foundations of Computer Science, FOCS 2015, Berkeley, CA, USA, 17-20 October, 2015, pages 689–708. IEEE Computer Society, 2015. doi:10.1109/FOCS.2015.48.
  • [4] Benny Applebaum. Cryptographic Hardness of Random Local Functions: Survey. Computational complexity, 25:667–722, 2016. doi:10.1007/s00037-015-0121-8.
  • [5] Benny Applebaum, Boaz Barak, and Avi Wigderson. Public-key cryptography from different assumptions. In Proceedings of the 42nd ACM Symposium on Theory of Computing, STOC 2010, Cambridge, Massachusetts, USA, 5-8 June 2010, pages 171–180. ACM, 2010. doi:10.1145/1806689.1806715.
  • [6] Sanjeev Arora, David R. Karger, and Marek Karpinski. Polynomial time approximation schemes for dense instances of NP-hard problems. In Proceedings of the Twenty-Seventh Annual ACM Symposium on Theory of Computing, 29 May-1 June 1995, Las Vegas, Nevada, USA, pages 284–293. ACM, 1995. doi:10.1145/225058.225140.
  • [7] Boaz Barak, Siu On Chan, and Pravesh K. Kothari. Sum of Squares Lower Bounds from Pairwise Independence. In Proceedings of the Forty-Seventh Annual ACM on Symposium on Theory of Computing, STOC 2015, Portland, OR, USA, June 14-17, 2015, pages 97–106. ACM, 2015. doi:10.1145/2746539.2746625.
  • [8] Boaz Barak and Ankur Moitra. Noisy Tensor Completion via the Sum-of-Squares Hierarchy. In Proceedings of the 29th Conference on Learning Theory, COLT 2016, New York, USA, June 23-26, 2016, volume 49 of JMLR Workshop and Conference Proceedings, pages 417–445. JMLR.org, 2016. URL: http://proceedings.mlr.press/v49/barak16.html.
  • [9] Boaz Barak and David Steurer. Proofs, beliefs, and algorithms through the lens of sum-of-squares, 2016. Lecture notes in preparation, available on http://sumofsquares.org.
  • [10] Wolfgang Barthel, Alexander K Hartmann, Michele Leone, Federico Ricci-Tersenghi, Martin Weigt, and Riccardo Zecchina. Hiding solutions in random satisfiability problems: A statistical mechanics approach. Physical review letters, 88(18):188701, 2002.
  • [11] Siavosh Benabbas, Konstantinos Georgiou, Avner Magen, and Madhur Tulsiani. SDP gaps from pairwise independence. Theory of Computing, 8(1):269–289, 2012. doi:10.4086/toc.2012.v008a012.
  • [12] Andrej Bogdanov and Youming Qiao. On the security of Goldreich’s one-way function. In Approximation, Randomization, and Combinatorial Optimization. Algorithms and Techniques: 12th International Workshop, APPROX 2009, pages 392–405. Springer, 2009. doi:10.1007/978-3-642-03685-9_30.
  • [13] Xue Chen, Wenxuan Shu, and Zhaienhe Zhou. Algorithms for Sparse LPN and LSPN Against Low-noise. In 38th Annual Conference on Learning Theory (COLT 2025). Association for Computational Learning (ACL), 2025.
  • [14] Amin Coja-Oghlan, Colin Cooper, and Alan Frieze. An efficient sparse regularity concept. SIAM Journal on Discrete Mathematics, 23(4):2000–2034, 2010. doi:10.1137/080730160.
  • [15] Amin Coja-Oghlan, Andreas Goerdt, and André Lanka. Strong refutation heuristics for random k-SAT. Combinatorics, Probability & Computing, 16(1):5, 2007.
  • [16] Uriel Feige. Relations between average case complexity and approximation complexity. In Proceedings of the thiry-fourth annual ACM symposium on Theory of computing, pages 534–543, 2002. doi:10.1145/509907.509985.
  • [17] Vitaly Feldman, Will Perkins, and Santosh S. Vempala. Subsampled Power Iteration: a Unified Algorithm for Block Models and Planted CSP’s. In Advances in Neural Information Processing Systems 28: Annual Conference on Neural Information Processing Systems 2015, December 7-12, 2015, Montreal, Quebec, Canada, pages 2836–2844, 2015. URL: https://proceedings.neurips.cc/paper/2015/hash/9597353e41e6957b5e7aa79214fcb256-Abstract.html.
  • [18] Vitaly Feldman, Will Perkins, and Santosh S. Vempala. On the Complexity of Random Satisfiability Problems with Planted Solutions. SIAM Journal on Computing, 47(4):1294–1338, 2018. doi:10.1137/16M1078471.
  • [19] Noah Fleming, Pravesh Kothari, and Toniann Pitassi. Semialgebraic Proofs and Efficient Algorithm Design. Foundations and Trends® in Theoretical Computer Science, 14(1-2):1–221, 2019. doi:10.1561/0400000086.
  • [20] Dimitris Fotakis, Michael Lampis, and Vangelis Th. Paschos. Sub-exponential Approximation Schemes for CSPs: From Dense to Almost Sparse. In 33rd Symposium on Theoretical Aspects of Computer Science, STACS 2016, February 17-20, 2016, Orléans, France, volume 47 of LIPIcs, pages 37:1–37:14. Schloss Dagstuhl – Leibniz-Zentrum für Informatik, 2016. doi:10.4230/LIPIcs.STACS.2016.37.
  • [21] Andreas Goerdt and André Lanka. Recognizing more random unsatisfiable 3-sat instances efficiently. Electron. Notes Discret. Math., 16:21–46, 2003. doi:10.1016/S1571-0653(04)00461-5.
  • [22] Oded Goldreich. Candidate One-Way Functions Based on Expander Graphs. Electron. Colloquium Comput. Complex., 2000. URL: https://eccc.weizmann.ac.il/eccc-reports/2000/TR00-090/index.html.
  • [23] Venkatesan Guruswami, Jun-Ting Hsieh, Pravesh K. Kothari, and Peter Manohar. Efficient algorithms for semirandom planted csps at the refutation threshold. In 64th IEEE Annual Symposium on Foundations of Computer Science, FOCS 2023, Santa Cruz, CA, USA, November 6-9, 2023, pages 307–327. IEEE, 2023. doi:10.1109/FOCS57990.2023.00026.
  • [24] Venkatesan Guruswami, Pravesh K. Kothari, and Peter Manohar. Algorithms and certificates for Boolean CSP refutation: smoothed is no harder than random. In STOC ’22: 54th Annual ACM SIGACT Symposium on Theory of Computing, Rome, Italy, June 20 - 24, 2022, pages 678–689. ACM, 2022. doi:10.1145/3519935.3519955.
  • [25] Johan Håstad. Some optimal inapproximability results. Journal of the ACM (JACM), 48(4):798–859, 2001. doi:10.1145/502090.502098.
  • [26] Samuel B. Hopkins, Jonathan Shi, and David Steurer. Tensor principal component analysis via sum-of-square proofs. In Proceedings of The 28th Conference on Learning Theory, volume 40 of Proceedings of Machine Learning Research, pages 956–1006, Paris, France, 03–06 July 2015. PMLR. URL: https://proceedings.mlr.press/v40/Hopkins15.html.
  • [27] Jun-Ting Hsieh, Pravesh K. Kothari, and Sidhanth Mohanty. A simple and sharper proof of the hypergraph Moore bound. In Proceedings of the 2023 ACM-SIAM Symposium on Discrete Algorithms, SODA 2023, Florence, Italy, January 22-25, 2023, pages 2324–2344. SIAM, 2023. doi:10.1137/1.9781611977554.ch89.
  • [28] Russell Impagliazzo and Ramamohan Paturi. On the Complexity of k-SAT. J. Comput. Syst. Sci., 62(2):367–375, 2001. doi:10.1006/jcss.2000.1727.
  • [29] Haixia Jia, Cristopher Moore, and Doug Strain. Generating Hard Satisfiable Formulas by Hiding Solutions Deceptively. Journal of Artificial Intelligence Research, 28:107–118, 2007. doi:10.1613/jair.2039.
  • [30] Pravesh K. Kothari, Ryuhei Mori, Ryan O’Donnell, and David Witmer. Sum of squares lower bounds for refuting any CSP. In Proceedings of the 49th Annual ACM SIGACT Symposium on Theory of Computing, STOC 2017, Montreal, QC, Canada, June 19-23, 2017, pages 132–145. ACM, 2017. doi:10.1145/3055399.3055485.
  • [31] Colin McDiarmid. On the method of bounded differences. In Surveys in combinatorics, 1989 (Norwich, 1989), volume 141 of London Math. Soc. Lecture Note Ser., pages 148–188. Cambridge Univ. Press, Cambridge, 1989.
  • [32] Ryuhei Mori and David Witmer. Lower Bounds for CSP Refutation by SDP Hierarchies. In Approximation, Randomization, and Combinatorial Optimization. Algorithms and Techniques, APPROX/RANDOM 2016, September 7-9, 2016, Paris, France, volume 60 of LIPIcs, pages 41:1–41:30, 2016. doi:10.4230/LIPIcs.APPROX-RANDOM.2016.41.
  • [33] Ryan O’Donnell and David Witmer. Goldreich’s PRG: evidence for near-optimal polynomial stretch. In 2014 IEEE 29th Conference on Computational Complexity (CCC), pages 1–12. IEEE, 2014. doi:10.1109/CCC.2014.9.
  • [34] Prasad Raghavendra, Satish Rao, and Tselil Schramm. Strongly refuting random CSPs below the spectral threshold. In Proceedings of the 49th Annual ACM SIGACT Symposium on Theory of Computing, STOC 2017, Montreal, QC, Canada, June 19-23, 2017, pages 121–131. ACM, 2017. doi:10.1145/3055399.3055417.
  • [35] Alexander S. Wein, Ahmed El Alaoui, and Cristopher Moore. The Kikuchi Hierarchy and Tensor PCA. In 60th IEEE Annual Symposium on Foundations of Computer Science, FOCS 2019, Baltimore, Maryland, USA, November 9-12, 2019, pages 1446–1468. IEEE Computer Society, 2019. doi:10.1109/FOCS.2019.000-2.