Locally Testable Codes - Cheraghchimahdi.cheraghchi.info/talks/MSThesis_talk.pdf · Related Research Areas Locally Testable Codes PCPs Hardness of Approximation Locally Decodable

Locally Testable Codes

Mahdi Cheraghchi

[email protected]

Ecole Polytechnique Federale de Lausanne

July 05, 2005

Mahdi Cheraghchi (EPFL) Locally Testable Codes July 05, 2005 1 / 34

Related Research Areas

LocallyTestableCodes

PCPsHardness of

Approximation

LocallyDecodable

Codes

Average CaseComplexity

PrivateInformationRetrieval

SelfVerification

Low-DegreeTest

PropertyTesting


Error Correcting Codes

Encoding: C : Σk → Σn

Message length: k

Block length: n(k)

Rate: R(k) = kn(k)

Alphabet: Σ(k)

Absolute Hamming distance: ∆(~x, ~y), ∆(~x, C)

Distance: δ(~x, ~y), δ(~x, C)

Absolute minimum distance: min ∆(~w, C)Minimum distance: min δ(~w, C)δ-close: δ(~x, ~y) ≤ δ, δ(~w, C) ≤ δ

δ-far: δ(~x, ~y) ≥ δ, δ(~w, C) ≥ δ


Error Correcting Codes

Encoding: C : Σk → Σn

Message length: k

Block length: n(k)

Rate: R(k) = kn(k)

Alphabet: Σ(k)

Absolute Hamming distance: ∆(~x, ~y), ∆(~x, C)

Distance: δ(~x, ~y), δ(~x, C)

Absolute minimum distance: min ∆(~w, C)Minimum distance: min δ(~w, C)δ-close: δ(~x, ~y) ≤ δ, δ(~w, C) ≤ δ

δ-far: δ(~x, ~y) ≥ δ, δ(~w, C) ≥ δ


Probabilistic Oracle Machine

Standard Turing machine

Receives an explicit (normal) input.

Complexity measures are functions of explicit input length.

Receives a sequence of iid and uniform random bits as an extra input.

One (or more) extra random-access and read-only oracle tape(s)

Can query an oracle at a particular position.

Oracles can be thought of as black box functions.

Query complexity q(n): The maximum number of probes into theoracles, over all possible inputs and random choices.

Randomness complexity r(n): The maximum number of random bitsused, over all possible inputs of certain length.


Non-Adaptive Probabilistic Oracle Machine

Each query is independent of the outcome of all previous queries.

Based on the explicit input and random bits, computes:1 A sequence of query locations I = (i1, . . . , iq),2 A boolean circuit D : 0, 1q → 0, 1.

Queries the oracle π and accepts iff D(π|I) = 1.

Decision complexity: Maximum size of D on inputs of a certainlength.

We will focus on non-adaptive probabilistic oracle machines.


Polynomial Low-Degree Testing

A Software Verification Problem

A program is given as a black-box that computes some function f(x). Isf(x) a polynomial of degree d?

Formal setting: Given a function f as an oracle, and inputs d ∈ Nand δ ∈ (0, 1), efficiently distinguish between the case that

1 f is a degree d polynomial,2 f is δ-far from degree d polynomials.

Self-Correcting Software

A program is given as a black-box. We know that the function f(x) itcomputes is close to some polynomial g(x) of degree d. Efficientlycompute g(x).


Polynomial Low-Degree Testing

A Software Verification Problem

A program is given as a black-box that computes some function f(x). Isf(x) a polynomial of degree d?

Formal setting: Given a function f as an oracle, and inputs d ∈ Nand δ ∈ (0, 1), efficiently distinguish between the case that

1 f is a degree d polynomial,2 f is δ-far from degree d polynomials.

Self-Correcting Software

A program is given as a black-box. We know that the function f(x) itcomputes is close to some polynomial g(x) of degree d. Efficientlycompute g(x).


