Codes on Graphs: Normal Realizations

Codes on Graphs: Normal Realizations Autor: G. David Forney Seminarvortrag von Madeleine Leidheiser und Melanie Reuter 1

Inhaltsverzeichnis: 1. Einführung 3 1.1 Motivation 3 1.2 Einleitung 3 2. Graphendarstellungen 6 2.1 Trellis 6 2.2 Factor Graph 7 2.3 Normal Graph 8 3. Algorithmus 9 3.1 Cut Set Bound 9 3.2 Sum-Product Algorithmus 10 3.3 Belief Propagation 17 2

1. Einführung: 1.1 Motivation: Ausgangspunkt: Wir gehen von der Situation aus, das ein Sender einem Empfänger Nachrichten übermitteln will, zum Beispiel über ein Kabel. Dazu wird eine Nachricht in binäre Vektoren/ Wörter umgewandelt. Diese Vektoren werden dann beim Sender codiert es werden weitere Bits nach bestimmten Regeln hinzugefügt und beim Empfänger wieder decodiert. Bei der Übertragung können die Nachrichten dann aber aufgrund von Störungen beschädigt werden, so dass die Vektoren/ Wörter, die der Empfänger erhält, fehlerhaft sein können. Man spricht dann meist von geflippten Bits (statt einer 0 wurde eine 1 empfangen oder umgekehrt). Diese Fehler müssen dann noch zusätzlich beim Decodieren behoben werden. In unserem Vortrag werden wir einen solchen Algorithmus vorstellen, den man zur Fehlerbehebung beim Decodieren verwendet. Er versucht, zu einem erhaltenen Wort das nächstgelegene gültige Codewort zu finden. 1.2 Einleitung: Zunächst eine Definition, was unter einer generalized state realization, also unter einer möglichen Darstellung eines Codes, verstanden wird: Definition: In einer generalized state realization besteht ein Code aus symbol variables, state variables und constraints. Diesen constraints kann man entnehmen, welche der symbol variables unabhängig und welche abhängig sind und damit an welchen Stellen des Codewortes nach dem Codieren die information Bits und an welcher Stelle die redundanten Bits stehen. Die symbol variables sind dann also die information und die redundanten Bits, die in unserer Betrachtung nur die Werte 0 und 1 annehmen können. Dazu erst einmal folgendes Beispiel: 3

Beispiel: Wir betrachten den (8,4,4) Hamming Code. Dabei steht die 8 für die Länge der Codewörter die erste 4 für die Anzahl der redundanten Bits und die zweite 4 für die Hamming Distanz, also den minimalen Abstand zwischen zwei Codewörtern ( x y 4 für x, y Codewörter). Für dieses Beispiel haben wir 8 symbol variables y 1,... y 8 und 4 constraints, die die so genannte parity-check Matrix H ergeben: y 1 y 2 y 3 y 4 =0 y 2 y 4 y 5 y 7 =0 y 3 y 4 y 5 y 6 =0 y 5 y 6 y 7 y 8 =0 H = 1 1 1 1 0 0 0 0 1 0 1 0 1 1 0 1 0 0 0 1 1 1 1 0 0 0 0 0 0 1 1 1 Wir sagen, dass y 1, y 2, y 3 und y 5 unsere unabhängigen information Bits und damit y 4, y 6, y 7 und y 8 die abhängigen redundanten Bits sind. Diese parity-check Matrix H wird bei der Decodierung dazu genutzt, um zu überprüfen, ob ein erhaltenes Codewort x zulässig ist. Dies ist genau dann der Fall, wenn H x = 0 gilt. Auch bei der Codierung benötigt man eine Matrix, und zwar die Generator Matrix G. Sie erzeugt aus zu sendenden binären Wörtern u zulässige binäre Codewörter y. Es gilt y = u T G. Dabei sind in unserem Beispiel x F 2 8 und u F 2 4. Aus den beiden Gleichungen für die Codierung und Decodierung folgt folgende Beziehung zwischen G und H: G T H = 0 Der (8,4,4) Code aus unserem Beispiel ist self-dual, das heißt, dass G = H ist. Damit ist G: 1 1 1 1 0 0 0 0 1 G = 0 1 0 1 1 0 1 0 0 0 1 1 1 1 0 0 0 0 0 0 1 1 1 Eine Bedingung für self-dual Codes ist, dass die Anzahl der information Bits gleich der Anzahl der redundanten Bits ist, damit beide Matrizen die gleiche Größe haben. 4

