Lipics-ITCS-2019-29.Pdf (0.5

From Local to Robust Testing via Agreement Testing

Irit Dinur1 Department of Mathematics and Computer Science, Weizmann Institute of Science, Rehovot, Israel [email protected] Prahladh Harsha2 Tata Institute of Fundamental Research, India [email protected] Tali Kaufman Department of Computer Science, Bar-Ilan University, Ramat Gan, Israel [email protected] Noga Ron-Zewi Department of Computer Science, University of Haifa, Haifa, Israel [email protected]

Abstract A local tester for an error-correcting code is a probabilistic procedure that queries a small subset of coordinates, accepts codewords with probability one, and rejects non-codewords with probability proportional to their distance from the code. The local tester is robust if for non-codewords it satisfies the stronger property that the average distance of local views from accepting views is proportional to the distance from the code. Robust testing is an important component in constructions of locally testable codes and probabilistically checkable proofs as it allows for composition of local tests. In this work we show that for certain codes, any (natural) local tester can be converted to a roubst tester with roughly the same number of queries. Our result holds for the class of affine- invariant lifted codes which is a broad class of codes that includes Reed-Muller codes, as well as recent constructions of high-rate locally testable codes (Guo, Kopparty, and Sudan, ITCS 2013). Instantiating this with known local testing results for lifted codes gives a more direct proof that improves some of the parameters of the main result of Guo, Haramaty, and Sudan (FOCS 2015), showing robustness of lifted codes. To obtain the above transformation we relate the notions of local testing and robust testing to the notion of agreement testing that attempts to find out whether valid partial assignments can be stitched together to a global codeword. We first show that agreement testing implies robust testing, and then show that local testing implies agreement testing. Our proof is combinatorial, and is based on expansion / sampling properties of the collection of local views of local testers. Thus, it immediately applies to local testers of lifted codes that query random affine subspaces m in Fq , and moreover seems amenable to extension to other families of locally testable codes with expanding families of local views.

2012 ACM Subject Classiﬁcation Theory of computation → Computational complexity and cryptography

1 Supported by ERC-CoG grant number 772839. 2 Research supported in part by the UGC-ISF grant and the Swarnajayanti Fellowship. Part of the work was done when the author was visiting the Weizmann Institute of Science.

© Irit Dinur, Prahladh Harsha, Tal Kaufman, and Noga Ron-Zewi; licensed under Creative Commons License CC-BY 10th Innovations in Theoretical Computer Science (ITCS 2019). Editor: Avrim Blum; Article No. 29; pp. 29:1–29:18 Leibniz International Proceedings in Informatics Schloss Dagstuhl – Leibniz-Zentrum für Informatik, Dagstuhl Publishing, Germany 29:2 From Local to Robust Testing via Agreement Testing

Keywords and phrases Local testing, Robust testing, Agreement testing, Aﬃne-invariant codes, Lifted codes

Digital Object Identiﬁer 10.4230/LIPIcs.ITCS.2019.29

1 Introduction

Our main result shows a transformation from local testing to robust testing for the class of aﬃne-invariant lifted codes. We start by describing the notions of local testing, robust testing, and lifted codes.

1.1 Local testing and robust testing A code is a subset C ⊆ Σn. The elements of C are called codewords, Σ is the alphabet of

the code, and n is the block length. The rate of the code is the ratio (log|Σ| |C|)/n. The code is linear if Σ = Fq where Fq is the ﬁnite ﬁeld of q elements, and C is an Fq-linear n subspace of Fq . It will be convenient to think of codewords in C as functions f : U → Σ where U is a domain of size n. For a pair of functions f, g : U → Σ we let dist(f, g) denote the fraction of inputs x ∈ U for which f(x) 6= g(x). The relative distance dist(C) of the code is the minimum of dist(f, g) over all codewords f, g ∈ C. For a function f : U → Σ we let dist(f, C) denote the minimum of dist(f, g) over all codewords g ∈ C. A local tester for the code C is a probabilistic oracle algorithm that on oracle access to a function f : U → Σ makes at most Q queries to f, and accepts f ∈ C with probability one, while rejecting f 6∈ C with probability at least α · dist(f, C). We refer to Q as the query complexity of the tester, and to α as the soundness. In this work we shall restrict our attention to local testers that pick a random subset K ⊆ U of cardinality Q according 3 to some distribution, and accept if and only if f|K ∈ C|K . The requirement then is that f|K ∈ C|K with probability one whenever f ∈ C, and

Pr[f|K ∈/ C|K ] ≥ α · dist(f, C) (1) K otherwise. In this work we will be interested in the stronger notion of robustness. We say that a local tester as above is robust if for non-codewords the average distance of its local views from accepting views is proportional to the distance of the given function from the code. That is, as before we require that f|K ∈ C|K with probability one whenever f ∈ C, but instead of (1) we now require that EK dist(f|K ,C|K ) ≥ α · dist(f, C) (2)

whenever f∈ / C. Here we refer to α as the robustness of the tester. The notion of robustness was introduced by Ben-Sasson and Sudan [8] based on analogous notions for probabilistically checkable proofs [5, 15]. Robustness is a natural property of local testers that relates the global distance of a function from the code to its local distance from accepting views on local views. Moreover, robustness is also an important ingredient in constructions of locally testable codes and probabilistically checkable proofs as it allows for composition of local tests. Speciﬁcally, it follows by deﬁnition that if a code C is robustly

3 Local testers may generally apply a more complex predicate on f|K . However, natural local testers are typically of the restricted form we consider, and moreover it can be shown that a local tester for a linear code must be of this form [6]. I. Dinur, P. Harsha, T. Kaufman, and N. Ron-Zewi 29:3 testable with query complexity Q and soundness α, and additionally each local restriction 0 0 C|K is locally testable with query complexity Q and soundness α , then the code C is locally testable with query complexity Q0 and soundness α · α0. This property is useful when local restrictions can be tested eﬃciently which can happen if the code has many symmetries (as is the case with the class of lifted codes considered in this work) or can be achieved, in the case of probabilistically checkable proof, by attaching a short proof of proximity.

One can easily observe that (2) implies (1) since f|K ∈/ C|K whenever dist(f|K ,C|K ) > 0, so robustness is a stronger requirement than local testing. For the other direction, note that a local tester with soundness α has robustness at least α/Q since dist(f|K ,C|K ) ≥ 1/Q whenever f|K ∈/ C|K . A natural question is whether this loss in roubstness is necessary, and whether robustness is strictly stronger notion than local testing. In this work we shall show that this loss is unnecessary for the class of lifted codes, discussed below.

1.2 Lifted codes

` Lifted codes are specified by a base code C ⊆ {Fq → Fq} and a dimension m ≥ `. We further assume that the base code C is linear and affine-invariant, that is, for any codeword f ∈ C, ` ` and for any affine transformation A : Fq → Fq it holds that f ◦ A ∈ C. Given these we define `%m m the lifted code C to be the code consisting of all functions f : Fq → Fq that satisfy that f|L ∈ C for any `-dimensional affine subspace L. Lifted codes were first introduced by Ben-Sasson et al [7], and their local testability properties were further explored in subsequent work [20, 21, 19]. They are a natural generalization of the well-studied family of Reed-Muller codes, and moreover they also give rise to new families of locally testable codes that outperform Reed-Muller codes in certain range of parameters [20]. Specifically, lifted codes lead to one of the two known constructions (the other one being tensor codes [8, 9, 27, 24]) of high-rate locally testable codes (i.e., locally testable codes with rate approaching one and sublinear locality). Generally, lifted codes form a natural subclass of affine-invariant codes satisfying the “single-orbit characterization” property that is known to imply local testability, as well as local decodability [23]. There is a natural local test associated with lifted codes: on oracle access to a function m f : Fq → Fq, pick a uniform random `-dimensional affine subspace L and accept if and only if f|L ∈ C. It follows immediately by definition that this test accepts any valid codeword f ∈ C`%m with probability one, but more work is required to show that this test is sound. Specifically, since the test forms a single orbit characterization, it follows from [23] that it has soundness roughly q−2`. The dependence of the soundness on the dimension ` was later eliminated in [21] who showed soundness that is only a function of q (though an extremely quickly decaying one). As for robustness, the above local testing results, together with the straightforward transformation from local testing to robust testing, immediately give robustness that is dependent on the dimension `. This was eliminated recently in [19] who showed robustness of the form poly(δ) (about δ74, where δ is the relative distance of the code) for the local test that queries subspaces of slightly larger dimension of 2`. Interestingly, [19] did not rely on the aforementioned local testing results, but rather relied on viewing lifted codes as the intersection of “modified tensor codes”. They then proceeded by showing that these modified tensor codes are robustly testable (using the proof method of [27] showing robustness of tensor codes), and that this implies local testability of the lifted code (see Section 2.4 for more details about the proof method of [19]).

I T C S 2 0 1 9 29:4 From Local to Robust Testing via Agreement Testing

1.3 Our results

Our main result gives a transformation from local testing to robust testing, that does not suﬀer the factor of Q (the query complexity) loss in robustness, for the class of lifted codes. The transformation uses local testability in a “black-box” manner, and shows that if a code in this family is locally testable (using the natural subspace tester) then it is also robustly testable with roughly the same number of queries and robustness. For k ≥ `, let the k-dimensional (subspace) test denote the local tester that on oracle m access to a function f : Fq → Fq queries a uniform random k-dimensional aﬃne subspace K `%k and accepts if and only if f|K ∈ C .

` I Theorem 1 (Main). Let C ⊆ {Fq → Fq} be an aﬃne-invariant linear code, and m ≥ k ≥ `. Suppose that C`%m is locally testable using the k-dimensional test with query complexity k `%r `%m q and soundness α, and let δ := mink≤r≤m dist(C ). Then C is robustly testable 2k using the (2k + logq(4/δ))-dimensional test with query complexity O(q /δ) and robustness Ω(α · δ3).

Note that if the relative distance δ is constant, we only incur a constant multiplicative loss in robustness and testing dimension. To apply the above theorem one can instantiate it with the local testing result of [23] that says that lifted codes are locally testable using the `-dimensional test with soundness ≈ q−2` (see Theorem 6 below). However, to obtain constant robustness we need that the soundness of the initial local tester would be constant (independent of q and `), and for this we observe (in Proposition 19) that the soundness of [23] can be easily ampliﬁed to Ω(1) at the cost of increasing the testing dimension to ≈ 3`.4 Using this observation we obtain the following.

` I Corollary 2. Let C ⊆ {Fq → Fq} be an aﬃne-invariant linear code of relative distance δ, `%m and m ≥ `. Then C is robustly testable using the (6` + logq(128/δ))-dimensional test with robustness Ω(δ3).

Compared to the above corollary, [19] use lower dimension of 2`, but also obtain lower soundness of Ω(δ74). As described next, our proof is combinatorial, relying mainly on expansion / sampling properties of the collection of local views. In particular, it uses very little about the algebraic structure of lifted codes or the base code. We thus hope that such techniques would prove useful in the future for showing robustness for other families of locally testable codes with similar expansion properties.

2 Proof overview

Our proof is based on a new connection between the notions of local testing, robust testing, and agreement testing. Speciﬁcally, we show that for the class of lifted codes agreement testing implies robust testing, and local testing implies agreement testing. The combination of these two implications gives our main Theorem 1. Next we elaborate on the notion of agreement testing, followed by an overview of each of the implications.

4 Such an ampliﬁcation with similar blow-up in query complexity can be easily obtained by repeating the test and accepting if and only if all invocations accept; we however need that the tester would be a subspace tester which can be obtained using sampling properties of aﬃne subspaces. I. Dinur, P. Harsha, T. Kaufman, and N. Ron-Zewi 29:5

2.1 Agreement testing An agreement test attempts to find out whether partial assignments to local views can be stitched together to a single global codeword. Let C ⊆ {U → Σ} be a code, and let S be a collection of subsets of U. An agreement tester for C, S is a probabilistic oracle algorithm that receives oracle access to a collection of partial assignments {fS : S → Σ | S ∈ S} on sets of S, where fS ∈ C|S for any S ∈ S. The tester queries a few of the fS’s, and is required to accept with probability one any collection (fS)S that is consistent with some global codeword g ∈ C (that is, g|S = fS for any S ∈ S), while rejecting any inconsistent collection (fS)S with probability proportional to the minimal fraction of fS’s that must be changed in order to be consistent with some global codeword. In this work we focus on the two query agreement tester that picks a pair of sets S, S0 ∈ S according to some distribution 0 and accepts if and only if fS and fS0 agree on their intersection S ∩ S . Agreement testing has first appeared in PCP constructions [3, 2] as so-called “low degree tests”, and is a key component in the proof of almost all PCP theorems. A prime example is the line vs. line low degree test [17, 26] in the proof of the PCP theorem. In the PCP construction, a function on a large vector space is replaced by an ensemble of (supposed) restrictions to all possible affine lines. These restrictions are supplied by a prover and are not a priori guaranteed to agree with any single global function. The “low degree test” is run by the verifier to check that restrictions on intersecting lines agree with each other, i.e. they give the same value to the point of intersection. The main point of the argument is to show that the passing of the test implies agreement with a single global function. In these early low degree tests (including the linearity testing work of [10]) an agreement test component can be discerned but quite implicitly. Indeed, it was only separated in the works [25, 4] that looked at the so-called list-decoding regime5, with the goal of proving a large gap for the PCP. Goldreich and Safra [18] tried to separate the algebraic aspect of the low degree test from the combinatorial, and formulated a more general “consistency test” which is also referred to as an agreement test. They also proved a certain local to global result which was too weak to be useful for PCPs. In hindsight it is clear that since their family of subsets consisted of axis parallel lines, the expansion was not strong enough for a good agreement test. Only recently [13] the role of expansion underlying the family of subsets had begun to be uncovered. Work on agreement testing then continued the combinatorial direction of [18] mainly in the list-decoding regime for direct product testing [15, 12, 22, 16, 14]. The techniques developed in this line of work turn out to be useful also for agreement testing in the unique-decoding regime (which is the more standard testing regime), and in particular for our work here.

2.2 Agreement testing implies robust testing We begin with an overview of the simpler implication from agreement testing to robust testing. Suppose that we have a two query agreement tester for C, S as described above. We would like to show that the local tester that queries a random S ∈ S is robust. Let T be the collection of subsets of U formed by pairwise intersections of sets in S. The main properties we need out of S, T are sampling properties, speciﬁcally, that S samples well the set of points U, and that for any S ∈ S all sets in T contained in S sample well the set of points in S. The main property we need out of the code is that its restrictions to sets in T

5 In the list decoding regime one would like to reject a function that is (1 − )-far from the code with very high-probability of 1 − O().

I T C S 2 0 1 9 29:6 From Local to Robust Testing via Agreement Testing

have distance. In the case of lifted codes these properties can be guaranteed by letting S, T be families of affine subspaces of fixed dimension. To see that the proposed local tester is indeed robust, suppose that we have a function f : U → Σ that is close to C|S on a typical S, our goal is to show that f is close to a codeword g ∈ C. We first create an instance (fS)S for the agreement tester by letting fS ∈ C|S be the closest valid assignment to f|S. Next observe that since f|S is typically close to fS, and by assumption that T ’s sample well inside S’s, for a typical T and S, S0 containing T it holds that fS|T ≈ f|T ≈ fS0 |T , and by distance property on T this implies in turn that typically fS|T = fS0 |T . Consequently, agreement testability implies the existence of a codeword g ∈ C that agrees with most fS, and so g|S = fS ≈ f|S for most S. But since S samples well inside U we conclude that f must be close to g as required.

2.3 Local testing implies agreement testing

We now turn to the local testing to agreement testing implication which is a bit more involved. Suppose that we have a local testing algorithm for C that queries a random set K ∈ K and accepts if and only if f|K ∈ C|K . We would like to obtain an agreement tester for C with respect to some collection of subsets S. As before, let T be the collection of subsets of U formed by pairwise intersections of sets in S. Once more the main properties we require out of S, T , K are sampling properties. Specifically, we need that S samples well inside U, and that for any T ∈ T all sets in K contained in T sample well inside T . We also require distance properties out of C, specifically that C has distance on U and on restrictions to sets in S and T . Once more, in the case of lifted codes these properties can be guaranteed by letting S, T , K be families of affine subspaces of fixed dimension.

To show agreement testability, let (fS)S be a collection of valid assignments to sets in 0 S (so fS ∈ C|S for any S), and suppose that fS agrees with fS0 on S ∩ S for most pairs 0 S, S . Our goal will be to ﬁnd a global codeword g ∈ C that agrees with most fS. We ﬁnd the function g in the following three stages.

Initial stage

In the ﬁrst stage we deﬁne for any K ∈ K a “most popular function” PlurK by choosing the most common value among fS|K going over all S ∈ S containing K. We then show, using the assumption that fS’s typically agree on their intersections, that this most popular function is obtained with overwhelming probability for a typical K.

Local structure stage

In the second stage we define for each K ∈ K a function gK : U → Σ by letting gK (x) be the most common “vote” among all fS that contain K and x and agree with PlurK on K (this function is well defined because of the initial stage). We then show that for a typical K, gK is close to some function hK ∈ C, and moreover hK |S = fS for most S containing K. To see why the above holds, first note that by assumptions that C has distance on T ’s, and K’s sample well inside T ’s, if a pair of fS’s agree on K then they must typically also agree on their whole intersection. Therefore gK (x) is also typically defined with overwhelming 0 probability. Consequently, for a typical K, and most K , gK |K0 agrees with some fS. Recalling that fS’s are valid assignments, local testability then implies the existence of hK ∈ C that is close to gK . The fact that hK |S = fS for most S containing K follows by assumption that S samples well U, and distance property on S. I. Dinur, P. Harsha, T. Kaufman, and N. Ron-Zewi 29:7

Global structure stage

ˆ In the final stage we show that there exists K such that hKˆ agrees with fS for most S ˆ (not necessarily containing K). We can then set our “global function” g to be equal to hKˆ . To this end, we first observe that it suffices to show that most functions hK are in fact 0 identical. This now follows since for typical S ⊇ K ∪ K it holds that hK |S = fS = hK0 |S, and consequently since S samples U it must typically hold that hK = hK0 .

2.4 The proof method of Guo et al

The proof method of Guo et al [19] for showing robustness of lifted codes is very different from ours. In particular, it relies heavily on the algebraic structure of lifted codes. More specifically, the proof is based on viewing the lifted codes as the intersection of “modified ⊗m tensor codes”. The tensor product C of a code C ⊆ {Fq → Fq} can be thought of as the m ’axis-parallel lifting’ of C, that is, it is the code that consists of all functions f : Fq → Fq whose restrictions to any axis-parallel line belong to C. The “modified tensor code” is a code ⊗m m ⊗m ⊗m of the form Cb where b is a direction in Fq , and Cb consists of all functions f ∈ C whose restrictions to lines in direction b also belong to C. The authors first use the proof method of [27], showing robust testing of tensor codes, to show that the modified tensor codes are also robustly testable. They then use the fact that ⊗m the lifted code is the intersection of all codes of the form Cb for all directions b (this is true when the dimension of the base code for lifting is ` = 1; when ` > 1 the proof becomes more complicated) to deduce robust testability for the lifted code. However, since intersection of robustly testable codes is not necessarily robustly testable, a non-trivial work is required to show robust testability, which in particular exploits the degree structure of affine-invariant lifted codes. The above program can be carried out only when the dimension m of the lifted code is a small constant multiple of `, and the authors use the “bootstrapping” technique [26, 2, 4, 1] to extend the result to work for arbitrary large m. In contrast, we work directly with lifted codes of large dimension which allows us to m exploit the sampling / expansion properties of large affine subspaces in Fq . To the best of our knowledge, even for the special case of low-degree polynomials, this gives the first analysis of robustness that is not based on the two step approach of first analyzing the constant dimensional case and only then moving to the general dimensional case. As opposed to [19] who reprove local testability on the way, our proof uses local testability in a black-box manner. Thus, it exhibits a separation between the algebraic properties that are used for showing local testability, and the combinatorial properties that are needed in order to turn local testability into robust testability.

Paper organization

The rest of the paper is organized as follows. In Section 3 we set some notation, provide some deﬁnitions, and present the expansion properties of subspaces that we use. The transformation from agreement testing to robust testing is given in Section 4, while the transformation from local testing to agreement testing apperas in Section 5. We wrap-up in Section 6 with the full transformation from local testing to robust testing that proves our main Theorem 1 and Corollary 2.

I T C S 2 0 1 9 29:8 From Local to Robust Testing via Agreement Testing

3 Preliminaries

m For a prime power q, let Fq denote the finite field of q elements. Let {Fq → Fq} denote the m set of functions mapping Fq to Fq. In what follows we focus on codes which are subsets m m of functions C ⊆ {Fq → Fq}. For a pair of functions f, g : Fq → Fq we use dist(f, g) to m denote the fraction of inputs x ∈ Fq for which f(x) 6= g(x). The relative distance dist(C) of m the code C is minf6=g∈C {dist(f, g)}. For a function f : Fq → Fq we use dist(f, C) to denote ming∈C {dist(f, g)}. The code C is said to be linear if it is an Fq-linear subspace, i.e., for every α ∈ Fq and m m f, g ∈ C, we have αf +g ∈ C. A function A : Fq → Fq is said to be an affine transformation m×m m if there exist a matrix M ∈ Fq and a vector b ∈ Fq such that A(x) = Mx + b. The code C is said to be affine-invariant if for every affine transformation A and every f ∈ C we have f ◦ A ∈ C (where (f ◦ A)(x) = f(A(x))).

3.1 Lifted codes

m m A subset L ⊆ Fq is said to be an `-dimensional affine subspace if there exist α0 ∈ Fq and m P` linearly independent α1, . . . , α` ∈ Fq such that L = {α0 + i=1 αixi|x1, . . . , x` ∈ Fq}. We ` fix an arbitrary affine map γL : Fq → L (which we can view as a parameterization of L). For m ` a function f : Fq → Fq, the restriction f|L is viewed as a function in {Fq → Fq} through ? ` ` f ◦ γL : Fq → Fq. In particular, when we ask if f|L ∈ C ⊆ {Fq → Fq} what we are really asking is whether f ◦ γL ∈ C. Note that if C is affine-invariant, whether f|L ∈ C does not depend on the choice of the parametrization γL.

` I Deﬁnition 3 (Lifted codes). Let C ⊆ {Fq → Fq} be an aﬃne-invariant linear code, and m ≥ `. The m-dimensional lift C`%m of C is given by

`%m m m C := f : Fq → Fq | f|L ∈ C for every `-dimensional aﬃne subspace L ⊆ Fq .

` I Proposition 4 (Distance of lifted codes, [20], Theorem 5.1, Part (2)). Let C ⊆ {Fq → Fq} be an aﬃne-invariant linear code, and m ≥ `. Then dist(C`%m) ≥ dist(C) − q−`.

3.2 Local testing, robust testing, and agreement testing We now formally deﬁne the notions of local testing, robust testing, and agreement testing, specialized to the class of lifted codes and subspace testers. In the case of local testing and robust testing this simply means that the tester samples a uniform random k-dimensional aﬃne subspace and its accepting views are codewords in C`%k.

` I Deﬁnition 5 (Local testing of lifted codes). Let C ⊆ {Fq → Fq} be an aﬃne-invariant linear code, and m ≥ k ≥ `. The m-dimensional lift C`%m is (k, α)-testable if for every m f : Fq → Fq it holds that

`%k `%m Pr f|K ∈/ C ≥ α · dist(f, C ), K

m where the probability is over a uniform random k-dimensional aﬃne subspace K ⊆ Fq .

` I Theorem 6 ([23], Theorem 2.9). Let C ⊆ {Fq → Fq} be an aﬃne-invariant linear code, m and m ≥ `. Then the `-dimensional test rejects a function f : Fq → Fq with probability at 1 −2` `%m `%m q−2` least 2 · min q , dist(f, C ) . In particular, C is `, 2 -testable. I. Dinur, P. Harsha, T. Kaufman, and N. Ron-Zewi 29:9

` I Deﬁnition 7 (Robust testing of lifted codes). Let C ⊆ {Fq → Fq} be an aﬃne-invariant linear code, and m ≥ k ≥ `. The m-dimensional lift C`%m is (k, α)-robust if for every m f : Fq → Fq it holds that

`%k `%m EK dist(f|K ,C ) ≥ α · dist(f, C ),

m where the expectation is over a uniform random k-dimensional aﬃne subspace K ⊆ Fq . We note the following easy implications.

` I Proposition 8. Let C ⊆ {Fq → Fq} be an aﬃne-invariant linear code, and m ≥ k ≥ `. Then the following hold. 1. If C`%m is (k, α)-robust then it is (k, α)-testable. 2. If C`%m is (k, α)-testable then it is (k, α · q−k)-robust. 3. If C`%m is (k, α)-testable then it is (r, α)-testable for any k ≤ r ≤ m. 4. If C`%m is (k, α)-robust then it is (r, α)-robust for any k ≤ r ≤ m.

`%k `%k Proof. Part (1) follows since f|K ∈/ C whenever dist(f|K ,C ) > 0, while Part (2) `%k −k `%k follows since dist(f|K ,C ) ≥ q whenever f|K ∈/ C . Part (3) follows by observing that for a uniform random r-dimensional aﬃne subspace R,

`%r 1 `%r Pr f|R ∈/ C = ER f|R∈/C R `%k ≥ ER Pr f|K ∈/ C K⊆R `%k = Pr f|K ∈/ C , K

`%r `%k where the inequality follows since f|R ∈ C implies that f|K ∈ C for any K. `%r Finally, Part (4) follows by letting fR be the codeword in C that is closest to f|R, and noting that

`%k where the inequality follows since fR|K ∈ C for any K. J

We now turn to the definition of agreement testing. The agreement testers we consider are two query testers that for t < s, sample a uniform random t-dimensional affine subspace T , and a pair of uniform random s-dimensional affine subspaces S, S0 containing T , and accept if and only if fS, fS0 agree on T . m For a code C ⊆ {Fq → Fq} we let C(s) be the code containing all collections (fS)S of partial assignments to s-dimensional affine subspaces that are consistent with some global codeword g ∈ C, formally, C(s) := (fS)S | ∃ g ∈ C such that g|S = fS for any s-dimensional affine subspace S .

For a pair of collections (fS)S, (gS)S of partial assignments to s-dimensional affine subspaces we denote by dist((fS)S, (gS)S) the fraction of s-dimensional affine subspaces S for which fS 6= gS, and we define dist((fS)S,C(s)) accordingly.

I T C S 2 0 1 9 29:10 From Local to Robust Testing via Agreement Testing

` I Definition 9 (Agreement testing of lifted codes). Let C ⊆ {Fq → Fq} be an affine-invariant linear code, and m ≥ s > t ≥ `. The m-dimensional lift C`%m is (s, t, α)-agreement testable `%s if for every collection (fS)S where fS ∈ C for every s-dimensional affine subspace S it holds that

`%m Pr [fS|T 6= fS0 |T ] ≥ α · dist (fS)S,C (s) , T,S⊇T,S0⊇T

m where the probability is over a uniform random t-dimensional aﬃne subspace T ⊆ Fq , and uniform random s-dimensional aﬃne subspaces S, S0 containing T .

3.3 Subspace expansion

m Let d0, d1, d2 ∈ {0, 1, . . . , m} be integers, and let W ⊆ Fq be a ﬁxed aﬃne subspace of

dimension d0. We denote by Id1,d2 (d0) the bipartite graph whose left side are all d1- m dimensional aﬃne subspaces of Fq , whose right side are all d2-dimensional aﬃne subspaces m of Fq containing W , and an edge (U, V ) is present in the graph if and only if U ⊆ V (note that the structure of the graph is independent of the choice of W ). Our proof makes use of expansion properties of this graph.

I Proposition 10. The second largest normalized singular value of the adjacency matrix of −(d2−d1−d0)/2 Id1,d2 (d0) is at most q .

Proof. Let Gr(m, d1) be the Grassmann graph whose vertices are d1-dimensional spaces and edges connect two d1-spaces that intersect on an d1 − 1 space. We quote [11, Theorem 9.3.3] that gives the un-normalized eigenvalues d − jn − d − j j θ = qj+1 1 1 − j 1 1 1 and the degree is d n − d k = q 1 1 1 1 Plugging in j = 1 one gets the second largest eigenvalue in absolute value is approximately 1 λ(Gr(m, d )) ≈ √ . (3) 1 q

d2−d1 It can be shown that λ(Id1,d2 (0)) ≈ (λ(Gr(m, d1))) . When adding W we are

essentially moving to the graph Id1,d2−d0 (0), i.e. λ(Id1,d2 (d0)) ≈ λ(Id1,d2−d0 (0)). J

We shall use the following sampling property of Id1,d2 (d0).

I Proposition 11. Let G = (L ∪ R,E) be a bipartite graph with second largest normalized singular value λ. Then for any subset A ⊆ L of density α it holds that |N(A)| ≥ (1−λ2/α)·|R| where N(A) denotes the set of neighbors of A in R.

Proof. Let B := R \ N(A) and β := |B|/|R|. Noting that Pr(u,v)∈E[u ∈ A ∧ v ∈ B] = 0, by expander mixing lemma (see e.g., [13, Lemma 2.8.]) we have that

p αβ = Pr [u ∈ A ∧ v ∈ B] − αβ ≤ λ αβ, (u,v)∈E

2 2 and so β ≤ λ /α. It follows that |N(A)| = (1 − β)|R| ≥ (1 − λ /α)|R|. J I. Dinur, P. Harsha, T. Kaufman, and N. Ron-Zewi 29:11

4 From agreement testing to robust testing

In this section we prove the following lemma showing the agreement testing to robust testing implication.

` I Lemma 12 (Agreement testing implies robust testing). Let C ⊆ {Fq → Fq} be an aﬃne- invariant linear code, and m ≥ s > t ≥ `. Suppose that C`%m is (s, t, α)-agreement testable, and let δ := dist(C`%t). Then C`%m is s, Ω(αδ)-robust.

Proof. For simplicity of notation, in what follows we let T,S denote the random variables obtained by sampling a uniform random affine subspace of dimension t, s respectively. Suppose m `%s `%m that f : Fq → Fq has ES[dist(f|S,C )] ≤ , our goal is to find a codeword g ∈ C such that dist(f, g) ≤ O(/(αδ)). The proof proceeds as follows. We would like to apply our assumption on agreement testability, and towards this, we create an instance (fS)S for the agreement tester by letting `%s fS be the codeword in C that is closest to f|S. We then use the fact that fS is typically close to f|S, together with the fact that t-dimensional affine subspaces sample well inside s-dimensional affine subspaces, and the assumption that C has distance on t-dimensional affine subspaces, to show that PrT,S⊇T,S0⊇T [fS|T 6= fS0 |T ] is small. Agreement testability `%m then gives a codeword g ∈ C that is consistent with most fS, and using the fact that m s-dimensional affine subspaces sample well inside Fq this implies in turn that dist(f, g) is small. Details follow.

We begin by showing that PrT,S⊇T,S0⊇T [fS|T 6= fS0 |T ] is small. Recall first that `%s ES[dist(f|S, fS)] = ES[dist(f|S,C )] ≤ . Next observe that for a fixed s-dimensional affine subspace S, any point in a uniform random t-dimensional affine subspace contained in S is uniform in S. Thus we also have that ES, T ⊆S[dist(f|T , fS|T )] ≤ , and consequently Pr dist(fS|T , fS0 |T ) ≥ δ ≤ 2 · Pr dist(f|T , fS|T ) ≥ δ/2 T,S⊇T,S0⊇T T,S⊇T = 2 · Pr dist(f|T , fS|T ) ≥ δ/2 S, T ⊆S 4 ≤ . δ `%t But since fS|T , fS0 |T are both codewords of C , a code of relative distance δ, the above 4 implies in turn that PrT,S⊇T,S0⊇T [fS|T 6= fS0 |T ] ≤ δ . Our assumption on agreement testability now gives a codeword g ∈ C`%m that has PrS[g|S 6= fS] ≤ 4/(αδ). But since any point in a uniform random s-dimensional affine m subspace is uniform in Fq this gives in turn that 4 5 dist(f, g) = dist(f| , g| ) ≤ dist(f| , f )+ dist(f , g| ) ≤ + ≤ . ES S S ES S S ES S S αδ αδ J

5 From local testing to agreement testing

In this section we prove the following lemma that gives the local testing to agreement testing implication.

` I Lemma 13 (Local testing implies agreement testing). Let C ⊆ {Fq → Fq} be an aﬃne- invariant linear code, and m ≥ k ≥ `. Suppose that C`%m is (k, α)-testable, and let `%r `%m 2 δ := mink≤r≤m dist(C ). Then C is (2k + logq(4/δ), k + 1, Ω(α · δ ))-agreement testable.

I T C S 2 0 1 9 29:12 From Local to Robust Testing via Agreement Testing

Proof outline

For simplicity of notation, in what follows let s := 2k + logq(4/δ) and t := k + 1. We let both S, S0 (T , T 0 and K, K0, resp.) denote random variables obtained by sampling a uniform random aﬃne subspace of dimension s (t, k, resp.). `%s Let (fS)S be a collection of partial assignments such that fS ∈ C for every S, and

Pr [fS|T 6= fS0 |T ] ≤ . (4) T,S⊇T,S0⊇T

Our goal is to find a global codeword g ∈ C`%m that has Pr[g|S 6= fS] ≤ O . (5) S α · δ2 We find the codeword g in three stages. 1. In the initial stage (Section 5.1) we define for any k-dimensional affine subspace K a k “most popular function” PlurK : Fq → Fq by choosing the most common value among fS|K going over all S ⊇ K. We show that for a typical K, this function is obtained with an overwhelming plurality of 1 − O(). 2. In the “local structure” stage (Section 5.2) we define for any k-dimensional affine subspace m K a function gK : Fq → Fq by letting gK (x) be the most common “vote” among all fS that contain both K and x and agree with PlurK on K. We then show that for a `%m typical K, gK is close to some codeword hK ∈ C , and moreover hK |S = fS for most S containing K. 3. In the “global structure” stage (Section 5.3) we show that there exists Kˆ for which ˆ hKˆ |S = fS for most S (not necessarily containing K). We can then set our “global function” g to be equal to hKˆ .

5.1 Initial stage

k For any k-dimensional aﬃne subspace K we let PlurK : Fq → Fq denote the most common value among fS|K for S containing K, that is,

PlurK := pluralityS⊇K {fS|K }.

Next we use our assumption (4) to show that for a typical K, the function PlurK is obtained with overwhelming plurality.

I Lemma 14. EK Pr fS|K 6= PlurK ≤ 2. S⊇K

Proof. Since the collision probability lower bounds the probability of hitting the most common value, it suﬃces to show that Pr fS|K 6= fS0 |K ≤ 2. (6) K,S⊇K,S0⊇K

Clearly if t = k we would be done by (4), so the whole point is to show the same for 0 t > k. We describe a distribution on triples (S1,S ,S2) such that (S1,S2) are distributed as 0 0 in (6) but the pairs (S1,S ) and (S ,S2) are distributed as in (4): 1. Choose a uniform random k-dimensional aﬃne subspace K. 2. Choose a pair of uniform random t-dimensional aﬃne subspaces T1,T2 containing K. I. Dinur, P. Harsha, T. Kaufman, and N. Ron-Zewi 29:13

3. For i = 1, 2, choose a uniform random s-dimensional aﬃne subspace Si containing Ti. 0 4. Choose a uniform random s-dimensional aﬃne subspace S containing T1 ∪ T2 (this can be done since t = k + 1 and s ≥ k + 2).

0 One can check that indeed K,S1,S2 are distributed as in (6) while Ti,Si,S are distributed as in (4). Thus by our assumption (4), Pr fS1 |K 6= fS2 |K K,S1⊇K,S2⊇K ≤ Pr fS |T 6= fS0 |T + Pr fS0 |T 6= fS |T ≤ 2. 0 1 1 1 0 2 2 2 J T1,S1⊇T1,S ⊇T1 T2,S ⊇T2,S2⊇T2

5.2 Local structure

m Next we deﬁne for every k-dimensional aﬃne subspace K the function gK : Fq → Fq. As m described above, for every x ∈ Fq , we let gK (x) be the most common value among fS(x) for S that contain both K and x and agree with PlurK on K, that is,

gK (x) := pluralityS⊇K∪{x}, fS |K =PlurK {fS(x)}. `%m Next we would like to show that for a typical K, gK is close to some codeword hK ∈ C , and additionally hK |S = fS for most S containing K. We show these in three steps: 1. Boosting step (Lemma 15): In this step we show that for typical K, x, the plurality in the definition of gK (x) is obtained with overwhelming probability. 2. LTC step (Lemma 16): In this step we use the previous step to show that for a typical 0 0 `%k gK , for most K , gK |K0 agrees with some fS on K , and therefore is a codeword of C . By local testability assumption this implies in turn that such gK is close to being in the `%m `%m code C , and we denote by hK ∈ C the closest codeword to gK . 3. Agreement step (Lemma 17): In this step we show that a typical hK agrees with most fS for S ⊇ K. We start with the boosting step, showing that for typical K, x, the plurality in the definition of gK (x) is obtained with overwhelming probability. Intuitively, this follows by assumption that the code has distance on t-dimensional affine subspaces, together with the fact that k-dimensional affine subspaces sample well inside t-dimensional affine subspaces, which imply that if a pair of fS agree on K then they must typically also agree on their whole intersection.

I Lemma 15 (Boosting step). −k EK, x/∈K Pr fS(x) 6= gK (x) fS|K = PlurK ≤ O q · . S⊇K∪{x} δ · (1 − 4) Proof. Since the collision probability lower bounds the probability of hitting the most common value, it suﬃces to show that −k Pr fS (x) 6= fS0 (x) | fS |K = fS0 |K = PlurK ≤ O q · . K, x∈ /K, S⊇K∪{x},S0⊇K∪{x} δ · (1 − 4) Now we have that Pr fS (x) 6= fS0 (x) | fS |K = fS0 |K = PlurK K, x∈ /K, S⊇K∪{x},S0⊇K∪{x} ≤ Pr fS |T 6= fS0 |T | fS |K = fS0 |K = PlurK K, T ⊇K, S⊇T,S0⊇T PrT,S⊇T,S0⊇T,K⊆T fS |K = fS0 |K = PlurK | fS |T 6= fS0 |T · PrT,S⊇T,S0⊇T fS |T 6= fS0 |T = . PrK, T ⊇K, S⊇T,S0⊇T fS |K = fS0 |K = PlurK

I T C S 2 0 1 9 29:14 From Local to Robust Testing via Agreement Testing

Next we bound each of the terms above. By our assumption (4), the right hand term in the numerator is upper bounded by . To bound the denominator note that by Lemma 14,

Pr [fS|K = fS0 |K = PlurK ] ≥ 1 − 2 · Pr [fS|K 6= PlurK ] ≥ 1 − 4. (7) K,T ⊇K,S⊇T,S0⊇T K,S⊇K

To bound the left hand term in the numerator note first that since fS, fS0 are both `%s `%t codewords of C then fS|T , fS0 |T are distinct codewords in C , and so dist(fS|T , fS0 |T ) ≥ δ. We now apply Propositions 10 and 11 on the graph I0,k(0): The ambient space is T , and the graph connects the points of T (which are the 0-dimensional affine subspaces contained in T ) on the left to the k-dimensional affine subspaces contained in T on the right. By −k/2 Proposition 10 the graph I0,k(0) has second largest normalized singular value at most q , −k and so taking A = {x ∈ T | fS(x) 6= fS0 (x)} in Proposition 11 we deduce that at most q /δ fraction of K can miss A altogether. Thus,

−k q Pr fS|K = fS0 |K fS|T 6= fS0 |T ≤ . (8) T,S⊇T,S0⊇T,K⊆T δ

The ﬁnal bound is obtained by combining the bounds in (4), (7), and (8). J

Next we use the assumption on local testability to show that for a typical K, gK is close to being a codeword of C`%m.

I Lemma 16 (LTC step). distg ,C`%m ≤ O . EK K α · δ

Proof. To apply our assumption on local testability we first show that gK |K0 is typically `%k `%k a codeword of C . For this, first observe that if gK |K0 is not a codeword of C then `%s `%k gK |K0 6= fS|K0 for all S (since fS ∈ C and so fS|K0 ∈ C ). Thus we have 0 1 `%k 0 0 0 EK,K gK | 0 ∈/C ≤ EK,K Pr [gK |K 6= fS|K ] K S⊇K∪K0 ≤ EK,K0 Pr gK |K0 6= fS|K0 fS|K = PlurK + Pr [fS|K 6= PlurK ] S⊇K∪K0 K,S⊇K We claim that the above expression is at most O(/δ). To see this note first that by Lemma 14 the right hand term is at most 2 . To bound the left hand term, note that since 0 m each individual point in K is uniformly distributed in Fq this term is upper bounded by k q · EK, x Pr gK (x) 6= fS(x) fS|K = PlurK , S⊇K∪{x}

which is in turn at most O(/δ) by Lemma 15 (noting that the probability in the above expression is zero whenever x ∈ K). `%k Finally, for any k-dimensional aﬃne subspace K let K := PrK0 gK |K0 ∈/ C . Then on the one hand [ ] = 0 1 `%k ≤ O(/δ), and on the other hand EK K EK,K gK |K0 ∈/C `%m `%m dist(gK ,C ) ≤ K /α for any K by assumption that C is (k, α)-testable. We conclude that h i distg ,C`%m ≤ K ≤ O . EK K EK α α · δ J I. Dinur, P. Harsha, T. Kaufman, and N. Ron-Zewi 29:15

`%m For any k-dimensional aﬃne subspace K let hK ∈ C be the codeword that is closest to gK . Then by the above lemma, dist(g , h ) ≤ O . EK K K α · δ

The following lemma says that for a typical K we have that hK |S = fS for most S containing m K, which follows by the fact that s-dimensional aﬃne subspaces sample well inside Fq and by assumption that the code has distance on s-dimensional aﬃne subspaces.

I Lemma 17 (Agreement step). EK Pr hK |S 6= fS ≤ O . S⊇K α · δ2

Proof. We show that for typical S ⊇ K, on the one hand, by Lemma 16 and the fact that m s-dimensional aﬃne subspaces sample well inside Fq , dist(hK |S, gK |S) is small, and on the other hand, by Lemma 15, dist(gK |S, fS) is small. We then conclude by triangle inequality that dist(hK |S, fS) is small, which implies in turn that hK |S = fS by assumption that the code has distance on s-dimensional subspaces.

We start by showing that dist(hK |S, gK |S) is typically small. For this note that for a ﬁxed k-dimensional aﬃne subspace K and uniform random S containing K, each individual m point in S \ K is uniformly distributed in Fq \ K. Thus we have

δ dist(h | , g | ) ≤ q−(s−k) + dist(h , g ) ≤ + O , (9) EK,S⊇K K S K S EK K K 4 α · δ where the last inequality follows by choice of s ≥ k + logq(4/δ) and Lemma 16. Next we show that dist(hK |S, fS) is typically small. For this note that

EK, S⊇K dist(gK |S , fS ) −(s−k) ≤ q + EK, x∈ /K Pr gK (x) 6= fS (x) S⊇K∪{x} −(s−k) ≤ q + EK, x∈ /K Pr gK (x) 6= fS (x) fS |K = PlurK + Pr [fS |K 6= PlurK ] S⊇K∪{x} K, S⊇K δ ≤ + O , (10) 4 δ

where the last inequality follows by choice of s ≥ k + logq(4/δ) and Lemmas 15 and 14. Combining (9) and (10), by triangle inequality we have that

δ dist(h | , f ) ≤ + O , EK,S⊇K K S S 2 α · δ and by Markov’s inequality,

Pr dist(hK |S, fS) ≥ δ ≤ O . K,S⊇K α · δ2

`%s `%s Finally, since both hK |S and fS are codewords of C and dist(C ) ≥ δ we conclude that hK |S 6= fS with probability at most O α·δ2 over the choice of K and S ⊇ K. J

I T C S 2 0 1 9 29:16 From Local to Robust Testing via Agreement Testing

5.3 Global structure We now complete the proof of Lemma 13 by showing that there exists a codeword g ∈ C`%m that agrees with most fS. We start by showing that most functions hK are in fact identical, which follows by Lemma 17 and the fact that s-dimensional affine subspaces sample well m inside Fq . ˆ I Lemma 18. There exists a k-dimensional affine subspace K such that Pr hK 6= h ˆ ≤ O . K K α · δ2 Proof. By Lemma 17, Pr hK |S 6= hK0 |S ≤ 2 · Pr hK |S 6= fS ≤ O , K,K0,S⊇K∪K0 K,S⊇K α · δ2 and so by averaging there exists Kˆ such that Pr hK |S 6= hKˆ |S ≤ O 2 . K,S⊇K∪Kˆ α · δ Markov’s inequality then implies that 1 Pr hK |S 6= hKˆ |S ≥ S⊇K∪Kˆ 2 with probability at most O α·δ2 over the choice of K. `%m Next observe that if hK 6= hKˆ then since hK , hKˆ are both codewords of C and `%m dist(C ) ≥ δ, it must hold that dist(hK , hKˆ ) ≥ δ. We now apply Propositions 10 and 11 m on the graph I0,s(2k) that connects the points of Fq on the left to the s-dimensional affine subspaces containing K ∪Kˆ on the right. By Proposition 10 the graph I0,s(2k) has second largest −(s−2k)/2 m normalized singular value at most q , and so taking A = x ∈ Fq hK (x) 6= hKˆ (x) in Proposition 11 we deduce that −(s−2k) q Pr hKˆ |S 6= hK |S ≥ 1 − ≥ 1/2, S⊇Kˆ ∪K δ

where the last inequality follows by assumption that s ≥ 2k + logq(2/δ). It now follows that hK 6= hKˆ with probability at most O α·δ2 over the choice of K. J We can now complete the proof of Lemma 13.

`%m Proof of Lemma 13. Set g ∈ C to be the function hKˆ guaranteed by Lemma 18. By Lemmas 17 and 18, Pr g|S 6= fS = Pr g|S 6= fS ≤ Pr g 6= hK + Pr hK |S 6= fS ≤ O . S K,S⊇K K K,S⊇K α · δ2 So g satisﬁes (5) as required. J

6 From local testing to robust testing 6.1 Proof of Main Theorem 1 We can now combine Lemmas 12 and 13 to prove our main Theorem 1, showing a transformation from local testing to robust testing.

`%m 2 Proof of Theorem 1. By Lemma 13 we have that C is (2k + logq(4/δ), k + 1, Ω(α · δ ))- `%m agreement testable, and by Lemma 12 this implies in turn that C is (2k +logq(4/δ), Ω(α· 3 δ ))-robust. J I. Dinur, P. Harsha, T. Kaufman, and N. Ron-Zewi 29:17

6.2 Proof of Corollary 2 We now instantiate our main Theorem 1 with Theorem 6 to show that lifted codes are robustly testable. For this, we ﬁrst observe that one can amplify the soundness of the tester given by Theorem 6 to a constant (independent of q and `) at the cost of increasing the testing dimension to ≈ 3`.

` I Proposition 19. Let C ⊆ {Fq → Fq} be an aﬃne-invariant linear code, and m ≥ 3`+logq 4. `%m Then C is 3` + logq 4, Ω(1) -testable. 1 `%m Proof. If the `-dimensional test rejects with probability at least 2 · dist(f, C ) then by Part (3) of Proposition 8, the (3` + logq 4)-dimensional test also rejects with the same probability and we are done. Otherwise, by Theorem 6, the `-dimensional test rejects with 1 −2` probability at least 2 · q .