Linearity Test (BLR)

Low-degree test for degree one:

f(x1, . . . , xn) = α1x1 + · · ·+ αnxn.

Characterization: Over F2, f is linear iff

∀x,y ∈ Fn2 : f(x + y) = f(x) + f(y).

Linearity Testing Algorithm:1 Pick x,y ∈R Fn

2 .2 Accept if and only if f(x) + f(y) = f(x + y).

Requires only three queries.



Theorem (Simplified)

BLR-Test is complete and sound:

If f is linear it accepts with probability 1.

If for some δ ≤ 0.2, the probability that the test accepts is more than1− δ then f is 2δ-close to linear functions.

Linearity Self-Correction Algorithm:1 Given x, pick y ∈R Fn

2 .2 Output f(x + y)− f(y).

Requires only two queries.

Has perfect completeness.

Soundness: If f is δ-close to a linear function g, it outputs g(x) withprobability at least 1− 2δ.



Theorem (Simplified)

BLR-Test is complete and sound:

If f is linear it accepts with probability 1.

If for some δ ≤ 0.2, the probability that the test accepts is more than1− δ then f is 2δ-close to linear functions.

Linearity Self-Correction Algorithm:1 Given x, pick y ∈R Fn

2 .2 Output f(x + y)− f(y).

Requires only two queries.


Soundness: If f is δ-close to a linear function g, it outputs g(x) withprobability at least 1− 2δ.


Univariate Low-Degree Test for Arbitrary Degree

Characterization: f is a univariate polynomial of degree d over a fieldof size at least d + 2 iff the evaluations of f on any subset of d + 2points can be interpolated by a degree d polynomial.

Univariate Test:1 Pick distinct points x0, . . . , xd+1 ∈R F.2 Accept iff f a degree d polynomial on x0, . . . , xd+1.

The test has perfect completeness. Moreover, if f is δ-far fromdegree d polynomials, the test rejects with probability Ω(δ).

Requires d + 2 queries.

Problems:1 Does not easily extend to multivariate case,2 Is not well suited for application in program testing.


Multivariate Low-Degree Test for Arbitrary Degree

Characterization: A function f : Zp → Znp is a polynomial of degree d

iff

∀x,~h ∈ Znp ,

∑d+1i=0 αif(x + i · ~h) = 0,

αidef= (−1)(i+1)

(d+1

i

).

Evenly-Spaced-Points Test: Repeat O(d2 log( 1β )) times,

1 Pick x,~h ∈R Znp .

2 Reject if∑d+1

i=0 αif(x + i · ~h) 6= 0.

Perfect completeness.

Soundness: If f is not O( 1d2 )-close to a degree d polynomial, it is

rejected with probability at least 1− β.

Can be implemented using addition and subtraction only.


Locally Testable Codes (LTC)

A codeword tester with query complexity q, proximity parameter δand soundness error ε for a code C (q-local δ-tester)

1 Is a (non-adaptive) probabilistic oracle machine.2 Runs in polynomial time.3 Has query complexity at most q.4 Receives an alleged codeword as oracle.5 Completeness: Always accepts codewords.6 Soundness: Rejects oracles that are δ-far from the code with

probability at least ε.7 Can behave arbitrarily otherwise.

A code is (q, δ)-locally testable if there exists a q-local δ-tester for it.

By default, δ and ε are absolute constants in (0, 1).

Detection probability: 1− ε.


Locally Testable Codes, Variations

Stronger requirement: ε = Ω(δ).

More flexibility: Allowing two-sided error and/or adaptivity.

Tolerance: Extending the completeness margin by adding anotherproximity parameter.

Robustness: Non-codewords must be far from being accepted withhigh probability.

Assume (I,D) = T ~w;~r.

ρT (~w,~r)def= δ(~w, ~x | D(~x|I) = 1).

