Locally Testable Codes and Expanders Tali Kaufman Joint

Locally Testable Codes and Expanders Tali Kaufman Joint work with Irit Dinur

Codes as CSPs • A constraint satisfaction problem (CSP) is a sequence of constraints over variables: f 1 (x 1, x 2, x 5), f 2 (x 5, x 15), … For example, max-3 SAT, max-3 col, … • CSP describes a code if every two satisfying assignments are far apart (in Hamming distance). The minimum distance between a pair of sat assignments is the distance of the code. • Today : CSPs that yield codes. • Challenge: CSPs that yield large and robust codes.

Robust Codes • CSP describes a code if every two satisfying assignments are far apart (in Hamming distance). • CSP describes a robust code if a vector that is far from the code falsifies many constraints. • Robust codes are called LTCs (strong relation to PCP). • Want to understand: What makes a code robust?

Structure • One can associate a “constraint hyper-graph” with a CSP by placing a vertex per variable, and a hyper-edge per clause. • Two “separate” aspects of a CSP are – The graph structure. – The constraint type : what functions fi do we allow. Today we focus on the structure.

Constraint (Hyper graph) f 1 (x 1, x 2, x 3), f 2 (x 3, x 4, x 5), … x 1 x 2 x 6 x 3 x 4 x 5

Constraint graph f 1 (x 1, x 2, x 3), f 2 (x 3, x 4, x 5), … We replace every hyper-edge with a clique between its vertices, so that we deal with graphs instead of hypergraphs. x 1 x 2 x 6 x 3 x 4 x 5 x 4 x 2 x 6 x 3 x 5

Locally Testable Codes (LTCs) An LTC is given by a constraint graph G on n vertices. The valid codewords C(G) ⊆{0, 1}n are all assignments to [n] that satisfy all constraints. Two required properties of the constraint graph: 1. Distance: Every two codewords differ on Ω(n) coordinates. The minimum distance is the code distance. 2. Robustness: Assignment that is γ-far (in Hamming distance) from the code, falsifies at least ργ fraction of the constraints (for some fixed ρ > 0 ).

Our question(s) for today What is the relation between the structure of the constraint graph and the code obtained. What graphs lead to codes? [Sipser-Spielman] What graphs lead to robust codes (LTCs)?

Motivation • How can we construct LTCs? • Understand whether good LTCs exist. • Construct new, simpler LTCs, PCPs. • Understand the structure of general CSPs; CSPs that are hard to approximate.

What graphs lead to codes [Sipser-Spielman]: Expanders! Expanders are graphs without small cuts. G=(V, E) is an r-expander if for every S⊆V, |S| ≤ |V|/2 E(S, V-S) > r |S| In good expanders small sets expands even more. S V-S

Expanders lead to codes - The Idea Constraint graph: good expander. Constraints: local view; all zeros, or many non zeros. Satisfying assignment must have a distance. x 3 x 1 x 5 Non zero variables x 7 x 9 x 10 x 6 x 4 x 8 x 11 x 13 x 2 x 15 x 14 x 12 zero neighbors

Expanders lead to codes - The Idea x 3 x 1 x 5 Non zero variables x 7 x 9 x 10 x 6 x 4 x 8 x 11 x 13 x 2 x 15 x 14 x 12 zero neighbors Satisfying assignment can not have low support: Other issue: - Small set of non-zeros: by expansion its zero How to ensure neighborhood is large code? - Contradicts the requirement that each local constraint assigned many non zeros.

What graphs lead to robust codes? [Ben-Sasson, Harsha, Raskhodnikova]: Very good expanders yield codes that are NOT robust/LTC. Idea: • Remove one constraint from the constraint graph. • The resulted graph is still an expander. • All satisfying assignments of the new graph are far apart. • Some sat assignments of the new graph do not sat the original graph. Conclusion: there is a vector far from code that falsifies only one constraint from the constraint graph.

