# Gillat Kol joint work with Ran Raz Locally Testable Codes Analogues to the Unique Games Conjecture Do Not Exist.

## Presentation on theme: "Gillat Kol joint work with Ran Raz Locally Testable Codes Analogues to the Unique Games Conjecture Do Not Exist."— Presentation transcript:

Gillat Kol joint work with Ran Raz Locally Testable Codes Analogues to the Unique Games Conjecture Do Not Exist

Summary The Unique Games Conjecture (UGC) is an important open problem in the study of PCPs It conjectures the existence of PCPs with special properties Known PCP constructions are based on Locally Testable Codes (LTCs) with analogues properties We show that LTCs with properties analogues to the UGC do not exist Thus, show limitations of some of the current PCP constructions techniques

The PCP Theorem

A unbounded prover wants to convince a poly-time verifier that  SAT, by supplying a proof The verifier wants to only read constant number of symbols from the proof PCP Thm [BFL,FGLSS,AS,ALMSS ‘92]: This can be done! ‐Completeness:  SAT   proof accepted whp ‐Soundness:  SAT   proof rejected whp

The PCP Theorem Probabilistically Checkable Proof p i j (2 queries) 1.Toss coins to get locations i and j 2.Query p i and p j 3.Using p i and p j, decide if to accept b qpmy pwyrut Verifier

The Unique Games Conjecture

Why is the UGC Interesting? Almost all hardness of approximation results rely on the PCP Theorem Yet, for many fundamental problems, optimal hardness results are still not know The UGC is a strengthening of the PCP Theorem shown to imply many improved hardness results Max-Cut [MOO ‘05, KKMO ‘07], Vertex-Cover [KR ‘08], CSPs [Rag ‘08], …

Unique Tests The UGC deals with verifiers V that read 2 locations and only make unique tests:  i,j queried by V  permutation  ij :    s.t. V accepts iff  ij (p i ) = p j That is, after reading location i, there exists a unique value for location j that makes V accept (and vice versa)

The Unique Games Conjecture Unique Games Conjecture [Khot ‘02]: ,s > 0 consts  (const size depends on ,s) s.t.  V checking proofs for “  SAT” over  by only performing unique tests Completeness 1-  :  SAT   proof accepted wp ≥ 1-  Soundness s:  SAT   proof accepted wp < s Parallel Repetition Theorem [Raz ‘98]: Such a verifier exists when uniqueness is relaxed to projection

Locally Testable Codes

Error Correcting Codes Hamming Distance: ‐dist(u,w) = frac of coordinates u and w disagree on ‐agree(u,w) = frac of coordinates u and w agree on Error Correcting Code: C   n Relative Distance: C has relative distance 1-  if  u  w  C, dist(u,w) ≥ 1-  equiv. agree(u,w)   High relative distance  Good error correcting ability

Locally Testable Codes Locally Testable Code: A code C with a tester (prob algo) that checks if a given word v is in C by only reading a constant number of locations Completeness 1-  : v  C  accept wp ≥ 1-  Soundness s: dist(v,C) > 1/3  accept wp < s equiv. accept wp  s   u  C, agree(u,v)  2/3

Low Soundness LTCs Soundness (review): dist(v,C) > 1-  = 1/3  accept wp < s Observation: s cannot be lower than  #queries s is proportional to  : Can only expect low accept prob (small s) for words that are far from the code (small  ) Soundness (generalized): Let s(  ):(0,1)  [0,1] be arbitrary (monotone) function dist(v,C) > 1-   accept wp < s(  ) equiv. accept wp ≥ s(  )   u  C, agree(u,v)  

PCPs and LTCs Both PCP verifiers and LTC testers test if a given string is “close” to being “good” (good = valid proof /codeword) by reading only a constant number of locations in it Known PCP constructions are based on LTCs with analogues properties

