Low-degree Test Research Articles

ESTARK: extending STARKs with arguments

STARK is a widely used transparent proof system that uses low-degree tests for proving the correctness of a computer program. STARK consumes an intermediate representation known as AIR that is more appropriate for programs with a relatively short and structured description. However, an AIR is not able to succinctly express non-equality constraints, leading to the incorporation of unwanted polynomials. We present the eSTARK protocol, a new probabilistic proof that generalizes the STARK family through the introduction of a more generic intermediate representation called eAIR. We describe eSTARK in the polynomial IOP model, which combines the optimized version of the STARK protocol with the incorporation of three arguments into the protocol. We also explain various techniques that enhance the vanilla STARK complexity, including optimizations applied to polynomial computations, and analyze the tradeoffs between controlling the constraint degree either at the representation of the AIR or inside the eSTARK itself.

Proximity Gaps for Reed–Solomon Codes

A collection of sets displays a proximity gap with respect to some property if for every set in the collection, either (i) all members are δ-close to the property in relative Hamming distance or (ii) only a tiny fraction of members are δ-close to the property. In particular, no set in the collection has roughly half of its members δ-close to the property and the others δ-far from it. We show that the collection of affine spaces displays a proximity gap with respect to Reed–Solomon (RS) codes, even over small fields, of size polynomial in the dimension of the code, and the gap applies to any δ smaller than the Johnson/Guruswami–Sudan list-decoding bound of the RS code. We also show near-optimal gap results, over fields of (at least) linear size in the RS code dimension, for δ smaller than the unique decoding radius. Concretely, if δ is smaller than half the minimal distance of an RS code V ⊂ 𝔽 q n , then every affine space is either entirely δ-close to the code or, alternatively, at most an ( n/q )-fraction of it is δ-close to the code. Finally, we discuss several applications of our proximity gap results to distributed storage, multi-party cryptographic protocols, and concretely efficient proof systems. We prove the proximity gap results by analyzing the execution of classical algebraic decoding algorithms for Reed–Solomon codes (due to Berlekamp–Welch and Guruswami–Sudan) on a formal element of an affine space. This involves working with Reed–Solomon codes whose base field is an (infinite) rational function field. Our proofs are obtained by developing an extension (to function fields) of a strategy of Arora and Sudan for analyzing low-degree tests.

Efficient multivariate low-degree tests via interactive oracle proofs of proximity for polynomial codes

We consider the proximity testing problem for error-correcting codes which consist in evaluations of multivariate polynomials either of bounded individual degree or bounded total degree. Namely, given an oracle function $$f :L^m \rightarrow {\mathbb {F}}_q$$ , where $$L\subset {\mathbb {F}}_q$$ , a verifier distinguishes whether f is the evaluation of a low-degree polynomial or is far (in relative Hamming distance) from being one, by making only a few queries to f. This topic has been studied in the context of locally testable codes, interactive proofs, probalistically checkable proofs, and interactive oracle proofs. We present the first interactive oracle proofs of proximity (IOPP) for tensor products of Reed–Solomon codes (evaluation of polynomials with bounds on individual degrees) and for Reed–Muller codes (evaluation of polynomials with a bound on the total degree) that simultaneously achieve logarithmic query complexity, logarithmic verification time, linear oracle proof length and linear prover running time. Such low-degree polynomials play a central role in constructions of probabilistic proof systems and succinct non-interactive arguments of knowledge with zero-knowledge. For these applications, highly-efficient multivariate low-degree tests are desired, but prior probabilistic proofs of proximity required super-linear proving time. In contrast, for multivariate codes of length N, our constructions admit a prover running in time linear in N and a verifier which is logarithmic in N. Our constructions are directly inspired by the IOPP for Reed–Solomon codes of [Ben-Sasson et al., ICALP 2018] named “FRI protocol”. Compared to the FRI protocol, our IOPP for tensor products of Reed–Solomon codes achieves the same efficiency parameters. As for Reed–Muller codes, for fixed constant number of variables m, the concrete efficiency of our IOPP for Reed–Muller codes compares well, all things equal.