What graphs lead to robust codes? [BHR]: Very good expanders yield codes that are not robust/LTC. There is a vector far from code that falsifies only one constraint from the constraint graph. But: Maybe can test this code using *other* short constraint. I. e. constraints that are implied by original constraints. Example: f 1 (x 1, x 2, x 3): f 2 (x 4, x 5, x 6): f 3 (x 7, x 8, x 9): f 4 (x 3, x 6, x 9): f 5 (x 2, x 5, x 8): x 1 + x 2 + x 3 = 0 x 4 + x 5 + x 6 = 0 x 7 + x 8 + x 9 = 0 x 3 + x 6 + x 9 = 0 x 2 + x 5 + x 8 = 0 Imply: f 6 (x 1, x 4, x 7): x 1 + x 4 + x 7 = 0 Main point: Due to the high expansion, there are no short constraints that are implied by the original short constraints.

Our Conclusions so far High expansion of the constraint graph implies code (distance). High expansion implies NON robustness. What can we say about the structure of the constraint graphs of LTCs?

Structure theorem for LTCs C is ρ-LTC : w γ-away from C rejected with probability > ρ γ Theorem [Dinur-K]: The constraint graph of an LTC is a small set expander; all sets up to linear size expands. Theorem: In ρ-LTC with r. distance Δ and with constraint graph G=(V, E), every S ⊆ V ; |S|≤ 0. 75Δ|V| expands: E(S, V-S) > ρd/3 |S| d = |E|/|V|.

LTC decomposes on sparse cuts C is ρ-LTC : vector γ-away from C rejected with probability > ρ γ Decomposition on sparse cuts: Let |S| = γ|V|. If E(S, V-S) is a sparse cut, i. e. , E(S, V-S) < ρd/3|S|= ργ/3|E| then C =~ γ/3 CS x CV-S = {x. Sy. V-S | x. S C|S , y. V-S C|V-S} • Note C ⊆ CS x CV-S • Every c CS x CV-S is γ/3 -close to some codeword from C. • Main point: Such c can be rejected only by edges (constraints) that cross the cut (S, V-S) and since the cut is sparse, there are too few of those edges.

Sparse cuts occur only on large sets C is ρ-LTC : vector γ-away from C rejected with probability > ρ γ E(S, V-S) is a sparse cut: |S| = γ|V|= γ n , E(S, V-S) < ρd/3 |S|= ργ/3 |E| C =~ γ/3 CS x CV-S • Pick a ≠ a’ in CS with distance(a, a’) > |S|/3 = γ/3 n : • Consider a. S b. V-S C ; a’S b. V-S CS x CV-S ab C > Δn w C • Distance of a’b from C is < γ/3 n since C=~ γ/3 CS x CV-S < γ/3 n • The closest codeword of C to a’S b. V-S is w ≠ a. S b. V-S by LTC > γ/3 n a’b • By triangle-inequality distance (a’b, ab) = distance (a, a’) > (Δ - γ/3) n • In particular |S|= γ n > (Δ - γ/3) n ; |S| > 3/4 Δn

Structure theorem for LTCs We have shown: The constraint graph of an LTC is a small set expander. Our main theorem shows that the constraint graph can be decomposed into constant-many (regular) expanders with few edges in between.

Main Theorem [Dinur-K] • Let C be an LTC with constraint graph G=(V, E). Then V can be partitioned into V 1, …Vt, such that C =~ C 1 x C 2 x … x Ct and such that each G(Vi) is an expander, with few edges between expanders. Moreover, each Ci is an LTC. • t is at most 1/r. distance • Expansion depends on testability params

Summary and Questions • Expansion of a constraint graph implies distance. • Very high expansion of the constraint graph implies nonrobustness. • The constraint graph of a robust code (LTC) is a small set expander for linear size sets. It can be decomposed into constant many (regular) expanders with few edges in between. • Q: What “amount” of expansion implies LTC? • Q: What structure of the constraint graph implies LTC? • Recent work (Dinur-K, and Ben-Sasson-Viderman) shows that the constraint graph cannot be dense for LTCs with good rate.