Die 4 Zeilen aus G werden Generatoren genannt. Jede Linearkombination dieser 4 Generatoren erzeugt ein zulässiges Codewort. Dies ist leicht einzusehen, da die möglichen Koeffizienten dieser Linearkombinationen Vektoren u F 2 4 entsprechen., also genau unseren zu codierenden binären Wörtern, Definition: Der span eines Codewortes ist definiert als das Intervall vom ersten bis zum letzten Eintrag in der Matrix, der ungleich 0 ist. Eine minimum-span generator Matrix oder auch trellis-oriented generator Matrix ist definiert als die Menge von k linear unabhängiger generators mit kürzest möglicher effektiver Länge. Dabei ist k gleich der Anzahl der unabhängigen information Bits. Theorem: Eine Menge von k linear unabhängiger Generatoren ist genau dann eine minimum-span generator Matrix, wenn die Start- und Endzeiten aller spans unterschiedlich sind. Beweis: => Wenn alle Start- und Endzeiten unterschiedlich sind, dann entsprechen die Start- und Endzeiten einer gegebenen Linearkombination (mit Koeffizient ungleich 0) einer bestimmten Teilmenge der generators den frühesten Start- und spätesten Endzeiten der generators aus der gegebenen Menge. Daraus folgt, dass die generators, die irgendein non-generator Codewort formen, eine effektive Länge haben, die nicht größer ist als die effektive Länge des Codewortes. Also sind die gegebenen generaotrs tatsächlich die, deren effektive Längen so klein wie möglich sind. <= Wenn zwei Start- oder Endzeiten nicht verschieden sind, dann ist die Summe der zwei dazugehörigen generators ein Codewort, dessen effektive Länge kleiner ist als die Länge von mindestens einem der beiden generators. Wenn wir diesen generator durch das erhaltene Codewort ersetzen, erhalten wir eine Menge linear unabhängiger generators, von denen einer eine kürzere effektive Länge hat im Vergleich zu der ursprünglichen Menge, also war die ursprüngliche Menge nicht trellis-oriented. 5

Die Rückrichtung des Beweises bietet einen einfachen Greedy-Algorithmus an, um eine trellisoriented generator Matrix für eine gegebene generator Matrix zu finden: Sind die Start- oder Endzeiten zweier generators gleich, so ersetze den generator mit der größeren effektiven Länge durch die Summe der beiden generators, die notwendigerweise eine kürzere effektive Länge haben muss. Dieser Algorithmus reduziert in jedem Schritt die effektive Länge eines generators (und damit der Matrix) und muss daher nach endlich vielen Schritten ein einer trellis-oriented generator Matrix enden. G ist bereits eine minimum-span generator Matrix, nebenstehende Matrix ist keine solche Matrix 1 1 1 1 0 0 0 0 1 1 1 1 1 0 0 0 0 1 G = 0 1 0 1 1 0 1 0 0 1 0 1 1 0 1 0 G ' = 0 0 1 1 1 1 0 0 1 1 0 0 1 1 0 0 0 0 0 0 1 1 1 0 0 0 0 1 1 1 2. Graphendarstellungen: 2.1 Trellis: In der Trellisdarstellung betrachtet man das Codewort bitweise von vorne nach hinten. Zuerst befindet man sich im Zustand Null. Das erste Bit kann Werte 0 oder 1 annehmen, daher führen aus Zustand 0 zwei Kanten in zwei neue Zustände zum Zeitpunkt t=1. Für das zweite und das dritte Bit hat man jeweils auch wieder die Möglichkeit 0 oder 1. Die ersten drei Bits bestimmen den Wert des Vierten, daher hat man für das vierte Bit nur eine Möglichkeit. Außerdem, wenn man den Weg (0,0,0,0) und den Weg (1,1,1,1) betrachtet und die Werte in die Constraintgleichungen einsetzt, stellt man fest, dass es für die Bits 5 bis 8 keinen Unterschied macht ob man nun (0,0,0,0) oder (1,1,1,1) gegangen ist. Daher führen diese beiden Codeanfänge zum selben state. (-> Common future) Analog findet man die restlichen states bis zum Zeitpunkt t=8. Jeder Weg in dem Graphen von links nach rechts stellt ein zulässiges Codewort da und jedes zulässige Codewort findet sich als Weg im 6

