Optimal Lower Bounds for2-Query Locally Decodable

Linear Codes

Kenji Obata

Codes

Error correcting code

C : {0,1}n → {0,1}m

with decoding procedure A s.t.

for y {0,1}m with d(y,C(x)) ≤ δm,

A(y) = x

“Locally Decodable” Codes

• Weaken power of A: Can only look at a constant number q of input bits

• Weaken requirements: A need only recover a single given bit of x Can fail with some probability bounded away

from ½

Study initiated by Katz and Trevisan [KT00]

“Locally Decodable” Codes

Define a (q, δ, )-locally decodable code:

• A can make ≤ q queries (w.l.o.g. exactly q queries)

• For all x {0,1}n, all y {0,1}m with d(y, C(x)) ≤ δm, all inputs bits i 1,…, n

A(y, i) = xi w/ probability ½ +

LDC Applications

• Direct: Scalable fault-tolerant information storage

• Indirect: Lower bounds for certain classes of private information retrieval schemes(more on this later)

Lower Bounds for LDCs

• [KT00] proved a general lower bound

m ≥ nq/(q-1)

(at best n2, but known codes exponential)

• For 2-query linear LDCsGoldreich, Karloff, Schulman, Trevisan [GKST02] proved an exponential bound

m ≥ 2Ω(εδn)

Lower Bounds for LDCs

• Restriction to linear codes interesting, since known LDC constructions are linear

• But 2Ω(εδn) not quite right:

– Lower bound should increase arbitrarily as decoding probability → 1 (ε → ½)

– No matching construction

Lower Bounds for LDCs

• In this work, we prove that for 2-query linear LDCs,

m ≥ 2Ω(δ/(1-2ε)n)

• Optimal: There is an LDC construction matching this within a constant factor in the exponent

Techniques from [KT00]

• Fact: An LDC is also a “smooth” code (A queries each position w/ roughly the same probability)… so can study smooth codes

• Connects LDCs to information-theoretic PIR schemes: q queries ↔ q servers smoothness ↔ statistical indistinguishability

Techniques from [KT00]

• For i 1,…,n, define the recovery graph Gi associated with C: Vertex set {1,…,m} (bits of the codeword) Edges are pairs (q1, q2) such that, conditioned

on A querying q1, q2,

A(C(x),i) outputs xi with prob > ½

• Call these edges good edges (endpoints contain information about xi)

Techniques from [KT00]/[GKST02]

• Theorem: If C is (2, c, ε)-smooth, then Gi contains a matching of size ≥ εm/c.

• Better to work with non-degenerate codes Each bit of the encoding depends on more

than one bit of the message For linear codes, good edges are non-trivial

linear combinations

• Fact: Any smooth code can be made non-degenerate (with constant loss in parameters).

Core Lemma [GKST02]

Let q1,…,qm be linear functions on {0,1}n s.t. for every i 1,…,nthere is a set Mi of at least γm disjoint pairs of indices j1, j2 such that

xi = qj1(x) + qj2(x).

Then m ≥ 2γn.

Putting it all together…

• If C is a (2, c, )-smooth linear code, then (by reduction to non-degenerate code + existence of large matchings + core lemma),

m ≥ 2n/4c.

• If C is a (2, δ, )-locally decodable linear code, then (by LDC → smooth reduction),

m ≥ 2δn/8.

Putting it all together…

• Summary:locally decodable → smooth →big matchings → exponential size

• This work:locally decodable → big matchings

(skip smoothness reduction, argue directly about LDCs)

The Blocking Game

• Let G(V,E) be a graph on n vertices,w a prob distribution on E,Xw an edge sampled according to w,S a subset of V

• Define the blocking probability βδ(G) as

minw (max|S|≤δn Pr (Xw intersects S))

The Blocking Game

• Want to characterize βδ(G) in terms of size of a maximum matching M(G), equivalently defect d(G) = n – 2M(G)

• Theorem: Let G be a graph withdefect αn. Then

βδ(G) ≥ min (δ/(1-α), 1).

The Blocking Game

cliqueαn (1-α)n

Define K(n,α) to be the edge-maximal graph on n vertices with defect αn:

K1

K2

The Blocking Game

• Optimization on K(n,α) is a relaxation of optimization on any graph with defect αn

• If d(G) ≥ αn then

