Transcript Constraint Satisfaction, Semidefinite Programming and the

Locally Testable Codes
Analogues to the
Unique Games Conjecture
Do Not Exist
Gillat Kol
joint work with Ran Raz
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
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
i
b
p
r
j
y
w
q
p
y
m u
t
Probabilistically
Checkable Proof p
(2 queries)
1. Toss coins to get locations i and j
2. Query pi and pj
3. Using pi and pj, decide if to accept
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(pi) = pj
• 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 c1 = 10-102 and c2 = 1010||/
Let C n be an (,,s)-unique LTC.
If ,  c1 then |C|  c2
• I.e., fixing s fixes a const c1, s.t.  and  cannot both be
smaller than c1, unless C is of const size
• Some Tightness:  = {a, b, c, …}, C = {an, bn, cn, …}.
C is a unique-LTC with ==0 (test: vi = vj), 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(vi) = vj
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-4e edges (e = #edges in G)
G
G*
 n vertices
 210-4e edges
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* Violates Soundness
• 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!
Graph Decomposition
(Main)
Decomposition (Review)
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-4e edges (e = #edges in G)
G
G*
 n vertices
 210-4e edges
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: ui = wi}
How Many Edges Removed?
• 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, uj = ij (ui) = ij(wi) = wj  jA
• Conclusion:  2e edges were removed (Completeness) 
A = {i: ui = wi}
G
j
ij
i
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: Ev = set of edges violated by the word v
Ev∩A = edges in Ev with end-point in A
• Observation’: We only need to remove edges in Eu∩A
and Ew∩A!
Assume A is a random set of size n, and G is regular
• v,  frac of the edges in Ev are in Ev∩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!