Graphen. Im Bild sind die Nullen rot und die Einsen blau. 2.2 Factor Graph Von der Generatormatrix zum Faktorgraph: G = 1 1 1 1 0 0 0 0 1 0 1 0 1 1 0 1 0 0 0 1 1 1 1 0 0 0 0 0 0 1 1 1 Für jede Spalte der Matrix hat man einen Constraintknoten. An jeden Knoten i fügt man einen Dongle y i In einer Spalte i in der der Span einer Zeile beginnt wird ein Dongle angefügt. Die Werte der u i werden weitergeleitet, bis der Span beendet ist. u1 u2 u3 u4 C C C C C C C C y1 y2 y3 y4 y5 y6 y7 y8 7

Die Kanten zwischen zwei Knoten werden in einem Knoten zusammengefasst und die Eingänge u i weggelassen. So erhalten wir den Faktorgraph: C (2,1) C C C C C C C (4,2) (6,3) (6,3) (6,3) (6,3) (4,2) (2,1) Die ersten Zahl des Tupels gibt das state space profile an, die zweite das branch space profile. State space profile: Anzahl der Variablen die mit diesem Constraintknoten verbunden sind. Branch space profile: log 2 der Anzahl Kanten an dieser Stelle im Trellis. 2.3 Normal Graph: Definition: Ein normal graph ist ein Graph, in dem jede symbol variable Grad 1 und jede state variable Grad 2 hat. Symbol variables werden durch einen dongle dargestellt, state variables durch Kanten. C C C C C C C (2,1) (4,2) (6,3) (6,3) (6,3) (6,3) (4,2) (2,1) C 8

3. Algorithmus 3.1 Cut Set Bound: Past-Future Decomposition: Y P Y F Durch Gruppieren von je vier symbol variables zu je einem CP CF dongle und gruppieren von je vier Constraints aus dem normal graph zu Superconstraints erhalten wir diesen Graphen. Die state variable kann vier verschiedene Werte annehmen, entsprechend der Dimension des mittleren states im Trellis. Y P ={y 1, y 2, y 3, y 4 } Y P ={y 5, y 6, y 7, y 8 } Für einen Wert s j der state variable ist die Menge der Codewörter konsistent mit s j gleich Y P s j Y F s j. Theorem: Cut-set-bound Gegeben sei eine graphische Realisierung eines Codes C und ein cut-set X, dann ist die Größe des Alphabets (hier 0,1 n ) von unten begrenzt durch die minimal state space size eines trellis an der selben Trennstelle. Daraus folgt: Die Komplexität kreisfreier Graphen ist von unten beschränkt. 9

Beispiel: (24,12,8) Code, einmal als kreisfreier normal graph, einmal mit Kreis. Die Alphabetgröße der Kanten reduziert sich von 256 auf 16. 8 8 8 8 8 8 8 2 =256 8 4 4 4 4 4 4 4 4 2 =16 3.2 Sum-Product Algorithmus: Wir entwickeln den Sum-Product Algorithmus als einen APP decodierenden Algorithmus für einen Code C, der eine kreisfreie normal graph realization besitzt. Dabei steht APP für a posteriori probability. Zunächst einige grundlegende Notationen: Notationen: Menge der symbol variables: {Y i, i I } erhaltene Vektoren: r = {r i, i I } Codewort: y = {y i, i I } likelihood Vectoren: {{p r i y i, y i i },i I }, wobei i das Alphabet von Y i ist Daraus ergibt sich das likelihood eines Codewortes y = {y i, i I } C als komponentenweises Produkt pr y = i I pr i y i. 10