βδ(G) ≥ βδ(K(n,α))

• So, enough to think about K(n,α).

The Blocking Game

• Intuitively, best strategy for player 1 is to spread distribution as uniformly as possible

• A (λ1,λ2)-symmetric dist: all edges in (K1,K2) have weight λ1

all edges in (K2,K2) have weight λ2

• Lemma: (λ1,λ2)-symmetric dist w s.t.

βδ(K(n,α)) = max|S|≤δn Pr (Xw intersects S).

The Blocking Game

• Claim: Let w1,…,wk be dists s.t.

max|S|≤δn Pr (Xwi intersects S) = βδ(G).

Then for any convex comb w = γi wi

max|S|≤δn Pr (Xw intersects S) = βδ(G).

• Proof: For S V, |S| ≤ δn, intersection prob is ≤ γi βδ(G) = βδ(G). So

max|S| ≤ δn Pr (Xw intersects S) ≤ βδ(G).

But by def’n of βδ(G), this must be ≥ βδ(G).

The Blocking Game

• Proof: Let w’ be any distribution optimizing βδ(G). If w’ does, then so does π(w’) for π Aut(G) = Γ. By prior claim, so does

w = (1/|Γ|) πΓ π(w’).For eE, σΓ,

w(e) = (1/|Γ|) πΓ w’(π(e))

= (1/|Γ|) πΓ w’(πσ(e))= w(σ(e)). .

So, if e, e’ are in the same Γ-orbit, they have the same weight in w w is (λ1,λ2)-symmetric.

The Blocking Game

• Claim: If w is (λ1,λ2)-sym then S V,|S| ≤ δn s.t.

Pr (Xw intersects S) ≥ min (δ/(1-α), 1).

• Proof: If δ ≥ 1 – α then can cover every edge. Otherwise, set S = any δn vertices of K2. Then

Pr = δ (1/(1 - α) + ½ n2 (1 - α – δ) λ2)which, for δ < 1 - α, is at least

δ/(1 - α)

(optimized when λ2 = 0).

The Blocking Game

• Theorem: Let G be a graph withdefect αn. Then

βδ(G) ≥ min (δ/(1-α), 1).

• Proof: βδ(G) ≥ βδ(K(n,α)). Blocking prob on K(n,α) is optimized by some (λ1,λ2)-sym dist. For any such dist w, δn vertices blocking w with Pr ≥ min (δ/(1-α), 1).

Lower Bound for LDLCs

• Still need a degenerate non-degenerate reduction (this time, for LDCs instead of smooth codes)

• Theorem: Let C be a (2, δ, ε)-locally decodable linear code. Then, for large enough n, there exists a non-degenerate (2, δ/2.01, ε)-locally decodable linear code

C’ : {0,1}n {0,1}2m.

Lower Bound for LDLCs

• Theorem: Let C be a (2, δ, ε)-LDLC. Then, for large enough n,

m ≥ 21/4.03 δ/(1-2ε) n.Proof:• Make C non-degenerate• Local decodability

low blocking probability (at most ¼ - ½ ε) low defect (α ≤ 1 – (δ/2.01)/(1-2ε)) big matching (½ (δ/2.01)/(1-2ε) (2m) ) exponentially long encoding (m ≥ 2(1/4.02) δ/(1-2ε)n – 1)

Matching Upper Bound

• Hadamard code on {0,1}n

yi = ai · x (ai runs through {0,1}n)

2-query locally decodable Recovery graphs are perfect matchings on

n-dim hypercube Success parameter ε = ½ - 2δ

Can use concatenated Hadamard codes (Trevisan):

Matching Upper Bound

• Set c = (1-2ε)/4δ (can be shown that for feasible values of δ, ε, c ≥ 1).

• Divide input into c blocks of n/c bits, encode each block with Hadamard code on {0,1}n/c.

• Each block has a fraction ≤ cδ corrupt entries, so code has recovery parameter

½ - 2 (1-2ε)/4δ δ = ε• Code has length

(1-2ε)/4δ 24δ/(1-2ε)n

Conclusions

• There is a matching upper bound (concatenated Hadamard code)

• New results for 2-query non-linear codes (but using apparently completely different techniques)

• q > 2?– No analog to the core lemma for more queries– But blocking game analysis might generalize

to useful properties other than matching size