Preprocessing succinct non-interactive arguments for rank-1 constraint satisfiability from holographic proofs

We design a new preprocessing succinct non-interactive argument (SNARG) for rank-1 constraint satisfiability (R1CS) from holographic Interactive Oracle Proofs (IOPs). The protocol is secure in the random oracle model (ROM). We achieve polylogarithm time verifier and polylogarithm proof size. Our construction consists of two parts: (1) a holographic IOP for R1CS with linear size proof and logarithmic query complexity. (2) A cryptography complier converts holographic IOPs to SNARGs. In the first part, univariate sumcheck and low degree testing play an important role in the holographic IOP. In the second part, we use Merkle tree scheme and Fiat-Shamir heuristic to achieve succinctness and non-interactivity.

Spatial Isolation Implies Zero Knowledge Even in a Quantum World

Zero knowledge plays a central role in cryptography and complexity. The seminal work of Ben-Or et al. (STOC 1988) shows that zero knowledge can be achieved unconditionally for any language in NEXP , as long as one is willing to make a suitable physical assumption : if the provers are spatially isolated, then they can be assumed to be playing independent strategies. Quantum mechanics, however, tells us that this assumption is unrealistic, because spatially-isolated provers could share a quantum entangled state and realize a non-local correlated strategy. The MIP * model captures this setting. In this work, we study the following question: Does spatial isolation still suffice to unconditionally achieve zero knowledge even in the presence of quantum entanglement? We answer this question in the affirmative: we prove that every language in NEXP has a 2-prover zero knowledge interactive proof that is sound against entangled provers; that is, NEXP ⊆ ZK-MIP * . Our proof consists of constructing a zero knowledge interactive probabilistically checkable proof with a strong algebraic structure, and then lifting it to the MIP * model. This lifting relies on a new framework that builds on recent advances in low-degree testing against entangled strategies, and clearly separates classical and quantum tools. Our main technical contribution is the development of new algebraic techniques for obtaining unconditional zero knowledge; this includes a zero knowledge variant of the celebrated sumcheck protocol, a key building block in many probabilistic proof systems. A core component of our sumcheck protocol is a new algebraic commitment scheme, whose analysis relies on algebraic complexity theory.

Low-degree test with polynomially small error

A long line of work in Theoretical Computer Science shows that a function is close to a low-degree polynomial iff it is locally close to a low-degree polynomial. This is known as low-degree testing and is the core of the algebraic approach to construction of PCP. We obtain a low-degree test whose error, i.e., the probability it accepts a function that does not correspond to a low-degree polynomial, is polynomially smaller than existing low-degree tests. A key tool in our analysis is an analysis of the sampling properties of the incidence graph of degree-k curves and k′-tuples of points in a finite space \({\mathbb{F}^m}\). We show that the Sliding Scale Conjecture in PCP, namely the conjecture that there are PCP verifiers whose error is exponentially small in their randomness, would follow from a derandomization of our low-degree test.

Three-Player Entangled XOR Games are NP-Hard to Approximate

We show that for any $\varepsilon>0$ the problem of finding a factor $(2-\varepsilon)$ approximation to the entangled value of a three-player XOR game is NP-hard. Equivalently, the problem of approximating the largest possible quantum violation of a tripartite Bell correlation inequality to within any multiplicative constant is NP-hard. These results are the first constant-factor hardness of approximation results for entangled games or quantum violations of Bell inequalities shown under the sole assumption that P$\neq$NP. They can be thought of as an extension of H\aastad's optimal hardness of approximation results for MAX-E3-LIN2 [J. ACM, 48 (2001), pp. 798--859] to the entangled-player setting. The key technical component of our work is a soundness analysis of a plane-vs-point low-degree test against entangled players. This extends and simplifies the analysis of the multilinearity test by Ito and Vidick [Proceedings of the $53$rd FOCS, IEEE, Piscataway, NJ, 2012, pp. 243--252]. Our results demonstrate t...