Nimmt man gleichwahrscheinliche Codewörter an, dann sind die APPs {p y r, y C } proportional zu den likelihoods {pr y, y C } nach Bayes Gesetz: p y r= p r y p y p r y, p r y C p y r ist die Wahrscheinlichkeit für ein Codewort y, wenn r empfangen wurde. pr y ist die Wahrscheinlichkeit, dass wenn y gesendet wurde, man r empfängt. Sei C i y i die Teilmenge der Codewörter, in denen die symbol variable y i den Wert y i i annimmt. Der symbol APP Vektor {py i = y i r, y i i } ist dann gegeben durch: py i = y i r= y C i y i p y r y Ci y i pr y = y Ci y i i I p r i y i, y i i Genauso kann man es für die states entwickeln: Sei C j s j die Teilmenge der Codewörter, die konsistent sind mit der state variable j, die den Wert s j aus dem Alphabet S j annimmt. Dann ist der APP Vektor {p j =s j r, s j S j } gegeben durch: p j = s j r y C j s j i I p r i y i, s j S j Es gibt zwei grundlegende Regeln für den Algorithmus: 1. Past-future decomposition rule 2. Sum-product update rule Past future decomposition rule: Die Regel basiert auf der Cartesian-product decomposition der Cut-set bound. Da wir ja nur den Fall eines kreisfreien Graphen betrachten, ist jede Kante j ein cut-set. Das kartesische Produkt C j s j = Y P s j Y F s j gibt die Teilmenge der Codewörter an, die konsistent sind mit der state variable j, die den Wert s j hat. P und F bezeichnen dabei die beiden Komponenten des nicht-zusammenhängenden Graphen, der aus dem Entfernen der Kante j resultiert ist. Y P s j und Y F s j Sind die Mengen der symbol Werte in jeder Komponente, die konsistent sind mit j mit dem Wert s j. 11

Cartesian-product distributive law: Für X, Y disjunkte, diskrete Mengen und f(x) und g(y) zwei Funktionen, die auf X und Y definiert sind, gilt: x, y X Y f xg y = x X f x y Y g y Daraus ergibt sich die past future decomposition rule für states: p j = s j r y F Y F s j i I F pr i y i y P Y F s j i I P pr i y i p j =s j r P p j =s j r F Der Sum-product Algorithmus berechnet die APP Vektoren von Past und Future getrennt und multipliziert sie dann komponentenweise, um {p j =s j r} zu erhalten. Die past future decomposition rule für symbol variable ist ähnlich: py i = y i r pr i y i y Ci y i i i pr i y i p y i r i p y i r i i Da symbol variables Grad 1 haben, ist eine der beiden Komponenten des Graphen, den man nach einem Schnitt erhält, die symbol variable selbst und die andere Komponente ist der gesamte restliche Graph. Der Term p y i r i wird oft intrinsic genannt und p y i r i i extrinsic. Beispiel: Die Wahrscheinlichkeiten, ob eine 0 oder eine 1 gesendet wurde, bekommt man zunächst vom Kanal. Sie seien hier folgendermaßen bezeichnet: p y i = 0 p i bezeichnet die Wahrscheinlichkeit, dass eine 0 gesendet wurde. p y i = 1 q i bezeichnet die Wahrscheinlichkeit, dass eine 1 gesendet wurde. Dann gilt: i p i oder q i gibt die Wahrscheinlichkeit für ein erhaltenes Codewort an. 12

