Signale und Codes Vorlesung 11

Transkript

1 Signale und Codes Vorlesung 11 Nico Döttling January 31, / 22

2 Ein List-Decoder für WH k Theorem (Goldreich-Levin) Für jedes ɛ > 0 existiert ein effizienter List-Decoder für WH k welcher 1 2 ɛ Fehler korrigiert und eine poly(k) Lange Liste an Kandidaten ausgibt 2 / 22

3 Sei wieder c = c + e mit c x = m, x und e mit Gewicht ɛn (c und e sind nicht eindeutig!) n 2 Angenommen wir würden bereits l unabhängig gezogene zufällige fehlerfreie Positionen x 1,..., x l F k 2 von c kennen, also c xi = m, x i, dann könnten wir m i mit dem bereits gesehenen Decoder für WH k berechnen Idee von Goldreich und Levin: x 1,..., x l müssen garnicht unabhängig gezogen werden, es reicht wenn sie paarweise unabhängig gezogen werden. 3 / 22

4 Wie können wir l paarweise unabhängige x i erzeugen? Sei t = log(l 1) Identifiziere jede Zahl i {1,..., l} eindeutig mit einer nichtleeren Teilmenge T i {1,..., t} (z.b. über Binärdarstellung) Ziehe s 1,..., s t F k 2 Setze x i = j T i s j gleichverteilt zufällig 4 / 22