“LTCs Analogues to the UGC”? ( , ,s)-LTC: ,  > 0, s:(0,1)  [0,1] Relative distance 1-  (codewords agree   frac) Completeness 1-  (codewords accepted wp  1-  ) Soundness s(  ) (dist > 1-   accept wp < s(  )) The UGC requires a low-error PCP with unique tests Uniqueness: A Unique LTC is an LTC with unique tests Low-error: In known PCPs, the error originates from the completeness, soundness, and distance of the LTC used Thus, we would have wanted:  > 0 const,  LTC with ,  <  and s(  ) <  for some 

Our Results

Our Result Theorem (Main): Let n, , s:(0,1)  [0,1] be arbitrary (monotone) Assume s(  )  10 -5 for some fixed  Denote c 1 = 10 -10  2 and c 2 = 10 10 |  |/  Let C   n be an ( , ,s)-unique LTC. If ,   c 1 then |C|  c 2 I.e., fixing s fixes a const c 1, s.t.  and  cannot both be smaller than c 1, unless C is of const size Some Tightness:  = {a, b, c, …}, C = {a n, b n, c n, …}. C is a unique-LTC with  =  =0 (test: v i = v j ), and |C|=|  |

Proof

Constraint Graphs Proof by way of contradiction: Let C be such a unique LTC with tester T T can be viewed as a constraint graph G ‐Vertex set = [n] ‐There exist an edge (i,j) if T may query locations (i,j) ‐The edge (i,j) is associated with  ij A word v satisfies the edge (i,j) if  ij (v i ) = v j

Step 1 (Main): Decompose G Decompose G to small connected components by removing only a small number of edges (obtain G*) Each connected component of G* contains   n vertices G* contains  2  10 -4 e edges (e = #edges in G)   n vertices  2  10 -4 e edges G*G

Step 2: Constructing a “Bad” Word Set k  1/  constant Partition the connected components of G* to k sets, each containing  n/k vertices ( components of G* are small ) Let v* be “balanced” hybrid of any k different codewords (|C| large), agreeing with each on one of the k parts of G* G*

v* is far from the code: ‐v* is a hybrid of codewords ‐Codewords disagree on most coordinates (relative dist) ‐v* cannot agree with either on many coordinates v* is accepted with non-negligible prob: ‐On every component of G*, v* agrees with a codeword ‐On this component, v* only violates the edges violated by the codeword ‐v* satisfies most of the edges in G* (Completeness) ‐v* satisfies many edges ( G* contains many edges) v* violates soundness! v* Violates Soundness

Graph Decomposition (Main)

Decomposition (Review)   n vertices  2  10 -4 e edges G*G Decompose G to small connected components by removing only a small number of edges (obtain G*) Each connected component of G* contains   n vertices G* contains  2  10 -4 e edges (e = #edges in G)

Decomposition Algo: First Attempt Decomposition Algorithm: Repeat ‐ Select two new codewords u  w ‐ Disconnect A, the set of coordinates u  and w agree on A is small: |A|   n (relative distance) What about the number of removed edges? G A = {i: u i = w i }

How Many Edges Removed? A = {i: u i = w i } i  ij j G Observation: Each removed edge (i,j) violates either u  or w Proof: Assume i  A, and (i,j) satisfied by both u  and w. Then, u j =  ij (u i ) =  ij (w i ) = w j  j  A Conclusion:  2  e edges were removed (Completeness)

Is 2  Good Enough? No! We still may be removing too many edges: |A|  n /|  | (assume C is a random code)  To decompose G, repeat  |  | times Each iteration removes up to 2  frac of the edges  Algo removes up to 2  |  | frac of the edges Recall that |  | may be much larger than 1/   All edges may be removed!

Cutting Down Expenses Observation (review): Each removed edge violates u  or w Denote: E v = set of edges violated by the word v E v ∩A = edges in E v with end-point in A Observation’: We only need to remove edges in E u ∩A and E w ∩A! Assume A is a random set of size  n, and G is regular  v,  frac of the edges in E v are in E v ∩A Thus, each iteration removes  2  frac of the edges

But A = agree(u,w) Is Not Random Fix u. Since there are many codewords, u cannot agree with all on roughly the same set of coordinates Thus, random selection of w yields “random enough” A Most of the proof is devoted to showing that…

Thank You!

Similar presentations