y C i y i i p i oder q i gibt die Wahrscheinlichkeit für alle Codewörter, die an Stelle i den Wert y i annehmen, an. Betrachten wir zum besseren Verständnis folgenden Teil unseres trellis. Hierbei bezeichnet der state 00 den state, an dem die Wege 0000 und 1111 zusammen treffen. Da wir die dazwischenliegenden states weggelassen haben, wird 00 super state genannt. Den Teil links vom state 00 bezeichen wir als past, den Teil rechts als future. In folgender Tabelle kann man die Wahrscheinlichkeiten für die 4 möglichen Codewörter ablesen: Y 1,...,4 Past state Y 5,...,8 Future 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 00 0 0 0 0 1 1 1 1 0 0 0 0 1 1 1 1 p 1... p 8 p 1... p 4 q 5... q 8 q 1... q 4 p 5... p 8 q 1... q 8 Insgesamt benötigt man 32 Multiplikationen. Um jetzt zusätzlich die Wahrscheinlichkeit der Codewörter zu berechnen, die konsistent mit dem state 00 sind, müssen wir die 4 Einzelwahrscheinlichkeiten noch addieren und benötigen damit weitere 3 Additionen. Mit der past-future decomposition rule kann man die Berechnung allerdings auf 16 Multiplikationen und 2 Additionen reduzieren, wenn man zunächst past und future unabhängig von einander berechnet und dann miteinander multipliziert: p 1 p 2 p 3 p 4 q 1 q 2 q 3 q 4 p 5 p 6 p 7 p 8 q 5 q 6 q 7 q 8 13

Sum-product update rule: p j =s j r P = Ck s j j K p j =s jk j r P j Es handelt sich hierbei um eine lokale Regel für die Berechnung eines APP Vektors aus APP Vektoren, die eine Stufe zurück liegen. Wir können erst dann einen APP Vektor, also eine ausgehende Nachricht im Graphen, berechnen, wenn alle ankommenden Nachrichten eingegangen sind. Beispiel: Erst, wenn 1, 2, und 3 angekommen sind, kann der Knoten mit der constraint C berechnen. Der Algorithmus: Für jede Kante in dem Graphen wollen wir 2 APP Vektoren berechnen, jeweils einen für past und future. (Man kann sie sich als 2 Nachrichten vorstellen, die in die entgegengesetzten Richtungen geschickt werden.) Mit der sum-product update rule kann jede Nachricht berechnet werden, nachdem alle upstream Nachrichten an dem upstream Knoten angekommen sind. Jeder Knoten berechnet also eine ausgehende Nachricht an jeder Kante, nachdem er an allen anderen Kanten die eingehenden Nachrichten erhalten hat. Wenn man dann an allen Kanten 2 Nachrichten hat, können alle APPs mit der past-future decomposition rule berechnet werden. 14

Beispiel: In diesem Beispiel betrachten wir einen (zunächst) kreisfreien normal graph (- die gestrichelte Linie gehört erst einmal nicht dazu -) mit 4 symbol variables. Die APPs der symbol variables, die von außen (vom Kanal) gegeben sind, kommen zum Zeitpunkt 0 in den Knoten C 1, C 2, C 5 und C 6 an. Dann werden zum Zeitpunkt 1 die neu berechneten Nachrichten an die Knoten C 3 und C 4 geschickt. Damit der Knoten C 4 seine Nachrichten an die Knoten C 1, C 5 und C 6 schicken kann, benötigt er noch die Nachricht von Knoten C 3, nach der sum-product update rule. Da der Knoten C 4 aber bereits die Nachrichten von den Knoten C 1, C 5 und C 6 bekommen hat, kann er zum Zeitpunkt 2 eine Nachricht an Knoten C 3 schicken, der zum selben Zeitpunkt eine Nachricht in entgegengesetzte Richtung schickt. Zum Zeitpunkt 3 schicken dann C 3 und C 4 Nachrichten an C 1, C 2, C 5 und C 6, so dass zum Zeitpunkt 4 bei allen symbol variables die APPs ankommen, die vom System/ Graphen berechnet wurden. Die Multiplikation der beiden APPs ergibt dann den neuen APP Vektor für jede symbol variable. Betrachtet man nun den Graphen inklusive der gestrichelten Linie, so enthält der Graph jetzt einen Kreis C 1 C 4 C 6. Dann würde auch eine Nachricht von C 1 an C 6 und von C 6 an C 1 geschickt werden. Nun gibt es aber ein Problem: Um die Nachricht von C 6 an C 4 zu berechnen, braucht C 6 die Nachricht von C 1. Dafür braucht C 1 aber die Nachricht von C 4 und C 4 die von C 6. Damit haben wir einen Kreis und keine der Nachrichten kann mit den Regeln berechnet werden. (Genauso gilt es für die andere Richtung der Nachrichten.) 15