Consider the graph I`,3`+logq 4(0) with left hand side being all `-dimensional affine m subspaces of Fq and right hand side being all (3` + logq 4)-dimensional affine subspaces of m Fq . Next we apply Propositions 10 and 11 on the graph I`,3`+logq 4(0) with A being the collection of all `-dimensional affine subspaces on which the `-dimensional test rejects. Noting that the (3` + logq 4)-dimensional test will reject on any neighbor of A we conclude that the q−(2`+logq 4) 1 (3` + logq 4)-dimensional test rejects with probability at least 1 − q−2`/2 = 2 . J We now turn to the proof of Corollary 2.

Proof of Corollary 2. Suppose ﬁrst that δ < 2q−`. In this case by Theorem 6, C`%m is (`, Ω(q−2`))-testable, and so by Part (2) of Prposition 8, C`%m is also robustly testable using the `-dimensional test with robustness Ωq−3` ≥ Ω(δ3). By Part (4) of Proposition 8 it 3 follows that the (6` + logq(128/δ))-dimensional test also has robustness Ω(δ ). Next assume that δ ≥ 2q−`. In this case Proposition 4 gives that dist(C`%r) ≥ δ/2 for any ` ≤ r ≤ m, and so we may apply Proposition 19 and Theorem 1 and conclude that `%m 3 C is (6` + logq(128/δ), Ω(δ ))-robust. J

References 1 Sanjeev Arora. Probabilistic checking of proofs and hardness of approximation problems. PhD thesis, Princeton University, 1994. 2 Sanjeev Arora, Carsten Lund, Rajeev Motwani, Madhu Sudan, and Mario Szegedy. Proof veriﬁcation and the hardness of approximation problems. Journal of the ACM, 45(3):501– 555, May 1998. 3 Sanjeev Arora and Shmuel Safra. Probabilistic Checking of Proofs: A New Characterization of NP. Journal of the ACM, 45(1):70–122, January 1998. 4 Sanjeev Arora and Madhu Sudan. Improved Low Degree Testing and its Applications. Combinatorica, 23(3):365–426, 2003. 5 Eli Ben-Sasson, Oded Goldreich, Prahladh Harsha, Madhu Sudan, and Salil P. Vadhan. Robust PCPs of Proximity, Shorter PCPs, and Applications to Coding. SIAM J. Comput, 36(4):889–974, 2006. 6 Eli Ben-Sasson, Prahladh Harsha, and Sofya Raskhodnikova. Some 3CNF Properties Are Hard to Test. SICOMP: SIAM Journal on Computing, 35, 2005. 7 Eli Ben-Sasson, Ghid Maatouk, Amir Shpilka, and Madhu Sudan. Symmetric LDPC Codes are not Necessarily Locally Testable. In IEEE Conference on Computational Complexity, pages 55–65. IEEE Computer Society, 2011. doi:10.1109/CCC.2011.14. 8 Eli Ben-Sasson and Madhu Sudan. Robust locally testable codes and products of codes. Random Struct. Algorithms, 28(4):387–402, 2006. doi:10.1002/rsa.20120.

I T C S 2 0 1 9 29:18 From Local to Robust Testing via Agreement Testing

9 Eli Ben-Sasson and Michael Viderman. Composition of semi-LTCs by two-wise tensor products. Computational Complexity, 24(3):601–643, 2015. doi:10.1007/ s00037-013-0074-8. 10 Manuel Blum, Michael Luby, and Ronitt Rubinfeld. Self-Testing/Correcting with Applica- tions to Numerical Problems. In STOC, pages 73–83. ACM, 1990. 11 A. E. Brouwer, A. M. Cohen, and A. Neumaier. Distance-Regular Graphs. Springer Verlag, 1989. 12 Irit Dinur and Elazar Goldenberg. Locally Testing Direct Product in the Low Error Range. In FOCS, pages 613–622. IEEE Computer Society, 2008. doi:10.1109/FOCS.2008.26. 13 Irit Dinur and Tali Kaufman. High Dimensional Expanders Imply Agreement Expanders. In Chris Umans, editor, FOCS, pages 974–985. IEEE Computer Society, 2017. doi:10. 1109/FOCS.2017.94. 14 Irit Dinur and Inbal Livni-Navon. Exponentially Small Soundness for the Direct Product Z-Test. In Ryan O’Donnell, editor, Computational Complexity Conference, volume 79 of LIPIcs, pages 29:1–29:50. Schloss Dagstuhl - Leibniz-Zentrum fuer Informatik, 2017. doi: 10.4230/LIPIcs.CCC.2017.29. 15 Irit Dinur and Omer Reingold. Assignment Testers: Towards a Combinatorial Proof of the PCP Theorem. SIAM J. Comput, 36(4):975–1024, 2006. doi:10.1137/ S0097539705446962. 16 Irit Dinur and David Steurer. Direct Product Testing. In IEEE Conference on Computa- tional Complexity, pages 188–196. IEEE Computer Society, 2014. doi:10.1109/CCC.2014. 27. 17 Peter Gemmell, Richard J. Lipton, Ronitt Rubinfeld, Madhu Sudan, and Avi Wigder- son. Self-Testing/Correcting for Polynomials and for Approximate Functions. In Cris Koutsougeras and Jeﬀrey Scott Vitter, editors, STOC, pages 32–42. ACM, 1991. doi: 10.1145/103418.103429. 18 Goldreich and Safra. A Combinatorial Consistency Lemma with Application to Proving the PCP Theorem. SICOMP: SIAM Journal on Computing, 29, 1999. 19 Alan Guo, Elad Haramaty, and Madhu Sudan. Robust Testing of Lifted Codes with Ap- plications to Low-Degree Testing. In Venkatesan Guruswami, editor, FOCS, pages 825–844. IEEE Computer Society, 2015. doi:10.1109/FOCS.2015.56. 20 Alan Guo, Swastik Kopparty, and Madhu Sudan. New aﬃne-invariant codes from lifting. In ITCS, pages 529–540, 2013. 21 Elad Haramaty, Noga Ron-Zewi, and Madhu Sudan. Absolutely Sound Testing of Lifted Codes. Theory of Computing, 11:299–338, 2015. doi:10.4086/toc.2015.v011a012. 22 Russell Impagliazzo, Valentine Kabanets, and Avi Wigderson. New Direct-Product Testers and 2-Query PCPs. SIAM J. Comput, 41(6):1722–1768, 2012. doi:10.1137/09077299X. 23 Tali Kaufman and Madhu Sudan. Algebraic property testing: the role of invariance. In STOC, pages 403–412. ACM, 2008. doi:10.1145/1374376.1374434. 24 Swastik Kopparty, Or Meir, Noga Ron-Zewi, and Shubhangi Saraf. High-Rate Locally Correctable and Locally Testable Codes with Sub-Polynomial Query Complexity. Journal of ACM, 64(2):11:1–11:42, 2017. doi:10.1145/3051093. 25 Ran Raz and Shmuel Safra. A Sub-Constant Error-Probability Low-Degree Test, and a Sub-Constant Error-Probability PCP Characterization of NP. In STOC, pages 475–484. ACM, 1997. doi:10.1145/258533.258641. 26 Ronitt Rubinfeld and Madhu Sudan. Robust characterizations of polynomials with applications to program testing. SIAM Journal on Computing, 25(2):252–271, April 1996. 27 Michael Viderman. A combination of testability and decodability by tensor products. Ran- dom Struct. Algorithms, 46(3):572–598, 2015.