Quadratic Goldreich--Levin Theorems

Decomposition theorems in classical Fourier analysis enable us to express a bounded function in terms of few linear phases with large Fourier coefficients plus a part that is pseudorandom with respect to linear phases. The Goldreich--Levin algorithm [O. Goldreich and L. Levin, “A Hard-Core Predicate for All One-Way Functions," in Proceedings of the 21st Annual ACM Symposium on Theory of Computing, 1989, pp. 25--32] can be viewed as an algorithmic analogue of such a decomposition as it gives a way to efficiently find the linear phases associated with large Fourier coefficients. In the study of “quadratic Fourier analysis,” higher-degree analogues of such decompositions have been developed in which the pseudorandomness property is stronger but the structured part is correspondingly weaker. For example, it has been shown that it is possible to express a bounded function as a sum of a few quadratic phases plus a part that is small in the $U^3$ norm, defined by Gowers for the purpose of counting arithmetic progressions of length 4. We give a polynomial time algorithm for computing such a decomposition. A key part of the algorithm is a local self-correction procedure for Reed--Muller codes of order 2 (over $\F_2^n$) for a function at distance $1/2-\e$ from a codeword. Given a function $f:\F_2^n \to \{-1,1\}$ at fractional Hamming distance $1/2-\e$ from a quadratic phase (which is a codeword of the Reed--Muller code of order 2), we give an algorithm that runs in time polynomial in $n$ and finds a codeword at distance at most $1/2-\eta$ for $\eta = \eta(\e)$. This is an algorithmic analogue of Samorodnitsky's result [A. Samorodnitsky, “Low-Degree Tests at Large Distances,” in Proceedings of the 39th Annual ACM Symposium on Theory of Computing, 2007, pp. 506--515], which gave a tester for the above problem. To our knowledge, it represents the first instance of a correction procedure for any class of codes, beyond the list-decoding radius. For this purpose, we give algorithmic versions of results from additive combinatorics used in Samorodnitsky's proof and a refined version of the inverse theorem for the Gowers $U^3$ norm over $\F_2^n$.

Hard Functions for Low-Degree Polynomials over Prime Fields

In this article, we present a new hardness amplification for low-degree polynomials over prime fields , namely, we prove that if some function is mildly hard to approximate by any low-degree polynomials then the sum of independent copies of the function is very hard to approximate by them. This result generalizes the XOR lemma for low-degree polynomials over the binary field given by Viola and Wigderson [2008]. The main technical contribution is the analysis of the Gowers norm over prime fields. For the analysis, we discuss a generalized low-degree test, which we call the Gowers test , for polynomials over prime fields, which is a natural generalization of that over the binary field given by Alon et al. [2003]. This Gowers test provides a new technique to analyze the Gowers norm over prime fields. Actually, the rejection probability of the Gowers test can be analyzed in the framework of Kaufman and Sudan [2008]. However, our analysis is self-contained and quantitatively better. By using our argument, we also prove the hardness of modulo functions for low-degree polynomials over prime fields.

Guest column

In a projection PCP, also known as Label-Cover, the verifier makes two queries to the proof, and the answer to the first query determines at most one satisfying answer to the second query. Projection PCPs with low error probability are the basis of most NP-hardness of approximation results known today. In this essay we outline a construction of a projection PCP with low error and low blow-up. This yields sharp approximation thresholds and tight time lower bounds for approximation of a variety of problems, under an assumption on the time required for solving certain NP-hard problems exactly. The approach of the construction is algebraic, and it includes components such as low error, randomness-efficient low degree testing and composition of projection PCPs.

PCP Characterizations of NP: Toward a Polynomially-Small Error-Probability

This paper strengthens the low-error PCP characterization of NP, coming closer to the upper limit of the BGLR conjecture. Consider the task of verifying a written proof for the membership of a given input in an NP language. In this paper, this is achieved by making a constant number of accesses to the proof, obtaining error probability that is exponentially small in the total number of bits that are read. We show that the number of bits that are read in each access to the proof can be made as high as log β n , for any constant β < 1, where n is the length of the proof. The BGLR conjecture asserts the same for any constant β, for β smaller or equal to 1. Our results are in fact stronger, implying that the Gap-Quadratic-Solvability problem with a constant number of variables in each equation is NP-hard. That is, given a system of n quadratic equations over a field $${\mathcal{F}}$$ of size up to $$2^{\log^\beta n}$$ , where each equation depends on a constant number of variables, it is NP-hard to distinguish between the case where there is a common solution to all of the equations and the case where any assignment satisfies at most a $${2 / |\mathcal{F}|}$$ fraction of them. At the same time, our proof presents a direct construction of a low-degree test whose error-probability is exponentially small in the number of bits accessed. Such a result was previously known only relying on recursive applications of the entire PCP theorem.

Derandomized Parallel Repetition via Structured PCPs

A PCP is a proof system for NP in which the proof can be checked by a probabilistic verifier. The verifier is only allowed to read a very small portion of the proof, and in return is allowed to err with some bounded probability. The probability that the verifier accepts a false proof is called the soundness error, and is an important parameter of a PCP system that one seeks to minimize. Constructing PCPs with sub-constant soundness error and, at the same time, a minimal number of queries into the proof (namely two) is especially important due to applications for inapproximability. In this work we construct such PCP verifiers, i.e., PCPs that make only two queries and have sub-constant soundness error. Our construction can be viewed as a combinatorial alternative to the {}``manifold vs. point'' construction, which is the only construction in the literature for this parameter range. The {}``manifold vs. point'' PCP is based on a low degree test, while our construction is based on a direct product test. Our construction of a PCP is based on extending the derandomized direct product test of Impagliazzo, Kabanets and Wigderson (STOC 09) to a derandomized parallel repetition theorem. More accurately, our PCP construction is obtained in two steps. We first prove a derandomized parallel repetition theorem for specially structured PCPs. Then, we show that any PCP can be transformed into one that has the required structure, by embedding it on a de-Bruijn graph.

Sub-Constant Error Probabilistically Checkable Proof of Almost-Linear Size

We show a construction of a PCP with both sub-constant error and almost-linear size. Specifically, for some constant 0 < α < 1, we construct a PCP verifier for checking satisfiability of Boolean formulas that on input of size n uses $$\log\, n+O((\log\, n)^{1-\alpha})$$ random bits to make 7 queries to a proof of size $$n·2^{O((\log\, n)^{1-\alpha})}$$ , where each query is answered by $$O((\log\, n)^{1-\alpha})$$ bit long string, and the verifier has perfect completeness and error $$2^{-\Omega((\log\, n)^{\alpha})}$$ . The construction is by a new randomness-efficient version of the aggregation through curves technique. Its main ingredients are a recent low degree test with both sub-constant error and almost-linear size and a new method for constructing a short list of balanced curves.

Low-End Uniform Hardness versus Randomness Tradeoffs for AM

Impagliazzo and Wigderson [Proceedings of the 39th Annual IEEE Symposium on Foundations of Computer Science, IEEE Computer Society, Washington, DC, 1998, pp. 734-743] proved a hardness versus randomness tradeoff for BPP in the uniform setting, which was subsequently extended to give optimal tradeoffs for the full range of possible hardness assumptions (in slightly weaker settings). Gutfreund, Shaltiel, and Ta-Shma [Comput. Complexity, 12 (2003), pp. 85-130] proved a uniform hardness versus randomness tradeoff for AM, but that result worked only on the “high end” of possible hardness assumptions. In this work, we give uniform hardness versus randomness tradeoffs for AM that are near-optimal for the full range of possible hardness assumptions. Following Gutfreund, Shaltiel, and Ta-Shma, we do this by constructing a hitting-set-generator (HSG) for AM with “resilient reconstruction.” Our construction is a recursive variant of the Miltersen-Vinodchandran HSG [Comput. Complexity, 14 (2005), pp. 256-279], the only known HSG construction with this required property. The main new idea is to have the reconstruction procedure operate implicitly and locally on superpolynomially large objects, using tools from PCPs (low-degree testing, self-correction) together with a novel use of extractors that are built from Reed-Muller codes for a sort of locally computable error-reduction. As a consequence we obtain gap theorems for AM (and AM $\cap$ coAM) that state, roughly, that either AM (or AM $\cap$ coAM) protocols running in time $t(n)$ can simulate all of EXP (“Arthur-Merlin games are powerful”) or else all of AM (or AM $\cap$ coAM) can be simulated in nondeterministic time $s(n)$ (“Arthur-Merlin games can be derandomized”) for a near-optimal relationship between $t(n)$ and $s(n)$. As in Gutfreund, Shatiel, and Ta-Shma, the case of AM $\cap$ coAM yields a particularly clean theorem that is of special interest due to the wide array of cryptographic and other problems that lie in this class.

Sub-Constant Error Low Degree Test of Almost-Linear Size

Given (the table of) a function $f : \mathbb{F}^m \rightarrow \mathbb{F}$ over a finite field $\mathbb{F}$, a low degree tester tests its agreement with an m-variate polynomial of total degree at most d over $\mathbb{F}$. The tester is usually given access to an oracle $\mathcal{A}$ providing the supposed restrictions of f to affine subspaces of constant dimension (e.g., lines, planes, etc.). The tester makes very few (probabilistic) queries to f and to $\mathcal{A}$ (say, one query to f and one query to $\mathcal{A}$) and decides whether to accept or reject based on the replies. We wish to minimize two parameters of the tester: its error and its size. The error bounds the probability that the tester accepts although the function is far from a low degree polynomial. The size is the number of bits required to write the oracle replies on all possible tester queries. Low degree testing is a central ingredient in most constructions of probabilistically checkable proofs (PCPs). The error of the low degree tester is related to the error of the PCP, and its size is related to the size of the PCP. We design and analyze new low degree testers that have both subconstant error $o(1)$ and almost-linear size $n^{1+o(1)}$ (where $n = \left|\mathbb{F}\right|^{m}$). Previous constructions of subconstant error testers had polynomial size. These testers enabled the construction of PCPs with subconstant error, but polynomial size. Previous constructions of almost-linear size testers obtained only constant error. These testers were used to construct almost-linear size PCPs with constant error. The testers we present in this work enabled the construction of PCPs with both subconstant error and almost-linear size.

Derandomizing Polynomial Identity Tests Means Proving Circuit Lower Bounds

We show that derandomizing Polynomial Identity Testing is essentially equivalent to proving arithmetic circuit lower bounds for NEXP. More precisely, we prove that if one can test in polynomial time (or even nondeterministic subexponential time, infinitely often) whether a given arithmetic circuit over integers computes an identically zero polynomial, then either (i) NEXP ⊄ P/poly or (ii) Permanent is not computable by polynomial-size arithmetic circuits. We also prove a (partial) converse: If Permanent requires superpolynomial-size arithmetic circuits, then one can test in subexponential time whether a given arithmetic circuit of polynomially bounded degree computes an identically zero polynomial.Since Polynomial Identity Testing is a coRP problem, we obtain the following corollary: If RP = P (or even coRP ⊆ ∩e > 0 NTIME(2ne), infinitely often), then NEXP is not computable by polynomial-size arithmetic circuits. Thus establishing that RP = coRP or BPP = P would require proving superpolynomial lower bounds for Boolean or arithmetic circuits. We also show that any derandomization of RNC would yield new circuit lower bounds for a language in NEXP.We also prove unconditionally that NEXPRP does not have polynomial-size Boolean or arithmetic circuits. Finally, we show that NEXP ⊄ P/poly if both BPP = P and low-degree testing is in P; here low-degree testing is the problem of checking whether a given Boolean circuit computes a function that is close to some low-degree polynomial over a finite field.

Improved Low-Degree Testing and its Applications

NP = PCP(log n, 1) and related results crucially depend upon the close connection between the probability with which a function passes a low degree test and the distance of this function to the nearest degree d polynomial. In this paper we study a test proposed by Rubinfeld and Sudan [30]. The strongest previously known connection for this test states that a function passes the test with probability δ for some δ > 7/8 iff the function has agreement ≈ δ with a polynomial of degree d. We present a new, and surprisingly strong, analysis which shows that the preceding statement is true for arbitrarily small ≈, provided the field size is polynomially larger than d/δ. The analysis uses a version of Hilbert irreducibility, a tool of algebraic geometry. As a consequence we obtain an alternate construction for the following proof system: A constant prover 1-round proof system for NP languages in which the verifier uses O(log n) random bits, receives answers of size O(log n) bits, and has an error probability of at most % MathType!Translator!2!1!AMS LaTeX.tdl!TeX -- AMS-LaTeX! % MathType!MTEF!2!1!+- % feaafeart1ev1aaatCvAUfeBSn0BKvguHDwzZbqefeKCPfgBGuLBPn % 2BKvginnfarmqr1ngBPrgitLxBI9gBamXvP5wqSXMqHnxAJn0BKvgu % HDwzZbqegm0B1jxALjhiov2DaeHbuLwBLnhiov2DGi1BTfMBaebbnr % fifHhDYfgasaacH8qrps0lbbf9q8WrFfeuY-Hhbbf9v8qqaqFr0xc9 % pk0xbba9q8WqFfea0-yr0RYxir-Jbba9q8aq0-yq-He9q8qqQ8frFv % e9Fve9Ff0dmeaabaqaciGacaGaaeqabaWaaqaafaaakeaacaaIYaWa % aWbaaSqabeaacqGHsislciGGSbGaai4BaiaacEgadaahaaadbeqaai % aaigdacqGHsislcqGHiiIZaaWccaWGUbaaaaaa!4CB1! $$ 2^{{ - \log ^{{1 - \in }} n}} $$ . Such a proof system, which implies the NP-hardness of approximating Set Cover to within Ω(log n) factors, has already been obtained by Raz and Safra [29]. Raz and Safra obtain their result by giving a strong analysis, in the sense described above, of a new low-degree test that they present. A second consequence of our analysis is a self tester/corrector for any buggy program that (supposedly) computes a polynomial over a finite field. If the program is correct only on δ fraction of inputs where % MathType!Translator!2!1!AMS LaTeX.tdl!TeX -- AMS-LaTeX! % MathType!MTEF!2!1!+- % feaafeart1ev1aaatCvAUfeBSn0BKvguHDwzZbqefeKCPfgBGuLBPn % 2BKvginnfarmqr1ngBPrgitLxBI9gBamXvP5wqSXMqHnxAJn0BKvgu % HDwzZbqegm0B1jxALjhiov2DaeHbuLwBLnhiov2DGi1BTfMBaebbnr % fifHhDYfgasaacH8qrps0lbbf9q8WrFfeuY-Hhbbf9v8qqaqFr0xc9 % pk0xbba9q8WqFfea0-yr0RYxir-Jbba9q8aq0-yq-He9q8qqQ8frFv % e9Fve9Ff0dmeaabaqaciGacaGaaeqabaWaaqaafaaakeaacqaH0oaz % cqGH9aqpcaaIXaGaai4lamaaemaabaGaamOraaGaay5bSlaawIa7am % aaCaaaleqabaGaeyicI4maaOGaeSOAI0JaaGimaiaac6cacaaI1aaa % aa!50F9! $$ \delta = 1/{\left| F \right|}^{ \in } \ll 0.5 $$ , then the tester/corrector determines δ and generates % MathType!Translator!2!1!AMS LaTeX.tdl!TeX -- AMS-LaTeX! % MathType!MTEF!2!1!+- % feaafeart1ev1aaatCvAUfeBSn0BKvguHDwzZbqefeKCPfgBGuLBPn % 2BKvginnfarmqr1ngBPrgitLxBI9gBamXvP5wqSXMqHnxAJn0BKvgu % HDwzZbqegm0B1jxALjhiov2DaeHbuLwBLnhiov2DGi1BTfMBaebbnr % fifHhDYfgasaacH8qrps0lbbf9q8WrFfeuY-Hhbbf9v8qqaqFr0xc9 % pk0xbba9q8WqFfea0-yr0RYxir-Jbba9q8aq0-yq-He9q8qqQ8frFv % e9Fve9Ff0dmeaabaqaciGacaGaaeqabaWaaqaafaaakeaacaWGpbWa % aeWaaeaadaWcaaqaaiaaigdaaeaacqaH0oazaaaacaGLOaGaayzkaa % aaaa!4880! $$ O{\left( {\frac{1} {\delta }} \right)} $$ values for every input, such that one of them is the correct output. In fact, our results yield something stronger: Given the buggy program, we can construct % MathType!Translator!2!1!AMS LaTeX.tdl!TeX -- AMS-LaTeX! % MathType!MTEF!2!1!+- % feaafeart1ev1aaatCvAUfeBSn0BKvguHDwzZbqefeKCPfgBGuLBPn % 2BKvginnfarmqr1ngBPrgitLxBI9gBamXvP5wqSXMqHnxAJn0BKvgu % HDwzZbqegm0B1jxALjhiov2DaeHbuLwBLnhiov2DGi1BTfMBaebbnr % fifHhDYfgasaacH8qrps0lbbf9q8WrFfeuY-Hhbbf9v8qqaqFr0xc9 % pk0xbba9q8WqFfea0-yr0RYxir-Jbba9q8aq0-yq-He9q8qqQ8frFv % e9Fve9Ff0dmeaabaqaciGacaGaaeqabaWaaqaafaaakeaacaWGpbWa % aeWaaeaadaWcaaqaaiaaigdaaeaacqaH0oazaaaacaGLOaGaayzkaa % aaaa!4880! $$ O{\left( {\frac{1} {\delta }} \right)} $$ randomized programs such that one of them is correct on every input, with high probability. Such a strong self-corrector is a useful tool in complexity theory—with some applications known.

Algebraic testing and weight distributions of codes

We study the testing problem, that is, the problem of determining (maybe probabilistically) if a function to which one has oracle access satisfies a given property.We propose a framework in which to formulate and carry out the analysis of several known tests. This framework establishes a connection between testing and the theory of weight distributions of codes. We illustrate this connection by giving a coding theoretic interpretation of several tests that fall under the label of low-degree tests. We also show how the connection naturally suggests a new way of testing for linearity over finite fields.We derive from the MacWilliams Theorems a general result, the Duality Testing Lemma, and use it to analyze the simpler tests that fall into our framework. In contrast to other analyses of tests, the ones we present elicit the fact that a test's probability of rejecting a function depends on how far away the function is from every function that satisfies the property of interest.

A Combinatorial Consistency Lemma with Application to Proving the PCP Theorem

The current proof of the probabilistically checkable proofs (PCP) theorem (i.e., ${\cal NP}={\cal PCP}(\log,O(1))$) is very complicated. One source of difficulty is the technically involved analysis of low-degree tests. Here, we refer to the difficulty of obtaining strong results regarding low-degree tests; namely, results of the type obtained and used by Arora and Safra [J. ACM, 45 (1998), pp. 70--122] and Arora et al. [J. ACM, 45 (1998), pp. 501--555]. In this paper, we eliminate the need to obtain such strong results on low-degree tests when proving the PCP theorem. Although we do not remove the need for low-degree tests altogether, using our results it is now possible to prove the PCP theorem using a simpler analysis of low-degree tests (which yields weaker bounds). In other words, we replace the strong algebraic analysis of low-degree tests presented by Arora and Safra and Arora et al. by a combinatorial lemma (which does not refer to low-degree tests or polynomials).