BCJR Algorithmus: (Bahl-Cocke-Jelinek-Raviv) Der BCJR Algorithmus ist eine Form des Sum-product Algorithmus, der auf einem chain-graph of a trellis läuft. Hier ein Teil eines solchen Graphen zur Veranschaulichung: Y 0 Y 1 Y 2 Y 3 Y 4 C 0 ε 0 ι 0 α 1 C 1 ε 1 ι 1 α 2 C 2 ε 2 ι 2 α 3 C 3 ε 3 ι 3 α 4 ι 4 C 4 ε 4 β 1 β 2 β 3 β 4 Y 0,... Y 4 sind die symbol variables, C 0,... C 4 repräsentieren constraints. Die Input Nachrichten sind die intrinsic APP Vektoren 0,... 4 und die Output Nachrichten sind die extrinsic APP Vektoren 0,... 4. Die Nachrichten dazwischen sind die vorwärts state APP Vektoren 0,... 4 und die rückwärts state APP Vektoren 0,... 4. Der Algorithmus läuft unabhängig vorwärts und rückwärts. In der Vorwärtsrichtung werden die j von links nach rechts mit der sum-product update rule aus den Nachrichten j 1 und j 1 berechnet. In der Rückwärtsrichtung werden die j von rechts nach links mit der sum-product update rule aus j 1 und j berechnet. Jede Output Nachricht i kann dann mit der sum-product update rule aus den Nachrichten i und i1 berechnet werden. Um dann die APP Vektoren einer input symbol Y i zu finden, müssen die Nachrichten i und i nach der past-future decomposition rule komponentenweise miteinander multipliziert werden. Genauso müssen j und j komponentenweise miteinander multipliziert werden, um die APP Vektoren einer state variable j zu finden. 16

3.3 Belief Propagation: Der Belief Propagation Algorithmus arbeitet auf dem Tannergraphen Der Tannergraph enthält für jede Gleichung einen Constraint-Knoten und für jedes Bit des Codeworts einen Symbol-knoten. Kommt ein Bit in einer Gleichung vor so sind die jeweiligen Knoten durch eine Kante verbunden. Der Tannergraph wird modifiziert: Die Constraintknoten sind hier +-Constraints. Für jede symbol variable wird ein neuer =-Constraintknoten eingeführt und die symbol variable als dongle angehängt. + + + + = = = = = = = = 17

Kleines Beispiel: y 0 + y 1 y 2 y 0 y 1 y 2 0 0 0 p 0 p 1 0 1 1 p 0 q 1 1 0 1 q 0 p 1 1 1 0 q 0 q 1 p i =P y i =0 r q i =P y i =1 r Gesucht ist die Wahrscheinlichkeit für den Wert von y 2, unter der Bedingung derer von y 0 und y 1. P y 2 =0 r= p 0 p 1 q 0 q 1 P y 2 =1 r= p 0 q 1 q 0 p 1 Da es nur zwei Möglichkeiten für den Wert eines Bits gibt, reicht es den Quotienten der Wahrscheinlichkeiten zu betrachten. y0 =ln p 0 q 0 y 1 =ln p 1 q 1 y 2 =ln p 0 p 1 q 0 q 1 p 0 q 1 q 0 p 1 Mit etwas Rechnen kommt man auf y 2 =2 artanh tanh 0 2 tanh 1 2 Der Wahrscheinlichkeitskoeffizient für für ein Bit wird also von den anderen bestimmt. Was ist nun, wenn es in dem Graphen Kreise gibt? Ein Bit beeinflusst dann die Information, die es über sich selbst aus dem Graphen bekommt. Der Algorithmus arbeitet nicht exakt. Daher sucht man Tannergraphen mit möglichst langem kleinsten Kreis um diesen Effekt zu minimieren. 18