ρT (~w)def= E~r[ρ

T (~w,~r)].A c-robust tester has perfect completeness and ∀~w, ρT (~w) ≥ δ(~w, C)/c.A code is c-robust if it has a c-robust tester.c-robust codes are locally testable with c · q queries. (for q being thequery complexity of the c-robust tester).


Locally Testable Codes, Parameters

We aim to optimize:1 The alphabet size (ideal case: |Σ| = 2),2 Query complexity (ideal case: q = O(1)),3 Rate (ideal case: R = O(1)),4 Randomness complexity (ideal case: r = lg n + O(1)).

Optimization of the two latter parameters coincide, as n ≤ q2r.

We focus on constant distance codes, even though it’s not a necessity.

Can we optimize all parameters simultaneously?!

Ultimate goal: Asymptotically optimal binary LTCs.

State of the art: Binary LTCs with O(1) queries and inverse poly-lograte. (Dinur 2005)


Locally Testable Codes, Parameters

We aim to optimize:1 The alphabet size (ideal case: |Σ| = 2),2 Query complexity (ideal case: q = O(1)),3 Rate (ideal case: R = O(1)),4 Randomness complexity (ideal case: r = lg n + O(1)).

Optimization of the two latter parameters coincide, as n ≤ q2r.

We focus on constant distance codes, even though it’s not a necessity.

Can we optimize all parameters simultaneously?!

Ultimate goal: Asymptotically optimal binary LTCs.

State of the art: Binary LTCs with O(1) queries and inverse poly-lograte. (Dinur 2005)


Locally Testable Codes

Limitations:

A 2-query LTC with minimum distance δ can have at most |Σ|3/δ

codewords.With high probability, a random (c, d)-regular LDPC code needs Ω(n)queries, even for adaptive testers with two-sided error.

Steps towards asymptotically optimal codes:1 Constant nearly linear length: For every ε > 0, n = O(k1+ε).2 Tight nearly linear length: n = O(k1+f(k)), where f(k) = o(1).

Examples: f(k) = 1/ log log n, f(k) = 1/ logc n, f(k) =exp((log log log n)c)/ log n.

3 Polylog nearly linear length: n = k · poly(log k). Tight nearly linearwith f(k) = poly(log log n)/ log n.

4 Linear length(?!!)


Hadamard Code

A message ~u ∈ Fk2 is considered as the linear function

`~u(x1, . . . , xk)def= 〈~u, ~x〉 = u1x1 + · · ·+ ukxk.

The encoding of ~u is the evaluation vector of `u.

Equivalently, the encoding of ~u is the evaluation of all k-variate linearfunctions at ~u. (`~u(~x) = `~x(~u))

Block length: 2k.

Schwartz-Zippel Lemma

A nonzero m-variate polynomial of degree ` can be zero on at most an `/qfraction of points in Fm

q .

Minimum distance: 1− `q = 1− 1

2 = 12 .

Locally testable by linearity testing.


Reed-Muller Codes

Fix a field Fq and parameters m and `.

Message is considered as an m-variate polynomial of total degree `.

Codeword is the evaluation vector of the message polynomial.

k =(m+`m

).

n = qm.

Minimum distance: 1− `/q.

Locally testable by Evenly-Spaced-Points test.


Polynomial-Line Testing

A proof-assisted low-degree test for multivariate polynomials.

Assumes the existence of a proper auxiliary proof.

Line through x with slope ~h: `(t) = x + t · ~h.

Characterization:

A finite field Fq with characteristic p such that q − qp ≥ d + 1.

