Download Local List-Decoding of Reed-Muller Codes and more Study notes Number Theory in PDF only on Docsity!
CS225: Pseudorandomness Prof. Salil Vadhan
Lecture 21: Local List-Decoding
April 26, 2007
Based on scribe notes by Kevin Matulef.
1 Local List Decoding
In previous lectures, we talked about a local decoding algorithm as a probabilistic algorithm which, when given oracle access to a function g close to some codeword fˆ, and given an input x, would output fˆ(x) with high probability. Pictorially, this is shown below:
x^ Dec^ f(x)
g oracle access
In order to decode from distances close to 1/2 with a binary code, we would like to formulate a notion of local list-decoding. This is slightly trickier to define, since for any function g, there may be several codewords fˆ 1 , fˆ 2 , ..., fˆs that are close to g. So what should our decoding algorithm do? One option would be for the decoding algorithm, on input x, to output a list fˆ 1 (x), f 2 ˆ(x), ... fˆs(x). However, rather than outputing each of these values, we want to be able to specify to our decoder which f^ ˆi(x) to output. We do this with a two-phase decoding algorithm. The probabilistic algorithms that accomplish these phases will be referred to as Dec 1 and Dec 2 :
- Dec 1 , using g as an oracle, returns a list of advice strings a 1 , a 2 , ..., a 2 , which can be thought of as “labels” for each of the codewords close to g.
- Dec 2 (again, using oracle access to g), takes input x and ai, and outputs fˆi(x).
The picture for Dec 2 is much like our old decoder, but it takes an extra input ai corresponding to one of the outputs of Dec 1 :
g oracle access
f_i(x) a_i
x Dec_
More formally,
Definition 1 A local δ list-decoding algorithm for a code Enc is a pair of probabilistic oracle algorithms (Dec 1 , Dec 2 ) such that for all received words g and all codewords fˆ = Enc(f ) with ∆( f, gˆ ) < δ, the following holds. With probability greater at least 1 / 2 over (a 1 , ..., as) ← Decg 1 , there exists an i ∈ [s] such that
∀x, Pr[Decg 2 (x, ai) = f (x)] ≥ 2 / 3.
To help clarify this definition, we make the following remarks. First, we don’t require that for all j, Decg 2 (x, aj ) are codewords, or even that they’re close to s; in other words some of the aj ’s may be junk. Second, we don’t explicitly require a bound on list size s, but certainly it is less than time(Dec 1 ).
As we did for locally (unique-)decodable codes, we can define a local δ list-decoding algorithm for codeword symbols, where Dec^2 should recover arbitrary symbols of the codeword fˆ rather than the message f. As before, this implies the above definition if the code is systematic.
Two lectures ago, we explained how having a local decoding algorithm and a worst-case hard function implied having an average-case hard function. Similarly, if we have a local list-decoding algorithm, we can make the following statement:
Proposition 2 If Enc has a local δ-list decoding algorithm (Dec 1 , Dec 2 ), and f is worst-case hard for non-uniform time t = t(`), then fˆ = Enc(f ) is (t′, δ)-hard, where t′^ = t/time(Dec 2 ).
Proof: Suppose that fˆ is not (t′, δ)-hard. Then some algorithm A running in time t′^ computes fˆ with error probability smaller than δ. But if Enc has a local δ list-decoding algorithm, then (with A playing the role of g) that means there exists ai (one of the possible outputs of DecA 1 ), such that DecA 2 (·, ai) computes f (·) everywhere. The running time of DecA 2 (·, ai) is time(A) · time(Dec 2 ) = t. Note that here we are using nonuniformity crucially to hardwire ai as advice, in order to select the right function from the list of possible decodings.
2 Local List-Decoding Reed–Muller Codes
Theorem 3 There is a universal constant c such that the m-variate Reed–Muller code of degree d over a finite field F can be locally (1 − ε)-list decoded in time poly(|F|, m) for ε = c
d/|F|.
Note that the distance at which list-decoding can be done approaches 1 as |F|/d → ∞. It matches the bound for Reed–Solomon codes (up to the constant c) with the benefit of sublinear-time de- coding for large enough m; however, the rate is worse than for Reed–Solomon codes.
Proof: Suppose we are given an oracle g : Fm^ → F that is (1−ε) close to some unkown polynomial p : Fm^ → F, and that we are given an x ∈ Fm. Our goal is is describe two algorithms, Dec 1 and Dec 2 , where Dec 2 is able to compute p(x) using a piece of Dec 1 ’s output (i.e. advice).
which can be made < 0 .01 for a large enough choice of the constant c in ε = c
d/|F|. To prove (2), let q 1 , ...qs all be degree ≤ d polynomials (not equal to p|), with agreement ≥ ε/2 with g|. Then we have that
Pr y ←R`
[qi(y) = p(y)] ≤
d |F| since degree d polynomials can agree on at most d places. Then by the Johnson bound (applied to RS codes), we know s = O(
F/d). Using this in the union bound, we have:
Pr y [∃i : qi(y) = p(y)] ≤ d |F|
· s = O
d |F|
This can also be made < 0 .01 for large enough choice of the constant c (since we may assume F/d > c^2 , else ε = 1 and the result is trivial).
3 A Binary Code
We now obtain the binary locally list-decodable code we wanted by concatenating the above code with a Hadamard code.
Theorem 5 For every ∈ N and ε > 0 , there is a code Enc mapping messages f : { 0 , 1 }^ → { 0 , 1 }
to codewords fˆ : { 0 , 1 } `ˆ → { 0 , 1 } such that:
ˆ = O( + log(1/ε)).- Enc is computable in time 2 O(`ˆ).
- Enc has a local (1/ 2 − ε) list-decoding algorithm that runs in time poly(`, 1 /ε).
Proof: Given and ε, we choose a finite field F of characteristic 2 and of size |F| = Θ(poly(, 1 /ε)) for a sufficiently large polynomial poly(·) to be determined below.
As in the low-degree extension described last time, we let H ⊆ F of size
|F|, m = d/(log |H|)e, view f : Hm^ → { 0 , 1 }, and let f 1 : Fm^ → F be a low-degree extension of f of total degree at most d = m · |H| ≤ ·
|F|. Now we define fˆ : Fm^ × F → { 0 , 1 } be obtained by encoding each symbol of f 1 in the Hadamard code.
We have seen that the outer (Reed-Muller) code is locally (1−ε 1 ) list-decodable in time poly(m, |F|) for ε 1 = O(d/
|F|) = O(
`/F 1 /^4 ) = O(ε^3 ).
The inner (Hadamard) code is (1/ 2 − ε, 2 ) list-decodable by brute force in time poly(|F|), with a list size of 2 = O(1/ε^2 ). By a local list-decoding analogue of Problem 1 on Problem Set 5, we deduce that the concatenated code is locally δ-list-decodable in time poly(m, |F|) = poly(`, 1 /ε) for
δ = (1 − ` 2 ε 1 )(1/ 2 − ε) = 1/ 2 − O(ε).
Changing ε by a constant factor gives the result.