5 Behauptung: Die x i sind paarweise unabhängig Denn: Wenn i i, dann ist T i T i Nehme OBdA an T i = T i {r} mit r / T i Fall folgt daraus) (der allgemeine Dann ist x i = j T i s j = s r + j T i \{r} s j = s r + x i Da s r zufällig gleichverteilt und unabhängig von den s i mit Index i in T i gezogen wird ist x i unabhängig von x i 5 / 22

6 Problem: Wenn wir s 1,..., s t zufällig ziehen wissen wir nicht ob sich an diesen Positionen von c ein Fehler befindet Aber: Es gibt nur so wenige s j (logarithmisch viele), dass wir c genausogut ignorieren können und die w j = m, s j einfach raten oder durchprobieren können! 6 / 22

7 Wir erhalten nun folgenden Algorithmus 1. Eingabe: y F n 2 2. Ziehe s 1,..., s t gleichverteilt zufällig 3. Setze für alle i {1,..., l} x i = j T i s j 4. Iteriere die folgenden Schritte über alle (w 1,..., w t ) F t 2 5. Setze für alle i {1,..., l} v i = j T i w j 6. Setze für alle j {1,..., k} und i {1,..., l} ˆm i,j = c xi +e j + v i 7. Setze für alle j {1,..., k} m j auf die Mehrheit der ˆm i,j 8. Füge m = (m 1,..., m k ) der Ausgabeliste hinzu 7 / 22

8 Wir argumentieren nun wie folgt In einer der 2 t = l 1 Iterationen erwischen wir den richtigen Wert für (w 1,..., w t ). In dieser Iteration berechnet der Algorithmus jedes m j korrekt mit Wkt k Also werden alle m i mit Wkt = 0.9 richtige berechnet. 8 / 22

9 Fixiere ein j {1,..., k} Definiere die Zufallsvariablen Z 1,..., Z l wie folgt Z i = { 1 falls v i = m, x i und c xi +e j = m, x i + e j 0 sonst Falls die Mehrheit der Z i den Wert 1 annimmt, dann berechnet der Algorithmus m j korrekt. 9 / 22

10 In der Iteration in welcher wir die richtigen Werte für (w 1,..., w t ) raten gilt v i = m, x i, also hängt Z i nur von dem zweiten Ereignis ab. Da x j gleichverteilt ist, tritt dieses Ereignis mit Wkt ɛ ein. Es gilt also E[Z i ] = Pr[Z i = 1] = ɛ 10 / 22

11 Es gilt also noch zu zeigen dass für die richtigen (w 1,..., w t ) mit hoher Wahrscheinlichkeit die Mehrheit der Z i den Wert 1 annimmt. Wir verwenden dazu die Chebychev-Ungleichung: Für jede auf R definierte Zufallsvariable Z und für jedes a > 0 gilt (falls E[Z] und Var[Z] existieren) Pr[ Z E[Z] a] Var[Z] a 2 dabei ist Var[Z] = E[(Z E[Z]) 2 ] 11 / 22

12 Definiere nun Z = l i=1 Z i Es gilt also E[Z] = E[ l i=1 Z i] = l i=1 E[Z i] = l 2 + ɛl. Es gilt weiter Var[Z] = l i=1 Var[Z i] = l 4 ɛ2 l da die Z j paarweise unabhängig sind. 12 / 22

13 Es gilt also Pr[Z l/2] = Pr[Z l/2 ɛl ɛl] Pr[ Z E[Z] ɛl] l 4 ɛ2 l ɛ 2 l 2 = 1 4ɛ2 4ɛ 2 l Wir haben l bisher noch nicht genau spezifiziert. Wähle nun l 1 4ɛ2 4ɛ 2 10k Dann gilt also Pr[Z l/2] 1 10k 13 / 22

14 Der Algorithmus berechnet also m korrekt mit Wkt 1 1/10 = 0.9 Durch Wiederholen können wir diese Wkt beliebig nahe an 1 bringen. 14 / 22

15 Weitere List-Decodable Codes? Wir können also den Walsh-Hadamard Code list-decodieren. Dieser Code ist leider für viele Anwendungen unpraktisch. Kann man algebraische Codes list-decodieren? 15 / 22

16 List Decoding für Reed-Solomon Codes Theorem (Sudan 96) Es existiert ein List-Decoder für den q-ären [n, k, n k + 1] RS Code welcher, gegeben c F n q eine Liste alle Codeworte c berechnet für die wgt( c c) n 2 kn gilt. 16 / 22

17 List Decoding für Reed-Solomon Codes Vergleiche dies mit dem sstandard-decoder für RS Codes Dieser kann n k+1 2 Fehler korrigieren. Also Anteil korrigierbarer Fehler 1 2 k n Der Anteil korrigierbarer Fehler ist beim List-Decoder 1 2 Das tendiert zu 1 für kleines k n k n 17 / 22

18 Wir benötigen nun etwas Computeralgebra. Multivariate Polynome Q(X, Y ) F q [X, Y ] lassen sich effizient faktorisieren. Technik: Hensel Lifting Siehe z.b. Geddes, Czapor, Labahn: Algorithms for Computer Algebra 18 / 22

19 Der List-Decoder sieht folgendermaßen aus. Seien dazu ξ 1,..., ξ n die Auswertungsstellen des RS-Codes (also c i = f (ξ i )) 1. Eingabe c = ( c 1,..., c n ). 2. Finde ein Bivariates Nichtnull-Polynom Q(X, Y ) F q [X, Y ] mit Grad nk in X und Grad n/k in Y sodass Q(ξ i, c i ) = Zerlege Q(X, Y ) in seine irreduziblen Faktoren mittels eines effizienten Faktorisierungsalgorithmus. 4. Für jeden Faktor der Form P(X ) Y teste ob Grad(P) k und ob für mindestens 2 kn Stellen ξ gilt dass P(ξ i ) = c i. Falls ja, füge P zur Ausgabeliste hinzu 19 / 22

20 Wir zeigen nun dass der Algorithmus korrekt ist. Zunächst: Ein bivariates Polynom Q(X, Y ) mit Grad X (Q) nk und Grad Y (Q) n/k mit Q(ξ i, c i ) = 0 (für i = 1,..., n) existiert immer. Denn: Q(ξ i, c i ) = 0 ist ein homogenes lineares Gleichungssystem mit ( kn + 1)( n/k + 1) = n + kn + k/n + 1 > n Unbekannten (den Koeffizienten von Q) und n Gleichungen. Das Gleichungssystem ist also unterbestimmt. Es existiert also immer eine Nichtnull-Lösung. Diese läßt sich z.b. durch Gauß-Elimination finden. 20 / 22

21 Wir müssen noch zeigen dass wenn für ein Codewort c = (P(ξ i )) i gilt dass wgt( c c) n 2 kn, dann ist P(X ) Y ein Faktor von Q(X, Y ). Es gelte also dass c mit c an mehr als 2 kn Stellen mit c übereinstimmt. Betrachte nun das Polynom H(X ) = Q(X, P(X )). Es gilt Grad(H) kn + k n/k = 2 kn 21 / 22

22 Wir wissen aber auch dass H(X ) mehr als 2 kn Nullstellen besitzt, da für mehr als 2 kn Stellen ξ i gilt dass P(ξ i ) = c i = c i und Q(ξ i, c i ) = 0 Also ist H(X ) = Q(X, P(X )) das Nullpolynom Damit gilt ist dann aber P(X ) Y ein Teiler von Q(X, Y ) Also findet der Algorithmus P(X ) 22 / 22