f : Fm → F is a polynomial of degree at most d iff for all x,~h ∈ Fm, frestricted to the line `x,~h is a univariate polynomial of degree d.

Robustness: If restriction of f is close to being degree d on mostlines, f is itself close to being a degree d polynomial.

Line representation of a polynomial f ∈ F(d)[Xm],

linesf : F2m → Fd+1,

maps a line ` to the restriction of f to `.


Polynomial-Line Testing

Polynomial-Line Test: Assumes auxiliary oracle B : F2m → Fd+1

1 Pick x,~h ∈R Fm and t ∈R F.2 Accept iff f(x + t · ~h) = B(x,~h)(t).

Needs only two queries, but over a large alphabet.

Completeness: If f is a degree d polynomial, it is accepted with theoracle linesf .

Soundness: For every constant ε > 0 and δ ≤ 18 − ε, if |F| = Ω(d) and

f is δ-far from being degree d, then it is rejected with probability atleast δ/2, no matter what the auxiliary oracle is.


Polynomial-Line Correction

Polynomial-Line Corrector: Is given a point x and assumes anauxiliary oracle B : F2m → Fd+1

1 Pick ~h ∈R Fm and t ∈R F \ 0.2 Let q = B(x,~h).3 if q(t) 6= f(x + t · ~h) then reject else output q(0).


Soundness: If f is δ-close to a degree d polynomial g, then theprobability of not returning g(x) is at most 2

√δ + d

|F|−1 .


Polynomial-Line Codes

Is based on the Polynomial-Line test.

Message: The coefficients of an m-variate polynomial of degreed ≥ m over a field of size Ω(d).

Codeword: For a message f , linesfTest:

1 Pick r ∈R Fm.2 Pick two lines `, `′ in Fm going through r, uniformly and independently

at random.3 Accept iff w` and w`′ agree at the intersection r.

Is complete and sound.

Alphabet: Fd+1.

Codeword length: n = F2m.

Message length: k =(m+d

m

)/(d + 1)

md≈ (d/m)m.

For n = poly(k), we need |F| = poly(d) and m d.



Problem: Bad rate!

Not linear but F-linear.

Randomly truncate the code to n = O(|F|m log |F|) lines.

Instantiations:

1 Tight nearly linear: d = mm, F = O(d).

k ≈ mm2−2m

n = O(|F|m log |F|) = mm2+o(m)

n ≈ exp(√

log k) · klog |Σ| = log |F|d+1 ≈ d log d ≈ exp(

√log k)

2 Constant nearly linear: d = mc for c > 1.

k ≈ m(c−1)m

n ≈ mcm = kc/(c−1)

log |Σ| ≈ d log d ≈ logc k

For 1− o(1) truncation choices, soundness is preserved.



Reduce the alphabet to F.

Concatenate with an inner code.

The inner code maps multilinear forms of total degree d′ to theirevaluations.

Assume hd′ = d + 1, and d′h variables x(j)i for j ∈ [d′] and i ∈ [h].

Message: Coefficients of

f(~x)def=

∑i1,...,id′∈[h]

qi1,...,id′ · x(1)i1· x(2)

i2· · ·x(d′)

id′

Codeword: Evaluation vector of f(~x).

n′ = |F|d′h = exp(d′ · (k′)

1d′ · log |F|).

Inner tester: d′ linearity tests and one total degree test.



Testing concatenated code: Emulate the outer test.

Each query only needs the value of a univariate polynomial q ofdegree d at some point t ∈ F.

Write q(t) as

q(t) =∑

i1,...,id′∈[h]

qi1,...,id′ t(i1−1)+(i2−1)h+···+(id′−1)hd′−1

.

So we need the inner-code entry corresponding to

〈t0, . . . , th−1, t0·h, . . . , t(h−1)·h, . . . . . . , t0·hd′−1

, . . . , t(h−1)·hd′−1〉.

Use an interpolating self-corrector to retrieve above ⇒ d′ + 1 queries.

Total amount of queries: 2(d′ + 1) = O(d′).



Instantiation:d := mc and d′ := 2c, for constant c > 1.n ≈ kc/(c−1)

k′ = d + 1n′ ≈ exp(d1/d′

) ≈ exp((log k)c/d′) = exp(

√log k) = ko(1)

nn′ ≈ (kk′)c/(c−1) ⇒ constant nearly linear.Alphabet size: O(d) ≈ logc k

Obtaining a binary code: Concatenate with Hadamard code.

Observe: Above tester checks a constant number of linear constraintsΣiαiai = 0 over F. (for query outcomes ai)

Pick a random binary sequence r and check 〈r,∑

i αiai〉 ≡ 0 mod 2.

Write it as∑

i〈r, αiai〉 ≡ 0 mod 2.

Hence we need to check if a linear combinations of the bits of ai iszero.

Obtain the combined value in one shot from the Hadamard encodingof ai.



Final parameters for the binary code Fkk′k′′2 to Fnn′n′′

2 :

nn′ ≈ (kk′)c/(c−1)

n′′ = 2k′′ = |F| = poly(log k) = ko(1)

nn′n′′ ≈ (kk′k′′)c/(c−1)

constant nearly linear length binary LTC.


Tensor Product Codes

Fully combinatorial!

An n2 × n1 matrix is a codeword of C1 ⊗ C2 iff every row is acodeword of C1 and every column is a codeword of C2.

Product tester: Pick a row (column) at random and verify if iscorresponds to a codeword of C1 (C2).

Generalize to m-dimensions by considering Cm.

m-Product tester is 216-robust for Cm for (d−1n )m.

⇒ Tensor product gives LTCs.

Theorem

For any family Ci with polynomial block length, let ti be a sequence ofintegers s.t. mi := 2ti satisfies di/ni ≥ 1− 1

7mi. Then Cmi

i is locallytestable with polylog query complexity and polynomial length.


Probabilistically Checkable Proofs (PCP)

correctness of the proof once it is found. Thus, while it is the task of the prover P to derive a valid

proof for the assertion, the verifier V merely has to check the validity of the proof. Thus, proofs

can be viewed as a labor-saving mechanism. We believe that there exist assertions that take require

a huge labor from the prover’s side to obtain a valid proof, however, once such a valid proof is

found, it is possible to express it in sufficiently simple terms such that even a weak verifier V can

check its validity.

Figure 1-1: Pictorial Representation of a Proof System

A deterministic verifier checks the truth of an assertion by reading every bit of the proof.

1.1 Complexity Theory via Proofs

Several concepts in Computational Complexity can be phrased in the language of proofs. The two

important computational tasks associated with a proof-system are proof-production (i.e, the work

of the prover, the task of actually deriving the proof) and proof-verification (i.e., the work of the

verifier). A host of complexity classes can be described by considering the complexity of either

of these tasks. The complexity class P captures precisely the class of family of assertions whose

proofs can be obtained in polynomial time in the length of the assertion. On the other hand, the

complexity class NP is the class of family of assertions that have proofs whose validity can be

checked by the verifier in polynomial time in the length of the assertion. In this terminology, the

question, we had asked earlier, of whether there exist a family of assertions whose proofs can be

verified in polynomial time but cannot be obtained in polynomial time is precisely the question

“P 6= NP?”, the most famous open-problem today in computer science.

18

2.1 Standard PCPs

We begin by recalling the formalism of a PCP verifier. Throughout this work, we restrict our at-

tention to nonadaptive verifiers, both for simplicity and because one of our variants (namely robust

PCPs) only makes sense for nonadaptive verifiers.

Definition 2.1.1 (PCP verifiers)

• A verifier is a probabilistic polynomial-time algorithm V that, on an input x of length n, tosses

r = r(n) random coinsR and generates a sequence of q = q(n) queries I = (i1, . . . , iq) and a circuit

D : 0, 1q → 0, 1 of size at most d(n).

We think of V as representing a probabilistic oracle machine that queries its oracle π for the positions

in I , receives the q answer bits π|I , (πi1 , . . . , πiq), and accepts iff D(π|I) = 1.

• We write (I,D)R←V (x) to denote the queries and circuit generated by V on input x and random coin

tosses, and (I,D) = V (x;R) if we wish to specify the coin tosses R.

• We call r the randomness complexity, q the query complexity, and d the decision complexity of

V .

Figure 2-1: PCP Verifier

The standard PCP verifier checks that the string x is in the language L be reading all of x and

probabilistically probing the proof π.

For simplicity in these definitions, we treat the parameters r, q, and d above (and other param-

eters below) as functions of only the input length n. However, at times we may also allow them to

30

A probabilistic polynomial time verifier.

Completeness: If x ∈ L, then ∃π : Pr[V π(x) = 1] = 1.

Soundness: If x /∈ L, then ∀π,Pr[V π(x) = 1] ≤ 12 .


Probabilistically Checkable Proofs (PCP)

NP proof and the query complexity a constant, the new PCP is at most polynomially longer than

the original NP proof. The PCP Theorem is constructive in the sense that it indicates how to

construct this new probabilistically checkable proof (PCP) from the old NP proof. Furthermore,

this construction is both complete and sound, i.e., valid proofs are always accepted while invalid

proofs are accepted with probability at most 1/2.

Figure 1-2: The PCP Theorem

Any NP proof can be rewritten into a PCP checkable by a probabilistic verifier in at most a constant

number of bit locations.

PCPs have had a tremendous impact on the study of combinatorial optimization problems in

the last decade. Starting with the seminal result of Feige et al. [FGL+96] which demonstrates the

connection between this model of proof verification and the hardness of approximation of sev-

eral combinatorial optimization problems, PCPs have been very effectively used to show that the

approximation version of several NP-hard combinatorial optimization problems are themselves

NP-hard. This is a very active area of research and some of the notable papers in this direction in-

clude (just to mention a few) [PY91, FGL+96, AS98, ALM+98, LY94, BGLR93, BGS98, Fei98, Has99,

Has01, Kho04]. However, we will not dwell into this hardness connection of PCPs in this disserta-

tion.

21

The PCP Theorem

NP = PCP(O(log n), O(1)).


PCP vs. LTC

LTCs can be considered as combinatorial counterparts of PCPs.

Combinatorial objects are more intuitive.

Idea: Obtain PCPs from LTCs.

Goldreich and Sudan 2002 (weaker result),Ben-Sasson and Sudan 2005 (polylog rate and query).

Stronger LTC results are only obtained from PCPs!

Challenge: Obtain short PCPs with low (and constant) querycomplexity.

Problems with obtaining LTCs from PCPs:

Unique encoding,Loss of linearity in compositions,Padding problems, dealing with auxiliary variables, etc.

A generic solution: PCPs of Proximity.


PCPs of Proximity

languages consisting of pairs of strings, which we refer to as a pair language. One pair language to

keep in mind is the CIRCUIT VALUE problem: CKTVAL = (C,w) : C(w) = 1. For a pair language

L, we define L(x) = y : (x, y) ∈ L. For example, CKTVAL(C) is the set of satisfying assignments

to C. It will be useful below to treat the two oracles to which the verifier has access as a single

oracle, thus for oracles π0 and π1, we define the concatenated oracle π = π0 π1 as πb,i = πbi .

Definition 2.2.1 (PCPs of proximity (PCPPs)) For functions s, δ : Z+ → [0, 1], a verifier V is a proba-

bilistically checkable proof of proximity (PCPP) system for a pair language L with proximity parameter

δ and soundness error s if the following two conditions hold for every pair of strings (x, y):

Completeness: If (x, y) ∈ L, then there exists π such that V (x) accepts oracle y π with probability 1.

Formally,

∃π Pr(I,D)

R←V (x)

[D((y π)|I) = 1] = 1.

Soundness: If y is δ(|x|)-far from L(x), then for every π, the verifier V (x) accepts oracle y π with

probability strictly less than s(|x|). Formally,

∀π Pr(I,D)

R←V (x)

[D((y π)|I) = 1] < s(|x|).

If s and δ are not specified, then both are assumed to be constants in (0, 1).

Figure 2-2: PCP of Proximity

The PCPP verifier checks that the pair (x, y) is in the pair-language L by reading all of x and prob-

abilistically probing the string y and the proof π.

32

A pair language L = (x, y), x is given as explicit input, y as oracle.

Completeness: If (x, y) ∈ L, then ∃π : Pr[V yπ(x) = 1] = 1.

Soundness: If y is δ(|x|)-far from L(x), then∀π,Pr[V yπ(x) = 1] ≤ s(|x|).δ(·): Proximity parameter, s(·): soundness error.


PCPs of Proximity

PCPP vs. PCP:

CktVal ≡ (x,C(x)) | C(x) = 1, P-complete.

CktSat ≡ C | C is a satisfiable circuit, NP-complete.

Assignment tester: PCPP verifier for CktVal.

An assignment tester is also a PCP verifier for CktSat.

PCPP vs. LTC:

Using an auxiliary code C0 with good parameters and a PCPP verifierfor membership in C0, an LTC can be built:

Codewords: (C0(x)t, π(x)) s.t. only 1/d-fraction goes to π(x).Distance: δ(C0)− 1/d.Tester: PCPP + a constant number of consistency checks.Proximity: Similar to PCPP.Block length: PCPP length times d.

Corollary: Assignment testers imply LTCs with (almost) similarparameters.


Best Known PCPPs

Ben-Sasson et al.:1 Query complexity O(1/ε), randomness lg n + O(logε n) ⇒ proof length

n · exp(logε n).2 Query complexity o(log log n), randomness

lg n + O((log log n)2/ log log log n) ⇒ proof length withquasi-polylogarithmic blowup.

Dinur: Query complexity O(1), randomness lg n + O(log log n) ⇒poly-log rate.

They also correspond to best known binary LTCs.


Locally Decodable Codes (a bird-eye view)

Assume: the sequence is δ-close to a codeword.

Idea: Retrieve one message symbol using a BPP oracle decoder withlow query complexity.

Basic constructions: Based on polynomial self-correctors, e.g.,Reed-Muller and Hadamard codes.

Problems:

Quasi-exponential block length in best known construction.Lower bounds: Binary 2-query: n = 2Ω(k), Arbitrary alphabet 2-query:n ≥ 2

εδk4 −1, Binary q-query: Ω(kq/(q−2)), . . . .

Theoretical applications: private information retrieval, average casecomplexity, etc.

Nearly linear length PCPPs imply nearly linear length LDCs in arelaxed sense.


Discussion and Selected References

S. Arora, C. Lund, R. Motwani, M. Sudan, and M. Szegedy. Proof verificationand the hardness of approximation problems. J. ACM, 45(3):501–555, 1998.

E. Ben-Sasson, O. Goldreich, P. Harsha, M. Sudan, and S. Vadhan. RobustPCPs of proximity, shorter PCPs and applications to coding. In STOC’04.

I. Dinur and O. Reingold. Assignment testers: Toward a combinatorial proofof the PCP-theorem. In Proceedings of FOCS’04.

K. Friedl and M. Sudan. Some improvements to total degree tests. InProceedings of ISTCS’95, pages 190–198.

O. Goldreich and M. Sudan. Locally testable codes and PCPs ofalmost-linear length. In Proceedings of FOCS’02, pages 13–22.

R. Rubinfeld and M. Sudan. Robust characterizations of polynomials withapplications to program testing. SIAM J. Comp., 25(2):252–271, 1996.

M. Sudan. Efficient Checking of Polynomials and Proofs and the Hardness ofApproximation Problems. PhD thesis, U.C. Berkeley, 1992.


Documents

Locally Testable Codes - Cheraghchimahdi.cheraghchi.info/talks/MSThesis_talk.pdf · Related Research Areas Locally Testable Codes PCPs Hardness of Approximation Locally Decodable