Kanalcodierung [überarbeitete Auflage] 9783486755169, 9783486721287

die Kanalcodierung zur Fehlererkennung und -korrektur ist ein wesentlicher Bestandteil in modernen digitalen Kommunikati

172 69 5MB

German Pages 549 Year 2013

Report DMCA / Copyright

DOWNLOAD FILE

Polecaj historie

Kanalcodierung [überarbeitete Auflage]
 9783486755169, 9783486721287

Citation preview

Kanalcodierung von

Prof. Dr.-Ing. Martin Bossert 3., überarbeitete Auflage

Oldenbourg Verlag München

Prof. Dr.-Ing. Martin Bossert forscht und lehrt seit 1993 an der Universität Ulm und leitet dort das Institut für Nachrichtentechnik. Der Schwerpunkt seiner Forschung sind Anwendungen der Informationstheorie, insbesondere informationstheoretische Methoden zur zuverlässigen und sicheren Datenübertragung und -speicherung, in der Molekularbiologie und bei Compressed Sensing.

Bibliografische Information der Deutschen Nationalbibliothek Die Deutsche Nationalbibliothek verzeichnet diese Publikation in der Deutschen Nationalbibliografie; detaillierte bibliografische Daten sind im Internet über http://dnb.d-nb.de abrufbar. © 2013 Oldenbourg Wissenschaftsverlag GmbH Rosenheimer Straße 143, D-81671 München Telefon: (089) 45051-0 www.oldenbourg-verlag.de Das Werk einschließlich aller Abbildungen ist urheberrechtlich geschützt. Jede Verwertung außerhalb der Grenzen des Urheberrechtsgesetzes ist ohne Zustimmung des Verlages unzulässig und strafbar. Das gilt insbesondere für Vervielfältigungen, Übersetzungen, Mikroverfilmungen und die Einspeicherung und Bearbeitung in elektronischen Systemen. Lektorat: Dr. Gerhard Pappert Herstellung: Tina Bonertz Titelbild: shutterstock.com, Grafikdesign Apetrei, München Einbandgestaltung: hauser lacour Gesamtherstellung: Beltz Bad Langensalza GmbH, Bad Langensalza Dieses Papier ist alterungsbeständig nach DIN/ISO 9706. ISBN 978-3-486-72128-7 eISBN 978-3-486-75516-9

Vorwort zur 3. Auflage Gegenüber der zweiten Auflage des Buches wurden einige Korrekturen, Ergänzungen und Änderungen vorgenommen. Die Korrekturen bedürfen keiner Erklärung. Die Änderungen betreffen hauptsächlich die Kapitel zu Reed–Solomon-Codes und zur Decodierung von Blockcodes. Im Detail gibt es folgende Veränderungen zur zweiten Auflage: Kapitel 2: Der Euklidische Algorithmus wurde in den Anhang verschoben. Kapitel 3: Auf dem Gebiet der Decodierung von RS-Codes sind in den letzten 15 Jahren zahlreiche Fortschritte erzielt worden. Dies hat eine vollständige Überarbeitung dieses Kapitels notwendig gemacht. Die Beschreibung der Decodierung wird durch Einführung des Fehlercodes vereinfacht und auf zwei Fälle reduziert. Durch Modifikationen dieser beiden Fällen werden dann viele existierende Algorithmen abgeleitet. Außerdem wurde die Fehler/Auslöschungskorrektur ebenfalls basierend auf dem Fehlercode neu beschrieben und bewiesen. Ferner wurden die Ideen von zwei Methoden zur Decodierung über die halbe Mindestdistanz, Interleaved RS Codes und Power Decodierung, sowie die Listendecodierung mittels Interpolation ergänzt. Kapitel 5: Hier wurde die wichtige Klasse der LDPC Codes aufgenommen. Neben den Ideen, werden zwei Konstruktionsmethoden durch Geometrie in endlichen Körpern eingeführt. Dafür wurden die negazyklischen Codes und Codes über Z4 gestrichen. Kapitel 7: Hier wurde Vieles „entrümpelt“, da einige Ergebnisse eher durch Studium der Originalarbeiten als durch ein Lehrbuch gelesen werden. Der freiwerdende Platz wurde durch die Beschreibung von iterativer Decodierung und eines Listen-ViterbiAlgorithmus genutzt. Ebenfalls wurden die Beweise von Evseevs Lemma und GMD Decodierung erneuert. Kapitel 8: Hier wurden einige kleine Änderungen vorgenommen. Dann möchte ich mich ganz besonders bei meinen Mitarbeitern bedanken, ohne deren Mithilfe diese dritte Auflage des Buches nicht hätte entstehen können: Helmut Grießer, Wenhui Li, Katharina Mir, Mostafa Mohamad, Christian Senger, Vladimir Sidorenko, Antonia Wachter–Zeh, Alexander Zeh und Henning Zörlein.

Ulm, im Februar 2013

Martin Bossert

Vorwort zur 2. Auflage Gegenüber der ersten Auflage des Buches wurden einige Korrekturen, Ergänzungen und Änderungen vorgenommen. Die Korrekturen bedürfen keiner Erklärung. Die Änderungen betreffen hauptsächlich die Kapitel über Faltungscodes, verallgemeinerte Codeverkettung und codierte Modulation. Hier hat die Erfahrung aus meinen Vorlesungen gezeigt, dass Beispiele sehr nützlich sind, um durch unübersichtliche Notation nicht das Verständnis zu verhindern. Die Ergänzungen waren notwendig, da auf einigen Teilgebieten wesentliche Resultate hinzugekommen sind, etwa bei der Beschreibung von Blockcodes durch Trellisdiagramme. Im Detail gibt es folgende Veränderungen zur ersten Auflage: Kapitel 1: Codeverkürzung und -erweiterung sowie die Definition des dualen Codes wurden vorgezogen und weitere Aufgaben mit Lösungen hinzugefügt. Kapitel 2: Die Definition von Ringen wurde ergänzt und weitere Beispiele angegeben (z.B. Gaußzahlen). Auch hier wurden zusätzliche Aufgaben mit Lösungen hinzugefügt. Kapitel 3: Der Beweis des Berlekamp-Massey-Algorithmus wurde durch die Beschreibung des Zusammenhangs mit dem Euklidischen-Algorithmus überflüssig. Die einfache und zweifache Erweiterung von RS-Codes wurde aufgenommen, da diese später benötigt werden. Kapitel 4: Nichtbinäre BCH-Codes und der Zusammenhang zu RS-Codes wurden ergänzt. Kapitel 5 heißt in der neuen Auflage „Weitere Codeklassen“, und es werden nun RM-, Simplex-, Walsh-Hadamard-, konstazyklische-, nichtbinäre Hamming- und QR-Codes erläutert. Dabei wird speziell auf Pseudo-Noise- (PN-) und orthogonale Sequenzen eingegangen und der Zusammenhang der Codeklassen beschrieben. Kapitel 6 heißt neu „Eigenschaften von Codes und Trellisdarstellung“. Auf dem Gebiet der Trellisdarstellung von Blockcodes sind speziell im Jahre 1996 einige elegante Ergebnisse veröffentlicht worden. Wegen der Wichtigkeit der Theorie der minimalen Trellisse wurde diese hier aufgenommen. Kapitel 7: Die Decodierung von Blockcodes hat ebenfalls in den letzten Jahren einige Fortschritte erfahren. Es war deshalb notwendig, dieses Kapitel neu zu strukturieren. Dabei wurde versucht, die Konzepte der Verfahren, die bisher veröffentlicht wurden, zu klassifizieren und einheitlich zu beschreiben. Nach der Definition von Kanalmodellen und möglichen Metriken werden Decodierverfahren angegeben, die keine Zuverlässigkeitsinformation verwenden. Danach werden Decodierverfahren mit Zuverlässigkeitsinformation aufgeteilt in solche, die Codesequenzen schätzen und solche, die Codesym-

VIII

Vorwort zur 2. Auflage

bole schätzen. Die ersteren werden als Listendecodierverfahren beschrieben, und letztere werden hauptsächlich zur iterativen Decodierung benutzt. Zum Schluß wird noch eine Verbindung zu Verfahren aus der Optimierungstheorie, wie etwa zu dem SimplexAlgorithmus, angegeben. Kapitel 8: Dieses Kapitel wurde neu überarbeitet und mit vielen Beispielen ergänzt, speziell mit Hinblick auf die Betrachtung von Faltungscodes durch ihre algebraischen Eigenschaften. Mit integriert wurden auch die Beschreibung als lineare zeitinvariante Systeme und neue Distanzmaße. Für den praktischen Gebrauch von Faltungscodes rückt zunehmend die Decodierung mit Ausgabe von Zuverlässigkeitsinformation (SoftOutput) in den Vordergrund, die ebenfalls mit aufgenommen wurde. Auch sind aktuelle Tabellen guter Faltungscodes angegeben. Des weiteren wird die Verbindung zur Theorie der Blockcodes über die sogenannte Unit-Memory-Beschreibung von Faltungscodes erläutert. Kapitel 9: Die verallgemeinerte Verkettung von Codes ist bisher nur in russischen Büchern beschrieben. Dank der engen Kooperation mit russischen Wissenschaftlern konnten diese Quellen genutzt werden und dieses mächtige Konzept wird hier grundlegend beschrieben. Dabei wurde versucht, auf viele bekannte Varianten einzugehen und auch neuere Ergebnisse, wie die der Verkettung mit inneren Faltungcodes, zu integrieren. Das Hauptziel ist dabei, das Verständnis der Konzepte durch Beispiele zu vermitteln, da eine allgemeingültige Notation sehr komplex ist. Mit Block- und Faltungscodes als innere bzw. äußere Codes werden die vier damit möglichen verketteten Codes untersucht. Bei den als mehrfach verketteten Codes beschreibbaren RM-Codes wird ein verbesserter Decodieralgorithmus erläutert. Kapitel 10: Codierte Modulation wird als Spezialfall der verallgemeinerten Codeverkettung einheitlich beschrieben. Auch hier wurden zur Veranschaulichung zahlreiche Beispiele ergänzt. Die aus der Literatur bekannten Verfahren werden ebenfalls mit dieser Beschreibung klassifiziert. Außerdem werden neue Konzepte für Modulationsverfahren mit Gedächtnis vorgestellt. Es ist klar, dass ein Buch nicht unabhängig vom Umfeld des Autors entsteht, ja es spiegelt sogar dieses wieder. Deshalb gilt mein erster Dank meinem Lehrer Viktor Zyablov vom Institute of Problems of Information Transmission (IPPI) der Akademie der Wissenschaften in Moskau, und meinen Kollegen Sergo Shavgulidze von der Universität in Tiflis, Georgien, und Valodja Sidorenko, ebenfalls vom IPPI. Von ihnen habe ich durch zahllose Diskussionen und gemeinsame Projekte sowohl menschlich wie fachlich viel gelernt. Dann möchte ich mich ganz besonders bei meinen Mitarbeitern bedanken, ohne deren Mithilfe das Buch nicht hätte entstehen können: Helmut Grießer, Ralph Jordan, Rainer Lucas, Adrian Donder, Armin Häutle und Hans Dieterich. Weiterhin waren wichtige Mithelfer: Markus Breitbach, Thomas Frey, Johannes Maucher, Ramon Nogueroles, Gottfried Rossmanith und Walter Schnug sowie Christoph Haslach, Sven Riedel, Gabriele Buch, Claudia Osmann, Armin Dammann, Michael Lentmeier, Christian Kempter, und die Gäste Stefan Dodunekov und Ernst Gabidulin. Ganz besonderen Dank auch Herrn Dr. J. Schlembach vom Teubner-Verlag für die

Vorwort zur 2. Auflage

IX

konstruktive Zusammenarbeit und den zahllosen weiteren Helfern, die zum Gelingen des Buches beigetragen haben. Des weiteren möchte ich mich bei den Studenten bedanken, die wertvolle Hinweise zur Darstellung des Stoffes gegeben haben. Ich habe mich immer gewundert, warum die Autoren den Familienangehörigen danken. Nach diesem Buch weiß ich es und danke ganz besonders meiner geliebten Familie, meiner Frau Inge und meinen Kindern Marie-Luise, Magdalena und Sebastian, für deren Verständnis.

Ulm, im Januar 1998

Martin Bossert

Vorwort zur 1. Auflage Das vorliegende Buch entstand aus dem Manuskript zu der Vorlesung Verfahren zur Kanalcodierung, die ich an der TH Karlsruhe seit 1987 halte. Die Vorlesung richtet sich an Studenten im Hauptstudium der Fachrichtungen Elektrotechnik mit Schwerpunkt Nachrichtentechnik, Informatik und Mathematik. Das Ziel der Vorlesung – und damit auch des Buches – ist, die Verfahren, Methoden und Prinzipien der Kanalcodierung zu erläutern. Dabei kann auf Beweise an manchen Stellen – selbstverständlich nicht überall – verzichtet werden, um die für die Anwendung wichtigen Stellen ausführlicher zu erörtern. Die Kapitel über verallgemeinerte Codeverkettung und über codierte Modulation sind neu hinzugekommen. Sie beruhen auf den Arbeiten, die ich 1987/88 durch ein Stipendium der Deutschen Forschungsgemeinschaft bei Prof. T. Ericson an der Universität Linköping in Schweden durchführen konnte. Obwohl diese Themen bisher nicht oder nur unvollständig im Vorlesungsmanuskript behandelt wurden, war der Inhalt schon wegen der aktuellen Thematik Teil der Vorlesung. In beiden Kapiteln wird versucht, sowohl die Grundlagen der Themen herauszuarbeiten als auch die Aufarbeitung für die Anwendung bereitzustellen. Die Übungsaufgaben mit Lösungen sind nun an den entsprechenden Stellen integriert und sollen die Möglichkeit bieten, den behandelten Stoff zu vertiefen. An dieser Stelle möchte ich erwähnen, dass ich den Großteil der Übungsaufgaben zusammen mit meinem damaligen Kollegen Dr. K. Huber als wissenschaftlicher Angestellter am Institut von Prof. B. Dorsch an der TH Darmstadt erarbeitet habe. Für die Mithilfe bei der Entstehung des Buches möchte ich mich bei Herrn P. Klund bedanken, der sehr sorgfältig mit dem nötigen Sachverstand einen großen Teil des handschriftlichen Vorlesungsmanuskripts in LATEX umgesetzt hat. Mein besonderer Dank gilt Herrn Dr. C. Mahr, der mit Rat und Tat geholfen hat. Weiterhin bedanke ich mich bei meinen Kollegen bei der AEG Mobile Communication Frau Leinauer und den Herren H. Dieterich, H. Dreßler, J. Gerstner, M. Heilig, M. Reiner, G. Rossmanith und Dr. G. Schnabl für deren Mithilfe. Nicht zuletzt gilt mein Dank Herrn Prof. H. Wolf, dem Leiter des Lehrstuhls für Nachrichtensysteme an der TH Karlsruhe, der die Vorlesung Verfahren zur Kanalcodierung unterstützt, und Dr. J. Schlembach vom Teubner-Verlag für die konstruktive Zusammenarbeit.

Ulm, im April 1991

Martin Bossert

Inhaltsverzeichnis Einleitung

1

1

Grundbegriffe

5

1.1 1.1.1 1.1.2

Gewicht, Distanz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Mindestdistanz und Fehlerkorrigierbarkeit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Hamming-Schranke . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

7 8 9

1.2

Prüfmatrix und Syndrom . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11

1.3

Decodierprinzipien . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12

1.4

Fehlerwahrscheinlichkeit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15

1.5

Hamming-Codes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17

1.6

Generatormatrix . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19

1.7

Zyklische Codes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20

1.8

Dualer Code . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21

1.9

Erweiterung und Verkürzung von Codes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21

1.10

Kanalkapazität und Kanalcodiertheorem . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23

1.11

Anmerkungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25

1.12

Übungsaufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26

2

Galois-Felder

2.1

Gruppen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29

2.2

Ringe, Körper . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29

2.3

Primkörper . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31

2.4

Gaußkörper . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34

2.5 2.5.1 2.5.2 2.5.3

Erweiterungskörper . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Irreduzible Polynome . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Primitive Polynome, Wurzeln . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Eigenschaften von Erweiterungskörpern . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

2.6

Kreisteilungsklassen und quadratische Reste . . . . . . . . . . . . . . . . . . . . . . . . . . . 42

2.7

Anmerkungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43

29

36 36 37 40

XIV

Inhaltsverzeichnis

2.8

Übungsaufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44

3

Reed-Solomon-Codes

47

3.1 3.1.1 3.1.2 3.1.3 3.1.4 3.1.5 3.1.6 3.1.7

Definition von RS-Codes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Diskrete Fourier-Transformation (DFT) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Parameter von RS-Codes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Generatorpolynom . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Prüfpolynom . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Codierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Zwei Eigenschaften zyklischer Codes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . GRS-Codes und Erweiterungen von RS-Codes . . . . . . . . . . . . . . . . . . . . . . . . .

47 48 50 51 52 53 54 55

3.2 3.2.1 3.2.2 3.2.3 3.2.4 3.2.5 3.2.6 3.2.7

Algebraische Decodierung bis zur halben Mindestdistanz . . . . . . . . . . . . . . . Prinzip der algebraischen Decodierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Der Fehler als zyklischer Code . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Decodierung mit Fehler-Generatorpolynom . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Decodierung mit Fehler-Prüfpolynom . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Verfahren von Sugiyama et al., Welch–Berlekamp und Gao . . . . . . . . . . . . . Verfahren von Gorenstein–Zierler, Peterson und Berlekamp–Massey . . . . Korrektur von Fehlern und Auslöschungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

59 59 62 64 70 75 80 83

3.3 3.3.1 3.3.2

Algebraische Decodierung über die halbe Mindestdistanz . . . . . . . . . . . . . . . 87 Interleaved RS-Codes (IRS). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87 Power Decodierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89

3.4

Algebraische Listendecodierung durch Interpolation . . . . . . . . . . . . . . . . . . . . 91

3.5

Anmerkungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92

3.6

Übungsaufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94

4

BCH-Codes

4.1 4.1.1 4.1.2 4.1.3 4.1.4

Primitive BCH-Codes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Definition mit Kreisteilungsklassen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Definition mit DFT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Eigenschaften von primitiven BCH-Codes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Berechnung des Generatorpolynoms . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

4.2

Nicht-primitive BCH-Codes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104

4.3

Verkürzte und erweiterte BCH-Codes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105

4.4 4.4.1 4.4.2

Nicht-binäre BCH-Codes und RS-Codes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106 Nicht-binäre BCH-Codes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106 Zusammenhang zwischen RS- und BCH-Codes . . . . . . . . . . . . . . . . . . . . . . . . . 106

4.5

Asymptotisches Verhalten von BCH-Codes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107

4.6

Decodierung von BCH-Codes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108

4.7

Anmerkungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109

4.8

Übungsaufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 110

97 97 97 100 100 102

Inhaltsverzeichnis

XV

5

Weitere Codeklassen

111

5.1 5.1.1 5.1.2 5.1.3 5.1.4

RM-Codes (1. Ord.), Simplex-Codes und Walsh-Sequenzen . . . . . . . . . . . . . Reed-Muller- und Hamming-Code . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Hamming- und Simplex-Code . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Simplex-Code und binäre Pseudo-Zufallsfolgen . . . . . . . . . . . . . . . . . . . . . . . . . Reed-Muller- und Simplex-Code . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

111 113 113 115 118

5.2

Reed-Muller-Codes höherer Ordnung. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 120

5.3

q-wertige Hamming-Codes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 123

5.4

Binäre Quadratische-Reste-Codes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 125

5.5 5.5.1 5.5.2

Low-Density Parity-Check Codes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 126 Definition und Darstellung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 126 LDPC Codes mit Euklidischer- und Projektiver Geometrie . . . . . . . . . . . . . 128

5.6

Anmerkungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132

5.7

Übungsaufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 133

6

Eigenschaften von Blockcodes und Trellisdarstellung

6.1

Dualer Code und MacWilliams-Identität . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 135

6.2

Automorphismus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 141

6.3

Gilbert-Varshamov-Schranke . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 141

6.4

Singleton-Schranke (MDS) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 143

6.5

Reiger-Schranke (Bündelfehlerkorrektur) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 144

6.6

Asymptotische Schranken . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 144

6.7 6.7.1 6.7.2 6.7.3

Minimales Trellis von linearen Blockcodes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Konstruktion mit Hilfe der Prüfmatrix . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Konstruktion mit Hilfe der Generatormatrix . . . . . . . . . . . . . . . . . . . . . . . . . . . Eigenschaften eines minimalen Trellis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

6.8

Anmerkungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 161

6.9

Übungsaufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 163

7

Weitere Decodierverfahren

165

7.1 7.1.1 7.1.2 7.1.3 7.1.4

Kanalmodelle und Metriken . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . q-närer symmetrischer Kanal . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Additives weißes Gaußsches Rauschen (AWGN) . . . . . . . . . . . . . . . . . . . . . . . . Zeitvariante Kanäle. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Hamming- und euklidische Metrik . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

166 167 168 169 171

7.2 7.2.1 7.2.2 7.2.3

Decodierprinzipien, Zuverlässigkeit, Komplexität und Codiergewinn . . . . MAP- und ML-Decodierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Zuverlässigkeit für die binäre Übertragung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Decodierkomplexität und der Satz von Evseev . . . . . . . . . . . . . . . . . . . . . . . . .

172 172 173 179

135

146 148 151 156

XVI

Inhaltsverzeichnis

7.2.4

Codiergewinn . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 181

7.3 7.3.1 7.3.2 7.3.3 7.3.4

Hard-Decision Decodierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Permutationsdecodierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Mehrheitsdecodierung (majority logic decoding) . . . . . . . . . . . . . . . . . . . . . . . . DA-Algorithmus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Viterbi-Algorithmus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

182 182 184 186 189

7.4 7.4.1 7.4.2 7.4.3 7.4.4

Soft-Decision Decodierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Generalized-Minimum-Distance (GMD) Decodierung . . . . . . . . . . . . . . . . . . . Chase- und Dorsch-Algorithmen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Listen-Viterbi-Algorithmus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Iterative Verfahren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

190 191 193 195 199

7.5

Decodierung als Optimierungsproblem . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 206

7.6

Anmerkungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 209

7.7

Übungsaufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 210

8

Faltungscodes

213

8.1 8.1.1 8.1.2 8.1.3 8.1.4 8.1.5 8.1.6 8.1.7 8.1.8 8.1.9 8.1.10

Grundlagen von Faltungscodes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Codierung durch sequentielle Schaltkreise . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Impulsantwort und Faltung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Einflusslänge, Gedächtnisordnung und Gesamteinflusslänge . . . . . . . . . . . . . Generatormatrix im Zeitbereich . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Zustandsdiagramm, Codebaum und Trellis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Freie Distanz und Distanzfunktion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Terminierung, Truncation und Tail-Biting . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Generatormatrix im transformierten Bereich . . . . . . . . . . . . . . . . . . . . . . . . . . . Systematische und katastrophale Generatormatrizen . . . . . . . . . . . . . . . . . . . Punktierte Faltungscodes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

214 215 216 218 220 222 226 230 234 238 241

8.2 8.2.1 8.2.2 8.2.3 8.2.4 8.2.5 8.2.6 8.2.7 8.2.8

Algebraische Beschreibung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Code, Generatormatrix und Codierer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Faltungscodierer in Steuer- und Beobachterentwurf . . . . . . . . . . . . . . . . . . . . . Äquivalente Generatormatrizen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Smith-Form einer Generatormatrix . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Basisgeneratormatrix . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Katastrophale Generatormatrizen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Systematische Generatormatrizen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Prüfmatrix und dualer Code . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

244 245 245 248 250 252 254 256 258

8.3 8.3.1 8.3.2

Distanzmaße . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 259 Spalten- und Zeilendistanz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 259 Erweiterte Distanzmaße . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 263

8.4 8.4.1 8.4.2 8.4.3

Maximum-Likelihood (Viterbi-) Decodierung . . . . . . . . . . . . . . . . . . . . . . . . . . . Metrik . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Viterbi-Algorithmus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Schranken zur Decodierfähigkeit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

267 269 271 275

Inhaltsverzeichnis

XVII

8.4.4 8.4.5

Interleaving . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 278 Soft-Output-Viterbi-Algorithmus (SOVA) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 279

8.5

Soft-Output-Decodierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 282

8.6 8.6.1 8.6.2 8.6.3

Sequentielle Decodierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Fano-Metrik . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Zigangirov-Jelinek (ZJ)-Decodierer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Fano-Decodierer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

285 286 287 289

8.7 8.7.1 8.7.2 8.7.3 8.7.4 8.7.5

(Partial-) Unit-Memory-Codes, (P)UM-Codes . . . . . . . . . . . . . . . . . . . . . . . . . . Definition von (P)UM-Codes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Trellis von (P)UM-Codes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Distanzmaße bei (P)UM-Codes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Konstruktion von (P)UM-Codes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . BMD-Decodierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

290 290 292 293 294 297

8.8

Tabellen guter Codes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 299

8.9

Anmerkungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 303

8.10

Übungsaufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 305

9

Verallgemeinerte Codeverkettung

9.1

Einführende Beispiele . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 310

9.2 9.2.1 9.2.2 9.2.3 9.2.4 9.2.5 9.2.6

GC-Codes mit Blockcodes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Definition von GC-Codes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Zur Partitionierung von Blockcodes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Codekonstruktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Decodierung von GC-Codes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . UEP-Codes mit mehrstufigem Fehlerschutz . . . . . . . . . . . . . . . . . . . . . . . . . . . . Zyklische Codes als GC-Codes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

9.3 9.3.1 9.3.2

Error Locating Codes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 356 Verallgemeinerte Error Locating (GEL) Codes . . . . . . . . . . . . . . . . . . . . . . . . . 357 GEL Codes für zweidimensionale Fehler . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 362

9.4 9.4.1 9.4.2 9.4.3 9.4.4 9.4.5

GC-Codes mit Faltungscodes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Partitionierung von (P)UM-Codes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Einführende Beispiele zur Partitionierung durch das Trellis . . . . . . . . . . . . . Partitionierung von Faltungscodes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Konstruktion und Decodierung eines GC-Codes . . . . . . . . . . . . . . . . . . . . . . . . Turbo-Codes und ungelöste Probleme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

9.5 9.5.1 9.5.2

GC-Codes mit Block- und Faltungscodes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 395 Innere Faltungs- und äußere Blockcodes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 395 Innere Block- und äußere Faltungscodes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 400

9.6 9.6.1 9.6.2 9.6.3

Mehrfachverkettung und Reed-Muller-Codes . . . . . . . . . . . . . . . . . . . . . . . . . . . GMC, Decodieralgorithmus für RM-Codes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . L-GMC, Listendecodierung von RM-Codes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Simulationsergebnisse und Komplexität . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

307

315 316 318 325 331 349 350

370 370 374 383 386 393

402 405 410 414

XVIII

Inhaltsverzeichnis

9.7

Anmerkungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 418

10

Codierte Modulation

10.1

Einführende Beispiele . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 423

10.2 10.2.1 10.2.2 10.2.3 10.2.4 10.2.5

GC mit Blockmodulation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Partitionierung von Signalen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Definition der Codierten Modulation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Lattices und verallgemeinerte Mehrfachverkettung . . . . . . . . . . . . . . . . . . . . . Decodierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Trelliscodierte Modulationssysteme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

426 426 428 430 434 438

10.3 10.3.1 10.3.2 10.3.3 10.3.4 10.3.5

GC mit Faltungsmodulation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Einführendes Beispiel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Algebraische Beschreibung der Faltungsmodulation . . . . . . . . . . . . . . . . . . . . Partitionierung für Faltungsmodulation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Äußere Faltungscodes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Äußere Blockcodes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

440 440 442 445 446 450

10.4

Anmerkungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 450

A

Euklidischer Algorithmus

A.1

Euklidischer Algorithmus für ganze Zahlen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 453

A.2

Euklidischer Algorithmus für Polynome . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 455

B

Metriken

B.1

Lee-Metrik . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 461

B.2

Manhattan- und Mannheim-Metrik . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 464

B.3

Kombinatorische Metrik . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 465

C

Lösungen zu den Übungsaufgaben

423

453

461

469

Literaturverzeichnis

501

Index

523

Einleitung Unter dem Begriff Codierung versteht man im allgemeinen die Zuordnung einer Nachrichtenmenge zu einer Menge von Symbolen oder Zeichen. Dabei können unterschiedliche Ziele verfolgt werden. Die Codierung zur Verschlüsselung oder zur Authentifizierung wird Kryptographie genannt und wird verwendet, um Nachrichten gegen mißbräuchliche Benutzung zu schützen. Die Quellencodierung versucht, eine Nachrichtenmenge zu komprimieren, und die Kanalcodierung versucht, eine Nachrichtenmenge gegen zufällige Störungen unempfindlich zu machen. Ein allgegenwärtiges Beispiel für Kanalcodierung stellt die Sprache bzw. der geschriebene Text dar. Die Sprache enthält Redundanz, und diese kann bei fehlerhafter Übertragung (Druckfehler, Lese-Schreibschwäche des Verfassers, etc.) zur Korrektur der Fehler benutzt werden. Die Redundanz ergibt sich aus der Tatsache, dass nicht alle Worte, die man etwa aus 7 Buchstaben bilden kann, gültige (sinnvolle) Worte einer Sprache darstellen. Die gültigen Worte sind die Codeworte, und die Decodierung bedeutet, ein gültiges Codewort möglichst „nahe“ an einer Buchstabenfolge zu finden. Um meiner Frau und meinen Kindern zu erklären, was Kanalcodierung ist, haben wir folgendes Experiment durchgeführt. Ich habe ein Sprichwort ausgewählt und die Kinder haben den Übertragungskanal gespielt, indem gewürfelt wurde und zusätzlich irgendein Buchstabe aus den 26 des Alphabets gezogen wurde. Die Zahl des Würfels entsprach den fehlerfreien Stellen zwischen denen ein regulärer Buchstabe gegen einen gezogenen ausgetauscht wurde. Heraus kam: „Eina Rdisd von raascnd Mqiler eeginft mit eqneo einzlgen Echrdtt.“ Chinesisches Sprichwort Meine Frau musste anschließend die Decodierung durchführen, indem sie für jedes fehlerhafte Wort ein gültiges Wort suchte (gleichzeitig benutzt man selbstverständlich implizit die sinnvolle Aussage des ganzen Satzes). Sie konnte alle Fehler korrigieren und die Aussage des Sprichwortes gibt Mut neue, auf den ersten Blick sehr komplexe Dinge anzugehen (etwa ein Lehrbuch zu schreiben oder aber zu studieren). Als Ursprung sowohl der Informationstheorie als auch der Kanalcodierung wird die Arbeit von C. E. Shannon [Sha48] aus dem Jahre 1948 angesehen, in der schon absolute Grenzen für die Möglichkeiten der Kanalcodierung angegeben wurden. Wie bei der Sprache werden bei der Kanalcodierung zusätzlich zu den Informations- noch Redundanzzeichen hinzugefügt, die benutzt werden, um durch Störungen entstandene Fehler zu erkennen bzw. zu korrigieren. Dies kann mit zwei prinzipiell unterschiedlichen Codeklassen durchgeführt werden: den Blockcodes, bei denen voneinander unabhängige Blöcke – die Codewörter – mit einem konstanten Verhältnis von Information und Redundanz gebildet werden, und den Faltungscodes, bei denen die Redundanz kontinuierlich durch Verknüpfung (Faltung) der Information gebildet wird.

2

Einleitung

Die Kanalcodierung ist ein recht junges Gebiet und das vorliegende Buch soll die grundlegenden Prinzipien, Methoden und Verfahren erläutern, die in der Kanalcodierung verwendet werden. Die Wahl eines Codes ist vor allem vom vorliegenden Kanal abhängig. Ein wesentlicher Punkt für die praktische Verwendung von Codes ist deren Decodierung, die im Vordergrund stehen soll. Des Weiteren wird in Kommunikationssystemen zunehmend das mächtige Konzept der Codeverkettung (codierte Modulation) eingesetzt, das von Grund auf im letzten Teil des Buches eingeführt wird. Elementare Kenntnisse in Wahrscheinlichkeitstheorie und Nachrichtentechnik werden vorausgesetzt. Zunächst werden im Kapitel 1 einige elementare Grundbegriffe, Modelle, Konzepte und Definitionen angegeben. Eine Abschätzung der erreichbaren Parameter von Blockcodes, d. h. ihrer Decodierfähigkeit, stellt eine obere Schranke bereit. Die möglichen Decodierprinzipien werden erörtert und die Decodierfehlerwahrscheinlichkeiten dazu definiert. In Kapitel 2 wird die Theorie der Galois-Felder erläutert, d. h. Primkörper und Erweiterungskörper. Ein wichtiges Hilfsmittel ist hierbei der Euklidische Algorithmus, der den größten gemeinsamen Teiler von zwei ganzen Zahlen berechnet. Die Kenntnisse der elementaren Algebra erleichtern die Codekonstruktionen, und erlauben später elegant zyklische Codes zu konstruieren, wie sie etwa als sogenannter CRC-Code (cyclic redundancy check ) bekannt sind. Die Reed-Solomon-Codes werden in Kapitel 3 eingeführt. Dabei werden aus zwei Gründen nur Primkörper verwendet, obwohl die Theorie auch unverändert für Erweiterungskörper gilt. Der erste Grund ist, dass das ungewohnte Rechnen in Erweiterungskörpern nicht die Theorie verdeckt und der zweite, dass man Reed-Solomon-Codes verstehen kann, auch wenn man sich „nur“ die Theorie zu Primkörpern angeeignet hat. Zur Decodierung wird eine neue Methode – der Fehlercode – eingeführt, mit der die bekannten algebraischen Decodierverfahren beschrieben und bewiesen werden. Dabei wird hauptsächlich der Euklidische-Algorithmus verwendet. Für die Erörterung von BCH-Codes in Kapitel 4 wird dann zusätzlich die Theorie der Erweiterungskörper benötigt. Hierbei konzentrieren wir uns auf Erweiterungen des binären Grundkörpers. Der Zusammenhang zwischen Reed-Solomon- und BCH-Codes wird erläutert, und zur Decodierung können ebenfalls algebraische Verfahren verwendet werden. Weitere Codeklassen, die von praktischem Interesse sind, werden in Kapitel 5 eingeführt. Dabei handelt es sich u. a. um Codes, die zur Erzeugung von orthogonalen bzw. biorthogonalen Signalen und PN-Sequenzen (pseudo noise) dienen. Namentlich sind dies Simplex-, Reed-Muller- und Hamming-Codes sowie Walsh- und Hadamard-Sequenzen. Außerdem werden die LDPC-Codes und die binären Quadratischen-Reste-Codes in Abschnitt 5.4 definiert, die mit zu den besten bekannten Codes gehören. In Kapitel 6 werden allgemeine Eigenschaften von Blockcodes behandelt, die dann in Kapitel 7 benutzt werden, um weitere Decodierverfahren herzuleiten. Inzwischen ist die Beschreibung eines Blockcodes durch ein Trellis (Netzdiagramm) zu einem unerlässlichen Hilfsmittel geworden, und deshalb werden die fundamentalen Begriffe, Definitionen und Eigenschaften dazu angegeben und erläutert. Auf die Decodierung von Blockcodes wird ausführlich in Kapitel 7 eingegangen. Es werden unterschiedliche Decodierverfahren beschrieben, die einerseits notwendig sind, um Codes decodieren zu können, die nicht algebraisch decodierbar sind, und andererseits

Einleitung

3

werden sie für die Anwendung, häufig sowohl wegen der größeren Decodiergeschwindigkeit, als auch wegen der Möglichkeit Zuverlässigkeitsinformation zu benutzen, dem algebraischen Verfahren vorgezogen. Die Methoden der Signalschätzung liefern nämlich im allgemeinen nicht nur eine binäre Entscheidung, sondern zusätzlich eine Information über die Zuverlässigkeit der Entscheidung. Wie diese zusätzliche Information zur Decodierung verwendet werden kann, wird wird ausführlich erläutert. Es werden Verfahren wie Permutationsdecodierung, Schwellwertdecodierung, Listendecodierung, iterative symbolweise Decodierung und Mehrheitsdecodierung beschrieben. Ein Code sollte so gewählt werden, dass er möglichst viele Fehler, die charakteristisch sind für den gegebenen Kanal, korrigieren kann, und die Komplexität der Decodierung im Rahmen des Möglichen liegt. Für Faltungscodes werden in Kapitel 8 die elementaren Theorien erläutert. Dabei werden sowohl die möglichen klassischen Beschreibungsformen von Faltungscodes angegeben, als auch die algebraische Betrachtung. Die große praktische Bedeutung verdanken die Faltungscodes der möglichen Decodierung durch den Viterbi-Algorithmus, der hier nochmals erörtert wird, obwohl wir ihn in Kapitel 7 bei der Decodierung von Blockcodes benutzt haben. Des Weiteren beschreiben wir die sequentielle Decodierung von Faltungscodes mittels Fano- und ZJ-Algorithmus sowie die Decodierung mit zusätzlicher Ausgabe von Zuverlässigkeitsinformation, die zunehmend praktische Bedeutung erlangt. Diese Methode kann u. a. bei der Verkettung von Faltungscodes verwendet werden. Die Punktierung (puncturing) von Faltungscodes ermöglicht es, Codes mit mehrstufigem Fehlerschutz zu konstruieren. Am Ende dieses Kapitels sind noch Tabellen von guten Faltungscodes angegeben. Im Kapitel 9 wird das Prinzip der verallgemeinerten Codeverkettung erläutert. Dieses sehr mächtige Prinzip geht von der Idee aus, zwei Codes seriell zu verketten, die dann innerer und äußerer Code genannt werden. Die Partitionierung des inneren Codes und die Anwendung mehrerer äußerer Codes führt dann zur verallgemeinerten Verkettung von Codes. Eine Beschreibung dieser Theorie hat bislang nur Eingang in russische Lehrbücher gefunden und wird deshalb umfassend in den Kapiteln 9 und 10 erläutert und für die Anwendung aufbereitet. Entscheidende Vorteile dieses Prinzips sind dabei u. a. die Möglichkeit, Codes mit mehrstufigem Fehlerschutz zu konstruieren, die gleichzeitige Korrektur von Bündel- und Einzelfehlern, und die für die Anwendung wichtige Tatsache, dass aus mehreren kurzen Codes relativ lange Codes konstruiert werden können. Wir werden auf die verallgemeinerte Verkettung von Block- und Faltungscodes eingehen, wobei anzumerken ist, dass sich das Gebiet noch in der Forschung befindet, d. h. noch viele ungelöste Probleme existieren. Mit Hilfe der verallgemeinerten Codeverkettung gelingt es, die Klasse der Reed-MullerCodes einfach zu beschreiben. Die Konsequenz dieser Beschreibung ist ein neues Decodierverfahren, das die Benutzung von vorhandener Zuverlässigkeitsinformation erlaubt. Dieses neue Decodierverfahren werden wir in Abschnitt 9.6.1 erläutern. Es hat, verglichen mit allen bisher bekannten Decodierverfahren für Reed-Muller-Codes, eine extrem geringe Komplexität, d. h. die Decodierung benötigt wenig Rechenoperationen. Die Theorie der verallgemeinerten Codeverkettung erlaubt als Spezialfall die codierte Modulation in Kapitel 10 zu beschreiben. Deshalb werden die Kenntnisse aus Kapitel 9 fast vollständig für Kapitel 10 vorausgesetzt. Die codierte Modulation stellt zur Zeit einen aktuellen Forschungsschwerpunkt in der Nachrichtentheorie dar. Der Zugang zu

4

Einleitung

diesem Gebiet mittels verallgemeinerter Codeverkettung erlaubt sowohl eine abstrakte Beschreibung als auch Konstruktionsmethoden für codierte Modulationssysteme. Weit verbreitet ist die codierte Modulation auch unter dem Namen trelliscodierte Modulation. Die Benutzung von mehrdimensionalen Räumen erlaubt eine flexiblere Ausnutzung der verwendeten Verfahren bei codierten Modulationssystemen. Die mehrdimensionalen Signalkonstellationen sind auch unter dem Namen Lattice bekannt, und einige davon werden wir als verallgemeinerte Codeverkettung beschreiben. Über 200 Beispiele dienen dazu, die Theorie sofort zu veranschaulichen. Die Beispiele sind häufig Voraussetzung für weitere Beispiele und sollten deshalb nachvollzogen werden. Am Ende der Kapitel 1–8 sind Übungsaufgaben angegeben, deren mögliche Lösungen im Anhang C beschrieben werden. Die Aufgaben sollen zum tieferen Verständnis beitragen, sind jedoch keine Voraussetzung für den Inhalt der jeweils folgenden Kapitel. Als Leser dieses Buches ist es möglich unterschiedliche Schwerpunkte zu setzen, und deshalb sollen im Folgenden einige Hinweise über spezielle Teilgebiete des Buches angegeben werden: • Die Codierung und Decodierung der BCH- und RS-Codes werden durch die Kapitel 1–4 abgedeckt. • Die Decodierung von binären linearen Blockcodes wird durch die Kapitel 1, 6 und 7 beschrieben. • Die Theorie zu Faltungscodes und ihre Decodierung befinden sich in Kapitel 8. Zusätzlich werden noch die Abschnitte 7.1 und 7.2 für die Kanalmodelle, die Metrik und die Zuverlässigkeitsinformation benötigt. • Die Beschreibung von Blockcodes durch ein Trellis sowie die Theorie zum minimalen Trellis ist in Abschnitt 6.7 erläutert. Hierzu ist die Kenntnis von Kapitel 1 vorausgesetzt. Einige Themen, wie beispielsweise Viterbi-Decodierung oder Zuverlässigkeitswerte, werden sowohl im Kontext von Block- als auch von Faltungscodes behandelt. Die Wiederholung scheint aber durchaus sinnvoll, da man die Thematik so aus unterschiedlichen Perspektiven kennenlernt. Im Hinblick auf die Notation habe ich mich an den gängigen Veröffentlichungen orientiert, um die Lektüre weiterführender Literatur zu erleichtern. Da diese Notation bei Block- und Faltungscodes etwas unterschiedlich ist, spiegelt sich dies auch in diesem Buch wider.

1

Grundbegriffe

Das Problem der Kanalcodierung kann durch das in Bild 1.1 gezeigte Modell beschrieben werden. Die Informationsfolge i des Senders wird durch einen Codierer in die Codefolge c umgewandelt. Durch eventuell auftretende Störungen im Kanal wird eine Folge r empfangen, aus der der Decodierer die mit größter Wahrscheinlichkeit gesendete Informationsfolge ˆi bestimmen muss. Dazu äquivalent ist, aus der empfangenen Folge r die Codefolge c bzw. die Fehlerfolge f zu bestimmen. Der Kanal beschreibt verschiedenartige Gegebenheiten, z. B. Schreiben und Lesen auf bzw. von einem Speicher, Senden, Toleranzen von Herstellungsverfahren, Nebensprechen auf Leitungen, usw. Um diese Gegebenheiten zu abstrahieren, werden Kanalmodelle verwendet. Ist der Kanal gedächtnislos, so kann er durch die Angabe der bedingten Wahrscheinlichkeit beschrieben werden: P (r | c) , d. h. die Wahrscheinlichkeit, dass das Zeichen r empfangen wurde unter der Annahme, dass das Zeichen c gesendet wurde. In Bild 1.2 ist das sehr einfache Modell des symmetrischen Binärkanals (binary symmetric channel, BSC) angegeben. Im folgenden wollen wir annehmen, dass die Folgen aus binären Zeichen 0 und 1 bestehen. Beim BSC wird eine gesendete 0 mit der Wahrscheinlichkeit p im Kanal verfälscht und als 1 empfangen, d. h. ein Fehler ist aufgetreten, und mit der Wahrscheinlichkeit 1 − p korrekt übertragen; entsprechend symmetrisch für eine gesendete 1. Um zu gewährleisten, dass bei Rechenoperationen mit 0 und 1 als Ergebnis wiederum nur die Zeichen 0 und 1 entstehen, definieren wir das Rechnen modulo einer Zahl. Definition 1.1 (Modulorechnung) Seien a, c ∈ Z ganze Zahlen und b ∈ N, d ∈ N0 (N0 und N ist die Menge der ganzen positiven Zahlen mit bzw. ohne Null) und gelte a = c · b + d, so schreibt man a = d mod b,

es gilt: d < b,

(sprich: a kongruent d modulo b). Beim Rechnen modulo einer Zahl b werden Vielfache der Zahl b nicht berücksichtigt, d. h. c·b=0

mod b. f

Quelle

i

Codierer

c

+

r

Decodierer

Abb. 1.1: Digitales Übertragungssystem.

ˆi

Senke

6

1 Grundbegriffe 0

1−p

0 p p

1

1−p

1

P (r|c) Abb. 1.2: Symmetrischer Binärkanal (BSC).

Beispiel 1.1 (Modulorechnung) Es folgen einige Rechenbeispiele: 71 = 1 mod 7,

−13 = 2 mod 5,

30 = 6 mod 8,

25 · 31 = 4 · 3 = 5 mod 7.



Blockcode: Ein Blockcode C der Länge n ist die Menge der Vektoren c, die aus n Zeichen c0 , . . . , cn−1 bestehen. Jeder Blockcode kann durch unterschiedliche Codierer erzeugt werden. Ein möglicher Codierer für einen linearen Code (Definition 1.3) ordnet jeder Informationsfolge aus k Zeichen i0 , i1 , . . . , ik−1 genau eine Codefolge zu, wobei k die Dimension des Codes ist. Die Anzahl der Redundanzzeichen ist n − k. Das Verhältnis k/n wird als Coderate bezeichnet. Werden ausschließlich binäre Zeichen verwendet, so spricht man von einem binären Blockcode und die Symbole 0 und 1 werden auch das Alphabet des Codes genannt. Beispiel 1.2 (Parity-Check-Code, PC-Code) Die Codiervorschrift eines PC-Codes (single parity check code) der Länge n lautet: Wähle die ersten n − 1 Stellen c0 , c1 , . . . , cn−2 eines Codewortes c = (c0 , c1 , . . . , cn−1 ) als P die n − 1 Informationszeichen i0 , i1 , . . . , in−2 und die (n − 1)-te Stelle cn−1 , so dass gilt: n−2 j=0 ij + cn−1 = 0 mod 2. Für n = 3 ergeben sich die folgenden Codewörter: (i1 i2 c2 ) = {(000), (011), (101), (110)}.  Beispiel 1.3 (Wiederholungscode, Repetition-Code, RP-Code) Ein binärer Wiederholungscode (repetition code) der Länge n besteht aus zwei Codewörtern, dem Nullwort c0 = c1 = . . . = cn−1 = 0 und dem Alleinsenwort c0 = c1 = · · · = cn−1 = 1. 

Definition 1.2 (Addition von Codewörtern) Die Addition zweier Codewörter c+a ist definiert durch die Addition der j-ten Stellen cj + aj , j = 0, 1, . . . , n − 1, jeweils mod 2. Definition 1.3 (Linearer Code) Ein Code C ist linear, wenn die lineare Verknüpfung (z. B. die Addition) von Codewörtern wieder ein Codewort ist. Wir werden uns ausschließlich mit linearen Codes beschäftigen. Für nichtlineare Codes sei auf [McWSl] verwiesen. Auch Parity-Check-Codes (Beispiel 1.2) und Wiederholungscodes (Beispiel 1.3) sind lineare Codes. Wir können eine binäre Folge auch als Vektor mit binären Komponenten betrachten und bezeichnen im Folgenden mit Fn2 alle möglichen binären Vektoren der Länge n.

1.1 Gewicht, Distanz

7

Definition 1.4 (Skalarprodukt) Seien a, b ∈ Fn2 = GF (2)n , so ist das Skalarprodukt definiert als ha, bi =

1.1

n−1 X i=0

ai · bi

mod 2.

Gewicht, Distanz

Wir wollen hier die sogenannte Hamming-Metrik definieren, die zunächst für unsere Betrachtungen genügt. In Kapitel 7 bzw. im Anhang B werden weitere Metriken eingeführt. Definition 1.5 (Hamming-Gewicht) Das (Hamming-) Gewicht eines Vektors c ist die Anzahl der von 0 verschiedenen Elemente von c: wt(c) =

n−1 X

wt(cj )

mit

wt(cj ) =

j=0



0, cj = 0 1, cj = 6 0.

Definition 1.6 (Hamming-Distanz) Die (Hamming-) Distanz zweier Vektoren a, c ist die Anzahl der unterschiedlichen Elemente von a und c: dist(a, c) =

n−1 X

wt(aj + cj )

mit

wt(aj + cj ) =

j=0

dist(a, c) = wt (a + c).



0, cj = aj 1, cj = 6 aj ,

Definition 1.7 (Gewichtsverteilung) Die Gewichtsverteilung W = (w0 , w1 , . . . , wn ) eines Codes C der Länge n gibt an, wie viele Codewörter (wj ) vom Gewicht j in C existieren. W kann auch als Polynom in x geschrieben werden, d. h. W (x) =

n X

w j xj .

j=0

Für lineare Codes C gilt immer w0 = 1, d. h. das Nullwort muss ein Codewort sein, da (c + c = 0 ∈ C). Außerdem ist die Gewichtsverteilung eines linearen Codes gleich der Distanzverteilung, d. h. die Hamming-Distanzen eines beliebigen Codewortes zu allen anderen Codeworten. Beispiel 1.4 (Gewichtsverteilung) Die Gewichtsverteilung des Parity-Check-Codes der Länge n = 3 aus Beispiel 1.2 ist: W = (1, 0, 3, 0). Die Gewichtsverteilung eines Wiederholungscodes der Länge n aus Beispiel 1.3 ist: w0 = 1,

wn = 1,

wj = 0, j = 1, . . . , n − 1.



8

1.1.1

1 Grundbegriffe

Mindestdistanz und Fehlerkorrigierbarkeit

Definition 1.8 (Mindestdistanz) Die Mindestdistanz d eines Codes C ist die minimale Distanz zweier unterschiedlicher Codewörter: d = min {dist(a, c)} . a,c∈C a6=c

Für lineare Codes ist die Mindestdistanz gleich dem minimalen Gewicht: d = min {wt(a + c)} = min {wt(c)} . a,c∈C a6=c

c∈C c6=0

Die Eigenschaft Mindestdistanz gleich Minimalgewicht ist sehr wichtig, da sie benutzt werden kann, um Codes mit bestimmtem Minimalgewicht zu konstruieren. Dies ist in der Regel sehr viel einfacher, als Codes mit bestimmter Mindestdistanz zu konstruieren. Wie viele Fehler kann man mit einem Code C korrigieren?

Dazu betrachten wir zwei Codewörter, die die Mindestdistanz d besitzen. Ist ein Fehler in einem Codewort aufgetreten, so hat das empfangene Wort die Distanz 1 zum Codewort. Der n-dimensionale Raum ist natürlich nicht auf Papier darstellbar. Wir wollen aber zur Veranschaulichung folgende Hilfsdarstellung wählen: Zwei benachbarte Punkte haben die Hamming-Distanz 1. Damit kann nun der Sachverhalt der Fehlerkorrigierbarkeit in Bild 1.3 dargestellt werden. Im linken Teil des Bildes 1.3 ist die Hamming-Distanz d zwischen a und c gleich 3. Gemäß der Definition der Mindestdistanz gilt damit, dass die Hamming-Distanz zwischen beliebigen Codewörtern ≥ 3 ist. Legen wir nun Kugeln um die Codewörter, in denen alle Vektoren mit der Hamming-Distanz 1 enthalten sind, so erkennt man im linken Teil von Bild 1.3, dass die Kugeln sich nicht überlappen, wenn die Mindestdistanz d = 3 ist. Man kann damit jeden Vektor mit der Hamming-Distanz ≤ 1 eindeutig einem Codewort zuordnen. Im rechten Teil von Bild 1.3 ist die Mindestdistanz d = 4. Der Vektor mit der Distanz 2 zu a und c kann nicht eindeutig a oder c zugeordnet werden. Wir können daher auch im Falle d = 4 nur alle Vektoren mit der Distanz ≤ 1 eindeutig einem Codewort zuordnen.

Wir wollen nun diese Überlegungen verallgemeinern. Ein empfangener Vektor r = c + f , c ∈ C, f Fehler, kann also solange eindeutig dem Codewort c zugeordnet werden, solange für die Distanz zu einem beliebigen anderen Codewort a ∈ C gilt: dist(c, c + f ) < dist(a, c + f ), oder: wt(f ) < wt(a + c + f ),   d−1 daraus folgt: wt(f ) ≤ , 2 wobei die größte ganze Zahl ist, die kleiner gleich x ist. Ist d ungerade, so ist  d−1  bxcd−1  d−1oder  d−2 = , und falls d gerade ist, so gilt = 2 2 2 2 .

1.1 Gewicht, Distanz

a

9

c

a

d=3

c

d=4

Abb. 1.3: Hamming-Distanzen.

Bei den Überlegungen wird vorausgesetzt, dass weniger Fehler wahrscheinlicher sind als viele und deshalb als Decodierentscheidung das Codewort mit geringster Distanz zum empfangenen Wort gewählt wird. Beispiel 1.5 (Mindestdistanz) ¨ ˝ Der Parity-Check-Code von Beispiel 1.2 hat die Mindestdistanz d = 2 und damit: d−1 = 0. Mit einem PC-Code können also keine Fehler korrigiert 2 werden, aber jede ungerade Fehleranzahl wird erkannt, da die Prüfsumme 6= 0 ist.  Beispiel 1.6 (Mindestdistanz) Der Wiederholungscode von Beispiel 1.3 hat die Mindestdistanz d = n, also: —  —   n−1 d−1 n−1 , n ungerade 2 = = n−2 , n gerade. 2 2 2 Im Falle eines BSC (Bild 1.2) lautet die Decodiervorschrift für einen Wiederholungscode: Zähle ¨ ˝ die Anzahl der Nullen im empfangenen Wort, ist sie größer als n−1 , so decodiere 0, sonst 1. 2 Bei Gleichheit, d. h. n2 , ist die Entscheidung beliebig (dies ist nur für gerade n möglich). 

Definition 1.9 (Linearer Blockcode, Fehlerkorrekturfähigkeit) Ein linearer Blockcode C(n, k, d) besitzt die Länge n, die Dimension k, d. h. im binären Fall existie  ren 2k Codewörter, und die Mindestdistanz d. Mit C können kleiner gleich e = d−1 2 Fehler eindeutig korrigiert oder kleiner gleich d − 1 Fehler eindeutig erkannt werden.

1.1.2

Hamming-Schranke

Die Frage, wie viele Codewörter bei gegebener Mindestdistanz d und Länge n existieren können, ist ein zentrales Problem der Kanalcodierung. Dabei sind zwei Fragestellungen möglich: Zum einen wie viele Codewörter höchstens existieren können und zum anderen, wie viele mindestens existieren können, d. h. obere und untere Schranken. Die Hammingn Schranke ist eine obere  Schranke. Zu einem Vektor c ∈ C(n, k, d) gibt es 1 Vektoren n n mit der Distanz 1, 2 Vektoren mit Distanz 2, usw. Dabei ist t definiert als:   n n · (n − 1) · · · (n − t + 1) = . t t · (t − 1) · · · 1 Insgesamt gibt es 2n binäre Vektoren der Länge n.

Satz 1.10 (Hamming-Schranke) Für einen binären Code C(n, k, d) muss gelten:        n n d−1 k n 2 · 1+ + ··· + ≤2 mit e = . 1 e 2

10

1 Grundbegriffe

Anschaulich betrachtet, bedeutet dies: Man legt um die Codewörter Korrekturkugeln mit möglichst großem Radius, derart, dass sich keine Kugeln überlappen. Der maximale Radius wird durch die halbe Mindestdistanz begrenzt (vergleiche Bild 1.3). Alle Vektoren, die innerhalb der Korrekturkugeln liegen, können eindeutig einem Codewort, das dem Mittelpunkt der Kugel entspricht, zugeordnet werden. Definition 1.11 (Perfekter Code) Gilt für einen Code C(n, k, d) Gleichheit in der Hamming-Schranke von Satz 1.10, so heißt der Code perfekt. Es gibt jedoch nur wenige perfekte Codes. Wir werden alle binären perfekten Codes kennenlernen, die existieren können, nämlich die Wiederholungscodes ungerader Länge, die einfehlerkorrigierenden Hamming-Codes und den Golay-Code (vergleiche auch Aufgabe 1.7 c). Die Hamming-Schranke vergleicht die Anzahl der Vektoren, die eindeutig einem Codewort zugeordnet werden können, mit der Anzahl aller möglichen Vektoren in Fn2 . Sie lässt daher eine Aussage zu, wie „gut“ der Raum durch Korrekturkugeln überdeckt ist. Die Hamming-Schranke wird im englischen Sprachgebrauch deshalb auch als sphere packing bound bezeichnet. Bei einem perfekten Code überdecken die Korrekturkugeln den gesamten Raum, d. h. alle Vektoren liegen innerhalb einer Korrekturkugel. Beispiel 1.7 (Hamming-Schranke) Für den Parity-Check-Code von Beispiel 1.2 lautet die Hamming-Schranke: k = n − 1, e = 0, 2n−1 (1) < 2n , d. h. der Code ist nicht perfekt. Für den Wiederholungscode der Länge n = 3 (Beispiel 1.3) lautet sie: k = 1, e = 1, !! 3 1 2 · 1+ = 21 · 4 = 8 = 23 = 8, 1 

d. h. der Code ist perfekt.

Satz 1.12 (Perfekte Wiederholungscodes) Alle binären Wiederholungscodes mit ungerader Länge sind perfekt. Beweis: Für Wiederholungscodes ungerader Länge n ist k = 1 und e = hungen: ! ! ! n X n n n n =2 und = j j n−j j=0

n−1 . 2

Mit den Bezie-

errechnet man: ! n 2· 1+ + ··· + 1 ! n =1+ + ··· + 1

n n−1 2

!!

n n−1 2

!

=

+

n n−1 2

!

+ ··· +

! ! n X n n +1= = 2n . 1 j j=0

2

1.2 Prüfmatrix und Syndrom

1.2

11

Prüfmatrix und Syndrom

Ein linearer Blockcode kann folgendermaßen definiert werden: Der Vektor (c0 , . . . , cn−1 ) ist genau dann ein Codewort c, wenn gilt: H · cT = 0

(oft auch c · HT = 0).

H heißt Prüfmatrix (Parity-Check-Matrix) und ist für einen Code der Länge n und Dimension k eine ((n − k) × n)-Matrix. Die Matrixmultiplikation von H mit einem Vektor cT entspricht einem Vektor, dessen Komponenten die Skalarprodukte der Zeilen von H mit dem Vektor cT sind. Dass die Anzahl der Zeilen gleich der Anzahl der Prüfstellen ist, wird offensichtlich bei systematischer Darstellung der Prüfmatrix H (siehe Definition 1.13). Damit der durch H definierte Code die Mindestdistanz d hat, müssen beliebige d − 1 Spalten von H linear unabhängig sein und d Spalten existieren, die linear abhängig sind. Beispiel 1.8 (Prüfmatrix) Der Parity-Check-Code von Beispiel 1.2 hat als Prüfmatrix H = (1, 1, . . . , 1), n − k = 1, d. h. eine (1 × n)-Matrix. Ein Wiederholungscode der Länge n hat als Prüfmatrix H eine ((n − 1) × n)-Matrix: 0 1 1 1 B1 1 C B C H=B. (frei bedeutet 0). C . . . @. . A 1 1



Jede Zeile der Prüfmatrix H muss mit einem transponierten Codewort multipliziert 0 ergeben und damit auch jede Linearkombination von Zeilen. Man kann also durch Linearkombinationen der Zeilen von H äquivalente Prüfmatrizen H0 erhalten. Definition 1.13 (Systematische Codierung) Die Abbildung von Informationszeichen auf ein Codewort heißt systematisch, wenn die k Informationszeichen unverändert ein Teil des Codewortes sind, d. h. Informations- und Redundanzzeichen getrennt sind. Die Prüfmatrix hat dann z. B. die Form: H = ( A | I ),

I ((n − k) × (n − k))-Einheitsmatrix.

Durch Linearkombinationen der Zeilen der Prüfmatrix kann jeder lineare Blockcode in systematischer Form dargestellt werden, aber nicht unbedingt durch ( A | I ), sondern die Einheitsmatrix kann auf beliebige n − k Spalten verteilt sein. Definition 1.14 (Syndrom) Das Syndrom s (Symptome der Fehler) wird definiert als Multiplikation eines transponierten empfangenen Wortes r = c + f , c ∈ C, f Fehler, mit der Prüfmatrix,  sT = H · rT = H · cT + f T = H · f T ,

und ist nur vom Fehler – nicht vom Codewort – abhängig, da H · cT = 0 für c ∈ C ist. Das Problem der Decodierung besteht darin, von einem Syndrom, das nur vom Fehler abhängt, auf den wahrscheinlichsten Fehler zu schließen, der zu s führt.

12

1 Grundbegriffe

1.3

Decodierprinzipien

Das Ergebnis einer Decodierung ist entweder korrekt oder falsch, oder aber die Decodierung liefert kein Ergebnis. Man spricht von korrekt korrigiert, falsch korrigiert und Decodierversagen. Mögliche Decodierergebnisse:

• Korrekte Decodierung: Das gesendete Codewort ist gleich dem decodierten Codewort, d. h. der Decodierer hat den im Kanal aufgetretenen Fehler korrigiert bzw. erkannt. • Falsche Decodierung: Das gesendete Codewort ist ungleich dem decodierten Codewort, d. h. der Decodierer hat zwar korrigiert, aber er hat einen Fehler berechnet, der nicht dem im Kanal aufgetretenen Fehler entspricht. Ist der im Kanal aufgetretene Fehler z. B. ein gültiges Codewort, so wird jeder Decodierer eine falsche Decodierung durchführen. • Decodierversagen: Der Decodierer findet keine Lösung. Dieser Fall kann bei bestimmten Decodierprinzipien eintreten. Der Decodierer kann nicht wissen, ob eine korrekte oder falsche Decodierung erfolgt ist. Dagegen wird ein Decodierversagen bemerkt. Ist ein Code C(n, k, d) gegeben und ein empfangenes Wort r ∈ / C liegt vor, so können verschiedene Decodierprinzipien gewählt werden. Es sei r empfangen mit r = c + f , c ∈ ˆ als gesendetes Codewort findet, C, f Fehler. Wenn der Decodierer eine Entscheidung c was gleichbedeutend ist mit ˆf als Fehler, so gilt: ˆ + ˆf . c+f =r=c ˆ (bzw. f = ˆf ) und bei falscher c 6= c ˆ (bzw. f 6= ˆf ). Bei korrekter Decodierung ist c = c Anmerkung: Bei den folgenden Decodierprinzipien wird ausschließlich ein BSC und Hamming-Metrik zugrunde gelegt. In Abschnitt 7.1 wird auf andere Kanäle und Metriken nochmals detaillierter eingegangen. Mögliche Decodierprinzipien:

• Fehlererkennung: Die Decodierung ist hier eine Überprüfung, ob ein empfangenes Wort r ein Codewort ist oder nicht, d. h. es wird nur getestet, ob r ∈ C ist. Für r ∈ / C wird dann korrekt decodiert (erkannt). Für f = 0 wird ebenfalls korrekt korrigiert, und für {f ∈ C, f 6= 0} wird falsch korrigiert. Ein Decodierversagen kann hier nicht auftreten.

1.3 Decodierprinzipien

13

• Maximum-Likelihood-Decodierung (ML):

ˆ decodiert, das mit größter Ein empfangenes Wort r wird als das Codewort c Wahrscheinlichkeit gesendet worden ist, d. h. ˆ) = max P (r | a) . P (r | c a∈C

Falls mehrere Codewörter mit gleicher Wahrscheinlichkeit existieren, so wird zufällig entschieden. Im Falle des symmetrischen Binärkanals bedeutet dies, dass ˆ decodiert wird, das die kleinste Hamming-Distanz zu r bedasjenige Codewort c sitzt. Bei der ML-Decodierung gibt es kein Decodierversagen, sondern nur korrekte oder falsche Decodierung. • Symbolweise Maximum-a-posteriori-Decodierung (s/s-MAP):

Hier wird ein einziges Symbol ci des Codes betrachtet und die Wahrscheinlichkeit berechnet, mit der dieses Symbol 0 bzw. 1 ist. Die Entscheidung erfolgt dann für jedes Symbol separat. Sind alle n Codesymbole entschieden, so muss der Vektor (c0 , c1 , . . . , cn−1 ) – im Gegensatz zur ML Decodierung – kein gültiges Codewort sein. In diesem Falle müssen wir unterscheiden, ob der Code in systematischer Form vorliegt oder nicht. Bei systematischer Codierung können wir nur die Informationssymbole entscheiden und damit kann kein Decodierversagen auftreten. Dagegen liegt Decodierversagen vor, wenn die entschiedenen Symbole bei nichtsystematischer Form kein Codewort bilden.

• Begrenzte-Mindestdistanz-Decodierung (BMD, bounded minimum distance decoding): Es  d−1wird  nur decodiert, falls sich r innerhalb einer Korrekturkugel mit Radius befindet. Hier können alle drei möglichen Ausgänge der Decodierung auftre2 ten: korrekte Decodierung, falsche Decodierung und Decodierversagen. Der Begriff Begrenzte-Distanz-Decodierung wird verwendet, falls die Korrekturkugeln einen   Radius kleiner als d−1 aufweisen. 2

• Decodierung über die halbe Mindestdistanz:

Es wird versucht, auch für r außerhalb einer Korrekturkugel zu decodieren. Eine ML-Decodierung ist demnach eine Decodierung über die halbe Mindestdistanz. Andererseits ist die Decodierung über die halbe Mindestdistanz in der Regel keine ML-Decodierung, unter anderem, da hier Decodierversagen möglich ist. Hier können demnach alle drei möglichen Ausgänge der Decodierung auftreten: korrekte Decodierung, falsche Decodierung und Decodierversagen.

Zur Erläuterung: Das Prinzip der Fehlererkennung wird in Nachrichtensystemen oft verwendet, um fehlerhafte Reaktionen des Systems zu vermeiden. Man spricht von Fehlerverdeckung (error concealment), d. h. falsche Informationen werden erkannt und nicht verwendet, also verdeckt. Hierzu können beispielsweise zwei Codes hintereinander verwendet werden, wobei der zuerst codierte und zuletzt decodierte zur Fehlererkennung verwendet wird und der zuletzt codierte und zuerst decodierte zur Fehlerkorrektur. Es kann auch ein Code verwendet werden, bei dem nur ein Teil seiner Decodierfähigkeiten ausgeschöpft wird.

14

1 Grundbegriffe

BMD-Decodierung bedeutet, dass nur dann korrigiert wird, wenn ein Codewort c existiert mit   d−1 dist(c, r) ≤ e = . 2 Das heißt, dass alle Vektoren, die nicht innerhalb von Korrekturkugeln liegen, in der Regel nicht decodiert werden können. Ihre Anzahl entspricht genau der Differenz der rechten und der linken Seite der Hamming-Schranke (Satz 1.10). Da es meistens viele Vektoren gibt, die eindeutig einem Codewort zugeordnet werden können, aber nicht innerhalb einer Korrekturkugel liegen, ist es oft erstrebenswert, zumindest einen Teil dieser Vektoren einem Codewort zuzuordnen. Dies ist möglich, falls es gelingt, über die halbe Mindestdistanz zu decodieren. Beispiele hierfür sind die algebraische Decodierung über die halbe Mindestdistanz (Abschnitt 3.3), das Decodierverfahren für binäre lineare Codes (Abschnitt 7.3.3) und das für verallgemeinert verkettete Codes (Abschnitt 9.2.4). Jede nicht-ML-Decodierung schöpft die Decodierfähigkeit eines Codes nicht voll aus. Die Decodierung eines Wiederholungscodes in Beispiel 1.6 ist eine ML-Decodierung. Für beliebige Codes wird eine ML-Decodierung erreicht, wenn man alle Codewörter mit dem empfangenen Wort vergleicht. Dies kann folgendermaßen durchgeführt werden: Standard-Array-Decodierung (ML): Sei C(n, k, d) ein linearer Blockcode. Ein Coset (Restklasse) eines beliebigen Vektors b ∈ Fn2 wird definiert, indem man zu b alle Codewörter des Codes C addiert, d. h. [C]b = {b + C} = {b + c, c ∈ C}. Die Cosets haben folgende Eigenschaften: • Jeder Coset enthält 2k Vektoren (Anzahl der Codewörter von C). • C ∪ {b1 + C} ∪ {b2 + C} ∪ . . . ∪ {b2n−k −1 + C} sind genau alle 2n Vektoren. • Zwei Cosets sind entweder gleich oder verschieden (teilweise Überlappung ist unmöglich). Damit ist offensichtlich, dass für alle Vektoren bi gilt: bi ∈ / C, außer für b = 0. Jedes bi ∈ [C]b erzeugt den Coset [C]b . Zur Decodierung werden nun die Cosets derart geordnet, dass in jedem Coset der Vektor mit kleinstem Gewicht an erster Stelle steht. Falls mehrere mit kleinstem Gewicht existieren, so wird einer davon zufällig ausgewählt. Man nennt sie die Cosetleader (Restklassenführer). Wird nun ein Vektor r = c + f empfangen, so wird der Coset gesucht, in dem r enthalten ist. Der Cosetleader entspricht dann dem Fehler mit kleinstem Gewicht, dessen Addition zu r ein Codewort ergibt. Diese Art der Decodierung wird StandardArray-Decodierung genannt und ist offensichtlich eine ML-Decodierung, ist aber nur für kurze Codes möglich, da die Komplexität zu groß ist.

1.4 Fehlerwahrscheinlichkeit

15

Beispiel 1.9 (Standard-Array) Gegeben sei ein Code mit den folgenden vier Codeworten (0000),

(0011),

(1100),

(1111) .

Dies ist ein (4,2,2) Code. Das Standard-Array besteht damit aus vier Cosets b = (0000) : b = (1000) : b = (0010) : b = (1001) :

{(0000), {(1000), {(0010), {(1001),

(0011), (1011), (0001), (1010),

(1100), (0100), (1110), (0101),

(1111)} (0111)} (1101)} (0110)} .

Das minimale Gewicht innerhalb eines Cosets ist in diesem Falle nicht eindeutig, was zu erwarten war, da die Mindestdistanz des Codes 2 ist. Würden wir z. B. b = (0100) addieren, so erhalten wir den Coset {(0100), (0111), (1000), (1011)}, der jedoch schon mit dem Vektor b = (1000) erzeugt wurde. 

Bei der BMD-Decodierung werden nur diejenigen empfangenen Vektoren r korrigiert,   die in einem Coset liegen, der einen eindeutigen Cosetleader vom Gewicht ≤ d−1 2 besitzt. Die Hamming-Schranke gibt daher Aufschluss über den Unterschied zwischen BMD und ML.

1.4

Fehlerwahrscheinlichkeit

Definition 1.15 (Restblockfehlerwahrscheinlichkeit) Die Restblockfehlerwahrscheinlichkeit PBlock gibt an, mit welcher Wahrscheinlichkeit ein gesendetes Codewort nicht dem decodierten Codewort entspricht (falsche Decodierung und Decodierversagen). Entsprechend gibt die Restbitfehlerwahrscheinlichkeit PBit an, mit welcher Wahrscheinlichkeit ein gesendetes Informationsbit nicht dem decodierten Informationsbit entspricht. Zur Berechnung der Fehlerwahrscheinlichkeit müssen die drei Fälle, korrigiert, nicht korrigiert und falsch korrigiert unterschieden werden. Wie schon beschrieben, liegt eine Falschkorrektur dann vor, wenn c gesendet wurde und dist(c + f , c) > dist(c + f , b) ist, c, b ∈ C, f Fehler, z. B. wenn f ∈ C, f 6= 0.

Wir wollen nun im Falle des symmetrischen Binärkanals von Bild 1.2 und eines Codes C(n, k, d) für die drei Decodierprinzipien (Fehlererkennung, BMD und ML-Decodierung) die Restblockfehlerwahrscheinlichkeit bestimmen. Für die Decodierung über die halbe Mindestdistanz kann die Restblockfehlerwahrscheinlichkeit nicht angegeben werden, da sie vom Decodierverfahren abhängt. Ähnliches gilt für die s/s-MAP-Decodierung. Für den BSC ist die Wahrscheinlichkeit, dass bei der Übertragung von n Binärzeichen bestimmte t Zeichen fehlerhaft sind: p(t) = pt (1 − p)n−t .

 Es gibt nt verschiedene Vektoren, in denen genau t Zeichen fehlerhaft sind. Die Wahrscheinlichkeit für t beliebige Fehler in n Stellen ist:     n n t · p(t) = p (1 − p)n−t . t t

16

1 Grundbegriffe

BMD-Decodierverfahren: Es gilt: PBlock =

  n X n j p (1 − p)n−j , j j=e+1

  denn ein BMD-Verfahren kann nur Fehler mit Gewicht kleiner gleich e = d−1 korrigie2 ren. Praktische BMD-Verfahren können in bestimmten Fällen mehr Fehler korrigieren, d. h. PBlock ist sicher eine obere Schranke. PBlock kann auch anders ausgedrückt werden, nämlich: PBlock = 1 −

e   X n j=0

j

pj (1 − p)n−j .

Beispiel 1.10 (Blockfehlerwahrscheinlichkeit) Ein Wiederholungscode der Länge n = 3 kann einen Fehler korrigieren. Damit gilt bei einem BSC mit Fehlerwahrscheinlichkeit p: PBlock

! 1 X 3 j =1− p (1 − p)3−j = 1 − (1 − p)3 − 3p(1 − p)2 . j j=0



Fehlererkennung: Es tritt genau dann ein Decodierfehler auf, wenn der Fehler ein Codewort (nicht Nullcodewort) ist. Sei W die Gewichtsverteilung des Codes, so gilt: PFBlock =

n X j=1

Für p =

1 2

wj pj (1 − p)n−j .

geht dieser Wert über in PFBlock =

n X j=1

wj

 n  n X  n n 1 1 1 1 = · wj = (2k − 1) ≈ n−k . 2 2 2 2 j=1

Anschaulich bedeutet dies: Werden zufällig Vektoren aus Fn2 ausgewählt, so bestimmt das Verhältnis von Codewörtern zu Vektoren im Raum die Wahrscheinlichkeit, dass ein 1 ausgewählter Vektor ein Codewort ist. Es gilt insbesondere, dass PFBlock ≤ 2n−k für 1 p ≤ 2 ist. Beispiel 1.11 (Fehlererkennung) Die Gewichtsverteilung des Parity-Check-Codes der Länge n = 3 ist in Beispiel 1.4 zu W = (1, 0, 3, 0) angegeben. Damit errechnen wir: PFBlock =

3 X j=1

wj pj (1 − p)n−j = 3p2 (1 − p).



1.5 Hamming-Codes

17

Maximum-Likelihood-Decodierung (ML): PMBlock berechnet sich hierbei zu: PMBlock = 1 −

n X j=0

bj · pj (1 − p)n−j , b0 = 1 ,

wobei bj die Anzahl der Cosetleader vom Gewicht j ist. Die bj können nur für kurze Codes bestimmt werden und sind für „lange“ Codes nicht bekannt. Außerdem ist für lange Codes kein praktikables ML-Decodierverfahren bekannt. Beispiel 1.12 (Fehlerwahrscheinlichkeiten) Für einen Code mit den Parametern (15, 7, 5) können wir die Werte ausrechnen und in einem Achsenkreuz über der Fehlerwahrscheinlichkeit p des BSC entsprechend Bild 1.4 auftragen. Der Code hat die Gewichtsverteilung W (x) = 1 + 18x5 + 30x6 + 15x7 + 15x8 + 30x9 + 18x10 + x15 .

1 0.8

4

0.6

3

PBlock

0.4

PMBlock PFBlock

0.2 0

PBlock

PBlock

−3

5

0

0.1

0.2

p

0.3

x 10

2k−n

PBlock PMBlock

2

PFBlock

1

0.4

0.5

0

0

0.1

0.2

p

0.3

0.4

0.5

Abb. 1.4: Vergleich der Fehlerwahrscheinlichkeiten bei Fehlererkennung, BMDund ML-Decodierung. Der rechte Teil des Bildes verwendet eine andere Skalierung der PBlock -Achse, um den Verlauf der Fehlerwahrscheinlichkeit bei Fehlererkennung zu verdeutlichen. 

1.5

Hamming-Codes

Definition 1.16 (Hamming-Code) Die Prüfmatrix H eines Hamming-Codes besteht aus 2h − 1 Spalten, die genau alle Vektoren aus Fh2 – ohne den Nullvektor – sind. Satz 1.17 (Parameter des Hamming-Codes) Die Parameter des Hamming-Codes sind: Länge: Dimension: Mindestdistanz:

n = 2h − 1 k = n−h d = 3.

18

1 Grundbegriffe

Beweis: Die Parameter n und k sind offensichtlich. Zwei beliebige Spalten sind linear unabhängig und es existieren drei Spalten, die linear abhängig sind. Damit ist die Mindestdistanz d = 3. 2

Wir wollen nun noch zeigen, dass Hamming-Codes perfekt sind, also Gleichheit bei der Hamming-Schranke, Satz 1.10, gilt. Satz 1.18 (Hamming-Codes sind perfekt) Alle einfehlerkorrigierenden HammingCodes gemäß Satz 1.17 sind perfekt. Beweis: Ein Hamming-Code hat die Parameter n = 2h − 1, k = n − h, e = 1 = Eingesetzt in Satz 1.10:

2

k

1+

¨ d−1 ˝ 2

.

!! n = 2n 1 1 + n = 2n−k

1 + 2h − 1 = 2h . Es gilt Gleichheit, d. h. alle Hamming-Codes sind perfekt.

2

Beispiel 1.13 (Hamming-Code und Decodierung) Wir wollen den Hamming-Code für h = 3 konstruieren. Die Prüfmatrix hat n = 23 − 1 = 7 Spalten und n − k = h = 3 Zeilen. Wir schreiben sie derart, dass die Spalte die Dualdarstellung der Spaltennummer ist, also 0 1 0 0 0 1 1 1 1 H = @0 1 1 0 0 1 1A , H · cT = 0 , c ∈ C. 1 0 1 0 1 0 1 Damit die Mindestdistanz 3 ist, müssen beliebige 2 Spalten linear unabhängig sein. Dies ist erfüllt, da es keine zwei identischen Spalten gibt. Es müssen ferner 3 Spalten existieren, die linear abhängig sind, z. B. Spalte 1 + Spalte 2 + Spalte 3 = 0, d. h. c = (1110000) ist ein Codewort mit Minimalgewicht, denn: 0 1 0 1 0 1 0 0 0 T H · c = @0A + @1A + @1A = 0. 1 0 1

Wir nehmen nun an, bei der Übertragung sei ein Fehler aufgetreten und es sei r = (1110010) = c + f mit f = (0000010) empfangen worden. Das Syndrom s errechnet sich zu: 0 1 0 1 0 1 0 1 0 1 0 0 0 1 1 T H · r = @0A + @1A + @1A + @1A = @1A = sT = H · f T 1 0 1 0 0 (vergleiche Definition 1.14). Die Decodiervorschrift lautet also: Das Syndrom ist die Dualzahl der Fehlerstelle. 

Der Hamming-Code von Beispiel 1.13 soll noch in systematischer Form dargestellt werden.

1.6 Generatormatrix

19

Beispiel 1.14 (Systematischer Hamming-Code) Durch entsprechende Linearkombination der Zeilen errechnet man die systematische Darstellung der Prüfmatrix des Hamming-Codes der Länge n = 7 zu: 0 1 0 1 1 1 1 0 0 H = @1 0 1 1 0 1 0A.  1 1 0 1 0 0 1

1.6

Generatormatrix

Ist ein Informationsvektor i = (i0 , i1 , . . . , ik−1 ) gegeben, so interessiert man sich für den zugehörigen Codevektor c = (c0 , c1 , . . . , cn−1 ). Da ein linearer Code ein linearer (Vektor-) Raum ist, existiert eine Basis für diesen Raum. Wir können damit eine Matrix G konstruieren, deren Zeilen eine beliebige Basis des Raumes darstellen. Die Matrix G wird als Generatormatrix bezeichnet und es gilt: c = i · G. Mit der Generatormatrix kann man aus den Informationszeichen das zugehörige Codewort berechnen. Die Generatormatrix ist eine (k × n)-Matrix. Alle Codewörter werden also durch Linearkombinationen der Zeilen der Generatormatrix gebildet. Aus einer gegebenen Generatormatrix G kann man sich durch Vertauschen oder Addition von Zeilen weitere Generatormatrizen G0 berechnen, die alle denselben Code erzeugen, die Abbildung von Informationsfolge zu Codefolge ist jedoch jeweils unterschiedlich. Vertauscht man die Spalten der Generatormatrix, so erhält man einen Code mit den selben Parametern, die Codeworte sind im allgemeinen jedoch unterschiedlich. Ein derartiger Code wird äquivalenter Code genannt (siehe hierzu Aufgabe 1.14). Im speziellen Fall der systematischen Darstellung kann die Generatormatrix einfach aus der Prüfmatrix bestimmt werden. Es gilt nämlich c0 = i0 , c1 = i1 , . . ., ck−1 = ik−1 und damit: H · cT = ( A | I ) · cT = 0 

     ck c0 i0  ..   .   .   .  = −A ·  ..  = −A ·  ..  cn−1 ck−1 ik−1 c = T



I0 −A



· iT

c = i · ( I0 | − AT ) = i · G. I stellt dabei eine ((n − k) × (n − k))-Matrix dar, während I0 eine Einheitsmatrix der Dimension (k × k) ist.

20

1 Grundbegriffe

Beispiel 1.15 (Generatormatrix eines Hamming-Codes) Die Generatormatrix des Hamming-Codes von Beispiel 1.13 berechnet sich aus der Prüfmatrix: 0

1 0 1 1 1 1 0 0 H=@1 0 1 1 0 1 0A=( A | I ) 1 1 0 1 0 0 1 0

1 B0 0 T G=( I |−A )=B @0 0

0 1 0 0

0 0 1 0

0 0 0 1

0 1 1 1

1 0 1 1

1 1 1C C. 0A 1



Um das Codewort c = (1110000) von Beispiel 1.13 zu erhalten, wählen wir als Information i = (1110): c = i · G = (1000011) + (0100101) + (0010110) = (1110000). Mit Hilfe der Generatormatrix können wir zeigen, dass gilt: Satz 1.19 (Häufigkeit von 0 und 1 im linearen Code) Betrachtet man alle Codeworte eines binären linearen Codes C, so nimmt jede Stelle ci , i = 0, . . . , n − 1, gleich oft den Wert 0 und 1 an. Beweis: Sei G eine Generatormatrix des Codes C. Durch Addition von Zeilen der Generatormatrix ändern wir die Menge aller Codeworte nicht, nur die Zuordnung von Information zu Codewort. Damit können wir durch Addition von entsprechenden Zeilen die Generatormatrix auf eine Form bringen, in der die i-te Spalte nur eine einzige 1 enthält. Bei der Berechnung eines Codewortes wird das Symbol ci genau dann 1 sein, wenn die Zeile, in der diese 1 steht, addiert wird. Dies ist jedoch genau dann der Fall, wenn die entsprechende Informationsstelle 1 ist. Die Informationsstelle ist aber genau in der Hälfte aller möglichen Informationsfolgen gleich 1. 2

1.7

Zyklische Codes

Eine zyklische Verschiebung eines Codewortes c = (c0 , c1 , . . . , cn−1 ) um i Stellen ergibt den Vektor (ci , ci+1 , . . . , cn−1 , c0 , . . . , ci−1 ). Definition 1.20 (Zyklischer Code) Ein Code heißt zyklisch, wenn er linear ist und wenn jede zyklische Verschiebung eines Codewortes wiederum ein Codewort ergibt. Zyklische Codes können durch Polynome beschrieben werden und sind daher für praktische Anwendungen sehr interessant, da die Multiplikation und die Division von Polynomen als Schieberegisterschaltungen realisiert werden können (vergleiche Aufgabe 3.2). Wir werden später zyklische Codes mit Hilfe der Polynomschreibweise definieren.

1.8 Dualer Code

1.8

21

Dualer Code

Die Generatormatrix eines Codes kann als Prüfmatrix eines anderen Codes betrachtet werden und umgekehrt. Man spricht von dualen Codes. Definition 1.21 (Dualer Code) Der Code C ⊥ , dessen Generatormatrix G⊥ die Prüfmatrix H eines Codes C ist, wird als dualer Code C ⊥ des Codes C bezeichnet. Insbesondere gilt für das Skalarprodukt (Definition 1.4): c ∈ C, b ∈ C ⊥ | hc · bT i = 0. Da jede (transponierte) Zeile der Prüfmatrix mit jeder Zeile der Generatormatrix multipliziert Null ergeben muss, gilt dies auch für alle Linearkombinationen von Zeilen. Die Länge des dualen Codes C ⊥ ist gleich der des Codes C: n⊥ = n. Für dessen Dimension gilt k ⊥ = n − k. Die Mindestdistanz von C ⊥ kann nicht durch eine einfache Beziehung beschrieben werden. Beispiel 1.16 (Dualer Code) Die Generatormatrix G⊥ und die Prüfmatrix H⊥ des zum Hamming-Code von Beispiel 1.13 dualen Codes C ⊥ lauten: 0 1 0 1 1 1 1 0 0 G⊥ = H = @ 1 0 1 1 0 1 0 A = ( A | I ), 1 1 0 1 0 0 1 0

1 B0 ⊥ H =G=B @0 0

0 1 0 0

0 0 1 0

0 0 0 1

0 1 1 1

1 0 1 1

1 1 1C C. 0A 1

Das Skalarprodukt der ersten Zeile von H mit der zweiten Zeile von G ist: 0·0+1·1+1·0+1·0+1·1+0·0+0·1=2=0

1.9

mod 2.



Erweiterung und Verkürzung von Codes

Die Verkürzung von Codes kann auf folgende zwei Arten durchgeführt werden: i) Es werden in der Regel nur Codeworte ausgewählt, die an den ersten (oder letzten) Stellen Null sind. Praktisch bedeutet dies: Ein Teil der Information wird zu Null gesetzt, und der Code wird um die entsprechende Anzahl Stellen verkürzt. Hierbei bleibt die Mindestdistanz erhalten. ii) Es werden bestimmte Stellen jedes Codewortes punktiert, d. h. gelöscht (der Wert kann 0 oder 1 sein). Bei der Punktierung ist die sich ergebende Mindestdistanz von den punktierten Stellen abhängig.

22

1 Grundbegriffe

Beide Fälle der Verkürzung ergeben wieder einen linearen Code. Für zyklische Codes ist die Verkürzung in Abschnitt 4.3 definiert. Die Punktierung wird bei Faltungscodes häufig verwendet, um Codes bestimmter Raten zu erzeugen (vergleiche Abschnitt 8.1.10). Beispiel 1.17 (Verkürzung von Codes) Benutzen wir die Generatormatrix G aus Beispiel 1.15. Um den Code zu verkürzen, wählen wir die ersten beiden Informationsstellen immer zu Null, d. h. die ersten beiden Codestellen werden auch immer Null sein, daher können sie weggelassen werden. Um das Codewort von Beispiel 1.13 zu erhalten, wählen wir als Information i = (0010): c = i · G = (0010110) =⇒ (10110). Damit haben wir einen um zwei Stellen verkürzten Code konstruiert. Bei der Punktierung streichen wir etwa die 3. Stelle bei allen Codeworten: (0010110) =⇒ (000110).



Zur Erweiterung eines Codes fügt man dem Code ein Symbol (0 oder 1) hinzu, damit sich gerades Gewicht ergibt. Dies ist selbstverständlich nur bei Codes sinnvoll, die Codeworte mit ungeradem Gewicht besitzen. Die ungerade Mindestdistanz steigt dann um 1. Satz 1.22 (Prüfmatrix eines erweiterten Codes) Sei H die ((n−k)×n)-Prüfmatrix eines (n, k, d)-Codes, d ungerade, dann ergibt sich die ((n − k + 1) × (n + 1))-Prüfmatrix des erweiterten Codes durch Hinzufügen der Alleinsenzeile und der Spalte (100 . . . 0)T . Damit hat der erweiterte Code mit Prüfmatrix Hex die Parameter (n + 1, k, d + 1):

Hex



 1 1 ... 1 1 0  = ..   . H . 0

Beweis: Die Länge und die Dimension ergeben sich durch die Matrix. Da der Code linear ist, gilt: Mindestdistanz = Minimalgewicht. Sei c ∈ C ein Codewort mit wt(c) = d, dann hat das erweiterte Codewort cex das Gewicht wt(cex ) = d + 1. 2 Beispiel 1.18 (Erweiterung von Codes) Dem Codewort aus Beispiel 1.17 wird eine 1 angehängt. D. h. (0010110) =⇒ (00101101). Die entsprechende Prüfmatrix ergibt sich zu: 0

1 B0 H=B @1 1

1 1 0 1

1 1 1 0

1 1 1 1

1 1 0 0

1 0 1 0

1 0 0 1

1 1 0C C. 0A 0



1.10 Kanalkapazität und Kanalcodiertheorem

1.10

23

Kanalkapazität und Kanalcodiertheorem

Die Kanalkapazität gibt an, wie viel Information über einen gegebenen Kanal übertragen werden kann. Sie wurde im Jahre 1948 von C. E. Shannon in seiner grundlegenden Arbeit zur Informationstheorie [Sha48] definiert. Ein bemerkenswertes Ergebnis von Shannon ist das Kanalcodiertheorem, das beweist, dass mit Kanalcodierung die Restblockfehlerwahrscheinlichkeit beliebig klein gemacht werden kann, wenn ein Code mit der Coderate kleiner als die Kanalkapazität verwendet wird. Dieses Theorem sagt aus, dass durch die Verwendung von geeigneten Codes eine nahezu fehlerfreie Informationsübertragung erreicht werden kann. Leider basiert der Beweis auf Wahrscheinlichkeitsbetrachtungen und stellt daher keine Konstruktionsregeln für die zu verwendenden Codes bereit. Daher bleibt es ein Problem der Kanalcodierung, Codes zu finden, die „leicht“ zu codieren und zu decodieren sind und gleichzeitig eine möglichst große Coderate bei möglichst großer Mindestdistanz haben. Wir haben hierzu schon eine obere Schranke – die Hamming-Schranke, Satz 1.10 – kennengelernt und werden in den Abschnitten 6.3 und 6.4 noch weitere Schranken herleiten. Wir wollen im Folgenden die Kanalkapazität und das Kanalcodiertheorem erläutern und dabei die informationstheoretischen Begriffe ohne ausführliche Herleitung angeben. Für eine detaillierte Beschreibung wird auf die gängigen Lehrbücher, z. B. [PeWe] oder [WoJa], verwiesen. Selbstinformation: (self-information) Die Selbstinformation I eines Zeichens x, das mit der Wahrscheinlichkeit p(x) auftritt, ist definiert zu: I = ld

1 . p(x)

Mit ld wird der Logarithmus zur Basis 2 (logarithmus dualis) bezeichnet. Die Selbstinformation gibt den Informationsgehalt eines Zeichens an. Ein sicheres Zeichen, d. h. p(x) = 1, hat die Selbstinformation I = 0, und je unwahrscheinlicher ein Zeichen ist, desto größer ist seine Selbstinformation: I → ∞ für p(x) → 0. Unsicherheit (Entropie): Sei X eine Menge von Zeichen xi ∈ X, die mit der Wahrscheinlichkeit p(xi ) auftreten. Die Unsicherheit (Entropie) H(X) ist definiert als Mittelwert der Selbstinformation: H(X) =

X i

p(xi ) · ld

1 . p(xi )

Für gleichwahrscheinliche binäre Zeichen gilt: p(0) = 12 , p(1) = 12 , und damit ist die Unsicherheit H = 12 ld 2 + 12 ld 2 = 1. Die Unsicherheit wird maximal bei gleichwahrscheinlichen Zeichen. Die bedingte Wahrscheinlichkeit P (yj | xi ) ist die Wahrscheinlichkeit für das Ereignis yj , wenn das Ereignis xi bekannt ist, und die Verbundwahrscheinlichkeit P (xi , yj ) ist

24

1 Grundbegriffe

die Wahrscheinlichkeit, dass xi und yj eintreten. Damit kann man entsprechend die Verbundunsicherheit und die bedingte Unsicherheit definieren: XX 1 H(Y | X) = P (xi , yj ) ld , P (y j | xi ) i j H(X | Y ) =

XX i

P (xi , yj ) ld

j

1 , P (xi | yj )

H(X, Y ) = H(Y ) + H(X | Y ) = H(X) + H(Y | X).

Für statistische Unabhängigkeit, d. h. P (xi , yj ) = p(xi ) · p(yj ), gilt: H(X, Y ) = H(X) + H(Y ),

H(X | Y ) = H(X),

H(Y | X) = H(Y ).

Die Transinformation (mutual information) I(X ∧ Y ) ist definiert durch: I(X ∧ Y ) = H(X) − H(X | Y ) = H(Y ) − H(Y | X).

Definition 1.23 (Kanalkapazität) Die Kanalkapazität ist definiert als das Maximum der Transinformation I(X∧Y): C = max {H(X) − H(X | Y )} = max {H(Y ) − H(Y | X)} . p(xi )

p(xi )

Wir wollen im folgenden Beispiel die Kanalkapazität des symmetrischen Binärkanals berechnen. Beispiel 1.19 (Kanalkapazität eines BSC) Für einen symmetrischen Binärkanal mit der Fehlerwahrscheinlichkeit p gilt: P (1 | 1) = P (0 | 0) = 1 − p, P (1 | 0) = P (0 | 1) = p,

1 (1 − p), 2 1 P (0, 1) = P (1, 0) = p. 2 P (1, 1) = P (0, 0) =

Es folgt damit (maxp(xi ) {H(Y )} = 1 bei gleichwahrscheinlichen Zeichen): H(Y | X) = p · ld

1 1 + (1 − p) · ld . p 1−p

Die Kanalkapazität C hängt nur vom Kanal ab und lautet für den BSC: C(p) = 1 − H(p) = 1 − p · ld

1 1 − (1 − p) · ld . p 1−p

In Bild 1.5 ist die Kanalkapazität C eines symmetrischen Binärkanals in Abhängigkeit der Fehlerwahrscheinlichkeit p dargestellt. 

Das Kanalcodiertheorem sagt aus, dass die Restblockfehlerwahrscheinlichkeit durch geeignete Wahl eines Codes beliebig klein gemacht werden kann. Selbstverständlich ist die Kanalkapazität eine theoretische Grenze, die in der Praxis nur mit extrem hohem Aufwand erreicht werden kann.

1.11 Anmerkungen

25

0.9 0.8 0.7 C(p)

0.6 0.5 0.4 0.3 0.2 0.1 0

0.2

0.4

0.6

0.8

p Abb. 1.5: Kanalkapazität des symmetrischen Binärkanals.

Satz 1.24 (Kanalcodiertheorem) Für jede reelle Zahl ε > 0 und jede Coderate R kleiner als die Kanalkapazität (R < C) existiert ein binärer Code C der Länge n und der Dimension k, R = nk , n hinreichend groß, so dass die Restblockfehlerwahrscheinlichkeit nach der Decodierung kleiner als ε ist. Wir wollen an dieser Stelle keinen Beweis angeben (ein einfacher Beweis findet sich in [Bos12]), jedoch eine Überlegung: Wählt man die Codelänge n hinreichend groß, d. h. so groß, dass die Anzahl der Fehler in einem Codewort fast immer dem Erwartungswert entspricht, so kann man fast jedes Codewort korrigieren, sofern der Erwartungswert der Fehler kleiner als die Anzahl der korrigierbaren Fehler ist. Sind mehr Fehler als die korrigierbare Anzahl aufgetreten, so kann der Decodierer nicht korrekt korrigieren. Gelingt es, diese Zahlen durch Wahrscheinlichkeitsbetrachtungen abzuschätzen, so kann man den Beweis führen.

1.11

Anmerkungen

Erste grundlegende Arbeiten zu Blockcodes stammen von M. J. E. Golay, [Gol49] 1949, und R. W. Hamming, [Ham50] 1950. Shannon waren die Hamming-Codes vor seiner Veröffentlichung zur Begründung der Informationstheorie [Sha48] bekannt. Die ersten Codekonstruktionen basierten u. a. auf kombinatorischen Überlegungen und Golay hat schon 1949 den einzigen perfekten, mehrfehlerkorrigierenden binären Code konstruiert, der existiert. Arbeiten zur Gruppenstruktur von Codes stammen u. a. von D. Slepian und wir werden seine Beschreibung in den folgenden Kapiteln nutzen. Wir haben in diesem ersten Kapitel einige Grundbegriffe kennengelernt, um lineare Blockcodes und ihre Eigenschaften zu beschreiben. Die Fehlerkorrektureigenschaft hängt von der Mindestdistanz ab, die bei linearen Blockcodes gleich dem Minimalgewicht ist.

26

1 Grundbegriffe

Eine Folgerung daraus ist, dass für lineare Blockcodes die Distanzverteilung gleich der Gewichtsverteilung ist. Als Kanalmodell haben wir ein einfaches Modell, den symmetrischen Binärkanal, eingeführt, das vorläufig zur Kanalbeschreibung genügt. Zu einem der zentralen Probleme der Kanalcodierung, der Abschätzung der möglichen Parameter (Länge, Dimension und Mindestdistanz) eines Codes, wurde die Hamming-Schranke angegeben. Die Beschreibung eines linearen Blockcodes durch Prüfmatrix H und Generatormatrix G wurde erläutert, und es wurden zwei einfache Codiervorschriften für den ParityCheck- (PC) und den Wiederholungscode (RP) angegeben. Wir haben zyklische Codes definiert und die Erweiterung bzw. Verkürzung von Codes eingeführt. Die Prüfmatrix H multipliziert mit dem empfangenen Vektor ergibt das Syndrom. Sind bei der Übertragung Fehler aufgetreten, so ist das Syndrom s ungleich 0, falls der Fehler f kein Codewort ist. Es können verschiedene Decodierprinzipien angewendet werden: Maximum-LikelihoodDecodierung (ML), Begrenzte-Mindestdistanz-Decodierung (BMD), symbolweise MAPDecodierung (s/s-MAP), Decodierung über die halbe Mindestdistanz und Fehlererkennung. Dabei ist im Falle eines BSC die sich ergebende Restblockfehlerwahrscheinlichkeit berechenbar. Allerdings kann die Berechnung für längere Codes nur bei BMD durchgeführt werden, da die Gewichtsverteilung in der Regel nicht bekannt ist. Die StandardArray-Decodierung stellt ein ML-Decodierverfahren dar, was für längere Codes nicht praktikabel ist. Wir haben die informationstheoretischen Begriffe Unsicherheit (Entropie) und Kanalkapazität beschrieben. Außerdem haben wir das Kanalcodiertheorem erläutert, das aussagt, dass die Restblockfehlerwahrscheinlichkeit nach der Decodierung beliebig klein gemacht werden kann, wenn ein Code mit der Rate kleiner als die Kanalkapazität verwendet wird. Weitere Informationen bzw. andere Beschreibungsformen der elementaren Grundbegriffe der Codierungstheorie findet man auch in den einleitenden Kapiteln z. B. von [Lint], [McWSl], [HeQu], [Schu] und [Bla], sowie in den klassischen Büchern zur Codierungstheorie [ClCa] und [Gal]. Die Beschreibung von Codes mittels Prüf- und Generatormatrix ist zur Konstruktion von Codes nicht so gut geeignet. Deshalb wollen wir im nächsten Kapitel die notwendigen mathematischen Grundlagen angeben, um Codes mit Polynomen über endlichen Zahlenkörpern beschreiben zu können.

1.12

Übungsaufgaben

Aufgabe 1.1 Zeigen Sie, dass die Quersumme einer ganzen Zahl modulo 9 gleich der Zahl modulo 9 ist. Zeigen sie zunächst, dass gilt: (a + b)

mod 9 = ((a

mod 9) + (b

(a · b)

mod 9 = ((a

mod 9) · (b

mod 9)) mod 9))

mod 9 mod 9.

und

1.12 Übungsaufgaben Aufgabe 1.2 Gegeben sei die n = 7. 0 0 0 0 1 1 H=@0 1 1 0 0 1 0 1 0 1

27 Prüfmatrix H eines binären linearen Blockcodes C der Länge 1 1 1 1 1A 0 1

a) Ist c1 ∈ F72 , c1 = (0, 1, 0, 1, 0, 1, 0) ein Codewort des Codes C?

b) Geben Sie die Parameter des Codes und die Coderate R an.

c) Sei c2 = (1, 1, 0, 1, 1, 0, 1) ∈ F72 . Bestimmen Sie mindestens 3 mögliche Fehlervektoren f derart, dass die Addition c2 + f ein Codewort von C ist.

d) Decodieren Sie c3 = (0, 1, 1, 1, 0, 1, 0) bezüglich des Codes C. Aufgabe 1.3 Lösen Sie folgende Aufgaben: a) Wie viele verschiedene Vektoren h enthält Fm 2 ?

b) Mit allen Vektoren aus Fm 2 , die ungleich dem Nullvektor sind, kann eine Matrix gebildet werden, in der die Vektoren hT die Spaltenvektoren darstellen. Diese Matrix ist die Prüfmatrix eines Hamming-Codes. Bestimmen Sie die Länge n, die Dimension k und die Coderate R eines Hamming-Codes in Abhängigkeit von m. c) Führen Sie die Konstruktion für m = 4 durch. Wie viele Fehler kann dieser Code korrigieren? Aufgabe 1.4 Lösen Sie folgende Aufgaben: a) Berechnen Sie die Wahrscheinlichkeit Pr (e), dass bei der Übertragung von n Bits über einen symmetrischen Binärkanal (BSC) mit der Fehlerwahrscheinlichkeit p genau e Zeichen fehlerhaft sind. b) Welche Bedingung müssen n, e und p, (e
0, so dass ar = 1 mod p gilt. Falls gilt r = p − 1, so ist a ein primitives Element. Man beachte, dass in einem Ring nicht für jedes Element a ein Exponent r existiert, für den ar = 1 gilt. Für diese Elemente ist keine Ordnung definiert. Beispiel 2.4 (Ordnung der Elemente in GF (5)) wir berechnen 11 = 1 mod 5,

24 = 1 mod 5,

34 = 1 mod 5,

42 = 1 mod 5.

Das Element 1 hat die Ordnung 1, das Element 4 hat die Ordnung 2, und die Elemente 2 und 3 haben die Ordnung 4. Man überzeugt sich, dass keine kleineren Exponenten existieren. 

Satz 2.10 (Existenz eines primitiven Elements) (ohne Beweis) Jedes Galois-Feld besitzt mindestens ein primitives Element. Ist α ein primitives Element von GF (p), dann sind auch alle αj mit ggT(j, p − 1) = 1 primitive Elemente von GF (p). Es gibt also Φ(p − 1) primitive Elemente.

Satz 2.11 (Ordnungen sind Teiler von p − 1) Die Ordnungen aller Elemente eines Galois-Feldes GF (p) müssen p − 1 teilen. Beweis: Ein Element β habe die Ordnung r, d. h. β r = 1 mod p. Gemäß Satz 2.10 und Definition 2.7 kann man jedes Element von GF (p) als Potenz des primitiven Elementes α darstellen, d. h. β = αl . Nehmen wir an r 6 | (p − 1), so können wir schreiben (p − 1) = j · r + i,

Rest 0 < i < r.

Mit dem Euler/Fermat-Theorem (Satz 2.5) gilt jedoch: β p−1 = 1 = β j·r+i = (β r )j · β i = 1 · β i 6= 1 , da r gemäß Definition 2.9 die kleinste Zahl ist, für die β r = 1 gilt, und 0 < i < r ist.

2

2.3 Primkörper

33

Beispiel 2.5 (Primitives Element) Das Element 2 ist ein primitives Element von GF (5): 21 = 2, 22 = 4, 23 = 8 = 3, 24 = 16 = 1 mod 5. Das Element 3 ist ebenfalls ein primitives Element: 31 = 3, 32 = 9 = 4, 33 = 27 = 2, 34 = 81 = 1 mod 5. Das Element 4 hat die Ordnung 2 (2 ist Teiler von 4 = p − 1): 41 = 4, 42 = 16 = 1 mod 5. Man kann alle Elemente von GF (5) entweder durch Potenzen von 2 oder 3 darstellen. Der Null wird formal der Exponent −∞ zugeordnet. Um zwei Elemente zu multiplizieren, kann man die Exponenten modulo p − 1 addieren. Etwa: 2 · 4 = 8 = 3 = 21 · 22 = 23 = 3 mod 5. Wir haben damit zwei mögliche Darstellungsformen der Elemente eines Primkörpers, die Darstellung mittels des Exponenten und die als Zahl. 

Jetzt können wir die Behauptung aus Satz 2.2 beweisen, dass ein Element aus Zm invertierbar ist, wenn gilt: ggT(a, m) = 1. Denn mit Satz A.2 folgt, dass zwei Zahlen w und v existieren mit v·a+w·m=1

=⇒

v · a = 1 mod m,

d. h. a−1 = v mod m. Beispiel 2.6 (Euklidischer Algorithmus) Wir berechnen ggT(42, 24): Zunächst ist 42 : 24 = 1 Rest 18, bzw. 42 = 1 · 24 + 18. Dann 24 : 18 = 1 Rest 6, bzw. 24 = 1 · 18 + 6 und 18 : 6 = 3 Rest 0, 18 = 3 · 6 + 0. Damit ist ggT(42, 24) = 6. Jetzt wollen wir jeden Rest, d. h. 42, 24, 18, 6 und 0, entsprechend dem erweiterten Euklidischen Algorithmus durch die Zahlen 42 und 24 darstellen. Mit der Rekursion für vi und wi berechnen wir zunächst diese Werte mit den Quotienten q1 = 1, q2 = 1 und q3 = 3 und den Startwerten v−1 = 1, w−1 = 0, v0 = 0 und w0 = 1. Wir erhalten zunächst v1 = v−1 − q1 v0 = 1 und w1 = w−1 − q1 w0 = −1. Dann v2 = v0 − q2 v1 = −1 und w2 = w0 − q2 w1 = 2 und schließlich v3 = v1 − q3 v2 = 4 und w3 = w1 − q3 w2 = −7. Damit errechnen wir: 42 = 1 · 42 − 0 · 24, 24 = 0 · 42 + 1 · 24, 18 = 1 · 42 − 1 · 24, 6 = −1 · 42 + 2 · 24 und 0 = 4 · 42 − 7 · 24. 

Definition 2.12 (Teilerfremd, relativ prim) Gilt für zwei Zahlen a und b, mit a, b 6= 0: ggT(a, b) = 1, so sind a und b teilerfremd; man sagt auch: relativ prim. Existenz eines inversen Elementes: Jedes Element α < p ist gemäß der Definition einer Primzahl zu p teilerfremd, d. h. für alle α ∈ GF (p) gilt: ggT(α, p) = 1. Mit Satz A.2 folgt, dass zwei Zahlen a und b existieren, für die a·α+b·p=1

34

2 Galois-Felder

ist. Anders ausgedrückt: a · α = 1 mod p a = α−1 . Damit haben wir verifiziert, dass für jeden Primkörper GF (p) zu jedem Element α 6= 0 ein eindeutiges inverses Element α−1 existiert.

2.4

Gaußkörper

In diesem Abschnitt wollen wir eine interessante Darstellung eines Primkörpers GF (p) als Beispiel präsentieren, die auf Gaußzahlen aufbaut und die Theorie der Körper vertiefen soll. Eine Gaußzahl ζ ist eine komplexe Zahl, deren Real- und Imaginärteil ganze Zahlen sind [Hub94]: √ ζ = u + jv, u, v ∈ Z und j = −1. Aus der Zahlentheorie ist bekannt, dass jede Primzahl p der Form p = 4 · u + 1 (oder: p = 1 mod 4) wie folgt ausgedrückt werden kann: p = (a + jb)(a − jb) = a2 + b2 . Die Zahl Π = a + jb wird Gaußsche Primzahl genannt, und das Rechnen modulo Π ist definiert durch (Π∗ = a − jb):   w · Π∗ ζ = w mod Π = w − · Π, Π · Π∗ wobei [·] das Runden zur nächstgelegenen Gaußzahl bedeutet. Weitere mögliche Gaußsche Primzahlen, die wir hier nicht betrachten wollen, sind: 1 + j, −1 − j, −1 + j, 1 − j und die Zahlen l, −l, jl, −jl, wobei l eine Primzahl mit der Eigenschaft l = 3 mod 4 ist. Satz 2.13 (Gaußkörper GΠ ) Sei p = 4u + 1, u ∈ Z, eine Primzahl mit Π = (a + jb), Π∗ = (a − jb) und p = Π · Π∗ = a2 + b2 , dann bilden die Gaußzahlen modulo Π gerechnet den Körper GΠ = {0, ζ1 , ζ2 , . . . , ζp−1 }. D. h. es gilt: ζi = m + jl mod Π,

m, l ∈ Z.

Beweis: GF (p) ist ein Körper. Jedes Element m ∈ GF (p) kann auf ein Element ζ ∈ GΠ umkehrbar eindeutig abgebildet werden durch » – m · Π∗ m mod Π = ζ = m − · Π, m = (ζ · b · Π∗ + ζ ∗ · t · Π) mod p, Π · Π∗ wobei für t und b gilt: 1 = t · Π + b · Π∗ . Weiterhin ist für alle m1 , m2 ∈ GF (p) und ζ1 , ζ2 ∈ GΠ m1 + m2 mod p m1 · m2 mod p

←→ ←→

ζ1 + ζ2 mod Π , ζ1 · ζ2 mod Π.

2.4 Gaußkörper

35 jv 2 1 −2

−1 −1

1

2

u

−2

Abb. 2.1: Gaußkörper G4+j .

Anmerkung: » – (ζ1 + ζ2 )Π∗ ζ1 + ζ2 mod Π = ζ1 + ζ2 − ·Π , Π · Π∗ » – (ζ1 · ζ2 )Π∗ ζ1 · ζ2 mod Π = ζ1 · ζ2 − · Π. Π · Π∗

2

Beispiel 2.7 (Gaußkörper G4+j ) Die Primzahl p = 17 = 1 mod 4 kann als 17 = (4+j)(4−j) dargestellt werden. Die Gaußzahl 13 + 11j ergibt modΠ = 4 + j gerechnet »

– » – (13 + 11j)(4 − j) 63 + 31j 13 + 11j − (4 + j) = 13 + 11j − (4 + j) (4 + j)(4 − j) 17 = 13 + 11j − [3, 7 + 1, 8j](4 + j) = 13 + 11j − (4 + 2j)(4 + j)

= 13 + 11j − (14 + 12j) = −1 − j. Rechnen wir die Zahlen 9 und 10 mod Π, so erhalten wir: – 9(4 − j) (4 + j) = 9 − (2 − j)(4 + j) = 9 − (9 − 2j) = 2j, (4 + j)(4 − j) 10 mod Π = 1 + 2j. 9 mod Π = 9 −

»

Die Zahlen {1, 2, . . . , 16} mod Π gerechnet ergeben GΠ = {1, 2, −1 − j, −j, 1 − j, 2 − j, −1 − 2j, −2j, 2j, 1 + 2j, −2 + j, −1 + j, j, 1 + j, −2, −1}. Wir wollen noch überprüfen, ob für 9 · 10 = 90 = 5 mod 17 auch entsprechend 2j(1 + 2j) = 1 − j mod Π gilt. Wir errechnen: 2j(1 + 2j) −

»

– » – 2j(1 + 2j)(4 − j) 14 12 (4 + j) = (−4 + 2j) − − + j (4 + j) (4 + j)(4 − j) 17 17 = −4 + 2j − (−1 + j)(4 + j) = (−4 + 2j) − (−5 + 3j) = 1 − j.

Die Elemente des Körpers G4+j sind in Bild 2.1 dargestellt.



36

2.5

2 Galois-Felder

Erweiterungskörper

Bisher sind wir nur in der Lage, eine sehr begrenzte Anzahl von Galois-Feldern, nämlich die Primkörper GF (p), zu konstruieren. Wir wollen im Folgenden die Erweiterung eines Primkörpers GF (p) beschreiben und mit diesem allgemeineren Fall sehr viel flexibler bei der Konstruktion von Galois-Feldern werden. Bei der heutigen Technik werden vorwiegend Dualdarstellungen von Zahlen verwendet, allerdings können durch Primkörper die binären Stellen häufig nicht ausgenutzt werden (z. B. p = 71 benötigt 7 Stellen, 27 = 128). In der Praxis werden deshalb fast immer Erweiterungen von GF (2) verwendet, unter anderem, um die Dualdarstellung von Elementen eines Galois-Feldes besser auszunutzen. Anmerkung: Eine andere übliche Schreibweise eines Restklassenringes Zm ist Z/(m). Dabei stellt Z den Ring der ganzen Zahlen dar und /(m) bedeutet das Rechnen mod m. Entsprechend wollen wir im Folgenden den Ring Zm [x] der Polynome mit Koeffizienten aus Zm modulo Polynomen p(x) betrachten, bzw. Zm [x]/p(x). War m = p eine Primzahl, so ergab sich ein Körper GF (p), und entsprechend: Ist p(x) ein primitives Polynom, so ist GF (p)[x]/p(x) ein Erweiterungskörper.

2.5.1

Irreduzible Polynome

Definition 2.14 (Irreduzibles Polynom) Ein Polynom p(x) mit Koeffizienten aus GF (p) ist irreduzibel bezüglich GF (p), wenn es nicht als Produkt von Polynomen kleineren Grades, die ebenfalls Koeffizienten aus GF (p) haben, dargestellt werden kann. Eine Primzahl kann nicht als Produkt von kleineren Zahlen dargestellt werden. Somit ist die Definition von irreduziblen Polynomen analog zu der von Primzahlen. Es genügt nicht, dass p(x) keine Nullstellen aus GF (p) hat um irreduzibel zu sein (dies ist notwendig, aber nicht hinreichend). Dies erklärt man sich folgendermaßen: Seien p1 (x), p2 (x) irreduzibel bzgl. GF (p), dann hat p(x) = p1 (x) · p2 (x), mit grad p1 (x), grad p2 (x) > 1, keine Nullstellen aus GF (p), ist aber nicht irreduzibel. Beispiel 2.8 (Irreduzibles Polynom) Gegeben sei p(x) = x4 + x + 1 mit Koeffizienten aus GF (2). Um zu testen, ob p(x) irreduzibel ist, können wir überprüfen, ob ein Polynom f (x) mit grad f (x) < grad p(x) existiert, das p(x) ohne Rest teilt. Hat p(x) den Grad m, so existieren 2m (allgemein pm ) Polynome f (x) mit grad f (x) < m (einschließlich f (x) = 0); also m = 4, p = 2 =⇒ 16 Polynome, nämlich: 0, 1, x, x2 , x3 , 1 + x, . . . , 1 + x + x2 + x3 . Für alle f (x) 6= 0, 1 müssen wir nun überprüfen, ob sie p(x) ohne Rest teilen (6 | bedeutet „teilt nicht“). 9 xi 6 | p(x) i = 1, 2, 3 > > i = (1 + x ) 6 | p(x) i = 1, 2, 3 > .. > > . > ; (1 + x + x2 + x3 ) 6 | p(x)

=⇒ p(x) ist irreduzibel bzgl. GF (2).



2.5 Erweiterungskörper

37

Satz 2.15 (Existenz eines inversen Polynoms) Ist das Polynom p(x) mit den Koeffizienten pi ∈ GF (p) und grad p(x) = m irreduzibel bezüglich GF (p), so hat jedes der pm − 1 (alle außer 0) Polynome b(x) mit grad b(x) < m und den Koeffizienten bi ∈ GF (p) ein eindeutiges inverses Polynom b−1 (x) modulo p(x), d. h. b(x) · b(x)−1 = 1 mod p(x). Beweis: ∀b(x) : b(x) 6 | p(x) =⇒ ggT(b(x), p(x)) = 1. Mit dem Euklidischen Algorithmus kann man dies als b(x) · a(x) + c(x) · p(x) = 1 darstellen, und damit folgt: a(x) = b−1 (x) mod p(x).

2

Beispiel 2.9 (Inverses Polynom) Sei p(x) = x4 + x + 1, pi ∈ GF (2), so gilt: p(x) = 0 mod p(x) x4 + x + 1 = 0 mod p(x) x4 + x = 1 mod p(x) x · (x3 + 1) = 1 mod p(x) x−1 = 1 + x3 . Mit Hilfe des Euklidischen Algorithmus kann man zu jedem Polynom b(x), für das gilt grad(b(x)) < 4, bi ∈ GF (2), das inverse Polynom b−1 (x) berechnen. 

Zu jedem Polynom p(x) (nicht notwendigerweise irreduzibel) mit Koeffizienten aus GF (p) bilden alle Polynome mit kleinerem Grad zusammen mit der Addition und Multiplikation modp(x) einen Ring. Genau dann, wenn p(x) irreduzibel ist, ist dieser Ring sogar ein Körper, da gemäß Satz 2.15 jedes Polynom kleineren Grades ein Inverses besitzt. Dieser mit Hilfe von p(x) konstruierte Erweiterungskörper hat pgrad p(x) Elemente und ist eine Darstellung des Erweiterungskörpers GF (pgrad p(x) ), den wir im folgenden Abschnitt genauer betrachten werden.

2.5.2

Primitive Polynome, Wurzeln

Definition 2.16 (Nullstellen, Wurzeln eines Polynoms) Sei p(x) ∈ GF (p)[x], ein irreduzibles Polynom, so hat es gemäß Definition 2.14 keine Nullstellen aus GF (p). Ein Element α aus einem Erweiterungskörper GF (pgrad p(x) ) heißt Wurzel oder Nullstelle von p(x), wenn p(α) = 0.

38

2 Galois-Felder

Definition 2.17 (Erweiterungskörper) Sei p(x) irreduzibel über GF(p) und α 6∈ GF (p) Nullstelle von p(x) mit grad p(x) = m, dann ist der Erweiterungskörper GF (pm ) der kleinste Körper, der GF (p) und α enthält. Anmerkung: x2 + 1 = 0 hat keine Lösung√∈ R, aber es können komplexe Zahlen C definiert werden und damit j2 +1 = 0, j = ± −1, j ∈ C. Das bedeutet: j ist ein Element des Erweiterungskörpers. Beispiel 2.10 (Nullstelle) Gemäß Beispiel 2.8 ist p(x) = x4 + x + 1 irreduzibel über GF (2). Wir definieren: α sei eine Wurzel (Nullstelle) von p(x), d. h. p(α) = α4 + α + 1 = 0.



Definition 2.18 (Primitives Polynom) Sei p(x) ∈ GF (p)[x] ein irreduzibles Polynom mit grad p(x) = m. Das Element α ∈ GF (pm ) ist Wurzel von p(x) (vergleiche Definition 2.7). Das Polynom p(x) heißt primitiv, wenn die Potenzen seiner Nullstelle αi mod p(α) alle pm − 1 Elemente (ohne Null) des Erweiterungskörpers erzeugen. Das Element α ∈ GF (pm ) heißt primitives Element. Elemente des Erweiterungskörpers: Ein Element eines Erweiterungskörpers GF (pm ) wird damit definiert als die Nullstelle α des primitiven Polynoms p(x), nämlich p(α) = 0. Die Potenzen des Elementes α, modulo p(α) gerechnet, ergeben den Erweiterungskörper ohne {0}. Wir können die Elemente des Erweiterungskörpers auf zwei Arten darstellen: Exponentendarstellung: Gemäß Definition 2.18 können wir jedes Element ungleich 0 des Erweiterungskörpers als Potenz des primitiven Elementes α darstellen. Dies nennt man Exponentendarstellung. Komponentendarstellung: Wir können aber die Elemente des Erweiterungskörpers auch durch die Koeffizienten der Polynome f (α) darstellen. Dies nennt man Komponentendarstellung. Schreibt man die Polynome f (α) (entsprechend Definition 2.18) als fm−1 xm−1 + fm−2 xm−2 + · · · + f0 , so sind sie durch ihre Koeffizienten eindeutig bestimmt und es genügt zu schreiben: fm−1 fm−2 . . . f1 f0 ,

fi ∈ GF (p).

Die Schwierigkeit, das Element 00 . . . 0 in der Exponentendarstellung zu beschreiben, wird häufig durch die Darstellung α−∞ gelöst. Die Multiplikation führen wir durch die Addition modulo pm − 1 der Exponenten aus. Die Addition dagegen wird als Addition der einzelnen Komponenten im Grundkörper GF (p) durchgeführt. Die Multiplikation der Polynome wird modulo p(α) durchgeführt. Als Beispiel werden wir mit dem primitiven Polynom p(x) und dem primitiven Element α aus Beispiel 2.10 den Erweiterungskörper GF (24 ) konstruieren.

2.5 Erweiterungskörper

39

Tabelle 2.1: Galois-Feld GF (24 ) (Logarithmentafel). Exp. −∞ 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14

Komponenten

α α2 α3 α2 α3 +α2 α3 α2 3 α α2 α3 +α2 α3 +α2 α3 +α2 α3

15

α +α +α +α +α +α +α

0 0000 1 0001 0010 0100 1000 +1 0011 0110 1100 +1 1011 +1 0101 1010 +1 0111 1110 +1 1111 +1 1101 +1 1001

Berechnung

α4 = α + 1 α5 = α · α4 = α2 + α α6 = α · α5 = α3 + α2 α7 = α · α6 = α4 + α3 = α3 + α + 1 α8 = α · α7 = α4 + α2 + α = α2 + 1 α9 = α · α8 = α3 + α α10 = α · α9 = α4 + α2 = α2 + α + 1 α11 = α · α10 = α3 + α2 + α α12 = α · α11 = α3 + α2 + α + 1 α13 = α · α12 = α3 + α2 + 1 α14 = α · α13 = α4 + α3 + α = α3 + 1

1 0001 α15 = α · α14 = α4 + α

=1

Beispiel 2.11 (Galois-Feld GF (24 )) Das Galois-Feld GF (24 ) mit dem primitiven Polynom p(x) = x4 + x + 1, pi ∈ GF (2) und dem primitiven Element α, p(α) = 0, kann durch die Logarithmentafel in Tabelle 2.1 dargestellt werden. Multiplikation: α9 · α7 = α16 mod 15 = α

(αi mod 15 )

Addition: α4 + α5 = 0011 ⊕ 0110 = 0101 = α8 (⊕ bezeichnet die komponentenweise Addition im Grundkörper). 

Wir haben gesehen, dass man für die Komponenten eines Erweiterungskörpers GF (pm ) ein primitives Polynom p(x) ∈ GF (p)[x] mit grad p(x) = m benötigt. Es ist daher nützlich zu wissen: Satz 2.19 (Existenz eines primitiven Polynoms) (ohne Beweis) Für jeden Körper GF (p) und jede Zahl m ∈ N existiert mindestens ein primitives Polynom p(x) = p0 + p1 x + · · · + pm xm , pi ∈ GF (p). Anmerkung: Bei der Suche nach primitiven Polynomen genügt es nicht, irreduzible Polynome zu suchen, denn: Nicht jedes irreduzible Polynom ist ein primitives Polynom. Es genügt ein Gegenbeispiel. q(x) = x4 + x3 + x2 + x + 1 ist irreduzibel über GF (2), aber nicht primitiv, denn es gilt beispielsweise: q(α) = 0 :

α4 = α3 + α2 + α + 1,

α5 = α · α4 = α4 + α3 + α2 + α = 1 = α0 .

40

2 Galois-Felder Tabelle 2.2: Primitive Polynome. m primitives Polynom p(x) m primitives Polynom p(x) 1 2 3 4 5 6 7 8

x+1 2 x +x+1 x3 + x + 1 x4 + x + 1 x5 + x2 + 1 x6 + x + 1 x7 + x + 1 8 6 x + x + x5 + x4 + 1

9 10 11 12 13 14 15 16

x9 + x4 + 1 x10 + x3 + 1 x11 + x2 + 1 12 7 x + x + x4 + x3 + 1 x13 + x4 + x3 + x + 1 x14 + x8 + x6 + x + 1 x15 + x + 1 16 12 x + x + x3 + x + 1

Existieren verschiedene primitive Polynome, so ergeben sich damit äquivalente Erweiterungskörper, d. h. es genügt theoretisch eines zu kennen. Für die Praxis zeigt sich aber, dass verschiedene primitive Polynome sich unterschiedlich gut zur Realisierung in integrierten Schaltkreisen eignen. In Tabelle 2.2 sind primitive Polynome zur Konstruktion von Erweiterungskörpern GF (2m ) für m ≤ 16 angegeben. 2·π

Diese Art von Erweiterungskörpern wird wegen der Analogie (ej· N )N = 1 oft Kreisteilungskörper genannt. Im folgenden Abschnitt werden wir weitere Eigenschaften von Erweiterungskörpern untersuchen.

2.5.3

Eigenschaften von Erweiterungskörpern

Die komplexen Zahlen sind ein Erweiterungskörper der reellen Zahlen. Betrachten wir die konjugiert komplexen Zahlen −j, j, so erhalten wir: (x − j) · (x + j) = x2 + 1. Das Produkt von zwei Polynomen mit konjugiert komplexen Wurzeln (∈ C) ergibt ein Polynom mit Koeffizienten aus R und nicht aus C. Dazu analog gilt für Erweiterungskörper: Satz 2.20 (Konjugiert komplexe Wurzeln) Sei p(x) ∈ GF (p)[x] mit grad p(x) = m irreduzibel bezüglich GF (p), und sei α eine Wurzel von p(x), dann sind mit α auch 2

αp , αp , · · · , αp

m−1

Wurzeln von p(x). Man nennt die Wurzeln konjugiert komplex. Siehe Beweis zu Satz 4.1. Damit kann man p(x) in Linearfaktoren zerlegen: p(x) = (x − α) · (x − αp ) · · · · · (x − αp

m−1

).

Das Produkt von konjugiert komplexen Linearfaktoren (Elemente aus GF (pm )) ergibt ein Polynom mit Koeffizienten aus GF (p). In Primkörpern haben wir die Ordnung von Elementen α ∈ GF (p) definiert. Für Erweiterungskörper gilt entsprechend Definition 2.6:

2.5 Erweiterungskörper

41

Definition 2.21 (Ordnung eines Elements) Sei β ∈ GF (pm ) und n die kleinste Zahl, für die gilt: β n = 1, so heißt n die Ordnung von β. Ist n = pm − 1, so ist β ein primitives Element. Man nennt β auch häufig n-te primitive Einheitswurzel. Aus Definition 2.21 folgt, dass alle β i , 0 ≤ i < n, verschieden sind. m

Satz 2.22 (Produkt von irreduziblen Polynomen) (ohne Beweis) xp − x ist das Produkt aller über GF (p) irreduziblen Polynome vom Grad s, s | m, 1 ≤ s < m. Dieser Satz wird nach der Definition der Kreisteilungsklassen einsichtig. Aus Satz 2.22 folgt (vergleiche auch Satz 2.11): βp

m

−1

= 1 für alle β ∈ GF (pm ).

Satz 2.23 (Teiler der Ordnung) Für die Ordnung n gemäß Definition 2.21 muss gelten: n | pm − 1. Falls n darstellbar ist als n = ps − 1 ,

so gilt:

s | m.

Beweis: Für n 6 | pm − 1 würde gelten: pm − 1 = x · n + r, β

pm −1



x·n

0 n − 1 bedeutet dies, dass die Koeffizienten an den Stellen (i · n + j), i = 0, 1, . . ., zu dem Koeffizienten an der Stelle j des modulo gerechneten Polynoms addiert werden. Etwa n = 6: 1 + x3 + x12 + x29 = 2 + x3 + x5 mod (x6 − 1). Beliebige Polynome (unendlich großer Grad möglich) mit Koeffizienten aus GF (p) = Fp ergeben mod (xn − 1) gerechnet einen Polynomring, der mit Fpm [x] bezeichnet wird. Er besteht aus allen pn möglichen Polynomen vom Grad ≤ n − 1. Polynome werden addiert, indem die Koeffizienten mit gleichem Exponenten von x addiert werden. Also W (x) = A(x) + B(x) bedeutet, dass Wi = Ai + Bi , i = 0, . . . , n − 1 ist. Zwei Polynome können komponentenweise multipliziert werden, indem Wi = Ai · Bi , i = 0, . . . , n − 1 gebildet wird. Die Multiplikation von Polynomen mod (xn −1) (entspricht einer zyklischen Faltung) ergibt W (x) = A(x) · B(x) mit Wj = A0 Bj + A1 Bj−1 + . . . + An−1 Bj−n+1 , j = 0, . . . , n − 1, wobei die Indizes modn gerechnet werden. Für j = 0 ist beispielsweise −n + 1 = 1. Eine Multiplikation mit xi a(x) = b(x) mod (xn − 1) gerechnet ist damit eine zyklische Verschiebung der Polynomkoeffizienten um i Stellen. Es gilt also für die Koeffizienten bj = aj−i , wobei die Indizes modn gerechnet werden.

Es sei nochmals erwähnt, dass alles Folgende für Körper GF (pm ) gilt, wir jedoch uns nachfolgend der Einfachheit halber auf GF (p) beschränken.

3.1.1

Diskrete Fourier-Transformation (DFT)

Betrachten wir die Polynome A(x) = A0 + A1 x + A2 x2 + · · · + An−1 xn−1 ∈ Fp [x] und a(x) = a0 + a1 x + a2 x2 + · · · + an−1 xn−1 ∈ Fq [x], wobei A(x) gegeben ist und die n Koeffizienten ai von a(x) durch Evaluation des Polynoms A(x) an den n Stellen x = αi , also ai = A(αi ) berechnet werden. Die DFT wird durch a(x) b rb A(x) bezeichnet und ermöglicht die Berechnung des transformierten Polynoms aus dem Polynom oder auch die Berechnung des Polynoms aus dem transformierten Polynom. Satz 3.1 (Diskrete Fourier-Transformation) Sei α ∈ GF (p) ein Element der Ordnung n = p − 1 und A(x) ein Polynom vom Grad ≤ n − 1 mit Koeffizienten aus GF (p). Aus dem Polynom a(x) mit ai = A(αi ), i = 0, . . . , n−1 kann das Polynom A(x) berechnet werden durch Aj = n−1 · a(α−j ), j = 0, . . . , n − 1. Beweis: Im ersten Schritt ersetzen wir die Polynomauswertung durch eine Summe und erhalten ai = A(x = αi ) = A0 + A1 αi + A2 (αi )2 + . . . An−1 (αi )n−1 =

n−1 X

Aj αij .

(3.1)

j=0

Ebenfalls können wir die Auswertung an den Stellen x = α−j als Summe schreiben zu ` ´ Aj = n−1 a(α−j ) = n−1 a0 + a1 α−j + a2 (α−j )2 + . . . an−1 (α−j )n−1 = n−1

n−1 P l=0

al α−jl .

(3.2)

3.1 Definition von RS-Codes

49

Wir überprüfen nun, ob sich wieder ai ergibt, wenn wir in Gleichung (3.1) den Koeffizienten Aj durch Gleichung (3.2) ersetzen. Denn damit hätten wir gezeigt, dass die Polynome a(x) und A(x) durch die Fourier-Transformation ineinander umrechenbar sind. Die Ersetzung von Aj ergibt: Aj

n−1 Xz j=0

}|

−1

(p − 1)

{ n−1 X −1 n−1 X a(α−j ) αij = n al α−jl αij . j=0

(3.3)

l=0

Jetzt vertauschen wir die Summationen und schreiben den Faktor n−1 vor die Summation, d. h.

n−1

n−1 X

al

n−1 X

α−jl αij = n−1

j=0

l=0

n−1 X

al

n−1 X

α(i−l)j .

(3.4)

j=0

l=0

Betrachten wir die rechte Summe genauer, so können wir zwei Fälle unterscheiden. 1. l 6= i: P j In diesem Fall benutzen wir die Gleichung n−1 j=0 z = n−1 X

α(i−l)j =

j=0

n−1 X“

αi−l

j=0

”j

=

1−z n 1−z

mit der wir schreiben können

1 − (α(i−l) )(p−1) = 0 mod p. 1 − αi−l

Denn jedes Element (α(i−l) )n = 1 und somit ist der Zähler gleich null. Der Nenner ist ungleich Null, da wir den Fall l 6= i betrachten. Damit ergibt die Summe Null.

2. l = i: Der Exponent (i − l)j von α ist in diesem Fall gleich Null, also n−1 X

α(i−l)j =

j=0

n−1 X

α0 =

j=0

n−1 X

1 = n.

j=0

Setzen wir nun dieses Ergebnis in Gleichung (3.4) ein, so erhalten wir −1

n

n−1 X l=0

al

n−1 X j=0

α

(l−i)j

=



n−1 ai n = ai für l = i n−1 al · 0 = 0 für l 6= i.

Damit haben wir gezeigt, dass wenn die inverse Transformation von A(x) das Polynom a(x) ergibt, dann die Transformation von a(x) wieder A(x) ist. 2

Anmerkung: Im Falle von Erweiterungskörpern GF (2m ) ist n−1 = 1, da im Grundkörper gerechnet wird ((2m − 1) · 1 = 1 mod 2). Die Transformation der Folge ai in die Folge Ai zusammen mit der Rücktransformation ist in der Literatur unterschiedlich bezeichnet. In [McWSl] heißt sie Mattson-Solomon-Polynom, und in [Bla] wird sie als diskrete Fourier-Transformation bezeichnet. Ein wichtiger und nützlicher Satz der DFT ist der Faltungssatz, den wir häufig anwenden werden, um verschiedene Sätze und Behauptungen zu beweisen. Wir wollen den Faltungssatz ohne Beweis angeben.

50

3 Reed-Solomon-Codes

Satz 3.2 (Faltungssatz) Die Polynommultiplikation mod (xn − 1) entspricht einer zyklischen Faltung und die komponentenweise Multiplikation einer Multiplikation. Es gilt: a(x) b

rb A(x),

b(x) b c(x) b C(x) rb

ci = ai · bi , C i = Ai · B i ,

rb B(x)

br C(x) = A(x) · B(x) mod (xn − 1) b c(x) = a(x) · b(x) mod (xn − 1).

Wir benötigen noch den folgende Satz, der aus der Algebra bekannt ist und auch für Galois-Felder gilt. Satz 3.3 (Fundamentalsatz der Algebra) Ein Polynom A(x) = A0 + A1 x + A2 x2 + · · · + A` x` vom Grad ` (A` 6= 0) mit Koeffizienten Ai ∈ GF (p) hat höchstens ` verschiedene Nullstellen αj ∈ GF (p). Beweis: Ist α ∈ GF (p) eine Nullstelle von A(x), so enthält A(x) den Linearfaktor (x − α), d. h. A(x) = (x − α)A∗ (x), wobei grad A(x) = grad (A∗ (x)) + 1 gilt, usw. 2

3.1.2

Parameter von RS-Codes

Definition 3.4 (RS-Code) Gegeben sei ein Galois-Feld GF (p) und die Menge aller Polynome C(x) vom Grad ≤ k − 1 mit Koeffizienten aus GF (p). Die Menge aller Codeworte des RS-Codes C ist definiert durch C = {c(x) b

rb C(x), grad C(x) < k} .

Satz 3.5 (Parameter RS-Code) Der Code entsprechend Definition 3.4 besitzt die Länge n, die Dimension k und die Mindestdistanz d = n − k + 1. Es ist damit ein C(n, k, d = n − k + 1) Code über dem Alphabet GF (p). Beweis: Die Länge n folgt aus der Tatsache, dass grad c(x) ≤ n − 1 ist, also n Koeffizienten besitzt, von denen einige 0 sein können. Aus grad C(x) ≤ k − 1 folgt die Dimension k und es gilt |{C(x)}| = pk . Gemäß Satz 3.3 besitzt C(x) höchstens k − 1 Nullstellen, d. h. jedes von null verschiedene Codewort c(x) hat mindestens n − (k − 1) = n − k + 1 von Null verschiedene Stellen, also Gewicht ≥ n−k+1. Da bei linearen Codes Minimalgewicht gleich Mindestdistanz ist (vergleiche Abschnitt 1.1), gilt d ≥ n − k + 1. Andererseits sind alle Polynome C(x) gültige Codeworte, also auch C(x) = (x − αi1 )(x − αi2 ) · · · (x − αik−1 ), das einem c(x) mit Gewicht n − k + 1 entspricht und somit muss gelten d = n − k + 1. 2

Für ein Element α ∈ GF (p) der Ordnung n gilt entsprechend Definition 2.9: αn = 1 mod p. Ist α ein primitives Element, so ist n = p − 1. Die Gleichung xn − 1 = 0, gilt für alle Potenzen eines Elementes α ∈ GF (p) der Ordnung n, also für alle Elemente αi , i = 0, . . . , n−1. Damit hat das Polynom xn −1 genau n verschiedene Linearfaktoren (x−αi ) und kann als deren Produkt dargestellt werden, d. h.:

3.1 Definition von RS-Codes

51

Satz 3.6 (Linearfaktoren von (xn − 1)) Sei α ∈ GF (p) ein Element der Ordnung n, so gilt: xn − 1 =

n−1 Y i=0

(x − αi ).

Beispiel 3.1 (Reed-Solomon-Code) Mit GF (7) wollen wir einen RS-Code konstruieren, der die Mindestdistanz d = 5 hat. Wir benötigen ein Element der Ordnung 6, also ein primitives Element von GF (7), und Polynome A(x) vom Grad k − 1 ≤ n − d = 1, d. h. k = 2.

Zunächst prüfen wir nach, ob α = 5 ein primitives Element von GF (7) ist: 51 = 5, 52 = 25 = 4, 53 = 25 · 5 = 4 · 5 = 20 = 6. Wir könnten eigentlich hier abbrechen, denn 5 ist ein primitives Element, da gemäß Satz 2.11 die Ordnungen Teiler von p − 1 = 6 sein müssen, d. h. 2, 3 oder 6. Der Vollständigkeit halber: 54 = 30 = 2, 55 = 10 = 3, 56 = 15 = 1. Es sei nochmals darauf hingewiesen, dass die Exponenten mod(p − 1) zu rechnen sind, z. B.: 59 = 54 · 55 = 2 · 3 = 6 = 59 mod 6 = 53 = 6 6= 59 mod 7 = 52 = 4.

Die Codewörter c(x) des RS-Codes erhalten wir durch die Vorschrift ci = C(αi ), C(x) = C0 + C1 x mit C0 , C1 ∈ GF (7). Es existieren pk = 7 · 7 = 49 verschiedene C(x) und somit 49 Codewörter. Wir wollen eines davon berechnen. Wir wählen C(x) = 5 + 3x: c0 c1 c2 c3 c4 c5 =⇒

3.1.3

C(α0 ) C(α1 ) C(α2 ) C(α3 ) C(α4 ) C(α5 )

= = = = = =

= = = = = =

C(1) C(5) C(4) C(6) C(2) C(3)

= = = = = =

c = (1, 6, 3, 2, 4, 0).

5+ 3 5+3 · 5 5+3 · 4 5+3 · 6 5+3 · 2 5+3 · 3

= = = = = =

1 mod 7 6 mod 7 3 mod 7 2 mod 7 4 mod 7 0 mod 7 

Generatorpolynom

Ein RS-Code der Länge n, der Dimension k und der Mindestdistanz d = n − k + 1 wird definiert durch alle (Informations-) Polynome i(x) vom Grad < k. Die Codewörter können durch Multiplikation mit dem Generatorpolynom berechnet werden: c(x) = i(x) · g(x), grad g(x) = n − k. Jedes Codewort c(x) muss durch g(x) teilbar sein, denn ein RS-Code ist definiert durch die Menge der Polynome C(x) vom Grad ≤ k − 1, d. h. Ci = 0 für k ≤ i ≤ n − 1. Entsprechend der Transformationsvorschrift von Definition 3.1 gilt: Ci = n−1 · c(α−i ) = 0 für k ≤ i ≤ n − 1.

Das Codewort c(x) muss daher an den Stellen α−i für alle i : k ≤ i ≤ n − 1 Nullstellen besitzen, d. h. die Linearfaktoren (x−α−i ) enthalten. Das Produkt dieser Linearfaktoren ist gerade das Generatorpolynom g(x) vom Grad n − k: g(x) =

n−1 Y i=k

(x − α−i ) .

52

3 Reed-Solomon-Codes

Ein RS-Code ist zyklisch, denn für c(x) ∈ C gilt: x · c(x) = x · i(x) · g(x) = i0 (x) · g(x) mod (xn − 1) ∈ C.

Beide Eigenschaften folgen auch direkt aus dem Faltungssatz 3.2. Es gilt Gi = 0, i = k, . . . , n − 1. Damit gilt für jedes Polynom I(x), dass das Polynom C(x), das durch Cj = Gj Ij , j = 0, . . . , n − 1 berechnet wird, vom Grad ≤ k − 1 ist. Ferner korrespondiert dies gemäß Faltungssatz mit c(x) = i(x)g(x) mod (xn − 1). Des Weiteren können wir einen zyklischen Shift schreiben als c˜(x) = x` c(x) mod (xn − 1), was gemäß Faltungssatz korrespondiert mit C˜i = Ci αi` . Da die Koeffizienten αi` der Transformierten ˜ des Polynoms x` alle ungleich 0 sind, entspricht C(x) einem gültigen Codewort, den ˜ Ci = 0, i = k, . . . , n − 1, da Ci an diesen Stellen gleich 0 ist. Anmerkung: Da grad g(x) = n − k ist und es genau so viele verschiedene Nullstellen besitzt sind alle n − (n − k) = k Koeffizienten Gi 6= 0, i = 0, . . . , k − 1.

Beispiel 3.2 (Generatorpolynom) Das Generatorpolynom des RS-Codes von Beispiel 3.1 errechnet sich als (α = 5: primitives Element von GF (7)): Ai = 0, i = 2, 3, 4, 5, g(x) =

5 Y

(x − α−i )

i=2

˛ = (x − α−2 )(x − α−3 )(x − α−4 )(x − α−5 ) ˛ mod 6 (für Exp.) = (x − α4 )(x − α3 )(x − α2 )(x − α)

= (x2 − (α4 + α3 )x + α7 )(x2 − (α2 + α)x + α3 ) = (x2 − x + 5)(x2 − 2x + 6)

˛ = x4 − x3 + 5x2 − 2x3 + 2x2 − 10x + 6x2 − 6x + 30 ˛ mod 7 (für Koeff.)

g(x) = x4 + 4x3 + 6x2 + 5x + 2.

Das Codewort c(x) von Beispiel 3.1 muss durch g(x) teilbar sein, also c(x) : g(x) = i(x): 4x4 + 2x3 + 3x2 + 6x + 1 : x4 + 4x3 + 6x2 + 5x + 2 = 4 4x4 + 2x3 + 3x2 + 6x + 1 0 Also ist c(x) = 4 · g(x) , i(x) = 4 + 0 · x.

3.1.4



Prüfpolynom

Das Prüfpolynom h(x) wird abgeleitet durch die Beziehung c(x) · h(x) = 0 mod (xn − 1) für alle c(x) ∈ C . Wendet man darauf die Korrespondenz den Faltungssatz 3.2 an, so ergibt sich: Ci · Hi = 0, i = 0, 1, . . . n − 1, h(x) b rb H(x).

(3.5)

Hi muss genau an den Stellen 0 sein, an denen Ci ungleich 0 ist, bzw. sein kann. Entsprechend den Überlegungen zum Generatorpolynom ist das Prüfpolynom h(x) berechenbar durch: h(x) =

k−1 Y i=0

(x − α−i ) , grad h(x) = k.

3.1 Definition von RS-Codes

53

Da die Nullstellen von g(x) und h(x) disjunkt sind und alle möglichen αi enthalten, gilt gemäß Satz 3.6: g(x) · h(x) =

n−1 Y i=0

(x − α−i ) =

n−1 Y j=0

(x − αj ) = xn − 1.

Beispiel 3.3 (Prüfpolynom) Das Prüfpolynom h(x) des RS-Codes von Beispiels 3.1 ist: h(x) =

1 Y

(x − α−i ) = (x − α0 )(x − α−1 ) = (x − 1)(x − 3) = x2 + 3x + 3.

i=0

Für das Codewort c(x) = 4x4 + 2x3 + 3x2 + 6x + 1 muss gelten: c(x) · h(x) = 0 mod (x6 − 1). Also (4x4 + 2x3 + 3x2 + 6x + 1) · (x2 + 3x + 3) = 4x6 + 2x5 + 3x4 + 6x3 + x2 12x5 + 6x4 + 9x3 + 18x2 + 3x + 12x4 + 6x3 + 9x2 + 18x + 3 mod7 : ∗ 14 21 21 28 21 ∗ = = = = = 0 0 0 0 0

∗ x6 = 1, d. h. 4x6 = 4x0 muss zu 3 addiert werden. (4 + 3 = 7 = 0 mod 7).

3.1.5



Codierung

Mit dem Generator- und Prüfpolynom lassen sich 4 verschiedene Codiermethoden angeben. Zwei davon führen zu einer systematischen Codierung, d. h. Informations- und Prüfzeichen sind getrennt. Alle Methoden liefern ein und denselben Code, aber es werden denselben k Informationszeichen unterschiedliche Codewörter zugeordnet. Methode 1: (nicht-systematische Codierung) Die k Informationsstellen sind die Koeffizienten des Polynoms C(x) = C0 + C1 x + · · · + Ck−1 xk−1 ; das Codewort c(x) ergibt sich durch Rücktransformation. Methode 2: (nicht-systematische Codierung) Die k Informationsstellen sind die Koeffizienten des Polynoms i(x) = i0 + i1 x + · · · + ik−1 xk−1 ; das Codewort c(x) ergibt sich durch Multiplikation mit dem Generatorpolynom: c(x) = i(x) · g(x). Methode 3: (systematische Codierung) Die k Informationsstellen sind die Koeffizienten cn−k , cn−k+1 , . . . , cn−1 ; die n − k Prüfstellen werden wie folgt berechnet:  cn−1 xn−1 + · · · + cn−k xn−k : g(x) = i(x) + rest(x) c(x) = cn−1 xn−1 + · · · + cn−k xn−k − rest(x).

Methode 4: (systematische Codierung) Die k Informationsstellen sind die Koeffizienten cn−k , cn−k+1 , . . . , cn−1 ; die n − k Prüfstellen werden wie folgt berechnet: cj = −

k 1 X · cn−i+j · hi , j = 0, 1, . . . , n − k − 1. h0 i=1

Der Index n − i + j ist dabei mod n zu rechnen, und h(x) ist das Prüfpolynom.

54

3 Reed-Solomon-Codes

Bei der Decodierung in Abschnitt 3.2 wird sich zeigen, dass es für die Berechnung eines Fehlers unerheblich ist, welche Methode zur Codierung verwendet wurde. Selbstverständlich ist aber die Information nur unter Kenntnis der Methode aus einem Codewort wieder bestimmbar. Prinzipiell gelten diese Methoden für alle zyklischen Codes. Die Symbolfehlerrate in den Informationssymbolen hängt von der Abbildung der Information auf die Codeworte ab.

3.1.6

Zwei Eigenschaften zyklischer Codes

Wir wollen hier zwei Eigenschaften von zyklischen Codes beschreiben, die für das Verständnis der Decodierung im nächsten Abschnitt wichtig sind. Satz 3.7 (Lineare Abhängigkeit von zyklischen Shifts) Sei c(x) ein Codewort eines C(n, k, d = n − k + 1) RS-Code, bei dem alle k Koeffizienten im transformierten Bereich ungleich 0 sind, d.h. Cj 6= 0, j ∈ [0, k−1]. Dann gilt, dass k aufeinanderfolgende zylische Shifts von c(x) linear unabhängig sind. Sie stellen damit also eine Basis des Codes dar. Andererseits sind beliebige k + 1 zyklische Shifts von c(x) linear abhängig. Beweis: Entsprechend dem Faltungssatz 3.2 gilt, ein `-zyklischer Shift c(l) (x) des Codewortes c(x) ergibt c(l) (x) = x` c(x) mod (xn − 1) (l)

(l)

⇐⇒

(l)

Ci

= n−1 α−i` Ci , i ∈ [0, n − 1].

(l)

Deshalb können wir den Vektor (C0 , C1 , . . . , Ck−1 ) mit Koeffizienten 6= 0 schreiben als (l)

(l)

(l)

(C0 , C1 , . . . , Ck−1 ) = n−1 (α0 C0 , α−` C1 , . . . , α−`(k−1) Ck−1 ). Damit können wir die k verschiedenen transformierten Codeworte, die den k konsekutiven zyklischen Shifts c(l) (x) mit ` ∈ {`1 , `1 + 1, . . . `1 + k − 1} des Codewortes c(x) entsprechen, in eine Matrix schreiben 0 (l1 ) 1 0 1 (l ) (l1 ) C0 C1 1 . . . Ck−1 C0 0 . . . 0 (l1 +1) (l1 +1) B (l1 +1) C B C C1 . . . Ck−1 B C0 C B 0 C1 . . . 0 C −1 B C = n V B C, . .. B C .. @ A @ A . (l1 +k−1) (l1 +k−1) (l1 +k−1) 0 0 . . . C k−1 C0 C1 . . . Ck−1 wobei V eine (k × k) Vandermonde Matrix ist, für die gilt: 0

B α B V =B @

α−`1 0

α−`1

−(`1 +1)0

−(`1 +1)

α

.. .

α−(`1 +k−1)0 α−(`11 +k−1)

1 ... α−`1 (k−1) −(`1 +1)(k−1) C ... α C C. .. A . −(`1 +k−1)(k−1) ... α

Da die k Koeffizienten von C(x) alle 6= 0 sind und eine Vandermonde Matrix vollen Rang besitzt folgt, dass alle Matrizen vollen Rang k besitzen und damit sind die Zeilen linear unabhängig. Deshalb existiert keine Menge mit k Faktoren, so dass die Linearkombination der Zeilen 0 ergibt. Die zweite Aussage folgt aus der Tatsache, dass ein Code ein linearer Unterraum der Dimension k ist. Daher sind beliebige k + 1 Codeworte linear abhängig. 2

3.1 Definition von RS-Codes

55

Die folgende zweite Eigenschaft folgt aus der Tatsache, dass der Grad aller Codeworte ungleich des Nullcodewortes mindestens n − k sein muss, was dem Grad des Generatorpolynoms entspricht. Satz 3.8 (Aufeinanderfolgende Stellen gleich 0 in einem Codewort) Jedes Codewort c(x) ungleich dem Nullcodewort eines zyklischen (n, k) Codes kann nicht mehr als k − 1 aufeinanderfolgende Stellen gleich 0 besitzen. Beweis: Jedes Codewort c(x) 6= 0 ist ohne Rest durch das Generatorpolynom g(x) teilbar. Damit kann jedes Codewort als Produkt des Informationspolynoms i(x) und des Generatorpolynoms c(x) = i(x)g(x) mit grad i(x) < k dargestellt werden. Daher gilt: grad c(x) ≥ grad g(x) = n − k. Nehmen wir an ein Codewort a(x) würde existieren, welches k aufeinanderfolgende Koordinaten 0 besitzt. Da der Code zyklisch ist, können wir a(x) zyklisch verschieben in ein Polynom b(x) derart, dass die k aufeinanderfolgende Koordinaten bn−1 , . . . , bn−k gleich 0 sind. Jedoch besitzt dieses Polynom b(x) damit Grad kleiner als n − k und kann damit kein gültiges Codewort sein. 2

Anmerkung: Dieser Satz kann auch aus Theorem 1.8.1 in [Bla] abgeleitet werden. Weiterhin kann man die systematische Codierung mit dem Prüfpolynom (Methode 4 aus Abschnitt 3.1.5) mittels rückgekoppelten Schieberegister realisieren. Damit ergibt sich die Aussage, dass ein solches Schieberegister der Länge k nicht Sequenzen mit mehr als k − 1 aufeinanderfolgenden Nullen - oder aber die Allnullsequenz - produzieren kann. Der folgende Abschnitt kann beim ersten Lesen übersprungen und mit der Decodierung in Abschnitt 3.2 Seite 59 fortgefahren werden.

3.1.7

GRS-Codes und Erweiterungen von RS-Codes

Sei α ein Element der Ordnung n. Multiplizieren wir die Stellen ci eines Codewortes mit αib , b ∈ N0 , so erhalten wir einen anderen Code, der aber dieselbe Mindestdistanz hat, denn es gilt: Für C(x) rb

ci · αib = 0 ⇐⇒ ci = 0. b c(x) bedeutet dies:

ci · αib b

rb xb · C(x) mod (xn − 1),

also ein um b Stellen zyklisch verschobenes Polynom. Sei U (x) = xb · C(x) mod (xn − 1) so gilt: Ci = Ui+b ,

d. h. die Stellen Ci = 0 sind zyklisch verschoben (der Index i + b ist mod n zu rechnen). Definition 3.9 (RS-Code) Ein RS-Code der Dimension k, der Länge n und der Mindestdistanz d = n − k + 1 wird definiert durch u(x) b rb U (x) mit U (x) = xb · C(x) mod (xn − 1) und grad C(x) < k. C = {u(x) | u(x) b

rb U (x)}

56

3 Reed-Solomon-Codes

Sind bei einem RS-Code bei allen transformierten Codewörtern bestimmte d − 1 aufeinanderfolgende Stellen 0, dann ist die Mindestdistanz d. Dabei wird 0 und n gleichgesetzt, d. h. aufeinanderfolgend kann auch bedeuten: n − i, n − i + 1, . . . , n − 1, 0, 1, . . . , j. Die n unterschiedlichen Elemente, die wir mit einem Element aus GF (p) der Ordnung n erzeugen können, sollen in beliebiger Reihenfolge sortiert werden. Seien α0 , α1 , . . . , αn−1 solche n unterschiedlichen Elemente. Satz 3.10 (GRS-Code) Ein generalisierter RS-Code ist definiert durch CGRS = {c(x) | ci = βi · C(αi ), βi 6= 0, i = 0, 1, . . . , n − 1} ,

wobei βi ∈ GF (p), βi 6= 0, eine Menge von n Faktoren ist und C(x) = C0 + C1 x + · · · + Ck−1 xk−1 , Ci ∈ GF (p) ist. Der Code hat die Länge n, die Dimension k und die Mindestdistanz d = n − k + 1.

Beweis: Gemäß Satz 3.3 hat C(x) höchstens k − 1 Nullstellen, d. h. das Polynom c(x) hat mindestens n − k + 1 = d von Null verschiedene Stellen. Da die Faktoren βi 6= 0 sind, ändern sie an dem Gewicht von c(x) nichts. 2

Erweiterung von RS-Codes um eine StelleEs gibt RS-Codes C(n, k, d) über GF (p), die wie folgt um eine Stelle erweitert werden können: Satz 3.11 (Einfach erweiterter RS-Code) Es existieren RS-Codes C(n, k, d) über GF (p), c(x) ∈ C, die um eine Stelle cn erweitert werden können:   n−1 X Cerw = ci , i = 0, 1, . . . , n − 1, cn = − ci = −c(1) , i=0

wobei c(x) b rb C(x) = C0 + C1 x + · · · + Ck−1 xk−1 , Ci ∈ GF (p), ist. Der Code besitzt die Länge n + 1, die Dimension k und die Mindestdistanz d = n − k + 2: Cerw (n + 1, k, d + 1) = Cerw (p, k, n − k + 2).

Beweis: Sei c(x) ∈ C(n, k, d) ein Codewort mit minimalem Gewicht. Damit die Mindestdistanz des Codes Cerw gleich d+1 ist, muss cn 6= 0 sein (Mindestdistanz = Minimalgewicht bei linearen Codes). Es gilt −cn = c(x = 1) und c(x) = i(x) · g(x). Damit muss für c(1) = 0 entweder i(x = 1) = 0 oder g(x = 1) = 0 sein oder beide. Wir können den RS-Code gemäß Definition 3.9 so konstruieren, dass gilt: g(1) 6= 0. Falls i(1) gleich 0 wäre, könnten wir aber schreiben: i(x) = (x − 1) · ˜i(x) und damit c(x) = i(x) · g(x) = ˜i(x) · (x − 1) · g(x). Sei das Generatorpolynom des erweiterten Codes definiert als: g˜(x) = (x − 1) · g(x). Das Codepolynom c(x) ist teilbar durch das neue Generatorpolynom g˜(x). Damit gehört c(x) zu einem Code mit einem Generatorpolynom, das den Faktor (x − 1) enthält, und kann somit nicht Gewicht d haben, was der Voraussetzung widerspricht. 2

Mit der Definition der DFT kann man die Stelle cn auch definieren als −n · C(0), denn C0 = n−1 · c(1).

Die Erweiterung eines RS-Codes um eine Stelle führt zu einem nicht-zyklischen RSCode. Das ergibt sich aus der Tatsache, dass der Faktor (x − 1) sowohl im Informationspolynom als auch im Generatorpolynom auftauchen kann.

3.1 Definition von RS-Codes

57

Erweiterung von RS-Codes um zwei StellenZu der folgenden Beschreibung werden die Kenntnisse von Erweiterungskörpern (Abschnitt 2.5) und von nicht-primitiven BCHCodes (Abschnitt 4.2) vorausgesetzt. Wir werden zunächst einen nicht-primitiven BCH-Code der Länge n über dem Grundkörper GF (q) definieren. Dabei ist q = pm , d. h. GF (q) ist ein Prim- oder ein Erweiterungskörper. Sei GF (q l ) ein Erweiterungskörper und β ∈ GF (q l ) ein Element der Ordnung n. Die Kreisteilungsklassen sind definiert als Ki = {i · q j mod n, j = 0, 1, . . . , l − 1}.

Das Generatorpolynom des Codes C(n, k, d) über GF (q) ist definiert als (Abschnitt 4.2): Y [ g(x) = (x − β i ), M = Ki , i∈M

und die maximale Anzahl d − 1 aufeinanderfolgender Nullstellen von g(x) definiert die geplante Mindestdistanz d (designed distance). Für die Dimension k gilt: k = n − |M|. Ein zweifach erweiterter RS-Code hat die Parameter Cerw2 (n = q + 1, k, d), d. h. wir wählen n = q + 1, l = 2 und erhalten die speziellen Kreisteilungsklassen Ki = {i · q j mod q + 1, j = 0, 1}.

Man beachte, dass beim Rechnen mod (q + 1) gilt: a · q = q − a + 1 mod (q + 1). Bei einer Beschränkung auf gerade q folgt (dabei ist jeweils gezeigt, dass sich für j = 2 das gleiche Element wie für j = 0 ergibt): K0 = {0}

K1 = {1, q}, da 1 · q 2 : (q + 1) = q Rest − q, −q = 1 mod (q + 1)

K2 = {2, q − 1}, da 2q 2 : (q + 1) = 2q Rest − 2q, −2q = 2 mod (q + 1) K3 = {3, q − 2}, d 3q 2 = 3 mod (q + 1) .. .

Ein Code mit den Kreisteilungsklassen M = K0 ∪ K1 ∪ . . . ∪ Kt hat dann die geplante Mindestdistanz d = 2t + 2, da 2t + 1 aufeinanderfolgende Zahlen in M vorkommen, nämlich M = {q − t + 1, . . . , q − 1, q, 0, 1, 2, . . . , t}, |M| = 2t + 1. Außerdem hat ein Code mit den Kreisteilungsklassen M = {K q2 , K q2 −1 , . . . , K q2 −t+1 } die geplante Mindestdistanz d = 2t + 1 und |M| = 2t. Für ungerade q lässt sich die Mindestdistanz durch ähnliche Überlegungen finden. Für einen Faktor einer Kreisteilungsklasse des Generatorpolynoms errechnet man Y mi (x) = (x − αj ) = (x − αi )(x − αq−i+1 ) j∈Ki

= (x − αi )(x − α−i ) = x2 − x(αi + α−i ) + 1.

Anmerkung: Das Element (αi +α−i ) ist aufgrund der Trace-Funktion aus dem Grundkörper GF (q). Das Produkt über alle möglichen mi (x) ergibt xn − 1. Damit haben wir den folgenden Satz bewiesen:

58

3 Reed-Solomon-Codes

Satz 3.12 (Zweifach erweiterter RS-Code) Es existieren für RS-Codes der Länge n = 2m − 1 zweifach erweiterte zyklische Codes mit den Parametern Cerw2 (2m + 1, k, n − k + 3)

bzw.

Cerw2 (n + 2, k, d + 2).

Im Gegensatz zur einfachen Erweiterung von RS-Codes führt diese Methode der Erweiterung um zwei Stellen zu einem zyklischen RS-Code. Das folgende Beispiel aus [McWSl] soll veranschaulichen, wie solche zweifach erweiterten Codes konstruiert werden können. Beispiel 3.4 (Zweifach erweiterter RS-Code) Wir wollen einen Code der Länge n = 9 mit dem Alphabet GF (23 ) konstruieren. Dazu benutzen wir ein primitives Element η ∈ GF (26 ), denn 26 − 1 = 63, und 9 | 63, und 7 | 63. Das Element α = η 9 hat Ordnung 7 und kann damit als primitives Element von GF (23 ) benutzt werden. Dagegen ist das Element β = η 7 9-te Einheitswurzel, d. h. β ist ein Element der Ordnung 9. Es gilt: α = η 9 , α2 = η 18 , α3 = η 27 , α4 = η 36 , α5 = η 45 , α6 = η 54 , α7 = η 63 = 1,

und β = η 7 , β 9 = η 63 = 1. Die Kreisteilungsklassen errechnen sich zu Ki = {i · 8j mod 9, j = 0, 1},

i = 0, 1, 2, 3, 4.

Konkret ergeben sich die Werte: K0 = {0}, K1 = {1, 8}, K2 = {2, 7}, K3 = {3, 6}, K4 = {4, 5}. Weiterhin gelten folgende Zusammenhänge: β +β −1 = η 7 +η 56 = α5 , β 2 +β −2 = η 14 +η 49 = α3 β 3 + β −3 = η 21 + η 42 = α0 und β 4 + β −4 = η 28 + η 35 = α6 . Damit kann man x9 − 1 mit Elementen aus GF (23 ) faktorisieren, nämlich: x9 − 1 = (x − 1)(x2 + x + 1)(x2 + α3 x + 1)(x2 + α5 x + 1)(x2 + α6 x + 1). m

Das bedeutet, ein Polynom x2 +1 − 1 hat nur die Nullstellen 1 und die Paare β i , β −i entsprechend den Kreisteilungsklassen, d. h. nur quadratische Faktoren. Wir haben damit folgende Codes der Länge 9 konstruiert: Code

Generatorpolynom g(x)

C(9, 7, 3) C(9, 6, 4) C(9, 5, 5) C(9, 4, 6) C(9, 3, 7) C(9, 2, 8)

x2 + α 6 x + 1 (x − 1)(x2 + α5 x + 1) (x2 + x + 1)(x2 + α6 x + 1) (x − 1)(x2 + α3 x + 1)(x2 + α5 x + 1) (x2 + x + 1)(x2 + α3 x + 1)(x2 + α5 x + 1) (x − 1)(x2 + x + 1)(x2 + α3 x + 1)(x2 + α5 x + 1)



3.2 Algebraische Decodierung bis zur halben Mindestdistanz

3.2

59

Algebraische Decodierung bis zur halben Mindestdistanz

Wir wollen die bekannten algebraischen Decodieralgorithmen einheitlich beschreiben. Dazu werden wir zuerst den Fehler, seine Transformation und deren Eigenschaften analysieren. Wir werden zeigen, dass es sich bei dem Fehler um ein Codewort eines zyklischen Codes handelt, wobei die Codeworte in diesem Fall im transformierten Bereich liegen. Der zentrale Algorithmus zu den Beweisen der Eigenschaften ist der erweiterte Euklidische Algorithmus, der im Anhang A auf Seite 453 angegeben ist. Wir werden die bekannten Algorithmen in zwei Klassen unterteilen je nachdem, ob sie auf einem Generator- oder Prüfpolynom basieren. Prinzipiell wird die algebraische Decodierung in zwei Schritte aufgeteilt. Zunächst werden die Fehlerstellen berechnet und danach die Fehlerwerte an diesen Stellen, wobei der erste Schritt wesentlich schwieriger ist. Beginnen wollen wir mit einer Beschreibung der Grundidee der algebraischen Decodierung.

3.2.1

Prinzip der algebraischen Decodierung +

Abb. 3.1: Fehler bei der Übertragung.

Wir betrachten die Übertragung eines Codeworts c(x) eines q-nären Codes über einen qnären Kanal entsprechend Bild 3.1 und nehmen an, dass τ Fehler in den n Codesymbolen aufgetreten sind. Die fehlerhaften Stellen sind j1 , j2 , . . . , jτ und das Fehlerpolynom ist damit e(x) = ej1 xj1 + ej2 xj2 + · · · + ejτ xjτ mit Koeffizienten ungleich null (sonst wären weniger als τ Fehler aufgetreten). Wir empfangen das Polynom y(x) mit „Zeitbereich “

Transformierter Bereich

c(x)

C(x)

e(x)

E(x)

y(x)

Y (x)

Abb. 3.2: Idee der Fehlerkorrektur.

y(x) = c(x) + e(x). Wir kennen jedoch weder c(x) noch e(x), sondern nur den verwendeten Code C aus  dem c(x) stammt und das Empfangspolynom y(x). Wir wollen voraussetzen, dass τ ≤ d−1 2 Fehler aufgetreten sind. Um festzustellen, ob y(x) ein Codewort ist, berechnet man entsprechend Bild 3.2 die Transformierte Y (x) des Empfangspolynoms y(x) c(x) + e(x) = y(x) b rb Y (x) = C(x) + E(x)

60

3 Reed-Solomon-Codes

und prüft, ob Yk = · · · = Yn−1 = 0 gilt (hellgraue Stellen in Bild 3.2; die dunkelgrauen Stellen Y0 , . . . , Yk−1 sind E0 + C0 , . . . , Ek−1 + Ck−1 ). Ist e(x) = 0, so ist Y (x) = C(x), und die Koeffizienten Yk , . . . , Yn−1 sind gleich 0. Ist dagegen e(x) 6= 0, so gilt wegen Ck = · · · = Cn−1 = 0: Yi = Ei , i = k, k + 1, . . . , n − 1 . Das Polynom S(x) = S0 + S1 x + · · · + Sd−2 xd−2 mit S0 = Yk = Ek , S1 = Yk+1 = Ek+1 , . . . , Sd−2 = Yn−1 = En−1 wird auch als Syndrom bezeichnet und ist nur vom transformierten Fehler E(x) abhängig. Fehlerstellenpolynom: Es wird ein Fehlerstellenpolynom λ(x) definiert mit der Eigenschaft λi = 0 ⇐= ei 6= 0,

d. h. λi · ei = 0 .

Die Koeffizienten von λ(x) sind an den Fehlerstellen gleich 0 und an den Nicht-Fehlerstellen beliebig, da dort die Koeffizienten von e(x) gleich 0 sind. Damit ist eine Menge von Polynomen definiert. Aus dieser Menge wählt man nun diejenigen Polynome aus, für die grad Λ(x), λ(x) b rb Λ(x), gleich der Anzahl der Fehlerstellen ist. Das bedeutet, man fordert zusätzlich λi 6= 0 ⇐ ei = 0. Mit der Transformation von Definition 3.1 kann man λ(x) durch Λ(x) darstellen als:

Λ(x) =

Y

(x − αi ).

(3.6)

i∈{j1 ,...,jτ }

Der Grad von Λ(x) entspricht der Anzahl der Koeffizienten von λ(x), die gleich 0 sind, also die Anzahl der Fehlerstellen. Gelingt es, ein Λ(x) mit möglichst kleinem Grad zu berechnen, dann entsprechen die Fehlerstellen den Nullstellen von Λ(x). Gemäß Faltungssatz 3.2 gilt: λ i · ei = 0 b Für τ ≤

 d−1  2

rb Λ(x) · E(x) = 0 mod (xn − 1).

(3.7)

Fehler gilt für Λ(x) gemäß Gleichung (3.6):

Λ(x) = Λ0 + Λ1 · x1 + · · · + Λτ · xτ ,

also grad Λ(x) = τ . Man hat damit eigentlich τ + 1 Koeffizienten Λi , i = 0, 1, . . . , τ , zu bestimmen. Da man sich aber nur für die τ Nullstellen des Polynoms interessiert, ist ein beliebiger Koeffizient frei wählbar. In Gleichung (3.6) ist Λτ zu 1 gewählt. Eine Normierung verändert die Nullstellen von Λ(x) nicht.

3.2 Algebraische Decodierung bis zur halben Mindestdistanz

61

Wir schreiben die Polynommultiplikation Λ(x) · E(x) = 0 mod (xn − 1) in Matrixdarstellung und nehmen an, d sei ungerade und τ = (d − 1)/2: Λ0 E0 Λ0 E1 .. . Λ0 En−τ −1 ∗ Λ0 En−τ ∗ ∗ Λ0 En−2 ∗ Λ0 En−1

+ Λ1 En−1 + Λ1 E0 + + .. . + +

+ Λ2 En−2 + Λ2 En−1

Λ1 En−τ −2 + Λ2 En−τ −3 Λ1 En−τ −1 + Λ2 En−τ −2

+ . . . + Λt En−t + . . . + Λt En−t+1 .. . + . . . + Λτ En−2τ −1 + . . . + Λτ En−2τ

Λ1 En−3 Λ1 En−2

+ . . . + Λτ En−τ −2 + . . . + Λτ En−τ −1

+ Λ2 En−4 + Λ2 En−3

= 0 = 0 = = .. . = =

0 0

(3.8)

0 0.

Es gibt τ Gleichungen, die mit ∗ in Gleichung (3.8) markiert sind, in denen nur bekannte Koeffizienten von E(x) (auch Sydrom genannt) und τ unbekannte Koeffizienten Fehlerstellenpolynoms vorkommen. Denn der kleinste Koeffizient der mit ∗ markierten Gleichungen ist En−2τ = Ek und da gilt 2τ = d − 1 ist n − d + 1 = k. Wegen τ Gleichungen für τ Unbekannte ist das lineare Gleichungssystem (LGS) im Prinzip lösbar. Was passiert, wenn weniger Fehler aufgetreten sind und effiziente Algorithmen zur Berechnung von Λ(x), die gleichzeitig die Anzahl der Fehler liefern, werden wir in den folgenden Abschnitten ableiten. Ebenfalls werden wir dort auf die Berechnung der Fehlerwerte eingehen. Zunächst soll noch ein Beispiel für das Decodierprinzip angegeben werden. Beispiel 3.5 (Lösen des LGS) Wir wollen annehmen, das Codewort c(x) von Beispiel 3.1 sei gesendet worden und es sei ein Fehler e(x) = 5x4 + 3x aufgetreten. Mit c(x) = 4x4 + 2x3 + 3x2 + 6x + 1 wird dann y(x) = c(x) + e(x) = 2x4 + 2x3 + 3x2 + 2x + 1 empfangen. Wir kennen nur y(x) und den RS-Code, und wir berechnen nun die Stellen, an denen ein transformiertes Codewort 0 sein muss (α = 5 ist primitives Element): S0 = E2 = = = = = =

n−1 · r(α−2 ) = 6 · r(α4 ) 6 · (2 · α16 + 2α12 + 3α8 + 2α4 + 1) 6 · (2 · α4 + 2α0 + 3α2 + 2α4 + 1) 6 · (2 · 2 + 2 · 1 + 3 · 4 + 2 · 2 + 1) 6 · (4 + 2 + 12 + 4 + 1) = 6 · 23 5 mod 7

S1 = E3 = = = =

6 · r(α3 ) = 6 · (2 · α12 + 2α9 + 3α6 + 2α3 + 1) 6 · (2α0 + 2α3 + 3α0 + 2α3 + 1) 6 · (2 + 12 + 3 + 12 + 1) 5 mod 7.

Ferner ist S2 = E4 = 3 und S3 = E5 = 3. Damit ist der bekannte Teil des transformierten Fehlerpolynoms E(x) = . . . + 5x2 + 5x3 + 3x4 + 3x5 (das Syndrom ist damit S(x) = 5 + 5x + 3x2 + 3x3 ).

62

3 Reed-Solomon-Codes

Wir wollen annehmen, dass 2 Fehler aufgetreten sind: Λ(x) = Λ0 + Λ1 x + x2 . Damit können wir die Prüfgleichungen mit den bekannten Koeffizienten von E(x) angeben und das lineare Gleichungssystem lösen. E4 · Λ0 + E3 · Λ1 + E2 = 0 E5 · Λ0 + E4 · Λ1 + E3 = 0 9 3 · Λ0 + 5 · Λ1 + 5 = 0 = 2 · Λ1 = 0 Λ1 = 0 ; 3 · Λ0 + 3 · Λ1 + 5 = 0 Λ0 = 3

Λ(x) = 3 + x2 .

Die Fehlerstellen sind die 2 Nullstellen von Λ(x); wir probieren alle Elemente von GF (7) durch: 1: 2: 3: 4: 5:

3+1 3+4 3+9 3 + 16 3 + 25

= = = = =

4 0 mod 7 =⇒ 1. Nullstelle: 2 = α4 5 mod 7 5 mod 7 0 mod 7 =⇒ 2. Nullstelle: 5 = α1

Λ(x) = (x − 2) · (x − 5) = (x − α4 ) · (x − α1 ). Die Fehler sind also an der 1. und 4. Stelle, d. h. e(x) = e4 x4 + e1 x .

3.2.2



Der Fehler als zyklischer Code

Um Eigenschaften des Fehlers abzuleiten, werden wir im Folgenden so tun, als ob wir e(x) kennen. Die Transformation E(x) des Fehlerpolynoms e(x) kann als Codewort eines linearen zyklischen Codes betrachtet werden, den wir Fehlercode nennen wollen. Definition 3.13 (Fehlercode (n, τ )) Gegeben das Fehlerpolynom e(x) = ej1 xj1 + ej2 xj2 + · · · + ejτ xjτ , dann definieren diese Fehlerstellen einen (n, τ ) Code mit FehlerGeneratorpolynom Y Γ(x) = (x − αi ) i∈[0,n−1]\{j1 ,...,jτ }

und Fehler-Prüfpolynom Y Λ(x) =

i∈{j1 ,...jτ }

(x − αi ).

Satz 3.14 (Zyklischer Fehlercode) Die Transformierte E(x) des Fehlerpolynoms e(x) = ej1 xj1 + ej2 xj2 + · · · + ejτ xjτ ist ein Codewort des zyklischen (n, τ ) Fehlercodes mit dem Fehler-Prüfpolynom Λ(x) (auch als Fehlerstellenpolynom bezeichnet) und dem Fehler-Generatorpolynom Γ(x), mit Λ(x)Γ(x) = xn − 1. Alle Codeworte des Fehlercodes können durch Linearkombination von τ aufeinanderfolgenden zyklischen Shifts von E(x) berechnet werden: β0 E(x) + β1 xE(x) + β2 x2 E(x) + · · · + βτ −1 xτ −1 E(x) = Ei (x) = Ω(x)Γ(x),

3.2 Algebraische Decodierung bis zur halben Mindestdistanz

63

Tabelle 3.1: Analogie zwischen RS-Code und Fehlercode..

Transformiertes Codewort Codewort Generatorpolynom Prüfpolynom Faltungssatz (1) Faltungssatz (2)

RS-Code C(x) c(x) g(x) h(x) Ci Hi = 0 c(x)h(x) = 0

Fehlercode e(x) E(x) Γ(x) Λ(x) λi ei = 0 Λ(x)E(x) = 0

mit βi ∈ Fq und grad Ω(x) < τ . Weiterhin gilt die Prüfgleichung Ei (x)Λ(x) = 0 mod (xn − 1). Beweis: Da ei = 0 für i ∈ [0, n − 1] \ {j1 , . . . , jτ } gilt E(αi ) = 0 und deshalb teilt (x − αi ) das Fehlercodewort E(x). Da Γ(x) das Produkt aller n − τ Linearfaktoren ist, teilt Γ(x) das Fehlercodewort E(x) und damit gilt E(x) = Ω(x)Γ(x) mit grad Ω(x) < τ . Äquivalent zu Gleichung (3.5) kann jedes Fehlercodewort des Fehlercodes durch das FehlerPrüfpolynom Λ(x) (Fehlerstellenpolynom) mit Grad τ überprüft werden. Für λ(x) ergibt der Faltungssatz 3.2 λi ei = 0, i ∈ [0, n − 1]

⇐⇒

Λ(x)E(x) = 0 mod (xn − 1) = Ω(x)(xn − 1).

Diese Gleichung impliziert, dass grad Ω(x) < grad Λ(x) = τ , da grad E(x) ≤ n−1. Weil (xn −1) alle Elemente des Körpers als Nullstellen hat und Λ(x) alle Fehlerstellen als Nullstellen, teilt Λ(x) das Polynom (xn − 1) und wir erhalten E(x) = Ω(x)

(xn − 1) = Ω(x)Γ(x). Λ(x)

Aus Satz 3.7 folgt, dass die τ aufeinanderfolgenden zyklischen Shift eine Basis des Fehlercodes sind, da alle ei 6= 0 für i ∈ {j1 , . . . , jτ }. 2

In Tabelle 3.1 wird die Analogie zwischen RS-Codes und Fehlercodes zusammengefasst. Wie bei RS-Codes durch die Polynome C(x), werden bei dem Fehlercode alle Fehlercodeworte durch Transformation von eˆ(x) = eˆj1 xj1 + eˆj2 xj2 + . . . + eˆjτ xjτ mit eˆl ∈ Fq wobei auch Koeffizienten null erlaubt sind. Wir wollen die Tatsache herausstellen, dass jedes Fehlercodewort des Fehlercodes die Form E(x) = Ω(x)Γ(x)

⇐⇒

εi = γi ωi , i ∈ [0, n − 1],

besitzt, mit γi 6= 0, λi = 0, i ∈ {j1 , . . . , jτ } und γi = 0, λi 6= 0, i 6∈ {j1 , . . . , jτ }. Die beiden folgenden Sätze wurden bereits implizit bewiesen, sollen aber wegen ihrer Wichtigkeit für die Decodierung nochmals separat und spezifisch formuliert werden. Der erste Satz folgt direkt aus Satz 3.7 und wurde auch bereits als Teil von Satz 3.14 bewiesen.

64

3 Reed-Solomon-Codes

Satz 3.15 (Lineare Abhängigkeit zyklischer Shifts) Beliebige τ aufeinanderfolgende zyklische Shifts des Fehlercodeworts E(x), das die Transformation des Fehlerpolynoms e(x) mit τ Koeffizienten ungleich null ist, sind linear unabhängig. Damit existiert keine Linearkombination dieser Shifts die null ergibt. Andererseits sind τ + 1 verschiedene Shifts linear abhängig. Die Faktoren der Linearkombination von τ + 1 aufeinanderfolgende zyklische Shifts, die zu null addieren, sind genau die Koeffizienten des Fehlerstellenpolynoms Λ(x), da Λ(x)E(x) = 0 mod (xn − 1). Diese Gleichung kann geschrieben werden als: Λ0 E(x) = Λ0 (E0 + E1 x + E2 x2 + . . . + En−1 xn−1 ) mod (xn − 1) Λ1 xE(x) = Λ1 (En−1 + E0 x + E1 x2 + . . . + En−2 xn−1 ) mod (xn − 1) Λ2 x2 E(x) = Λ2 (En−2 + En−1 x + E0 x2 + . . . + En−3 xn−1 ) mod (xn − 1) .. .

Λτ xτ E(x) = Λτ (En−τ + En−τ +1 x + . . . + En−τ −1 xn−1 ) mod (xn − 1).

Satz 3.16 (Aufeinanderfolgende Nullen in Fehlercodeworten) Der Grad eines Fehlercodeworts E(x) ungleich null kann nicht kleiner als n − τ sein und es kann nicht mehr als τ − 1 aufeinanderfolgende Koeffizienten null besitzen.

3.2.3

Decodierung mit Fehler-Generatorpolynom

Wir werden den erweiterten Euklidischen Algorithmus (siehe Anhang A Seite 453 oder [BB08]) zur Fehlerkorrektur verwenden. Das Prinzip dieses Algorithmus ist, dass Fehlercodeworte des Fehlercodes derart addiert werden, dass der Grad des neuen entstehenden Fehlercodewortes (das dem Rest eines Divisionsschrittes entspricht) kleiner wird. Wenn der Iterationsschritt erreicht ist, bei dem der Grad des Restes < n − τ ist, besitzt das dem Rest entsprechende Fehlercodewort τ aufeinanderfolgende Koeffizienten gleich null. Entsprechend Satz 3.16 muss dies damit das Fehler-Nullcodewort sein und die entsprechende Linearkombination des Fehlercodewortes E(x) ist das Fehlerstellenpolynom. Wir werden nun im Folgenden diese Vorgehensweise genauer erläutern und beweisen. Satz 3.17 (Größter gemeinsamer Teiler von E(x) und (xn − 1)) Der größte gemeinsame Teiler von E(x) (Transformierte des Fehlerpolynoms e(x) mit τ Koeffizienten ungleich null; entspricht den τ Fehlern) und dem Polynom (xn − 1) ist Γ(x) mit Grad n − τ ggT (E(x), (xn − 1)) = Γ(x). Beweis: Aus Satz 3.14 fogt, dass Γ(x) das Fehlercodewort E(x) teilt. Da τ die Anzahl der Koeffizienten des Fehlerpolynoms e(x) ist, kann E(x) nicht mehr als n − τ unterschiedliche Faktoren (Nullstellen) (x − αi ) besitzen. Das Polynom (xn − 1) besitzt n unterschiedliche Nullstellen. 2

Wir werden nun den Euklidischen Algorithmus anwenden, zunächst unter der Annahme, dass wir E(x) vollständig kennen, also Y (x) = E(x) + 0. Später werden wir den

3.2 Algebraische Decodierung bis zur halben Mindestdistanz

65

realistischen Fall Y (x) = E(x)+C(x) betrachten, bei dem wir nur die Summe Y (x) und weder C(x) noch E(x) kennen. Der Euklidische Algorithmus führt folgende Iterationen aus: ˜ (−1) (x) = (xn − 1) = E(x)Q(1) (x) R ˜ (0) (x) = E(x) = R ˜ (1) (x)Q(2) (x) R (1) ˜ ˜ (2) (x)Q(3) (x) R (x) = R .. . ˜ (j) (x) = R ˜ (j+1) (x)Q(j+2) (x) R .. . ˜ (l) (x) = R ˜ (l+1) (x)Q(l+2) (x) R

+ + +

˜ (1) (x) R ˜ (2) (x) R ˜ (3) (x) R

˜ (j+2) (x) +R

(3.9)

+ 0.

Mit dem erweiterten Euklidischen Algorithmus kann jeder Rest als Kombination der ˜ (−1) (x) = (xn − 1) und R ˜ (0) (x) = E(x) und den Polynomen U (j) (x) und Polynome R (j) V (x) ausgedrückt werden. Letztere können durch die Rekursion ˜ (j) (x) = U ˜ (j−2) (x) − Q(j) (x)U ˜ (j−1) (x), U V˜ (j) (x) = V˜ (j−2) (x) − Q(j) (x)V˜ (j−1) (x),

˜ (−1) = 0, U ˜ (0) = 1 U V˜ (−1) = 1, V˜ (0) = 0

(3.10)

berechnet werden. Damit ergeben sich die Reste zu (V˜ (1) (x) = 1): (xn − 1) ˜ (0) (x) = E(x) R ˜ (1) (x) R ˜ (2) (x) R

= = = = .. .

0 · E(x) 1 · E(x) ˜ (1) (x)E(x) U ˜ (2) (x)E(x) U

+ + + +

1 · (xn − 1) 0 · (xn − 1) 1 · (xn − 1) V˜ (2) (x)(xn − 1)

(3.11)

˜ (l) (x) = U ˜ (l) (x)E(x) + V˜ (l) (x)(xn − 1) R ˜ (l+1) (x) = U ˜ (l+1) (x)E(x) + V˜ (l+1) (x)(xn − 1) R (l+2) ˜ ˜ (l+2) (x)E(x) + V˜ (l+2) (x)(xn − 1). R (x) = 0 = U ˜ (j) (x) sind Fehlercodeworte, da sie Additionen von Fehlercodeworten sind, Alle Reste R denn es gilt: ˜ (j) (x) = U ˜ (j) (x)E(x) + V˜ (j) (x)(xn − 1) = U ˜ (j) (x)E(x) mod (xn − 1). R Dies kann anders ausgedrückt werden durch ˜ (j) E(x) = U ˜ (j) (E0 + E1 x + E2 x2 + . . . + En−1 xn−1 ) mod (xn − 1) U 0 0 (j) ˜ xE(x) = U ˜ (j) (En−1 + E0 x + E1 x2 + . . . + En−2 xn−1 ) mod (xn − 1) U 1 1 ˜ (j) x2 E(x) = U ˜ (j) (En−2 + En−1 x + . . . + En−3 xn−1 ) mod (xn − 1) U 2 2 .. . (j) j ˜ ˜ (j) (En−τ + En−τ +1 x + . . . + En−τ −1 xn−1 ) mod (xn − 1). Uj x E(x) = U j

66

3 Reed-Solomon-Codes

˜ (j) (x) Fehlercodewort und entsprechend Satz 3.14 durch Γ(x) teilbar. Damit ist R ˜ (l+2) (x) = 0 = U ˜ (l+2) (x) · E(x) mod (xn − 1) bedeutet, dass der Rest Die Gleichung R (l+2) ˜ R (x) eine Linearkombination von mindestens τ +1 aufeinanderfolgenden zyklischen ˜ (l+2) (x) = τ , da Shifts des Fehlercodewortes E(x) ist. Mit Satz 3.15 erhalten wir grad U null nicht durch ≤ τ aufeinanderfolgende zyklische Shifts erhalten werden kann. Weil ˜ (l+1) (x) = ggT(E(x), xn − 1) = Γ(x) und mit der Eigenschaft der Grade des gilt R Euklidischen-Algorithmus (Gleichung (A.2) Seite 457) erhalten wir ˜ (l+1) (x) + grad U ˜ (l+2) (x) = grad R ˜ (−1) (x) = n grad R ˜ (l+2) (x) = n. =⇒ n − τ + grad U ˜ (l+2) (x) = τ . Gemäß Satz 3.17 besitzen das Fehlercodewort E(x) Deshalb gilt grad U und das Polynom (xn − 1) den größten gemeinsamen Teiler Γ(x) und daher muss gelten ˜ (l+2) (x) = Λ(x). U ˜ (l+2) (x) = Λ(x) ist, benutzt die Ein anderer Gedankengang um zu beweisen, dass U (l+1) ˜ Tatsache, dass der Rest R (x) = Γ(x) im Euklidischen Algorithmus alle Reste ˜ (i) (x), i ∈ [−1, l] teilt. Deshalb sind alle Reste Fehlercodeworte und wir können alle R Gleichungen durch Γ(x) teilen und erhalten (ohne die beiden ersten): ˜ (1) (x)Ω(x) Ω(1) (x) = U (2) ˜ (2) (x)Ω(x) Ω (x) = U .. . ˜ (l) (x)Ω(x) Ω(l) (x) = U (l+1) ˜ (l+1) (x)Ω(x) Ω0 =U ˜ (l+2) (x)Ω(x) 0=U

+ 1 · Λ(x) + V˜ (2) (x)Λ(x) + + +

V˜ (l) (x)Λ(x) V˜ (l+1) (x)Λ(x) V˜ (l+2) (x)Λ(x).

˜ (i) (x) und V˜ (i) (x) relativ prim sind (Gleichung (A.2) Seite 457), Da die Polynome U ˜ (l+2) (x) = Λ(x) und −V˜ (l+2) (x) = Ω(x) kann die letzte Gleichung nur gelten, wenn U ist. Damit haben wir den folgenden Satz bewiesen. Satz 3.18 (Decodierung mit dem Euklidischen Algorithmus (C(x) = 0)) Sei e(x) ein Fehlerpolynom mit τ ≤ d−1 Koeffizienten ungleich null und dessen Trans2 formierte E(x) = Ω(x)Γ(x) (Fehlercodewort). Der Euklidische Algorithmus berech˜ (l+1) (x), das Fehlernet in Gleichung (3.11) das Fehler-Generatorpolynom Γ(x) = R (l+2) ˜ Prüfpolynom Λ(x) = U (x) und das Fehler-Informationspolynom Ω(x) = −V˜ (l+2) (x). Anmerkung: Wir wollen die Eigenschaften des Fehler-Generatorpolynoms Γ(x) und der Reste veranschaulichen, indem wir unterschiedliche Fehleranzahlen annehmen. ˜ (1) (x) = 0, 1 Fehler: In diesem Fall ist der Grad von Γ(x) gleich n − 1 und somit ist R (1) ˜ (x) sicher kleiner als n − 1 ist. Entsprechend Satz 3.16 ist R ˜ (1) (x) da der Grad von R das Fehler-Nullcodewort. Da Λ(x) Grad 1 hat, benötigen wir einen Quotienten Q(1) (x) vom Grad 1, zu dessen Berechnung zwei bekannte Stellen des Fehlercodewortes E(x) erforderlich sind, nämlich Yn−1 und Yn−2 . Distanz d = 3 genügt in diesem Fall.

3.2 Algebraische Decodierung bis zur halben Mindestdistanz

67

˜ (1) (x) = βΓ(x), 2 Fehler: Der Grad von Γ(x) ist in diesem Fall n−2 und es muss gelten R (2) ˜ ˜ (2) (x) = 0. In da der Grad von R (x) bereits kleiner als n − 2 ist und damit gilt R diesem Fall ist es ausreichend, wenn die Mindestdistanz des RS-Codes d = 5 ist, denn dann kennen wir 4 Koeffizienten des Fehlercodewortes E(x), nämlich Yn−1 , Yn−2 , Yn−3 und Yn−4 . Damit können wir entweder einen Quotienten Q(1) (x) vom Grad 2 oder zwei Quotienten Q(1) (x) und Q(2) (x) jeweils vom Grad 1 berechnen. In beiden Fällen erhalten wir das Fehlerstellenpolynom Λ(x) vom Grad 2. ˜ (3) (x) = 0 3 Fehler: Hier ist der Grad von Γ(x) gleich n − 3. Dann ist entweder R (2) ˜ oder bereits R = 0, da der Grad des Restes um mehr als 1 kleiner werden kann. Man überlegt sich, dass man d = 7 benötigt, um Λ(x) zu berechnen. Nun werden wir Y (x) = E(x) durch das transformierte empfangene Polynom Y (x) = E(x) + C(x) austauschen und den folgenden Satz beweisen. Satz 3.19 (Decodierung mit dem erweiterten Euklidischen Algorithmus) Sei E(x) ein Fehlercodewort, das die Transformierte eines Fehlerpolynoms e(x) mit τ ≤ d−1 Koeffizienten ungleich null ist. Es gilt E(x) = Ω(x)Γ(x). Sei y(x) = c(x) + e(x) 2 empfangen, so kann die Transformation Y (x) = E(x) + C(x) berechnet werden. Die Berechnung von ggT(Y (x), (xn − 1)) wird abgebrochen, wenn grad R(l+1) (x) > k − 1 + grad U (l+1) (x) und grad R(l+2) (x) ≤ k − 1 + grad U (l+2) (x) ist. Dann gilt: U (l+2) (x) = Λ(x), R(l+2) (x) = Λ(x)C(x) und V (l+2) (x) = −Ω(x). Beweis: Der Beweis besteht darin, zu zeigen, dass die Berechnung von ggT(E(x), (xn − 1)) und ggT(Y (x), (xn − 1)) für τ ≤ d−1 die gleichen Quotienten ergibt und somit die gleichen 2 (j) (j) (j) ˜ ˜ Polynome U (x) = U (x) und V (x) = V (j) (x) und damit das gleiche Fehlerstellenpoly˜ (l+2) (x) = Λ(x). Dazu betrachten wir die Gleichung (3.11). Für alle j, für nom U (l+2) (x) = U (j) ˜ ˜ (j) (x)C(x), können wir R(j) (x) definieren durch die gilt: grad R (x) > grad U ˜ (j) (x) + U ˜ (j) (x)C(x) R(j) (x) = R ˜ (j) (x) > grad U ˜ (j) (x)C(x). Damit können wir auch (für diese wobei gilt: grad R(j) (x) = grad R j) zu den Gleichungen ˜ (j) (x) = U ˜ (j) (x)E(x) + V˜ (j) (x)(xn − 1) R ˜ (j) (x)C(x) addieren und erhalten aus Gleichung (3.11) auf der rechten Seite U Y (x)

R

(j)

z }| { ˜ (j) (x) (E(x) + C(x)) +V˜ (j) (x)(xn − 1). (x) = U

˜ (j) (x) > grad U ˜ (j) (x)C(x) gilt für j = 1, . . . , l + 1. Wir Nun werden wir zeigen, dass grad R ˜ (l+1) (x) = grad Γ(x) = n − τ haben bereits die zwei folgenden Beziehungen abgeleitet grad R ˜ (l+1) (x) < grad U ˜ (l+2) (x) = τ . Ferner ist grad C(x) ≤ k − 1 = n − d. Für d ≥ 2τ + 1 und grad U gilt deshalb: ˜ (l+1) (x) < n − d + τ ≤ n − τ − 1 grad C(x)U ˜ (l+1) (x). < n − τ = grad Γ(x) = grad R ˜ (j) (x)C(x) keinen Einfluss Damit haben wir bewiesen, dass für j = 1, . . . , l + 1 das Polynom U auf die Berechnung der Quotienten des größten gemeinsamen Teilers von Y (x) = E(x) + C(x)

68

3 Reed-Solomon-Codes

und (xn −1) hat. Somit sind die U (j) (x) und V (j) (x), die dadurch berechnet werden identisch zu denen, die durch Berechnung des größten gemeinsamen Teilers von Y (x) = E(x) und (xn − 1) ˜ (j) (x) und V (j) (x) = V˜ (j) (x). Dies ist offensichtlich, da der Quotient sind, also U (j) (x) = U (j) Q (x) durch die Division von R(j−2) (x) durch R(j−1) (x) bestimmt wird und grad R(j−2) (x) > ˜ (l+1) (x) gilt. grad R(j−1) (x) > grad R(j) (x) > grad C(x)U Nun betrachten wir noch den Schritt j = l + 2, also R(l+2) (x) = U (l+2) (x)(E(x) + C(x)) + V (l+2) (x) · (xn − 1).

(3.12)

Es gilt grad R(l+1) (x) + grad U (l+2) (x) = n und somit grad U (l+2) (x) = n − (n − τ ) = τ , da gilt ˜ (l+1) (x) = grad Γ(x) = n − τ . Satz 3.18 besagt: grad R(l+1) (x) = grad R ˜ (l+2) (x)E(x) + V˜ (l+2) (x) · (xn − 1). 0=U ≥n

Streichen wir die Koeffizienten bei den Exponenten x (3.13) modxn rechnen, erhalten wir

V

(l+2)

˜ (l+2) (x) V ˜ (l+2) (x) U (l+2)

(x)+R U (l+2) (x)

(x)

(3.13) , indem wir die Gleichungen (3.12) und

= E(x) mod xn = E(x) + C(x) mod xn .

Subtrahieren wir die erste von der zweiten Gleichung erhalten wir −

V˜ (l+2) (x) V (l+2) (x) + R(l+2) (x) + = C(x) mod xn . ˜ (l+2) (x) U (l+2) (x) U

Dies kann umgeformt werden zu ˜ (l+2) (x)(V (l+2) (x) + R(l+2) (x)) −V˜ (l+2) (x)U (l+2) (x) + U = C(x) mod xn . (l+2) ˜ U (x)U (l+2) (x) Beide Seiten mit dem Nenner multipliziert ergibt ˜ (l+2) (x)(V (l+2) (x) + R(l+2) (x)) − V˜ (l+2) (x)U (l+2) (x) + U

˜ (l+2) (x)U (l+2) (x)C(x), =U

˜ (l+2) (x)U (l+2) (x)C(x) ≤ 2τ + k − 1 < n und der wobei modxn nicht benötigt wird, da grad U ˜ (l+2) (x) < n ist. Da grad ggT(V˜ (l+2) (x), U ˜ (l+2) (x)) = 0 größte Grad der linken Seite R(l+2) (x)U (l+2) (l+2) (l+2) ˜ ist (relativ prim) muss gelten U (x) = U (x) = Λ(x) and V (x) = −Ω(x). Weiterhin ergibt Gleichung (3.12) R(l+2) (x) = Λ(x)(E(x) + C(x)) − Ω(x) · (xn − 1) = Λ(x)Ω(x)Γ(x) + Λ(x)C(x) − Ω(x)Λ(x)Γ(x) = Λ(x)C(x), was der Multiplikation des Fehlerstellenpolynoms mit dem gesendeten transformierten RSCodewort entspricht. 2

Bestimmen wir die Nullstellen von Λ(x), haben wir die Fehlerstellen berechnet. Um die Nullstellen zu finden setzt man einfach alle (endlich vielen) Werte von GF (p) in Λ(x) ein und erhält dann die Menge {j1 , . . . , jτ } der Fehlerstellen. Die Fehlerwerte sind ej` = Ω(αj` ) · Γ(αj` ), ` = 1, . . . , τ.

3.2 Algebraische Decodierung bis zur halben Mindestdistanz

69

Mit dem Euklidischen Algorithmus haben wir Ω(x) und Λ(x) berechnet und können Γ(x) = (xn − 1)/Λ(x) berechnen. Mit dem sogenannten Forney-Algorithmus ist diese Division jedoch nicht notwendig. Dazu schreiben wir das Fehler-Generatorpolynom als Bruch und erhalten Ω(x)(xn − 1) ej` = . Λ(x) x=αj` Dabei existiert jedoch das Problem, dass Λ(αj` ) = 0 für Fehlerstellen und xn − 1 = 0 für alle Elemente des Galois-Feldes ist und damit sowohl Zähler als auch Nenner 0 sind, d.h. „0“ „0“ . Nach der Regel von L’Hospital kann der Wert durch Ableiten von Zähler und Nenner bestimmt werden.Es gilt: (Ω(x) · (xn − 1))0 = Ω0 (x)(xn − 1) + Ω(x) · n · xn−1 = Ω(x) · n · x−1 , ∀ αi ∈ GF (p).

Damit erhalten wir die Berechnungsvorschrift der Fehlerwerte zu Ω(x)nx−1 ej` = . Λ0 (x) x=αj`

Eine Alternative Fehlerwertberechnung basiert auf der Tatsache, dass der Euklidische Algorithmus R(l+2) (x) = Λ(x)C(x) liefert. Damit können wir den Werte des gesendeten RS-Codewortes direkt berechnen durch R(l+2) (x) cj` = , ` = 1, . . . , τ. Λ(x) x=αj` Die Fehlerwerte sind dann ej` = yj` − cj` .

Anmerkung: Praktisch wird man den Teil des Polynoms Y0 , . . . , Yk−1 bei der Division nicht berücksichtigen. Hierzu wird in Abschnitt 3.2.5 gezeigt, wie nur mit Polynomen mit Graden d−1 und d−2 gerechnet werden kann. Üblicherweise wird der bekannte Teil des Fehlercodewortes als Syndrom S(x) vom Grad d − 2 bezeichnet, mit S0 = Ek , S1 = Ek+1 , . . . , Sd−2 = En−1 . Beispiel 3.6 (Erweiterter Euklidischer Algorithmus) Wir betrachten erneut das transformierte Polynom Y (x) aus Beispiel 3.5 auf Seite 61. Wir berechnen zuerst die Quotienten R(−1) (x) = (x6 − 1) = (3x5 + 3x4 + 5x3 + 5x2 + ∼)(5x + 2) + 4x4 + ∼ und R(0) (x) = (3x5 + 3x4 + 5x3 + 5x2 + ∼) = (4x4 + ∼)(6x + 6)+ ∼ . Mit diesen Quotienten Q(1) (x) = 5x + 2 und Q(x) (x) = 6x + 6 können wir die Polynome U (i) (x) und V (i) (x) berechnen. Die erste Berechnung ergibt U (1) (x) = −(5x + 2) = 2x + 5 und V (1) (x) = 1. Die zweite U (2) (x) = 1−(6x+6)(2x+5) = 2x2 +6 und V (2) (x) = 0−(6x+6)(1) = x + 1. Wir können jeden Rest als Linearkombination darstellen: 4x4 + ∼ = (2x + 5)(3x5 + 3x4 + 5x3 + 5x2 + ∼) + 1 · (x6 − 1) ∼ = (2x2 + 6)(3x5 + 3x4 + 5x3 + 5x2 + ∼) + (x + 1)(x6 − 1).

70

3 Reed-Solomon-Codes

Wir erhalten U (2) (x) = Λ(x) = 2x2 + 6 und −V (2) (x) = Ω(x) = 6x + 6. Wir können Γ(x) berechnen zu (x6 − 1) : Λ(x) = 4x4 + 2x2 + 1.

Die Nullstellen von Λ(x) sind α4 = 2 und α1 = 5, da gilt 2 · 22 + 6 = 0 und 2 · 52 + 6 = 0. Die Fehlerwerte erhalten wir durch Auswertung von Ω(x)Γ(x) an den Fehlerstellen. Es gilt Ω(2)Γ(2) = 5 und Ω(5)Γ(5) = 3. Damit ist das Fehlerpolynom e(x) = 5x4 + 3x. Wir können die Fehlerwerte auch mit dem Forney-Algorithmus berechnen. Die Ableitung von Λ(x) = 2x2 + 6 ist 4x und damit 6x5 Ω(x)/4x = 5x4 (6x + 6). Ausgewertet an den Stellen 2 und 5 ergibt: 5 und 3. 

3.2.4

Decodierung mit Fehler-Prüfpolynom

Wir nehmen erneut an, dass τ ≤ (d − 1)/2 = e Fehler aufgetreten sind und bezeichnen die halbe Mindestdistanz mit e. Entsprechend der Methode 4 von Abschnitt 3.1.5 kann ein zyklischer Code durch das Prüfpolynom codiert werden. Dazu müssen k = grad h(x) aufeinanderfolgende Informationsstellen bekannt sein. Analog dazu kann das Fehlercodewort E(x) durch das Fehler-Prüfpolynom Λ(x) mit Grad τ codiert werden. Hier ist das Problem jedoch, dass d − 1 aufeinanderfolgende Stellen des Fehlercodewortes E(x) bekannt sind, das Fehler-Prüfpolynom Λ(x) jedoch nicht. Die Codiervorschrift lautet explizit: Ei = −

τ 1 X Ei−j Λj , i = [k + τ, n − 1]. Λ0 j=1

(3.14)

In Satz 3.15 wurde bewiesen, dass eine Codierung mit einem Polynom Λ(x) vom Grad < τ nicht möglich ist, da die Prüfgleichung nicht erfüllt werden kann. Offensichtlich ist die Codiervorschrift aus der Prüfgleichung Λ(x)E(x) = 0 mod (xn − 1) bzw. 0 = Ei Λ0 +

τ X j=1

Ei−j Λj , i ∈ [0, n − 1]

abgeleitet, wobei die Indizes modn berechnet werden. Es sei nochmals darauf hingewiesen, dass für den hypothetischen Fall der Codierung Λ(x) und τ Koeffizienten des Fehlercodewortes bekannt sind und damit werden ≥ τ unbekannte Koeffizienten des Fehlercodewortes berechnet. Im Gegensatz dazu sind für die Decodierung 2τ Koeffizienten des Fehlercodewortes bekannt und Λ(x) ist unbekannt. Für τ ≤ e kann man jedoch Λ(x) aus den 2e bekannten Koeffizienten berechnen, wie wir im Folgenden zeigen werden. Die Algorithmen in Abschnitt 3.2.6 stellen Varianten dieses Prinzips dar. Die Strategie des folgenden Decodierverfahrens ist, zyklische Shifts des Fehlercodewortes E(x) linear zu kombinieren, derart, dass die Anzahl l aufeinanderfolgender Koeffizienten null, im neu kreierten Fehlercodeword zunimmt. Wenn wir l = τ aufeinanderfolgender Koeffizienten null erreicht haben, muss das kreierte Fehlercodewort entsprechend Satz 3.16 das Nullcodewort sein. Die Linearkombination, die dazu geführt hat, entspricht Λ(x). Wir werden die Koeffizienten k + e bis k + e + l − 1 zu null setzen, indem wir aufeinanderfolgende zyklische Shifts des Fehlercodewortes E(x) entsprechend gewichtet addieren. Wenn wir l = τ aufeinanderfolgende Nullen errechnet haben, so sind die Koeffizienten von k + e + l zu n − 1 ebenfalls null.

3.2 Algebraische Decodierung bis zur halben Mindestdistanz

71

Tabelle 3.2: Berechnung aufeinanderfolgender Nullen für lz = lu + 1. .

xk+e−2

xk+e−1 (lu ) Ek+e−1 (lz ) Ek+e−1

xk+e

...

xk+e+lu −1

xk+e+lu

xk+e+lz

xk+e+lz +1

(lu ) Ek+e+l u +1 (lz ) Ek+e+l z (lz ) Ek+e+l z +1 ˆ (lz ) E k+e+lz

(lu ) Ek+e+l u +2 (lz ) Ek+e+l z +1 (lz ) Ek+e+l z +2 ˆ (lz ) E k+e+lz +1 (lz +1) Ek+e+l z +1

0

...

0

(lu ) Ek+e+l u

0

...

0

0

0

0

...

0

z Ek+e+l z

...

ˆ (lz ) E k+e−1

0

...

0

0

...

z Ek+e−1

0

...

0

0

.

...

.

...

.

z Ek+e−1

. .

(l )

(l +1)

(l )

0

. . . . . .

Im Folgenden werden wir nicht mod(xn − 1) rechnen. Sei E (l) (x) = L(l) (x)E(x) ein Fehlercodewort, das l aufeinanderfolgende Koeffizienten gleich null besitzt, beginnend (l) (l) (l) (l) bei (k + e), also Ek+e = Ek+e+1 = . . . = Ek+e+l−1 = 0 und Ek+e+l 6= 0. Wir nennen L(l) (x) = Lml xml + Lml +1 xml +1 + . . . + Le xe das assoziierte Polynom mit Koeffizienten von ml bis e = (d−1)/2. Der kleinste Koeffizient des assoziierten Polynoms, der ungleich null ist, ist also Lml . Damit ist das Fehlercodewort E (l) (x) die Linearkombination von e − ml + 1 aufeinanderfolgenden Shifts des Fehlercodewortes E(x), also E (l) (x) = Le xe E(x) + . . . + Lml +1 xml +1 E(x) + Lml xml E(x). Die Anzahl der aufeinanderfolgenden Nullen in E (l) (x), die mit den e − ml + 1 aufeinanderfolgenden Shifts kreiert werden kann, ist ≥ e − ml .

Nehmen wir an, wir hätten zwei solcher Fehlercodeworte E (lu ) (x) = L(lu ) (x)E(x) und E (lz ) (x) = L(lz ) (x)E(x), wobei gelten soll lu < lz und für den kleinsten Koeffizienten ungleich null gilt mz < mu (was später klar sein wird). Wir wollen nun zeigen, wie mit diesen beiden Fehlercodeworten ein neues Fehlercodewort berechnet werden kann, das mehr aufeinanderfolgende Koeffizienten null besitzt. Wir wollen dabei zwei Fälle unterscheiden, nämlich lz = lu + 1 und lz > lu + 1. Wir beginnen mit dem ersten Fall, der in Tabelle 3.2 illustriert ist. In der ersten Zeile sind die Exponenten von x angegeben. Die zweite Zeile zeigt E (lu ) (x) und die dritte E (lz ) (x). Das Fehlercodewort x−1 E (lz ) (x), das einem zyklischen Shift um eine Stelle nach links (x−1 ) des Fehlercodewortes E (lz ) (x) (dritte Zeile) entspricht, ist in der vierten Zeile angegeben. Wir können nun die zweite und vierte Zeile mit einem entsprechenden Faktor addieren und erhalten das Fehlercoˆ (lz ) (x). Nun addieren wir die dritte und die fünfte Zeile mit dewort der fünften Zeile E einem entsprechenden Faktor und erhalten das Ergebnis E (lz +1) (x) = L(lz +1) (x)E(x) (Zeile 6) mit mindestens lz + 1 aufeinanderfolgenden Koeffizienten null an den Stellen k + e bis k + e + lz . Damit haben wir gezeigt, dass wir mit zwei gegebenen Fehlercodeworten mit lz = lu + 1 und lu aufeinanderfolgenden Koeffizienten gleich null immer ein neues Fehlercodewort mit mindestens lz + 1 Nullen berechnen können. Wir wollen nun die Berechnung von E (lz +1) (x) = L(lz +1) (x)E(x) angeben. Das Zwischenpolynom ist ˆ (lz ) (x) = − E

(l )

u Ek+e+l u

(l )

z Ek+e+l z

x−1 E (lz ) (x) + E (lu ) (x)

72

3 Reed-Solomon-Codes Tabelle 3.3: Berechnung aufeinanderfolgender Nullen für lz > lu + 1.

.

xk+e

..

xk+e+lu −1

xk+e+lu

.

0

..

0

(lu ) Ek+e+l u

.

0

..

0

0

.

0

..

0

z Ek+e+l z

(l )

. . .

...

xk+e+lz −1

xk+e+lz

xk+e+lz +1

...

(lu ) Ek+e+l z −1

...

0

(lu ) Ek+e+l z (lz ) Ek+e+l z

(lu ) Ek+e+l z +1 (lz ) Ek+e+l z +1

(l )

z Ek+e+l z +1

..

. . .

...

. (l )

(l )

.

0

..

0

0

...

z Ek+e+l z

z Ek+e+l z +1

...

.

0

..

0

0

...

0

0

z Ek+e+l z +1

(l +1)

.

und das Ergebnispolynom ist (l )

E

(lz +1)

E z z (lz ) ˆ (x) + E (lz ) (x). (x) = − k+e+l E ˆ (lz ) E k+e+lz

Die entsprechenden assoziierten Polynome sind: ˆ (lz ) (x) = − L

(l )

u Ek+e+l u

(l )

z Ek+e+l z

x−1 L(lz ) (x) + L(lu ) (x)

und (l )

L(lz +1) (x) = −

z Ek+e+l ˆ (lz ) (x) + L(lz ) (x). L ˆ (lz ) E

k+e+lz

Der kleinste Koeffizient 6= 0 des assoziierten Polynoms ist mlz +1 = mlz − 1 und damit wird ein zusätzlicher zyklischer Shift des Fehlercodewortes E(x) benutzt. Der Koeffizient (lz +1) Ek+e+l = 0, jedoch können zusätzliche Koeffizienten null sein. Es können jz Koeffiziz (l +1)

z enten null sein, d.h. Ek+e+l = 0, i = 1, 2, . . . , jz . Dies führt zu unserem zweiten Fall z +i lz > lu + 1.

Anmerkung: Theorem 3 im Beweis des Berlekamp-Massey Algorithmus in [Mas69], ist äquivalent zu der beschriebenen Nullenerzeugung. Dieses Theorem ist bekannt als two wrongs make a right. Dieser Name beschreibt die Tatsache, dass aus zwei assoziierten Polynomen, die nicht k + e + lz Nullen erzeugen können, ein neues erzeugt wird, das k + e + lz Nullen erzeugen kann. Die zweite Zeile der Tabelle 3.3 ist E (lu ) (x) und die dritte E (lz ) (x). Man erkennt deutlich, dass wir die Shifts x−(lz −lu ) , . . . , x−1 , x0 des Fehlercodewortes E (lz ) (x) benötigen, damit das Ergebnis (letzte Zeile) mindestens lz + 1 aufeinanderfolgende Nullen besitzt. Der kleinste nichtverschwindende Koeffizient von L(lz +1) (x) ist mz − (lz − lu ). Anmerkung: Im Beweis des Berlekamp-Massey Algorithmus in [Mas69], entsprechen Theorem 1 und Lemma 1 dem beschriebenen Fall. Dort wird mit einem Hilfspolynom gearbeitet, das zählt, wie viele Nullen mehr erzeugt werden. Da wir mit negativen

3.2 Algebraische Decodierung bis zur halben Mindestdistanz

73

Shifts arbeiten, ergibt sich eine natürliche Erklärung für die zusätzlichen Shifts, die benötigt werden, wenn die zwei Polynome sich um mehr als einen Koeffizienten null unterscheiden. Damit können wir einen Algorithmus angeben, der ein Fehlercodewort E (jz ) (x) erzeugt mit jz > lz aufeinanderfolgenden Nullen, gegeben zwei Fehlercodeworte mit lu < lz Nullen (k+e ist der erste Koeffizient null). Unser erste beschriebener Fall liegt vor, wenn lz − lu = 1 ist, ansonsten der zweite Fall. Der Index des kleinsten Koeffizienten ungleich null von L(lu ) (x) und L(lz ) (x) werden mit mu und mz bezeichnet. Der Algorithmus berechnet das assoziierte Polynom L(lj ) (x) und sein mj , also wird folgende Abbildung berechnet   EX0 E (lu ) (x), L(lu ) (x), mu , E (lz ) (x), L(lz ) (x), mz   −→ E (lj ) (x), L(lj ) (x), mj . (3.15) “ ” Algorithmus 3.1: EX0 E (lu ) (x), L(lu ) (x), mu , E (lz ) (x), L(lz ) (x), mz .

Input: E (lu ) (x), L(lu ) (x), mu , E (lz ) (x), L(lz ) (x), mz



Initialization: j = lz − lu maximal benötigter Shift nach links i = 0 ein Zähler von 0 bis j. (lz ) A(x) = −(Ek+e+l )−1 E (lz ) (x), damit Ak+e+lz = −1 z (l )

z LA (x) = −(Ek+e+l )−1 L(lz ) (x). z B (0) (x) = E (lu ) (x) (0) LB (x) = L(lu ) (x) while i ≤ j do   (i) B (i+1) (x) = x−j+i Bk+e+lu +i A(x) + B (i) (x)   (i+1) (i) (i) LB (x) = x−j+i Bk+e+lu +i LA (x) + LB (x) i=i+1

(j)

(j)

(j)

Output: Find lj : lz < lj ≤ e such that Bk+e+lz = . . . = Bk+e+lj −1 = 0 and Bk+e+lj 6= 0. Der Index des kleinsten Koeffizienten ungleich null mj = mz − j. Setze (j)

E (lj ) (x) = B (j) (x), L(lj ) (x) = LB (x).

Gemäß Satz 3.16 können bei τ Fehlern mit 0 < τ ≤ e nicht alle Koeffizienten Ek+e bis En−1 gleichzeitig null sein, da der Abstand zwischen zwei nichtverschwindenen Koeffizienten τ ≤ e sein muss. Damit können wir den Algorithmus formulieren.

74

3 Reed-Solomon-Codes

Algorithmus 3.2: Decodieralgorithmus durch Linearkombination von Fehlercodeworten.

Input: Ek = Yk , . . . , Ek+e = Yk+e , . . . , En−1 = Yn−1 Initialisierung: if Ek = 0 then Berechne lz , mit Ek+1 = . . . = Ek+lz −1 = 0 und Ek+lz 6= 0, setze dann lu = 0, E (lu ) (x) = xe−lz −1 E(x), L(lu ) (x) = xe−lz −1 , mu = e − lz + 1, E (lz ) (x) = xe E(x), mz = e und L(lz ) (x) = xe , else if Ek+1 6= 0 then lu = 0, E (lu ) (x) = xe E(x), L(lu ) (x) = xe , mu = e, E (1) (x) = xe E(x) − (1) (1) (1) Ek e−1 E(x). Berechne lz , mit Ek+1 = . . . = Ek+lz −1 = 0 und Ek+lz 6= 0, Ek+1 x setze dann E (lz ) (x) = E (1) (x), L(lz ) (x) = xe −

Ek e−1 Ek+1 x

und mz = e − 1.

else (1) Berechne lz mit Ek+1 = . . . = Ek+lz −1 = 0 und Ek+lz 6= 0, setze dann lu = 0, E (lu ) (x) = xe E(x), E (lz ) (x) = xe−1 E(x), L(lu ) (x) = xe , mu = e L(lz ) (x) = xe−1 , and mz = e − 1 .

while lz < e and k + e + lz 6= n do   EX0 E (lu ) (x), L(lu ) (x), mu , E (lz ) (x), L(lz ) (x).mz −→ E (lj ) (x), L(lj ) (x), mj lu = lz , E (lu ) (x) = E (lz ) (x), L(lu ) (x) = L(lz ) (x), mu = mz lz = lj , E (lz ) (x) = E (lj ) (x), L(lz ) (x) = L(lj ) (x), mz = mj

Es ist lz = e. Setze τ = e − mz und falls Ek = 0, dann Λ(x) = x−mz +1 L(e) (x), sonst Λ(x) = x−mz L(e) (x), wobei mz der kleinste nichtverschwindende Koeffizient von L(e) (x) ist Output: Λ(x)

Wir wollen jetzt beweisen, dass der angegebene Algorithmus das Fehlerstellenpolynom berechnet. Satz 3.20 (Decodieralgorithmus durch Linearkombination von Fehlercodeworten decodiert bis zur halben Mindestdistanz) Der Algorithmus berechnet L(e) (x) und E(x)L(e) (x) mod (xn − 1) besitzt e aufeinanderfolgende Koeffizienten null von k + e bis n − 1 daher ist E(x)L(e) (x) = 0 mod (xn − 1). Das Fehlerstellenpolynom ist Λ(x) = x−mz L(e) (x), wobei mz der kleinste nichtverschwindende Koeffizient von L(e) (x) ist. Die Anzahl der Fehler ist τ = e − mz . Beweis: Die Anzahl der Fehler sei τ ≤ e. Wir nehmen an der Algorithmus würde pro Schritt eine zusätzliche Null erzeugen, d.h. lj = lz +1. Damit wäre das Ergebnis E (lj ) (x) = L(lj ) (x)E(x), wobei mit e − mj + 1 aufeinanderfolgenden Shifts lj = e − mj aufeinanderfolgende Nullen erzeugt werden. Ferner ist mj = mz − 1, da ein zusätzlicher Shift nach links verwendet wurde. In Schritt e − mj + 1 ≤ τ muss die Anzahl aufeinanderfolgender Nullen entsprechend Satz 3.15 noch kleiner als τ sein. Im folgenden Schritt ist das Fehlercodewort E (lz ) (x) mit e − mz + 1 = τ und lz = e − mz aufeinanderfolgenden Nullen und die Ausgabe ist xmj Λ(x) mit mj = mz − 1.

3.2 Algebraische Decodierung bis zur halben Mindestdistanz

75

Da der Algorithmus in einem Schritt die Anzahl der aufeinanderfolgenden Nullen um mindestens eins erhöht, kann entsprechend Satz 3.15 nur das Fehlernullcodewort sein. Des Weiteren werden genau τ + 1 = e − mj + 1 aufeinanderfolgende Shifts des Fehlercodewortes E(x) benutzt und die entsprechenden Koeffizienten bilden das Fehler-Prüfpolynom Λ(x). Nun betrachten wir den Fall, wenn in einem Schritt mehr als eine zusätzliche Null erzeugt wird. Wir nehmen an, dass lj = lz + 1 + δ Nullen erzeugt werden. In diesem Fall können wir E (lz ) (x) = x−δ E (lj ) (x) als eine neues Fehlercodewort benutzen, das dann genau eine Null mehr hat (wie im ersten Fall). Wir erzeugen damit δ + 1 zusätzliche aufeinanderfolgende Shifts. Dies ist notwendig, da die Anzahl aufeinanderfolgender Nullen lj = lz + 1 + δ ist gemäß Satz 3.15 die Anzahl benötigter zyklischer Shifts sicher größer als diese Zahl ist. Nachdem alle Shifts x−δ to x0 von E (lj ) (x) benutzt worden sind, sind wir entweder wieder beim ersten Fall oder aber die Anzahl an Shifts wird erneut an die Anzahl an Nullen angeglichen. Wenn e − mj + 1 ≤ τ ist, dann gilt lj < e. Der Algorithmus endet, wenn lj = e ist und dann ist das assoziierte Polynom L(e) (x) das Fehler-Prüfpolynom (Fehlerstellenpolynom) Λ(x). 2 Beispiel 3.7 (Decodierung durch Linearkombination von Fehlercodeworten) Das Fehlercodewort, das wir vom transformierten empfangenen Polynom kennen, lautet E(x) =∼ +5x2 + 5x3 + 3x4 + 3x5 . Wir verschieben das Fehlercodewort durch L(0) (x) = x2 um e = 2 Stellen zu L(0) (x)E(x) =∼ +5x4 + 5x5 + 3x6 + 3x7 . Dazu addieren wir −x−1 L(0) (x)E(x) =∼ −5x3 − 5x4 − 3x5 − 3x6 und erhalten L(1) (x) = x2 + 6x und L(1) (x)E(x) =∼ +0x4 + 2x5 + 0x6 . Nun addieren wir −x−1 L(0) (x)E(x) =∼ −5x3 − 5x4 − 3x5 − 3x6 und −x−1 L(1) (x)E(x) =∼ +2x4 + 0x5 und erhalten (5x + 1)E(x) =∼ +4x5 + 0x5 . Dazu addieren wir −2L(1) (x)E(x) =∼ +0x4 + 3x5 + 0x6 und haben 2 aufeinanderfolgende Nullen. Das assoziierte Polynom ist L(2) (x) = 5x2 + 2x + 5x − 1 = 5x2 + 1 = Λ(x) mit den Nullstellen 2 und 5. 

In den nächsten beiden Abschnitten sollen unsere zwei abgeleiteten Algorithmen zu bekannten Algorithmen aus der Literatur in Beziehung gesetzt werden. Es wird sich zeigen, dass alle bekannten Algorithmen als geringfügige Modifikationen unserer Algorithmen beschreibbar sind.

3.2.5

Verfahren von Sugiyama et al., Welch–Berlekamp und Gao

Die hier beschriebenen drei Algorithmen basieren auf dem Fehler-Generatorpolynom und benutzen daher alle den erweiterten Euklidischen Algorithmus. Der jüngste Algorithmus ist der von Gao [Gao02]. Das Ergebnis von Gao liefert direkt Satz 3.19 auf (l+2)

Seite 67. Der Rest ist R(l+2) (x) = Λ(x)C(x) und damit gilt C(x) = R Λ(x)(x) = Diese Aussage wird jedoch in [Gao02] anders als in Satz 3.19 bewiesen.

R(l+2) (x) . U (l+2) (x)

Sugiyama–Kasahara–Hirasawa–Namekawa-Algorithmus Da die Berechnung des Fehlers unabhängig vom gesendeten RS-Codewort ist, können ˆ wir ein beliebiges RS-Codewort C(x) zum Empfangswort Y (x) = C(x)+E(x) addieren. ˆ Wir wählen C(x) hier so, dass gilt: Cˆi = −Yi , i = [0, k − 1].

76

3 Reed-Solomon-Codes

ˆ ˆ Wir erhalten Yˆ (x) = Y (x)+ C(x) = C(x)+ C(x)+E(x). Die Decodiersituation hat sich ˆ nicht geändert sondern nur, dass das gesendete RS-Codewort nun C(x) + C(x) anstatt C(x) ist; wir kennen weder C(x) noch E(x). Jedoch haben wir nun Yˆi = 0, i ∈ [0, k − 1] und der nichtverschwindende Teil von Yˆ (x) ist Yˆi = Ei , i ∈ [k, n − 1]. Offensichtlich können wir Yˆ (x) durch xk teilen, was einem zyklischen Shift um −k entspricht. Wir wollen diesen Teil als Syndrom S(x) bezeichnen, also S(x) = xn−k Yˆ (x) mod (xn − 1), mit xn−k = xd−1 . Die Berechnung von ggT(Yˆ (x), (xn − 1)) und ggT(S(x), xd−1 ) liefern offensichtlich die gleichen Quotienten Q(i) (x) und deshalb die gleichen Polynome U (i) (x) und V (i) (x). Der Term −1 in xn − 1 kann ignoriert werden, da die Berechnung endet bevor der Einfluss von −1 beginnt. Der folgende Satz ist der Algorithmus aus [SKHN75]. Satz 3.21 (Erweiterter Euklidischer Algorithmus und Schlüssselgleichung) Für ein Fehlercodewort E(x) = Ω(x)Γ(x) eines Fehlerpolynoms mit τ ≤ d−1 2 Fehlern sei ˆ ˆ ˆ das modifizierte Empfangspolynom Y (x) = E(x)+C(x)+ C(x) mit Ci = −Yi , i = [0, k− ˆ ˆ 1] und das Syndrom S(x) = xn−k Yˆ (x) mod (xn − 1). Ferner sei E(x) = xn−k E(x) mod n d−1 ˆ ˆ (x − 1) = Ω(x)Γ(x). Die Berechnung von ggT(S(x), x ) wird abgebrochen, wenn gilt grad R(l+1) (x) > grad U (l+1) (x) und grad R(l+2) (x) < grad U (l+2) (x). Dann ist ˆ U (l+2) (x) = Λ(x), −R(l+2) (x) = Ω(x) und V (l+1) (x) = −Ω(x). Beweis: Die Berechnung von ggT(Yˆ (x), (xn − 1)) liefert die gleichen Polynome U (i) (x), i ∈ [1, l + 2] wie in Satz (3.11). Ebenfalls die gleichen U (i) (x), i ∈ [1, l + 2] erhalten wir bei der Berechnung von ggT(S(x), xd−1 ), da S(x) = xn−k Yˆ (x) mod (xn − 1) und xn−k xn = xn−k = xd−1 mod (xn − 1). Nun verschieben wir das modifizierte Empfangspolynom zyklisch durch Multiplikation mit xn−k und erhalten ˆ xn−k E(x) = E(x) mod (xn − 1) = F (x)(xn − 1). Wir dividieren diese Gleichung durch Γ(x), was ˆ xd−1 Ω(x) = Ω(x) − F (x)Λ(x) ergibt. Da gilt Fn−k−1 = En−1 , Fn−k−2 = En−2 , . . . F0 = Ek folgt F (x) = S(x). Deshalb ergibt die Berechnung von ggT(S(x), xd−1 ) in Schritt l + 2 R(l+2) (x) = U (l+2) (x)S(x) + V (l+2) (x)xd−1 , 2

was der Behauptung entspricht.

Es sei angemerkt, dass der Unterschied zu Sugiyama et al. ist, dass wir hier zwei Fehlerˆ Informationspolynome erhalten, nämlich −V (l+1) (x) = Ω(x) und −R(l+2) (x) = Ω(x). ˆ ˆ Ferner gilt: E(x) = Ω(x)Γ(x) und E(x) = xn−k E(x) mod (xn − 1) = Ω(x)Γ(x). Die üblicherweise verwendete Schlüsselgleichung ist wie folgt definiert. Definition 3.22 (Schlüsselgleichung) Die Schlüsselgleichung aus der das Fehlerstellenpolynom Λ(x) berechnet werden kann lautet ˆ Λ(x) · S(x) = −Ω(x) mod xd−1

ˆ mit grad Ω(x) < grad Λ(x).

3.2 Algebraische Decodierung bis zur halben Mindestdistanz

77

Welch–Berlekamp Algorithmus Da ein RS-Code maximum distance separable (MDS) ist (siehe Abschnitt 3.2.7), kann man beliebige k Koeffizienten des Empfangspolynoms y(x) auswählen und mit diesen systematischen Stellen ein Codewort c˜(x) berechnen. Seien diese k Stellen die Menge K = {j1 , j2 , . . . , jk } dann fordern wir, dass gilt c˜i = yi , i ∈ K. Dies kann sehr effizient im transformierten Bereich durchgeführt werden. Satz 3.23 (Modifiziertes Empfangspolynom) Gegeben Q seien jeine Menge von Codestellen K = {j1 , j2 , . . . , jk }, das Polynom Z(x) = (x − α ) vom Grad k und j∈K

das transformierte Empfangspolynom Y (x) = C(x) + E(x). Das Polynom A(x) vom Grad d − 2 ist eindeutig bestimmt durch das Polynom Z(x) und die d − 1 bekannten Koeffizienten des Fehlercodewortes E(x) mit Ek = Yk , . . . , En−1 = Yn−1 . Es gilt: ˜ Y˜ (x) = A(x) · Z(x) = Y (x) − C(x) mit c˜j = yj , j ∈ K, y˜j = 0, j ∈ K, und ˜ ˜ Yk = Yk , . . . , Yn−1 = Yn−1 . Beweis: Gegeben Z(x) = Z0 + Z1 x + . . . Zk xk und Y (x), dann kann A(x) durch die folgende Rekursion berechnet werden: Yn−1 = En−1 = Ad−2 Zk Yn−2 = En−2 = Ad−2 Zk−1 + Ad−3 Zk .. . Yk = Ek = Ad−2 Zk−d+2 + Ad−3 Zk−d+3 + . . . + A0 Zk . Mit der ersten Gleichung kann man Ad−2 berechnen. Danach ist die einzige Unbekannte der zweiten Gleichung Ad−3 , die somit berechnet werden kann usw. Mit der letzten Gleichung kann dann A0 berechnet werden und A(x) ist bestimmt. Da man jetzt A(x) und Z(x) kennt, kann man die restlichen k Koeffizienten Y˜0 , Y˜1 , . . . , Y˜k−1 berechnen. Gemäß Definition von Y˜ (x) gilt Y˜ (x) = 0 mod Z(x) oder Y˜ (αj ) = 0, j ∈ K. Weil Yk = Y˜k , . . . , Yn−1 = Y˜n−1 ist, besitzt das Polynom Y (x) − Y˜ (x) Grad < k und ist deshalb ein ˜ ˜ Codewort C(x) des RS-Codes. Die Evaluation von Y (x) − Y˜ (x) = C(x) an den Stellen αj ergibt c˜j = yj , j ∈ K, da Y˜ (αj ) = 0, j ∈ K ist. Damit gilt: y˜j = yj − c˜j , j ∈ [0, n − 1]. 2

Mittels dieser Re-Codierung erhält man eine interessante Variante der Decodierung mit dem erweiterten Euklidischen Algorithmus, die eine Verallgemeinerung des Welch– Berlekamp-Algorithmus ist. Satz 3.24 (Verallgemeinerter Welch–Berlekamp-Algorithmus) Die Berechnung des ggT(Y˜ (x), xn − 1) ergibt die gleichen U (i) (x) und V (i) (x) wie die Berechnung des Q n −1 ggT(A(x), Z(x)) mit Z(x) = xZ(x) = (x − αj ), wenn gilt: j6∈K

grad U (l+1) (x) ≤ grad R(l+1) (x) und grad U (l+2) (x) > grad R(l+2) (x) ist U (l+2) (x) = Λ(x). Beweis: Da Z(x) das Polynom (xn − 1) und ebenfalls Y˜ (x) teilt, muss Z(x) auch jeden Rest teilen ˜ (j) (x) = U (j) (x)Y˜ (x) + V (j) (x)(xn − 1), R

78

3 Reed-Solomon-Codes

was R(j) (x) = U (j) (x)A(x) + V (j) (x)Z(x) ˜ (l) (x) R . Z(x) (j)

ergibt, wobei R(l) (x) = (j)

(j)

Deshalb berechnet der Erweiterte Euklidische Algorithmus

U (x), V (x) und R (x), j = 1, 2, . . .. Die Abbruchbedingungen sind grad U (l+1) (x) ≤ grad R(l+1) (x) und grad U (l+2) (x) > grad R(l+2) (x). Wir erhalten U (l+2) (x) = Λ(x).

2

Beispiel 3.8 (Re-Codierung und Euklidischer Algorithmus) Wir betrachten erneut das Empfangspolynom aus Beispiel 3.5 auf Seite 61 und werden den erweiterten Euklidischen Algorithmus auf die Polynome A(x) und Z(x) anwenden. Dabei werden wir die gleichen Quotienten wie in Beispiel 3.6 erhalten. Y (x) = 3x5 + 3x4 + 5x3 + 5x2 + ∼ . Wir wählen die Menge an k = 2 Stellen zu K = {3, 4}. Damit berechnen wir Z(x) = (x−α3 )(x− α4 ) = (x+1)(x+5) = x2 +6x+5. Mit Y (x) und Z(x) berechnen wir A(x) mit Grad 3 rekursiv: A3 = Y5 = 3, A2 = Y4 − 6A3 = 6, A1 = Y3 − 6A2 − 5A3 = 3 und A0 = Y2 − 6A1 − 5A2 = 6. Das Polynom ist damit A(x) = 3x3 + 6x2 + 3x + 6. Wir berechnen Z(x) =

xn − 1 x6 − 1 = 2 = x4 + x3 + 3x2 + 5x + 4. Z(x) x + 5x + 5

Zur Berechnung des größten gemeinsamen Teilers von A(x) und Z(x) teilen wir Z(x) durch A(x), was Q(1) (x) = 5x + 2 und Rest R(1) (x) = 4x2 + 4x + 6 ergibt. Nun teilen wir A(x) durch R(1) (x) und erhalten Q(2) (x) = 6x + 6 und Rest R(2) (x) = 6x + 5. Die Quotienten sind identisch zu denen aus Beispiel 3.6 und somit ergibt sich auch hier das Fehlerstellenpolynom Λ(x) = 2x2 + 6. 

Falls A(x) Nullstellen besitzt, so hat man eine mögliche Decodierentscheidung gefunden. Satz 3.25 (Wurzeln des Re-Codierten Polynoms) Gegeben das transformierte empfangene Polynom Y (x) und ein Polynom Z(x) entsprechend Satz 3.23. Wenn A(x) Nullstellen {`1 , `2 , . . . , `δ } 6∈ K, mit δ ≥ 1, dann ist das Codewort c˜(x) eine mögliche Decodierentscheidung, wobei τ = n−k−δ ≤ d−2 Fehler aufgetreten sind. Das entsprechende Fehlerstellenpolynom ist Λ(x) = (x−α`1Z(x) ,und das Fehler-Generatorpolynom )···(x−α`δ ) `1 `δ ˜ ist Γ(x) = Z(x)(x−α ) · · · (x−α ). Ferner ist Y (x) das transformierte Fehlerpolynom. Falls δ ≥ e − 1 = d−1 2 − 1 ist, ist die Entscheidung eindeutig. Beweis: Wenn A(x) die Nullstellen {`1 , `2 , . . . , `δ } 6∈ K besitzt, dann gilt: Z(x)(x−α`1 ) · · · (x− α`δ )|Y˜ (x). Anders ausgedrückt k + δ Stellen von c˜(x) und y(x) sind identisch und n − k − δ verschieden und diese entsprechen den Fehlerstellen. Deshalb gilt Y˜ (x) = Ω(x)Z(x)(x − α`1 ) · · · (x − α`δ ) = Ω(x)Γ(x) und e(x) = y˜(x) ist das Fehlerpolynom. Im Falle δ ≥ e − 1 ist τ ≤ e und somit ist der Fehler eindeutig. 2

3.2 Algebraische Decodierung bis zur halben Mindestdistanz

79

Besteht also die Menge K der systematischen Stellen aus k fehlerfreien Stellen, dann ist ˜ ˜ C(x) = C(x) und S(x) = Y (x) − C(x) = E(x).

Bevor wir auf die spezielle Wahl von K eingehen, die zum Welch–Berlekamp-Algorithmus [WB] führt, wollen wir noch ein Beispiel zur Re-Codierung und der Decodierung mit dem erweiterten Euklidischen Algorithmus angeben. Beispiel 3.9 (Re-Codierung mit fehlerfreien Stellen) Wir betrachten erneut das Empfangspolynom aus Beispiel 3.5 auf Seite 61 Y (x) = 3x5 + 3x4 + 5x3 + 5x2 + ∼ . Wir wählen die Menge k = 2 Stellen anders als in Beispiel 3.8 zu K = {0, 2}. Damit berechnen wir hier Z(x) = (x − α0 )(x − α2 ) = (x + 6)(x + 3) = x2 + 2x + 4. Mit Y (x) und Z(x) berechnen wir A(x) mit Grad 3 rekursiv: A3 = Y5 = 3, A2 = Y4 − 2A3 = 4, A1 = Y3 − 2A2 − 4A3 = 6 und A0 = Y2 − 2A1 − 4A2 = 5. Das Polynom A(x) = 3x3 + 4x2 + 6x + 5

besitzt zwei Nullstellen 3 und 6, wobei 6 eine doppelte Nullstelle ist. Damit sind τ = 6−2−2 = 2 Fehler aufgetreten und das Fehlerstellenpolynom ist Λ(x) =

Z(x) x4 + 5x3 + x + 5 = = x2 + 3. (x − 3)(x − 6) x2 + 5x + 4

Ferner ist Γ(x) = Z(x)(x − 3)(x − 6) = (x2 + 2x + 4)(x2 + 5x + 4) = x4 + 4x2 + 2 und Y˜ (x) = E(x) = A(x)Z(x) = 3x5 + 3x4 + 5x3 + 5x2 + 6x + 6. 

Nun werden wir den Spezialfall K = {n−k, n−k +1, . . . , n−1} als systematische Stellen c˜j = yj , j ∈ K benutzen, um den Welch–Berlekamp-Algorithmus [WB] zu erhalten. In diesem Fall ergeben sich die redundanten Stellen des Codewortes c˜i , i ∈ [0, d − 2] durch Division von yn−k xn−k + . . . + yn−1 xn−1 durch das Generatorpolynom g(x) des RSCodes mit Grad n − k und Subtraktion des Restes. Das modifizierte Empfangspolynom ist s(x) = y(x) − c˜(x) = s0 + s1 x + . . . + sd−2 xd−2 .

˜ Wir wissen, dass für die Transformierte C(x) des Codewortes c˜(x) gilt: C˜i = 0, i ∈ [k, n − 1]. Wir können das transformierte Codewort von Y (x) subtrahieren und erhalten ˜ ˜ S(x) = Y (x) − C(x) = C(x) − C(x) + E(x).

(3.16)

Das modifizierte Empfangspolynom s(x) = y(x) − c˜(x) besitzt Nullkoeffizienten an den Stellen si = 0, i = d−1, . . . , n−1. Da gilt S(x) = A(x)Z(x) ist si = ai zi , i = 0, . . . , n−1. Es gilt jedoch zi = si = 0, i ∈ [d − 1, n − 1] und zi 6= 0, i ∈ [0, d − 2] und deshalb ai =

si , i ∈ [0, d − 2]. zi

Satz 3.26 (Welch–Berlekamp-Algorithmus) Die Berechnung des größten gemeinsamen Teilers ggT(S(x), xn − 1) mit S(x) aus Gleichung (3.16) ergibt die gleichen d−2 Q n −1 Polynome U (i) (x), wie ggT(A(x), Z(x)) mit Z(x) = xZ(x) = (x − αj ) = g(x)(x − j=0

1)/(x − αd−1 ).

80

3 Reed-Solomon-Codes

Beweis: Da Z(x) sowohl (xn − 1) als auch S(x) teilt, muss es auch jeden Rest R(j) (x) = U (j) (x)S(x) + V (j) (x)(xn − 1).

teilen. Wir erhalten also B (j) (x) = U (j) (x)A(x) + V (j) (x)Z(x), wobei B (l) (x) =

R(l) (x) Z(x)

ist. Damit können wir durch den Euklidischen Algorithmus U (j) (x) und

(j)

B (x), j = 1, 2, . . . berechnen. Wenn grad U (l+1) (x) ≤ grad B (l+1) (x) und grad U (l+2) (x) > grad B (l+2) (x) ist, dann haben wir B (l+2) (x) = A(x) mod g(x)(x − 1)/(x − αd−1 ), U (l+2) (x) berechnet. Dies ist genau Chambers Interpretation [Cha93] des Welch–Berlekamp-Algorithmus [WB]. 2

3.2.6

Verfahren von Gorenstein–Zierler, Peterson und Berlekamp–Massey

Die Algorithmen von Peterson [Pet60] und Gorenstein–Zierler [GZ61a] sind sehr ähnlich. Nehmen wir an, dass die maximale Anzahl τ = d−1 2 = e Fehler aufgetreten sind. Unter dieser Annahme können wir die Matrix Se berechnen, mit   Ek Ek+1 . . . Ek+e−1  Ek+1 Ek+2 . . . Ek+e  . Se =  .. .. . . ..   . . . . Ek+e−1 Ek+e . . . Ek+2e−2

Mit Hilfe der Definition des Fehlercodes können wir direkt den Rang dieser Matrix angeben, denn jede Zeile ist ein Teil eines Fehlercodewortes x−i E(x) mod (xn − 1). Gemäß Satz 3.16 kann keine Zeile τ oder mehr aufeinanderfolgende Koeffizienten null besitzen. Des Weiteren hat jede τ × τ Untermatrix (mit aufeinanderfolgenden Zeilen und Spalten) entsprechend Satz 3.15 vollen Rang τ . Dagegen sind die Zeilen einer (τ + 1) × (τ + 1) Untermatrix linear abhängig. Daher ist der Rang der Matrix Se genau τ. Gilt Rang (Se ) = e so sind e Fehler aufgetreten und wir können die Inverse Se−1 benutzen, um Λ0 , Λ1 , . . . , Λe zu berechnen. Es gilt     Λ0 Λ1 . . . Λe = Ek+l Ek+l+1 . . . Ek+2l−1 · Se−1 . Wenn Rang (Se ) = τ < e ist, dann sind τ Fehler aufgetreten und wir benutzen   Ek Ek+1 . . . Ek+τ −1  Ek+1 Ek+2 . . . Ek+τ   Sτ =  .. .. . . ..   . . . . Ek+τ −1 Ek+e . . . Ek+2τ −2 ,

um Λ(x) vom Grad τ zu berechnen. Während ein Algorithmus mit der Annahme e Fehler beginnt, fängt der andere mit der Annahme 1 Fehler an. Sobald die entsprechende Matrix vollen Rang besitzt hat man die Anzahl e der Fehler bestimmt.

3.2 Algebraische Decodierung bis zur halben Mindestdistanz

81

Berlekamp-Massey Algorithmus (BMA) Da E(x) ein Fehlercodewort ist kann es mit Methode 4 aus Abschnitt 3.1.5 mit dem Fehler-Prüfpolynom Λ(x) codiert werden. Der Berlekamp–Massey-Algorithmus (BMA) berechnet das Fehler-Prüfpolynom, indem er mit einem Startpolynom probiert, den bekannten Teil des Fehlercodwortes zu codieren Gleichung (3.14). Gelingt dies nicht, so muss er das Startpolynom modifizieren. Dabei können, je nach Situation, die Koeffizienten modifiziert werden oder aber gleichzeitig der Grad erhöht werden. Das FehlerPrüfpolynom Λ(x) kann somit eindeutig berechnet werden, wenn gilt 2τ < d, da ein Koeffizient von Λ(x) frei gewählt werden kann. Konkret wird also durch Λ(x) codiert, indem die τ Koeffizienten Ek , . . . , Ek+τ −1 des Fehlercodewortes als Information betrachtet werden und die restlichen n − k − τ Symbole des Fehlercodewortes durch die Rekursion Ei = −

τ 1 X Ei−j Λj , i = [k + τ, n − 1] Λ0 j=1

codiert werden. Stimmen die neu codierten Stellen mit denen des Fehlercodwortes überein, so hat man Λ(x) gefunden, wenn nicht muss man das Polynom modifizieren. Der BMA führt diese Modifikationen sehr effizient durch und verwendet dazu die Diskrepanz ∆i , das Hilfspolynom B (i) (x) und das Fehler-Prüfpolynom Λ(i) (x) mit Λ(0) (x) = 1. Das Syndrom S(x) wird bestimmt durch die bekannten Stellen des Fehlercodewortes Ek = S0 , Ek+1 = S1 , . . . , En−1 = Sd−2 . Die erste Diskrepanz ist ∆0 = Ek = S0 . Wenn S0 = Ek = 0 ist, dann sind gemäß Satz 3.16 mindestens zwei Fehler aufgetreten und der Grad muss erhöht werden. Die Berechnung der Diskrepanz wird durch grad Λ(j−1) (x)

∆j = Sj +

X

(j−1)

Λi

Sj−i

i=1

durchgeführt. Abhängig vom Wert der Diskrepanz, dem Grad von Λ(i) (x) und einem Zähler t, der zählt, wie häufig die Diskrepanz null war, gibt es zwei unterschiedliche Berechnungsvorschriften.  (j) Λ (x), falls ∆j = 0 (j+1) Λ (x) = Λ(j) (x) − ∆j xt B (j) , sonst. Die entsprechenden Regeln für das Hilfspolynom lauten  (j) B (x), falls 2 grad Λ(j) (x) > j (j+1) B (x) = (j) ∆−1 j Λ (x), sonst. (i) Vergleiche mit den Regeln Λ(i+1) (x) = Λ(i) (x)−∆i xB (i) (x) und B (i+1) (x) = ∆−1 i Λ (x) in Tabelle 3.2, wo die Anzahl der Nullen um eins erhöht wurde. Im Falle, dass mehr als eine zusätzliche Null erzeugt wurde, wird Λ(i+1) (x) = Λ(i) (x) und B (i+1) (x) = B (i) (x) gewählt. Der Fall von t zusätzlichen Nullen entspricht Tabelle 3.3. In Bild 3.3 ist ein Flußdiagramm des Berlekamp-Massey-Algorithmus angegeben, das verwendet werden kann, um die Schlüsselgleichung (3.22) zu lösen.

82

3 Reed-Solomon-Codes Startwerte:

S hieberegisterlänge Fehlerstellenpolynom Hilfspolynom Zähler

∆j = Sj +

l X

l=0 Λ(0) (x) = 1 B (0) (x) = 0 j = 0, k = 0

ja

(j)

Λi Sj−i = 0 ?

i=1

nein

Λ(j+1)(x) = Λ(j)(x) − ∆j xk B (j)(x)

Λ(j+1)(x) = Λ(j)(x)

ja

2l > j nein

(j) B (j+1)(x) = ∆−1 j Λ (x) l =j +1−l k=0

B (j+1)(x) = B (j)(x)

j =j+1 k =k+1

nein

ja

j >d−2

ENDE

Abb. 3.3: Berlekamp-Massey-Flußdiagramm.

Tabelle 3.4: Berechnung des Fehlerstellenpolynoms mit dem BMA (Beispiel 3.10). j k l

∆j

Λ(j+1) (x) Λ(1) = 1

5x0

2l > j

B (j+1) (x) B (1) = 5−1

0 0 0 ∆0 = S0 = 5 − · 0 = 1 nein =3 (1) 1 1 1 ∆1 = S1 + Λ1 S0 Λ(2) = 1 − 5x · 3 ja B (2) = B (1) = 3 =5 = 1 + 6x (2) 2 2 1 ∆2 = S2 + Λ1 S1 Λ(3) = Λ(2) − ∆2 x2 B (2) nein B (3) = 3(1 + 6x) =3 + 6 · 5 = 1 + 6x − 5x2 · 3 = 3 + 4x =5 = 1 + 6x + 6x2 (3) 3 1 2 ∆3 = S3 + Λ1 S2 Λ(4) = Λ(3) − 2xB (3) ja B (4) = B (3) (3) +Λ2 S1 =3 + 6 · 3 = 1 + 6x + 6x2 +6 · 5 −2x(3 + 4x) =2 = 1 + 5x2

Beispiel 3.10 (Berlekamp-Massey-Algorithmus) Wir wollen noch einmal mit Hilfe des BMA das Fehlerstellenpolynom zum Syndrom S(x) = 5 + 5x + 3x2 + 3x3 von Beispiel 3.5 berechnen (siehe Tabelle 3.4). Damit sind die Fehler an den Stellen 1 und 4. 

3.2 Algebraische Decodierung bis zur halben Mindestdistanz

83

Wir kennen mit Λ(x) die Fehlerstellen und damit im binären Fall auch den Fehlerwert, nämlich Λ(αi ) = 0 =⇒ ei = 1. Im Falle eines nicht binären Codes müssen wir noch den Wert von ei 6= 0 berechnen. Dazu haben wir bereits in Abschnitt 3.2.3 den ForneyAlgorithmus beschrieben. Da wir nun E(x) kennen, können wir durch Methode 4 aus Abschnitt 3.1.5 das komplette Fehlercodewort berechnen. Die Fehlerwerte ei sind dann die Evaluation an den Fehlerstellen Λ(αi ) = 0: ei = E(αi ). Der Berlekamp-Massey-Algorithmus (BMA) ist ein sehr effizientes Verfahren zur Berechnung von Λ(x) mit kleinstem Grad, das die Schlüsselgleichung (3.22) löst. Oft wird auch formuliert, der Berlekamp-Massey-Algorithmus findet das kürzeste rückgekoppelte Schieberegister mit den Rückkoppelungsfaktoren Λi , das alle Syndromkoeffizienten erzeugt (zu Schieberegisterschaltungen siehe die Übungsaufgaben 3.1 und 3.2). Damit haben wir einige Algorithmen beschrieben, die das Fehlerstellenpolynom berechnen, wenn die Anzahl der Fehler kleiner als die halbe Mindestdistanz ist. Falls mehr Fehler aufgetreten sind, kann man nicht exakt angeben, was passiert. Jedoch kann man sagen, wann Decodierversagen vorliegt. Decodierversagen: Besitzt das Fehlerstellenpolynom Λ(x) nicht so viele verschiedene Nullstellen, wie sein Grad angibt, so liegt ein Decodierversagen vor und es sind sicher mehr als die Anzahl der korrigierbaren Fehler aufgetreten.

3.2.7

Korrektur von Fehlern und Auslöschungen

Wir wollen in diesem Abschnitt eine Modifikation der Decodierung mit dem erweiterten Euklidischen Algorithmus beschreiben, mit der ρ > 0 Auslöschungen und τ Fehler mit 2τ + ρ < d korrigiert werden können. Stellen wir uns vor, dass wir von irgendeiner Instanz die Information bekommen, dass bestimmte Stellen des Codeworts falsch sind bzw. wir kennen überhaupt keinen Wert für diese Stellen. Solche Stellen wollen wir als Auslöschung bezeichnen. Die Existenz von Auslöschungen wird in Kapitel 7 einsichtig werden. Definition 3.27 (Auslöschungsstellen-Polynom)Sei Φ(x) = (x − αj1 )(x − αj2 ) . . . (x − αjρ ) das Auslöschungsstellen-Polynom, das Nullstellen (ϕi = 0) an den ρ ausgelöschten Stellen i ∈ {j1 , j2 , . . . , jρ } besitzt. Damit enthält das Empfangspolynom y 0 (x) Fehler und Auslöschungen und kann daher nicht transformiert werden, da das Symbol Auslöschung kein Element des Galoisfeldes ist. Wir definieren, dass Auslöschung multipliziert mit 0 gleich 0 ergibt. Damit können wir yi = yi0 · ϕi = (ci + ei )ϕi , i ∈ [0, n − 1] berechnen. Dabei ist yi = 0 an ausgelöschten Stellen und yi = ϕi (ci + ei ) an den anderen Stellen. Mit dem Faltungssatz 3.2 gilt: Y (x) = Φ(x)(C(x) + E(x)) mod (xn − 1).

(3.17)

Wir definieren den Auslöschungs-Fehler-Code anhand des Auslöschungs-Fehler-Prüfpolynoms Λ0 (x) = Λ(x)Φ(x) oder durch das Auslöschungs-Fehler-Generatorpolynom

84

3 Reed-Solomon-Codes

Γ(x), wobei gilt: Γ(x)Λ0 (x) = Γ(x)Λ(x)Φ(x) = xn − 1 und daher grad Γ(x) = n − τ − ρ. n −1 Wir definieren das Polynom W (x) = xΦ(x) für das gilt grad W (x) ≤ n − 1, da ρ > 0. Satz 3.28 (Größter gemeinsamer Teiler bei Auslöschungen) Der größte gemeinn −1 same Teiler von E(x) aus Gleichung (3.17) und W (x) = xΦ(x) ist ggT(W (x), E(x)) = Γ(x) mit grad Γ(x) = n − τ − ρ. Beweis: Die Nullstellen des transformierten Fehlerpolynoms E(x) sind identisch mit denen vom Fehlergeneratorpolynom Γ(x). Weil Γ(x)Λ(x)Φ(x) = xn − 1 ist, können wir schreiben W (x) =

Γ(x)Λ0 (x) xn − 1 = = Γ(x)Λ(x), Φ(x) Φ(x) 2

woraus direkt die Behauptung folgt.

Satz 3.29 (Auslöschungs-Fehler-Korrektur mit Euklidischem Algorithmus I) Sei y 0 (x) das empfangene Polynom mit τ Fehlern und ρ > 0 Auslöschungen und 2τ + ρ < d. Ferner sei Y (x) = (C(x) + E(x))Φ(x) mod (xn − 1) entsprechend Gleichung (3.17) mit grad W (x) ≤ grad Y (x). Bei der Berechnung von ggT(W (x), Y (x)) wenn gilt grad R(l+1) (x) > k − 1 + grad Φ(x) + grad U (l+1) (x) und grad R(l+2) (x) ≤ k − 1 + grad Φ(x) + grad U (l+2) (x) erhalten wir V (l+2) (x) = Λ(x), R(l+2) (x) = Λ(x)C(x) und U (l+2) (x) = Φ(x)Ω(x). Beweis: Wir benutzen die gleichen Argumente wie in Satz 3.21. Zuerst betrachten wir den Fall C(x) = 0. Dann gilt Y (x) = Φ(x)E(x) mod (xn − 1) wobei yi = ϕi εi = 0 an den ausgelöschten Stellen ist. Entsprechend Satz 3.28 ist der größte gemeinsame Teiler von Y (x) und W (x) = xn −1 gleich Γ(x). Damit gilt Φ(x) Γ(x) = R(l+1) (x) = U (l+1) (x)W (x) + V (l+1) (x)Y (x) 0 = R(l+2) (x) = U (l+2) (x)W (x) + V (l+2) (x)Y (x).

(3.18)

Da gilt grad Γ(x) + grad U (l+2) (x) = grad Y (x) ≤ n − 1, folgt dass grad U (l+2) (x) ≤ ρ + τ − 1 und grad V (l+2) (x) < ρ + τ − 1 ist. Aus der zweiten Zeile von Gleichung (3.18) erhalten wir U (l+2) (x)W (x) = U (l+2) (x)

xn − 1 = −V (l+2) (x)Y (x) Φ(x) = −V (l+2) (x)Ω(x)Φ(x)Γ(x).

Der zweite und der letzte Term ergibt U (l+2) (x)

xn − 1 = −V (l+2) (x)Ω(x)Φ(x)Γ(x). Φ(x)

Beide Seiten durch Γ(x) dividiert ergibt U (l+2) (x)Λ(x) = −V (l+2) (x)Ω(x)Φ(x).

3.2 Algebraische Decodierung bis zur halben Mindestdistanz

85

Wie in Satz 3.21 sind U (l+2) (x) und V (l+2) (x) relativ prim und damit U (l+2) (x) = Ω(x)Φ(x)

und

V (l+2) (x) = Λ(x).

Alternativ können wir die folgende Gleichung benutzen U (l+2) (x)

xn − 1 = −V (l+2) (x)Y (x). Φ(x)

Die Evaluation dieser Gleichung ergibt V (l+2) (αj )Y (αj ) = 0, j ∈ [0, n − 1], da die linke Seite xn −1 wegen Φ(x) null an allen außer den ausgelöschten Stellen ist. An den ausgelöschten Stellen ist jedoch per Definition Y (αj ) = 0. Deswegen muss V (l+2) (x) gleich Λ(x) sein und es muss gelten Φ(x)|U (l+2) (x). Nun können wir erneut überprüfen, dass wenn C(x) 6= 0 ist, die Berechnung von V (l+2) (x) durch C(x) nicht beeinflusst wird, solange gilt 2τ + ρ < d. 2

Im Falle, wenn wir Auslöschungen an bestimmten ρ Stellen definieren, etwa aufgrund von Zuverlässigkeitsinformation (siehe Abschnitt 7.2), kann ein weiteres AuslöschungsFehler-Decodierverfahren abgeleitet werden. Der wesentliche Unterschied im Fall, dass wir Auslöschungen definieren ist, dass alle yi0 Elemente aus dem Galoisfeld sind und somit die Transformation Y 0 (x) berechnet werden kann. Auch hier besitzt Φ(x) Nullstellen an den ρ definierten Auslöschungsstellen. Wir können für unsere Überlegungen Φ(x) = Φc (x)Φe (x) verwenden, wobei Φe (x) ausgelöschte Fehlerstellen und Φc (x) ausgelöschte fehlerfreie Stellen repräsentiert. Wenn wir Φ(x) definiert haben, existieren zwei Möglichkeiten. Bei der ersten berechnen wir Y (x) = Φ(x)Y 0 (x) = Φ(x) (C(x) + E(x)) mod (xn − 1) und Φ(x)E(x) mod (xn − 1) ist ein Codewort des Fehlercodes. Deswegen gilt: ggT (Φ(x)E(x) mod (xn − 1), (xn − 1)) = Φe (x)Γ(x). Die zweite Möglichkeit ist Y 0 (x) unverändert zu benutzen, und den größten gemeinsamen Teiler mit W (x) = (xn − 1)/Φ(x) zu berechnen. Dabei erhalten wir ggT (W (x), E(x)) =

Γ(x) . Φc (x)

Satz 3.30 (Auslöschungs-Fehler-Korrektur mit Euklidischem Algorithmus II) Sei Y (x) = C(x) + E(x) ein empfangenes transformiertes Polynom mit τr Fehlern und ρ > 0 definierten Auslöschungen. Die Anzahl an ausgelöschten Fehlern sei ρe . Ferner sei τr = τ + ρe und 2τ + ρ < d. Des Weiteren sei W (x) = (xn − 1)/Φ(x) mit grad W (x) ≤ grad Y (x). Bei der Berechnung von ggT(W (x), Y (x)), wenn gilt grad R(l+1) (x) > k − 1 + grad Φ(x) + grad U (l+1) (x) und grad R(l+2) (x) ≤ k − 1 + grad Φ(x) + grad U (l+2) (x), erhalten wir V (l+2) (x) = Λ(x), und U (l+2) (x) = Φc (x)Ω(x).

86

3 Reed-Solomon-Codes

Beweis: Wiederum nehmen wir zuerst an C(x) = 0. Dann berechnen wir ggT(W (x), E(x)) und erhalten die letzten beiden Gleichungen Γ(x) Φc (x)

= R(l+1) (x) = U (l+1) (x)W (x) + V (l+1) (x)Y (x) 0 = R(l+2) (x) = U (l+2) (x)W (x) + V (l+2) (x)Y (x).

Teilen wir die letzte Gleichung durch Γ(x)/Φc (x) ergibt sich 0 = U (l+2) (x)Λ(x) + V (l+2) (x)Φc (x)Ω(x), da gilt W (x) xn − 1 = = Λ(x). Γ(x)/Φc (x) Γ(x)Φe (x) Deswegen besitzt Λ(x) Nullstellen an den nicht ausgelöschten Fehlerstellen. Weiterhin ist ρ = ρc + ρe mit grad Φc = ρc und grad Λ(x) = τ − ρe . Da U (i) (x) und V (i) (x) relativ prim sind, ist Λ(x) = V (l+2) (x). Auch hier gilt für C(x) 6= 0 der Grad des Restes R(l+1) n − τr − ρc größer sein muss als k − 1 + grad V (l+1) (x). Mit dem Grad von Λ(x) erhalten wir grad V (l+1) (x) < τr − ρe − 1. Diese zwei Bedingungen gleichzeitig ergeben d > 2τr − ρe + ρc − 1 = 2τ + ρ.

2

Auslöschungs-Fehlerkorrektur kann mit der Re-Codierung aus Satz 3.24 kombiniert werden. Wir wollen jedoch nur den Fall einer Multiplikation mit Φ(x) angeben. Sei die Menge K = {i1 , i2 , . . . , ik } von k (nicht ausgelöschten) Stellen gegeben Dadurch ist Z(x) entsprechend Lemma 3.23 bestimmt. Bestimme B(x) d − 2 − ρ entsprechend Satz 3.23 zu Y˜ (x) = B(x)Φ(x)Z(x)

(3.19)

mit Y˜i = Yi , i ∈ [k + ρ, n − 1]. Auch hier ist B(x) eindeutig durch die Koeffizienten Yi , i ∈ [k + ρ, n − 1] und Z(x) bestimmt. Satz 3.31 (Auslöschungs-Fehlerkorrktur und Re-Codierung) Die Berechnung des größten gemeinsamen Teilers   xn − 1 n n ˜ ggT (Y (x), x − 1) , ggT(Y (x), x − 1), und ggT B(x), Φ(x)Z(x) mit Y˜ (x) und B(x) aus Gleichung (3.19) und grad Φ(x)Γ(x) = n − τr + ρ ergibt die gleichen Polynome U (i) (x) und V (i) (x) wenn grad U (i) (x) ≤ b d−1−ρ c. 2 Beweis: In dem Polynom Y (x) = Φ(x)Y 0 (x) = Φ(x) (C(x) + E(x)) mod (xn − 1) sind die Koeffizienten Yi , i ∈ [k + ρ, n − 1] nur vom Fehlercodewort abhängig, da grad Φ(x)C(x) ≤ k − 1 + ρ. Damit ist dies die gleiche Situation, wie bei einem Code der Mindestdistanz d − ρ. Entsprechend Satz 3.19 sind die Berechnungen bis grad U (i) (x) ≤ b d−1−ρ c unabhängig vom 2 Polynom Φ(x)C(x). Weil Y˜i = Yi , i ∈ [k + ρ, n − 1] gilt, ergeben beide Berechnungen die

3.3 Algebraische Decodierung über die halbe Mindestdistanz

87

gleichen Quotienten und daher die gleichen Polynome U (i) (x) und V (i) (x). Deshalb können wir schreiben R(l+1) (x) = U (l+1) (x)Y˜ (x) + V (l+1) (x)(xn − 1) R(l+2) (x) = U (l+2) (x)Y˜ (x) + V (l+2) (x)(xn − 1). Aus grad Φe (x)Γ(x)+grad U (l+2) (x) = grad(xn −1) folgt grad U (l+2) (x) = n−grad Φe (x)Γ(x) ≤ b d−1−ρ c. Weil Φ(x)Z(x) sowohl Y˜ (x) als auch (xn −1) teilt, muss es auch alle Reste R(i) (x), i = 2 1, . . . , l + 2 teilen. Damit gilt R(l+1) (x) Φ(x)Z(x) R(l+2) (x) Φ(x)Z(x)

n

(x −1) = U (l+1) (x)B(x) + V (l+1) (x) Φ(x)Z(x) n

(x −1) = U (l+2) (x)B(x) + V (l+2) (x) Φ(x)Z(x) .

Daher ist die Anzahl τ an Fehlern, die im nicht ausgelöschten Teil korrigiert werden kann d > 2τ + ρ.

2

Maximum distance separable, MDS Codes, die die Singleton-Schranke mit Gleichheit erfüllen heißen maximum distance separable. Beliebige k Stellen bestimmen eindeutig ein Codewort. Dies ist durch Auslöschungskorrektur einsichtig. Wenn man keine Fehler zulässt, kann man d − 1 = n − k Auslöschungen korrigieren. Man wählt also beliebige k Stellen aus und betrachtet die anderen n − k Stellen als Auslöschungen. Damit ist die Auslöschungskorrektur bei der algebraischen Decodierung beschrieben. Sie kann gegebenenfalls verwendet werden, um das Decodierergebnis zu verbessern. Speziell wird die Auslöschungskorrektur im Kapitel 9 benötigt, um verkettete Codes zu decodieren.

3.3

Algebraische Decodierung über die halbe Mindestdistanz

Wir wollen hier noch zwei Ideen beschreiben, wie eine Decodierung über die halbe Mindestdistanz ohne Verwendung von Zuverlässigkeitsinformation möglich ist. Für eine ausführliche Analyse wird jedoch an den entsprechenden Stellen auf weiterführende Literatur verwiesen.

3.3.1

Interleaved RS-Codes (IRS)

Bei interleaved RS-Codes wird angenommen, dass ` unterschiedliche RS Codeworte parallel übertragen werden und ein Fehler bei allen Codeworten an der gleichen Stelle auftritt. Dadurch können wir davon ausgehen, dass wir ` Teile von verschiedenen Fehlercodeworten des gleichen Fehlercodes kennen. Die entsprechenden Publikationen sind [BKY03, Kra03, SSB06, SSB09, KBB08, Sch07]. Bei sogenannten homogenen IRS Codes besitzen alle ` RS Codes die gleich Mindestdistanz d und wir wollen uns auf diesen Fall beschränken. Wir benötigen folgenden Satz, um die Decodierfähigkeit bei IRS Codes zu beweisen.

88

3 Reed-Solomon-Codes

Satz 3.32 (Basis aller Lösungen der Decodierung) Bei der Berechnung des größten gemeinsamen Teilers des transformierten Empfangspolynoms Y (x) mit xn − 1 mit (e) dem erweiterten Euklidischen Algorithmus erhält man für e = d−1 (x) 2 die Polynome U (e−1) und U (x). Alle möglichen Fehlerstellenpolynome vom Grad τ = e + τ0 sind durch Λi (x) = Pi (x)U (e) (x) + Ti (x)U (e−1) (x) berechenbar, wobei Pi (x) und Ti (x) zwei unbekannte Polynome mit grad Pi (x) = τ0 > grad Ti (x) sind. Beweis: Der erweiterte Euklidische Algorithmus berechnet U (j+1) (x) = −Q(j+1) (x)U (j) (x) + U (j−1) (x). Bis zu j+1 ≤ e hängen die Quotienten Q(j+1) (x) nicht vom RS-Codewort ab und sind deswegen identisch für alle möglichen Fehlercodes. Da wir den Quotienten Q(e+1) (x) nicht kennen, können wir U (e+1) (x) mit Unbekannten angeben zu U (e+1) (x) = −Q(e+1) (x)U (e) (x) + U (e−1) (x). Für jeden möglichen Wert von Ek−1 und Ek−2 kann man die Koeffizienten von Q(e+1) (x) bestimmen. Im nächsten Iterationsschritt errechnet man U (e+2) (x) = −Q(e+2) (x)U (e+1) (x) + U (e) (x)

= −Q(e+2) (x)(−Q(e+1) (x)U (e) (x) + U (e−1) (x)) + U (e) (x)

= (Q(e+2) (x)Q(e+1) (x) + 1)U (e) (x) − Q(e+2) (x)U (e−1) (x). Auch hier gilt, dass bei beliebigen Werten von Ek−3 und Ek−4 die Koeffizienten von Q(e+2) (x) bestimmt sind. Selbiges gilt für weitere Iterationen. 2

Satz 3.33 (Decodierung homogener IRS Codes)Wenn ` parallele RS Codes mit ` Mindestdistanz d benutzt werden, können τm = `+1 (d−1) Fehler mit hoher Wahrscheinlichkeit korrigiert werden. Beweis: Entsprechend Satz 3.32 können wir für jedes der ` Fehlercodeworte (e)

(e−1)

Λ(x) = Pi (x)Ui (x) + Ti (x)Ui

(x) i ∈ [1, `]

berechnen. Jede der ` Gleichungen für Λ(x) hat 2τ0 Unbekannte, wenn wir Λτ = 1 wählen (τ0 +1 Koeffizienten von Pi (x) und τ0 Koeffizienten von Ti (x); einer frei wählbar). Deshalb gibt es insgesamt 2`τ0 Unbekannte. Die Anzahl der Gleichungen ist (` − 1)τm , da die erste Gleichung von Λ(x) gleich den anderen (` − 1) sein muss. Wir können die Unbekannten berechnen, wenn die Anzahl der linear unabhängigen Gleichungen größer gleich der Anzahl der Unbekannten ist (` − 1)τm ≥ 2τ0 ` = 2`τ − `(d − 1) was bedeutet τm ≤

` (d `+1

− 1).

Die Einschränkung mit hoher Wahrscheinlichkeit muss gemacht werden, da die (` − 1)τm Gleichungen nicht immer linear unabhängig sind. Etwa wenn alle ` Fehlerpolynome identisch sind. 2

3.3 Algebraische Decodierung über die halbe Mindestdistanz

89

Die Wahrscheinlichkeit, dass alle ` Fehlercodeworte gleich sind ist sehr klein und wird in [SSB09] abgeschätzt. Sie ist kleiner als p4n . Eine interessante Anwendung ist, RS-Codes über GF (q ` ) mit der Länge q − 1 zu verwenden, die als ` parallele RS-Codes über GF (q) interpretiert werden können.

3.3.2

Power Decodierung

Wir werden hier die Idee aus [SSB10, Sch07] beschreiben, wie andere Fehlercodeworte des gleichen Fehlercodes durch Potenzieren (engl.: power) der Koeffizienten des empfangenen Polynoms y(x) berechnet werden können. Gemäß Faltungssatz 3.2 gilt ∀j : (yj )` = (cj + ej )`

⇐⇒

(Y (x))` mod (xn − 1).

Eine Stelle j kann bei der Potenzierung nur fehlerhaft sein, wenn ej 6= 0 ist, wegen (cj + ej )` . Deswegen erhalten wir im transformierten Bereich ein neues Fehlercodewort. Jedoch ist der Grad des potenzierten transformierten Codewortes grad(C(x))` ≤ `(k − 1). Der sichtbare Teil des neuen Fehlercodewortes (Syndrom) ist deshalb [`(k − 1), n − 1] was einer Mindestdistanz von d` = n − `(k − 1) entspricht. Wegen der Prüfgleichung Λ(x)E(x) = 0 mod (xn − 1) können wir das neue Fehlercodewort benutzen, wenn > τ Stellen sichtbar sind, was direkt eine Coderate des RS-Codes von R ≤ 1/3 impliziert. Wir wollen uns hier auf die Beschreibung der Quadrierung beschränken, aus der dann Verwendung höherer Potenzen direkt klar wird. Satz 3.34 (Power Decodierung, Quadrierung) Mit den Quadraten (yi )2 , i ∈ [0, n − 1] der Koeffizienten des Empfangspolynoms y(x) kann eine neues Fehlercodewort berechnet werden, wenn R ≤ 1/3 ist. Der Decodierradius (bei Decodierversagenswahrscheinlichkeit) ist   2(d − 1) − k + 1 τm ≤ . 3 ˜ Beweis: Durch Quadrieren erhalten wir Y 2 (x) = C 2 (x) + E(x). Der sichtbare Teil des Feh˜ lercodewortes E(x) sind n − 2k + 1 Stellen, da der Grad von C 2 (x) mindestens n − 2k + 1 ist. Wir benötigen 2τ0 Gleichungen, um entsprechend Satz 3.32 die unbekannten Polynome P (x) und T (x) zu berechnen. Wenn wir τm Fehler korrigieren wollen, gilt τm = d−1 + τ0 und damit 2 2τ0 = 2τm − d + 1. Die Anzahl an Gleichungen ergibt sich durch die Prüfgleichungen zu den ˜ n − 2k + 1 Koeffizienten des Fehlercodewortes E(x) mit Λ(x) = P (x)U (e) (x) + T (x)U (e−1) (x). Da eine Prüfgleichung τm + 1 Koeffizienten verknüpft, gibt es n − 2k + 1 − τm Prüfgleichungen. Deshalb muss gelten 2τ0 ≤ n − 2k + 1 − τm . Substituieren wir darin 2τ0 = 2τm − d + 1 ergibt sich 2τm − d + 1 ≤ n − 2k + 1 − τm , was der Behauptung entspricht. 2 Beispiel 3.11 (Power Decodierung) Gegegeben sei GF (11) mit dem primitiven Element α = 2. Es gilt mod11: 20 = 1, 21 = 2, 22 = 4, 23 = 8, 24 = 5, 25 = 10, 26 = 9, 27 = 7, 28 = 3, 29 = 6. Wir konstruieren einen RS-Code C(10, 3, 8), d.h. wir können 3 Fehler eindeutig korrigieren. Wir wählen die Information im transformierten Bereich C(x) = 3x2 + 7x + 10 und berechnen das Codewort c(x) = 6x9 + 3x8 + 8x7 + 8x6 + 6x5 + 10x4 + 5x3 + 9x2 + 3x + 9.

90

3 Reed-Solomon-Codes

Bei der Übertragung trete der Fehler e(x) = 2x7 + 7x4 + 5x3 + x auf. Damit empfangen wir das Polynom y(x) = c(x) + e(x) = 6x9 + 3x8 + 10x7 + 8x6 + 6x5 + 6x4 + 10x3 + 9x2 + 4x + 9. Das transformierte Empfangspolynom errechnet sich zu Y (x) = 8x9 + 8x8 + 7x7 + 5x6 + x5 + 10x4 + 5x3 + 6x2 + 8x + 6. Nun quadrieren wir jeden Koeffizienten von y(x) und erhalten y [2] (x) = 3x9 + 9x8 + x7 + 9x6 + 3x5 + 3x4 + x3 + 4x2 + 5x + 4. Die Transformation dieses Polynoms ergibt Y [2] (x) = 4x9 + 2x8 + 8x7 + x6 + 6x5 + 7x4 + 6x3 + 8x2 + 4x + 2. Nun berechnen wir den größten gemeinsamen Teiler von Y (x) und xn − 1 und zwar nur bis e = 3. (xn −1) : Y (x) = 7x+4 = Q(1) (x) Rest R(1) (x) = 7x8 +3x7 +6x6 +3x5 +2x4 +4x3 +8x2 +3x+8. Y (x) : R(1) (x) = 9x + 2 = Q(2) (x) Rest R(2) (x) = 2x7 + 10x6 + 10x5 + 3x4 + 2x3 + 7x2 + 7x + 1. R(1) (x) : R(2) (x) = 9x + 6 = Q(3) (x) wobei wir den Rest R(3) (x) nicht benötigen. Aus den Quotienten können wir durch Rekursion die Polynome U (3) (x) und U (2) (x) berechnen zu: U (3) (x) = 5x3 + 8x2 + 8x + 8 und U (2) (x) = 8x2 + 6x + 9 (wir haben dazu U (1) (x) = 4x + 7 benötigt). Damit wissen wir, dass ein Fehlerstellenpolynom für 4 Fehler lautet Λ(x) = (P1 x + P0 )U (3) (x) + T0 U (2) (x). Wir können Λ4 = 1 wählen, wodurch sich P1 = 9 errechnet. Damit erhalten wir die Koeffizienten von Λ(x) zu: Λ4 = 1, Λ3 = 6 + 5P0 , Λ2 = 6 + 8P0 + 8T0 , Λ1 = 6 + 8P0 + 6T0 und Λ0 = 8P0 + 9T0 . Wir können daher eine Prüfgleichung von Y [2] (x) angeben [2]

[2]

[2]

[2]

[2]

0 = Λ0 Y9 + Λ1 Y8 + Λ2 Y7 + Λ3 Y6 + Λ4 Y5 = 4(8P0 + 9T0 ) + 2(6 + 8P0 + 6T0 ) + 8(6 + 8P0 + 8T0 ) + (6 + 5P0 ) + 6 = 7P0 + 2T0 + 6.

Es ist keine zweite Prüfgleichung mit Y [2] (x) möglich, da wegen grad(C(x))2 = 4 der Koeffizient [2] Y4 nicht benutzt werden kann. Jedoch haben wir den Koeffizienten Y3 noch nicht benutzt und können deshalb die Prüfgleichung 0 = Λ0 Y7 + Λ1 Y6 + Λ2 Y5 + Λ3 Y4 + Λ4 Y3 = 7(8P0 + 9T0 ) + 5(6 + 8P0 + 6T0 ) + (6 + 8P0 + 8T0 ) + 10(6 + 5P0 ) + 5 = 2T0 + 2

verwenden. Daraus folgt direkt, dass T0 = 10 ist. Aus 0 = 7P0 + 2T0 + 6 = 7P0 + 4 folgt P0 = 1. Damit haben wir P (x) = 9x + 1 und T (x) = 10 berechnet und erhalten Λ(x) = (9x + 1)U (3) (x) + 10U (2) (x) = x4 + 6x2 + 8x + 10. Durch Auswertung an allen Stellen (Chien-Suche) erhalten wir die Nullstellen von Λ(x), nämlich {2, 5, 7, 8}. Damit sind die Fehlerstellen 1 wegen 21 = 2, 4 wegen 24 = 5, 7 wegen 27 = 7 und 3 wegen 23 = 8. 

3.4 Algebraische Listendecodierung durch Interpolation

3.4

91

Algebraische Listendecodierung durch Interpolation

Die Methode der bivariaten Interpolation verwendet die folgende Idee. Das transformierte Empfangspolynom Y (x) wird mit Λ(x) multipliziert und an allen Stellen ausgewertet, also Y (αj )Λ(αj ) = C(αj )Λ(αj ) + E(αj )Λ(αj ), j = 0, . . . , n − 1. Da E(αj )Λ(αj ) = 0 an allen Stellen ist, können wir diesen Term streichen. Nun benutzen wir die Tatsache, dass yj = C(αj ) an den Nicht-Fehlerstellen und Λ(αj ) = 0 an den Fehlerstellen ist und können schreiben yj Λ(αj ) − C(αj )Λ(αj ) = 0, j ∈ [0, n − 1]. Listendecodierung gemäß Sudan [Sud97] findet alle Codewörter, die im Abstand des gewählten Decodierradius τ um das Empfangspolynom y(x) liegen. Der Wert von τ wird durch die Listengröße L die Codelänge n und die Codedimension k wie folgt festgelegt: τ
215 3

1 + 15 + 15 · 7 + 35 · 13 > 256.

4.1.4



Berechnung des Generatorpolynoms

Die Berechnung eines Generatorpolynoms kann aufgeteilt werden, indem man die zu den jeweiligen Kreisteilungsklassen Ki gehörigen irreduziblen Polynome mi (x) getrennt berechnet und damit dann das Generatorpolynom g(x) = mi1 (x) · . . . · mis (x) bildet. In Tabelle 4.21 sind irreduzible Polynome aufgelistet (in Oktaldarstellung). Der mit Stern gekennzeichnete Eintrag in Tabelle 4.2 ist: 3

1 2

7.

Dies bedeutet: Die Kreisteilungsklasse K3 bezüglich der Zahl 26 − 1 = 63 besitzt das Polynom m3 = b 127 in Oktaldarstellung. Die Kreisteilungsklasse K3 errechnet sich zu: K3 = {3, 6, 12, 24, 48, 33} .

und das zugehörige Polynom lautet: Q m3 (x) = (x − αi ) = b i∈K3

1

= b 0 0 =

2 1 l x6 +

0

1 0 l x4 +

7 1 1 1 l l l x2 +x + 1.

Falls das zur Kreisteilungsklasse Kj gehörige Polynom mj (x) nicht in der Tabelle 4.2 aufgelistet ist, berechnet man aus Kj = {j · 2k

mod n, k = 0, . . . m − 1}

die Kreisteilungsklasse Ki mit Ki = {−j · 2k 1 Die

mod n, k = 0, . . . m − 1}

Tabelle ist ein Auszug aus der Tabelle in [PeWe, S. 476–492]

4.1 Primitive BCH-Codes

103

Tabelle 4.2: Irreduzible Polynome vom Grad ≤ 11. Grad 2

1

7

Grad 3

1

13

Grad 4

1

23

3

37

5

07

Grad 5

1

45

3

75

5

67

Grad 6

1 21

103 007

∗3

127

5

147

7

111

9

015

11

155

Grad 7

1 13

211 203

3 19

217 313

5 21

235 345

7

367

9

277

11

325

Grad 8

1 13 25 85

435 453 433 007

3 15 27

567 727 477

5 17 37

763 023 537

7 19 43

551 545 703

9 21 45

675 613 471

11 23 51

747 543 037

Grad 9

1 13 25 41 73

1021 1167 1743 1563 0013

3 15 27 43 75

1131 1541 1617 1713 1773

5 17 29 45 77

1461 1333 1553 1175 1511

7 19 35 51 83

1231 1605 1401 1725 1425

9 21 37 53 85

1423 1027 1157 1225 1267

11 23 39 55

1055 1751 1715 1275

Grad 10

1 13 25 37 49 69 85 101 149 341

2011 2157 2443 3543 3525 2701 2707 2055 3025 0007

3 15 27 39 51 71 87 103 155

2017 2653 3573 2107 2547 3323 2311 3575 2251

5 17 29 41 53 73 89 105 165

2415 3515 2461 2745 2617 3507 2327 3607 0051

7 19 31 43 55 75 91 107 171

3771 2773 3043 2431 3453 2437 3265 3171 3315

9 21 33 45 57 77 93 109 173

2257 3753 0075 3061 3121 2413 3777 2047 3337

11 23 35 47 59 83 99 147 179

2065 2033 3023 3177 3417 3623 0067 2355 3211

Grad 11

1 13 25 37 49 61 77 89 105 117 149 165 181 205 293 333

4005 4143 4577 5337 5711 4341 6263 5343 7041 5463 7621 7317 5411 7647 7723 5141

3 15 27 39 51 67 79 91 107 119 151 167 183 211 299 339

4445 4563 6233 5263 5221 6711 5235 4767 4251 5755 7161 5205 5545 6507 4303 7461

5 17 29 41 53 69 81 93 109 137 153 169 185 213 301 341

4215 4053 6673 5361 6307 6777 7431 5607 5675 6675 4731 4565 7565 6037 5007 5253

7 19 31 43 55 71 83 99 111 139 155 171 199 215 307

4055 5023 7237 5171 6211 7715 6455 4603 4173 7655 4451 6765 6543 7363 7555

9 21 33 45 57 73 85 101 113 141 157 173 201 217 309

6015 5623 7335 6637 5747 6343 5247 6561 4707 5531 6557 7535 5613 7201 4261

11 23 35 47 59 75 87 103 115 147 163 179 203 219 331

7413 4757 4505 7173 4533 6227 5265 7107 7311 7243 7745 4653 6013 7273 6447

und das Polynom mj (x) ergibt sich durch Rückwärtslesen von mi (x), d. h. mj (x) = x

grad mi (x)

  1 · mi . x

Beispiel 4.4 (Benutzung der Tabelle 4.2) Sei n = 127 = 27 − 1. Die Kreisteilungsklasse K15 ist: K15 = {15, 30, 60, 71, 99, 113, 120}.

104

4 BCH-Codes

In Tabelle 4.2 ist m15 nicht enthalten. Wir berechnen (mod127): -15 = 112, -30 = 97, -60 = 67, -71 = 56, -99 = 28, -113 = 14, -120 = 7, d. h. dies entspricht der Kreisteilungsklasse K7 . Aus der Tabelle 4.2 entnehmen wir: m7 = b 367 = b 011110111 = x7 + x6 + x5 + x4 + x2 + x + 1.

Rückwärtslesen:

m15 = x7 + x6 + x5 + x3 + x2 + x + 1.

4.2



Nicht-primitive BCH-Codes

Definition 4.8 (Nicht-primitiver BCH-Code) Sei β ∈ GF (2m ) ein Element der Ordnung n < 2m − 1, seien Ki die Kreisteilungsklassen bzgl. n und sei M die Vereinigungsmenge von beliebig vielen Kreisteilungsklassen, so hat ein nicht-primitiver BCHCode die Länge n und das Generatorpolynom Y g(x) = (x − β i ). i∈M

Die geplante Mindestdistanz ist d, falls d − 1 aufeinanderfolgende Zahlen in M existieren. Die wirkliche Mindestdistanz δ ist δ ≥ d.

Das meistbenutzte Beispiel für nicht-primitive BCH-Codes ist der perfekte Golay-Code G23 . Beispiel 4.5 (Golay-Code) Der Golay-Code G23 hat die Länge n = 23 und die Dimension k = 12. Wir benötigen ein Element der Ordnung 23. Gemäß Satz 2.21 muss gelten: n | 2m − 1. 23 6 | 31, 23 6 | 63, 23 6 | 127, . . ., 23 6 | 1023, 23 | 2047, 23 · 89 = 2047. D. h., das Element α89 ∈ GF (211 ) hat die Ordnung 23. Bestimmen wir die Kreisteilungsklassen bzgl. 23, so erhalten wir: K1 = {1, 2, 4, 8, 16, 9, 18, 13, 3, 6, 12}. Wir benötigen keine weitere Kreisteilungsklasse, da die Dimension k = n − |K1 | = 23 − 11 = 12 schon erreicht ist. Die geplante Mindestdistanz für G23 ist d = 5, da vier aufeinanderfolgende Zahlen in K1 enthalten sind. Die wirkliche Mindestdistanz ist 7. Das Generatorpolynom g(x) errechnet sich zu (β = α89 ∈ GF (211 )): g(x) = (x − β)(x − β 2 )(x − β 3 )(x − β 4 )(x − β 6 )(x − β 8 )(x − β 9 )·

· (x − β 12 )(x − β 13 )(x − β 16 )(x − β 18 ).

Aus Tabelle 4.2 entnehmen wir m89 (x) = b 5343: m89 (x) = b 5 = b 1 0 1 = x11 + x9 +

0

3 1 1 x7 +x6 +

4 1 0 x5 +

0

0

3 1 1 x+1.

Damit ist das Generatorpolynom von G23 :

g(x) = x11 + x9 + x7 + x6 + x5 + x + 1.



4.3 Verkürzte und erweiterte BCH-Codes

4.3

105

Verkürzte und erweiterte BCH-Codes

Verkürzte BCH-Codes Definition 4.9 (Verkürzter BCH-Code) Sei C ein BCH-Code der Länge n, der Dimension k, der geplanten Mindestdistanz d und dem Generatorpolynom g(x) (Definitionen 4.2 und 4.4), also: C = {i(x)g(x) | grad i(x) < k}.

Benutzt man nur Informationspolynome i(x) mit grad i(x) < k ∗ < k, so erhält man einen verkürzten BCH-Code C ∗ der Länge n∗ = n − (k − k ∗ ), der Dimension k ∗ und der geplanten Mindestdistanz d. Anders ausgedrückt bedeutet dies, wir benutzen nur eine Teilmenge des Codes, nämlich genau die Codewörter, die in den obersten k − k ∗ Informationsstellen 0 sind. Das Verkürzen ist auch bei RS-Codes möglich. Eine weitere Methode, um einen Code zu verkürzen ist die Punktierung (puncturing). Dabei wird eine (oder mehrere) Koordinate(n) (Stelle(n)) eines Codeworts gestrichen. Im Gegensatz zum Verkürzen gemäß Definition 4.9 ändert sich dabei meistens die Mindestdistanz (sie wird kleiner). Dafür bleibt die Dimension k gleich. Sowohl die Punktierung als auch das Verkürzen ist prinzipiell bei allen Codes möglich. Beim Punktieren bleibt die Anzahl der Codewörter erhalten. Damit können wir nun BCH-Codes nahezu beliebiger Länge konstruieren. Erweiterte BCH-Codes Definition 4.10 (Erweiterter BCH-Code) Sei C ein binärer Code. Der erweiterte Code Cˆ hat die Länge n + 1, d. h. eine Stelle, die den Wert 0 oder 1 hat, wird derart hinzugefügt, dass alle Codewörter a ∈ Cˆ gerades Gewicht haben. Die Erweiterung (Extension) eines Codes ist prinzipiell für jeden Code möglich. Ein erweiterter Code ist linear aber nicht mehr zyklisch! (Man beachte, dass jedoch die doppelte Erweiterung von RS-Codes (Abschnitt 3.1.7) zyklisch ist). Satz 4.11 (Mindestdistanz des erweiterten Codes) Ist die Mindestdistanz d eines ˆ Codes ungerade, so ist die Mindestdistanz dˆ des erweiterten Codes C: dˆ = d + 1.

ˆ = wt(ˆ ˆ Die Mindestdistanz ist gleich dem Minimalgewicht und damit Beweis: dist(ˆ a, b) a − b). gilt: Sei a ∈ C, wt(a) = d =⇒ wt(ˆ a) = d + 1. 2

Offensichtlich ist die Erweiterung eines Codes, der nur Codewörter mit geradem Gewicht besitzt, sinnlos, da man im voraus weiß, welchen Wert die zugefügte Stelle hat. Eine Erweiterung eines Codes auf ungerades Gewicht ist unzulässig, da der sich ergebende Code nicht mehr linear ist: 0 −→ 00 . . . 01,

(a + a) = 0 6∈ C,

a ∈ C.

106

4.4

4 BCH-Codes

Nicht-binäre BCH-Codes und RS-Codes

Die BCH-Codes können auch über nicht-binären Erweiterungskörpern definiert werden. Der Zusammenhang zwischen RS- und BCH-Codes wird dabei deutlich.

4.4.1

Nicht-binäre BCH-Codes

Sowohl primitive, als auch nicht-primitive BCH-Codes können nicht-binär sein. Dazu modifiziert man die entsprechenden Definitionen, indem man statt GF (2) einen Körper GF (q) benutzt. Dabei kann q eine Primzahl p oder eine Primzahlpotenz pl sein. Je nachdem, ob für die Ordnung n des Elements aus GF (q m ) gilt: n = q m − 1 oder n < q m − 1, erhält man einen primitiven bzw. nicht-primitiven BCH-Code der Länge n über dem Alphabet GF (q). Die Kreisteilungsklassen errechnen sich zu: Ki = {i · q j

mod n, j = 0, 1, . . . , m − 1}.

Das Generatorpolynom, die Mindestdistanz und die Dimension ergeben sich analog zu den entsprechenden Definitionen. Ein zweifach erweiterter RS-Code kann entsprechend Abschnitt 3.1.7 als nicht-primitiver BCH-Code definiert werden.

4.4.2

Zusammenhang zwischen RS- und BCH-Codes

Häufig findet man sowohl die Aussage, dass die RS-Codes eine Untermenge von BCHCodes sind, als auch diejenige, dass die BCH-Codes eine Untermenge von RS-Codes sind. Welche Aussage ist richtig? Die Antwort lautet: beide. Dies soll im Folgenden erläutert werden. Wir haben die BCH-Codes als Untermenge von RS-Codes beschrieben, indem wir ausgenutzt haben, dass gemäß Satz 4.1 ein Generatorpolynom nur Koeffizienten aus GF (q) hat, wenn wir alle konjugiert komplexen Wurzeln aus GF (q m ) benutzen. Anders ausgedrückt: BCH(n ≤ q m − 1, k = n − |M|, d ≤ δ) über GF (q) ⊂ RS(n ≤ q m − 1, k, d = n − k + 1) über GF (q m ), denn wir wählen als Codeworte des BCH-Codes nur diejenigen aus, die nur Komponenten aus GF (q) haben. Die Benutzung von mehr Nullstellen des Generatorpolynoms als für die Mindestdistanz notwendig sind bedingt, dass der BCH-Code nicht mehr die MDS-Eigenschaft hat. Andererseits gilt: Limitieren wir bei einem BCH-Code mit den Parametern (n ≤ q m − 1, k, d) über GF (q) die Länge auf n ≤ q − 1, so erhalten wir einen RS-Code mit den Parametern (n ≤ q − 1, k, d = n − k + 1): RS C(n ≤ q m − 1, k, d = n − k + 1) über GF (q m ) ⇓

Subfield-Subcode



Längenbeschränkung

BCH C(n ≤ q m − 1, k = n − |M|, d ≤ δ) über GF (q) RS C(n ≤ q − 1, k, d = n − k + 1) über GF (q).

4.5 Asymptotisches Verhalten von BCH-Codes

107

Beispiel 4.6 (Zusammenhang von RS- und BCH-Codes) Wir konstruieren einen (n = 53 − 1 = 124, k = 100, d = 124 − 100 + 1 = 25)-RS-Code über GF (53 ). Der Subfield-Subcode ist ein (n = 53 − 1, k = 66, d = 25)-BCH-Code über dem GF (5). Durch Längenbeschränkung erhalten wir einen (n = 5 − 1 = 4, k < 4, d = n − k + 1)-RS-Code, ebenfalls über GF (5). 

4.5

Asymptotisches Verhalten von BCH-Codes

Primitive BCH-Codes sehr großer Länge sind schlecht, d. h. es existieren – wenn man die Länge n gegen unendlich gehen lässt – keine BCH-Codes, deren Coderate R = k d n > 0 und gleichzeitig deren Verhältnis „Mindestdistanz zu Länge“ n > 0 ist. Dies wird auch als asymptotisch schlecht bezeichnet. Diese Tatsache gilt nicht für „kurze“ BCH-Codes bis zur Länge ∼ 213 , unter denen sich viele sehr gute Codes befinden. Außerdem bieten BCH-Codes die Eigenschaften: gute Decodierbarkeit, Konstruktion für nahezu beliebige Längen und gute Codierbarkeit. Daher werden BCH-Codes in der Praxis häufig verwendet. Satz 4.12 (BCH-Codes sind asymptotisch schlecht) Es existieren keine binären primitiven BCH-Codes, für die gilt: nd > ε und gleichzeitig nk > ε für n → ∞. Beweis: Für einen vollständigen Beweis wird auf [McWSl], Theorem 13, S. 269, verwiesen. Wir müssen zeigen, dass für n −→ ∞ entweder d/n gegen 0 geht, falls k/n nicht gegen 0 geht, oder aber k/n gegen 0 geht, falls d/n nicht gegen 0 geht: (i) (ii)

k >0 n d aus >0 n

aus

folgt folgt

d −→ 0, n k −→ 0. n

Wir werden nur den einfacheren Teil (i) zeigen. Für primitive BCH-Codes gilt: k = n − |M|, |M| ≤ m · (d − 1). Die Abschätzung |M| ≤ m · (d − 1) erhält man durch folgende Überlegung: Die Kreisteilungsklasse K1 ergibt auf jeden Fall d = 3, da {1, 2} ∈ K1 . Die Erhöhung der Mindestdistanz ist sicher größer gleich 1, wenn man eine weitere Kreisteilungsklasse hinzunimmt. Somit ergibt sich die obere Schranke für |M|, und wir erhalten: k ≥ n − m · (d − 1). Aus „k/n geht nicht gegen 0“ folgt: 1−

m · (d − 1) m · (d − 1) > 0 =⇒ < 1, n n

d
t, cR(ge ) 6= 0, d. h. c ∈ / CtA . Der Widerspruch beweist A Beziehung (6.8). Nun zeigen wir, dass |A| = dim(Ct ) = t − Rang(HA t ) gilt. Mit |B| = dim(CtB ) = n − t − Rang(HB t ) erhalten wir |S| = |G| − |A| − |B|

B = k − t + Rang(HA t ) − n + t + Rang(Ht ) B = Rang(HA t ) + Rang(Ht ) − Rang(H).

Somit erfüllt |Vt | Gleichung (6.6) und T ist minimal.

6.7 Minimales Trellis von linearen Blockcodes

155

⇐ Das Trellis T sei minimal und G sei keine LR-Matrix. Ohne Beschränkung der Allgemeinheit soll L (gi ) = L (gj ) und R (gi ) < R (gj ) sein. Wird die Zeile gj in der Generatormatrix G durch gj + gi ersetzt, erhalten wir G0 . Das Trellis T (G0 ) hat weniger Knoten |Vt0 | in der Tiefe L (gi ). Die Konstruktion beweist ⇐. 2

In den Beispielen 6.8 und 6.9 wurde gezeigt, dass die LR-Matrix G von Beispiel 6.8 das minimale Trellis ergibt. Die Matrix G aus Beispiel 6.9 ergab hingegen nicht das minimale Trellis. Die LR-Matrix kann jedoch aus jeder Generatormatrix mit Hilfe von Algorithmus 6.1 konstruiert werden. Algorithmus 6.1: Der LR-Algorithmus. Solange die LR-Eigenschaft nicht erfüllt ist finde ein Paar (i, j), so dass (L (gi ) = L (gj ) und R (gi ) ≥ R (gj )) oder (R (gi ) = R (gj ) und L (gi ) ≤ L (gj )) gi = gj + gi Beispiel 6.10 (Konstruktion einer LR-Matrix) Es soll der (5, 3, 2)-Code von Beispiel 6.7 betrachtet werden. Dieser Code hat die Parity-Check-Matrix „ « 1 1 0 1 0 H= . 0 1 1 0 1 Eine mögliche Generatormatrix des Codes lautet: 0

1 0 0 1 G = @0 1 0 1 0 0 1 0

1 0 1A . 1

Diese Matrix besitzt nicht die LR-Eigenschaft. Nun wird der LR-Algorithmus auf G angewendet. Nach dem ersten Schritt erhalten wir 0 1 1 0 0 1 0 G1 = @0 1 1 1 0A . 0 0 1 0 1 Nach dem zweiten Schritt ergibt sich eine LR-Generatormatrix

GLR

0

1 1 1 0 = @0 1 1 1 0 0 1 0

1 0 1 0 g1 0A = @g2 A . 1 g3

Satz 6.21 besagt, dass das minimale Trellis des Codes als das Shannon-Produkt von T (C) = T (g1 ) ∗ T (g2 ) ∗ T (g3 ) errechnet werden kann (vergleiche Bilder 6.11 und 6.12). Man erkennt, dass die minimalen Trellisse des (5, 3, 2)-Codes in diesem Beispiel und aus Bild 6.5 übereinstimmen. 

156

6 Eigenschaften von Blockcodes und Trellisdarstellung t=0

T (g1 ) :

T (g2 ) :

T (g1 ) ∗ T (g2 ) :

t=1

t=2

t=3

t=4

a

a

a

a

b

b

c

c

c

c

d

d

(a, c)

(a, c)

(a, c)

(b, c)

(b, c)

t=5

a

(b, d)

1 (a, d)

0

(a, d)

Abb. 6.11: Erster Schritt zur Berechnung eines minimalen Trellis für den (5, 3, 2)-Code aus Beispiel 6.10. t=0

T (g3 ) :

 T (g1 ) ∗ T (g2 ) ∗ T (g3 ) :

t=1

t=2

t=3

t=4

e

e

e

e

f

f

(a, c, e) (a, c, e) (a, c, e)

(a, e)

(b, c, e) (b, c, e) (a, c, f )

(a, f )

t=5

(b, d, e) (a, d, e)

1 (a, d, e) (a, d, f )

0

Abb. 6.12: Minimales Trellis, erhalten aus dem (5, 3, 2)-Code aus Beispiel 6.10.

6.7.3

Eigenschaften eines minimalen Trellis

Nun sollen einige Eigenschaften eines Codetrellis betrachtet werden. Da die Menge der Endteile eines linearen Codes separierbar ist (vergleiche Lemma 6.16) können nur Codeworte c, die gemeinsame Endteile (oder gemeinsame Zustände σ(c)) haben, durch einen gemeinsamen Knoten führen. Wir bezeichnen σ(c) als Zustand des Knotens ϑ,

6.7 Minimales Trellis von linearen Blockcodes

157

d. h. σ(ϑ) = b σ(c). Der Zustand σ(c) kann unter Verwendung des vorderen Teils cA t oder des Endteils cB t berechnet werden.

Zwei Knoten ϑ1 und ϑ2 in der Tiefe t eines Codetrellis T (C) werden äquivalent genannt, wenn σ(ϑ1 ) = σ(ϑ2 ) gilt. Zwei äquivalente Knoten können zusammengefasst werden und das entstandene Trellis beschreibt denselben Code. Wenn die Knoten ϑ1 und ϑ2 zusammengefasst werden, müssen alle Zweige, die mit ϑ1 und ϑ2 verbunden sind, nun mit dem gemeinsamen Knoten ϑ verbunden werden (gegebenenfalls werden parallele Zweige gelöscht). Ein Codetrellis, das keine äquivalenten Knoten besitzt, wird kanonisch genannt. Somit ist ein kanonisches Trellis eines linearen Codes so aufgebaut, dass alle Codeworte c mit dem Zustand σ t (c) in der Tiefe t durch einen gemeinsamen Knoten führen. Darum ist ein kanonisches Trellis eines linearen Codes eindeutig und isomorph zum Syndromtrellis. Ein Trellis ist isomorph zu einem anderen, wenn er aus diesem nur durch Umordnung der Knoten erzeugt werden kann. Offensichtlich kann ein kanonisches Trellis eines linearen Codes aus jedem anderen Codetrellis durch Zusammenfassen von äquivalenten Knoten konstruiert werden. Das kanonische Trellis hat minimale Knotenanzahl |V|. Die Umkehrung gilt auch, d. h. ein Trellis mit minimalen |V| ist kanonisch (ohne Beweis). Satz 6.22 (Kanonisches Trellis) Ein Codetrellis eines linearen Codes ist genau dann minimal, wenn es kanonisch ist. Eine Folgerung daraus ist, dass das Syndromtrellis minimal ist, da es kanonisch ist. Alle kanonischen Trellisse eines gegebenen linearen Codes sind isomorph. Mit Satz 6.22 erhalten wir: Satz 6.23 (Eindeutigkeit des minimalen Trellis) Alle minimalen Trellisse eines linearen Codes sind isomorph. Im folgenden wollen wir zeigen, dass das minimale Trellis eines linearen Codes nicht nur die kleinste Knotenanzahl |V| sondern auch die kleinste Zweiganzahl |E| und die kleinste zyklomatische Zahl Z(T ) = |E| − |V| + 1 hat. Somit ist die Komplexität der Decodierung eines Codes in minimaler Trellisdarstellung mit dem Viterbi-Algorithmus minimal. ˜ E) ˜ ein minimales (kanoSatz 6.24 (Minimale zyklomatische Zahl) Sei T˜ = (V, nisches) Trellis eines linearen Codes C und T = (V, E) ein nicht-minimales Trellis des Codes C. Dann gelten die folgenden Ungleichungen: ˜ < |V|, i) |V|

˜ < |E| ii) |E|

und

iii) Z(T˜) ≤ Z(T ).

Bevor wir den Satz beweisen, benötigen wir noch einige Zwischenergebnisse. Die Knoten ϑ0 , ϑ00 ∈ Vt in der Tiefe t werden gleichbenachbart genannt, wenn sie mit einem Knoten in der Tiefe t − 1 oder t + 1 durch Zweige e0 und e00 verbunden sind, die die gleichen Nummern c(e0 ) = c(e00 ) haben. Offensichtlich können gleichbenachbarte Knoten zusammengefasst werden. Wir wollen im Folgenden beweisen, dass ein Trellis, das gleichbenachbarte Knoten enthält, nicht kanonisch sein kann.

158

6 Eigenschaften von Blockcodes und Trellisdarstellung

ϑ′

ϑ′

α

α oder

ϑ

ϑ

α

α ϑ′′

ϑ′′

Abb. 6.13: Gleichbenachbarte Knoten (Lemma 6.25).

Lemma 6.25 (Gleichbenachbarte Knoten) Ein Trellis eines linearen Codes ist genau dann minimal (kanonisch), wenn es keine gleichbenachbarten Knoten hat. Beweis: Es genügt zu zeigen, dass jedes nicht-kanonische Trellis gleichbenachbarte Knoten hat. T (C) sei ein nicht-kanonisches (nicht-minimales) Trellis eines linearen Codes. L(ϑ) sei die Menge aller vorderen Teile derjenigen Codeworte aus T (C), die den Knoten ϑ beinhalten. R(ϑ) bezeichne die entsprechenden Endteile. Es existieren mindestens zwei Knoten ϑ1 , ϑ2 ∈ Vt für die gilt: σ (ϑ1 ) = σ (ϑ2 ) = σ. Die Menge der Knoten der Tiefe t, die den Zustand σ haben, sollen mit ϑ1 , . . . , ϑl ∈ Vt bezeichnet werden. Diese Menge besitzt die folgende Eigenschaft: Es existieren darin zwei Knoten ϑ0 und ϑ00 , für die i) entweder ein Codewort existiert, dessen vorderer Teil sowohl ϑ0 als auch ϑ00 enthält, ii) oder es existiert ein Codewort, dessen Endteil ϑ0 und ϑ00 enthält. Ansonsten wären die Mengen L (ϑ1 ) , . . . , L (ϑl ) (wie auch R (ϑ1 ) , . . . , R (ϑl )) paarweise disjunkt, d. h.: L (ϑi ) ∩ L (ϑj ) = ∅,

R (ϑi ) ∩ R (ϑj ) = ∅,

∀i 6= j, ∀i 6= j.

(6.9) (6.10)

Werden die gleichbenachbarten Knoten ϑ1 , . . . , ϑl zusammengefasst, erhalten wir ein Codetrellis T 0 (C), der u. a. die Codeworte S = {L (ϑ1 ) , R (ϑ2 )} enthält. Diese Codeworte haben in der Tiefe t den Zustand σ, daher mussten sie im Trellis T (C) einige der Knoten ϑ1 , . . . , ϑl beinhalten. Aber ausden Gleichungen (6.9) und (6.10) folgt, dass alle vorderen Teile der Codeworte in der Tiefe t (L (ϑ1 )) nur den Knoten ϑ1 beinhalten, und dass die entsprechenden Endteile (R (ϑ2 )) nur den Knoten ϑ2 beinhalten. Deshalb besitzt T (C) keine Codeworte aus der Menge S. Dieser Widerspruch beweist die Eigenschaft. Nehmen wir jedoch an, dasselbe Codewort beinhalte die Knoten ϑ0 und ϑ00 , dann gibt es zwei Pfade e0 und e00 mit diesen Knoten, und es gilt: c (e0 ) = c (e00 ). Dies aber bedeutet, dass zwei Knoten nach einer Verzweigung von e0 und e00 gleichbenachbart sind. 2 Beweis von Satz 6.24: Zum Beweis stellen wir uns ein Verfahren vor, das in jedem Schritt ein Paar gleichbenachbarter Knoten eines Trellis (solange solche vorhanden sind) vereinigt und damit ein neues Trellis konstruiert. Falls keine gleichbenachbarten Knoten mehr vorhanden sind, ist das Trellis gemäß Lemma 6.25 minimal. Da aber T (V, E) als nicht-minimal vorausgesetzt wurde, gibt es mindestens ein Paar gleichbenachbarter Knoten. Für jeden Schritt unseres Verfahrens gilt daher:

6.7 Minimales Trellis von linearen Blockcodes

159

• Die Anzahl der Knoten verringert sich um 1, d. h. i) ist korrekt. • Die Anzahl der Zweige verringert sich um mindestens 1 (> 1 kann z. B. auftreten, wenn parallele Übergänge vorhanden sind), d. h. ii) ist korrekt. • Die zyklomatische Zahl bleibt damit gleich oder verringert sich, d. h. iii) ist korrekt. 2

In [LBB96] wurde gezeigt, dass der folgende Algorithmus aus einem beliebigen Trellis ein minimales Trellis erzeugt. Beispiel 6.11 veranschaulicht diesen Algorithmus. Algorithmus 6.2: Algorithmus zur Erzeugung eines minimalen Trellis. Gegeben sei ein beliebiges Trellis T eines Codes C(n, k, d).

• Vereinige für t = 1, . . . , n − 1 alle gleichbenachbarten Knoten der Tiefe t, d. h. deren Zweige von Knoten der Tiefe t − 1 aus gleiche Symbole besitzen. • Vereinige für t = n − 1, . . . , 1 alle gleichbenachbarten Knoten der Tiefe t, d. h. deren Zweige von Knoten der Tiefe t + 1 aus gleiche Symbole besitzen.

• Das konstruierte Trellis ist minimal. Beispiel 6.11 (Algorithmus zur Erzeugung eines minimalen Trellis) Sechs Codewörter des (4, 3, 2)-Parity-Check-Codes werden ausgehend von der trivialen Trellisdarstellung mit dem

01

0

10 01 01 1 0 1 0 01 01 01 0 1 1 1 01 01 01 1 0 0 1 01 01 01 0 0 1 01 01 010 1 0 1 01 01 01 Abb. 6.14: Triviales Trellis. 0

1

0

1

01

Algorithmus schrittweise in ein minimales Trellis überführt, siehe Bild 6.14 und 6.15.



Die folgenden Definitionen eines minimalen Trellis sind gleichwertig: Ein minimales Trellis besitzt minimales |V|, ein minimales Trellis besitzt minimales |E|, und ein minimales Trellis ist kanonisch. Einige bisher beschriebene Ergebnisse können u. a. auf nichtlineare Codes und auf Gruppen-Codes verallgemeinert werden. Dazu definieren wir zunächst separierbare Codes.

160

6 Eigenschaften von Blockcodes und Trellisdarstellung

10 0 1 11 1 0 01 0 01 1 0 0 01 1 01 0

vorw¨arts

1

0

1

0

1 0 1

1

1

0

0

1

0

1

0 0

1

0

1 0 1

1

1

0

0

1

1

0 1

1

0

0

1

1

0

1

0

0

1

Minimales Trellis f¨ur B.

1

1

0

0

t=3 1

0

1

0

1 0 1

0 1

0

t=2 1

1

1

0

1 0

0

0

t=1 0

1

1 0

0

0

0

1

1

0

1

0

0

1

0 0

1

1 0 1

1

0

0

r¨uckw¨arts

Abb. 6.15: (zu Beispiel 6.11) Schrittweise Erzeugung des minimalen Trellis aus dem ursprünglich trivialen Trellis durch Verschmelzen von Zweigen.

Definition 6.26 (Separierbarer Code) Ein Code heißt separierbar, wenn die Endteile dieses Codes bezüglich der Tiefen t = 0, 1, . . . , n − 1 separierbar sind, d. h. die Endteile, die zu zwei unterschiedlichen vorderen Teilen gehören, sind entweder identisch oder disjunkt. Lemma 6.16 gilt damit auch für separierbare Codes. Weiterhin sind auch Satz 6.22, Satz 6.23, Satz 6.24 und Lemma 6.25 auf separierbare Codes anwendbar. Deshalb hat ein separierbarer Codes ein eindeutiges minimales Trellis (ausgenommen Isomorphismen) mit minimaler Anzahl von Knoten und Zweigen. Die Decodierung eines separierbaren Codes mit dem Viterbi-Algorithmus hat minimale Komplexität, wenn das minimale Codetrellis verwendet wird. Zur Separierbarkeit weiterer Codeklassen: Alle linearen Codes sind separierbar (Lemma 6.16). Des weiteren sind alle GruppenCodes separierbar. Ein Gruppen-Code ist dabei wie folgt definiert: Ein Alphabet Q sei eine additive Gruppe (auch nichtlinear) und die Codeworte eines Codes C stellen eine Gruppe (Abschnitt 2.1, Seite 29) bezüglich der komponentenweisen Addition der Codeworte dar. Eine allgemeinere Definition ergibt sich, wenn jede i-te Komponente eines Codewortes aus einem Alphabet Qi ist. Es kann gezeigt werden, dass Lemma 6.16 auch für Gruppen-Codes gilt, die damit ebenfalls separierbar sind. Weiterhin ist bekannt [SMH96], dass einige nichtlineare Codes auch separierbar sind. Im speziellen handelt es sich dabei um die Hadamard-Codes (Abschnitt 5.1.4, Seite 119), die Levenshtein-Codes [McWSl], die Delsarte-Goethals-Codes, die Kerdock-Codes und den Nordstrom-Robinson-Code (siehe z. B. [McWSl]). Anmerkung: Wir haben in diesem Abschnitt Codes betrachtet, deren Stellen gegeben waren, d. h. wir haben die Reihenfolge der Codewortpositionen als konstant betrach-

6.8 Anmerkungen

161

tet. Die Permutation der Spalten der Generator- oder Parity-Check-Matrix des Codes C ˜ Die Anzahl der Knoten |V| ˜ in dem minimalen Trelführt auf einen äquivalenten Code C. ˜ ˜ und |V| um mehrere lis von C kann kleiner oder größer als |V| sein. Dabei können sich |V| Zehnerpotenzen unterscheiden. Ein selbst für lineare Codes ungelöstes Problem besteht ˜ führt, darin, die Permutation zu finden, die auf ein minimales Trellis mit minimalem |V| das wir als optimales Trellis bezeichnen wollen. Neben vollständiger Suche gibt es eine Reihe von Algorithmen zur Lösung des Problems, die unterschiedliche Komplexität besitzen, jedoch nicht garantiert eine optimale Permutation finden. Einige Verfahren sind in [EBMS96] untersucht. Die Klasse der RM-Codes in Standard-Bitdarstellung [KTFL93] besitzt bereits ein optimales Trellis. Daraus folgt, dass auch für einige BCH-Codes gute Permutationen existieren, da diese als verkürzte RM-Codes betrachtet werden können (vergleiche Seite 296).

6.8

Anmerkungen

In diesem Kapitel haben wir einige allgemeine Eigenschaften von Codes dargestellt. Zunächst haben wir den zu einem Code C dualen Code C ⊥ definiert. Dabei ergab sich, dass die Prüfmatrix von C gerade der Generatormatrix von C ⊥ entspricht. Damit ergibt ein Codewort multipliziert mit einem Codewort des dualen Codes Null. Diese Eigenschaft werden wir im nächsten Kapitel benutzen, um mit Codewörtern des dualen Codes C ⊥ Decodierverfahren zu definieren. Wir haben die Gewichtsverteilung eines Codes C definiert und die MacWilliams-Identität, die im Jahre 1962 veröffentlicht wurde, angegeben. Der Beweis folgt der Arbeit [CW80]. Mit der MacWilliams-Identität kann man aus der Gewichtsverteilung eines Codes C die Gewichtsverteilung des dualen Codes C ⊥ berechnen. Ferner haben wir den Automorphismus kennengelernt, der, auf ein Codewort angewendet, die Koordinaten derart permutiert, dass sich wieder ein Codewort ergibt. Anschließend haben wir neben der Hamming-Schranke [Ham50] aus dem Jahre 1950, die bereits in Kapitel 1 auf Seite 9 eingeführt wurde, noch weitere Schranken vorgestellt. Wir haben die Gilbert- und die Varshamov-Schranke angegeben, die häufig als eine Schranke bezeichnet werden. Varshamov hat seine Arbeit [Var57] im Jahre 1957 veröffentlicht und Gilbert 1952 [Gil52]. Es handelt sich um untere Schranken, die aussagen, dass gute Codes existieren. Die Varshamov-Schranke ist etwas enger und sagt aus, dass lineare Codes existieren, die diese Schranke erreichen. Danach haben wir die Singleton-Schranke aus dem Jahre 1964 [Sin64] angegeben. Erfüllt ein Code die Singleton-Schranke mit Gleichheit, so hat der Code die Eigenschaft Maximum-Distance-Separable (MDS). Diese Eigenschaft hatte überraschende Konsequenzen. Zum einen ist die (Hamming-) Gewichtsverteilung für MDS-Codes berechenbar, zum anderen ist ein Codewort durch beliebige k Stellen eindeutig bestimmt. Wir haben gezeigt, dass, abgesehen von den trivialen Codes, keine binären MDS-Codes existieren. Singleton scheint der erste gewesen zu sein, der sich explizit mit MDS-Codes beschäftigt hat. Eine Verallgemeinerung der Singleton-Schranke für andere Metriken und einen einfachen Beweis für nichtlineare Codes findet man in [BS96]. Des weiteren haben wir zur Bündelfehlerkorrektur die Reiger-Schranke eingeführt.

162

6 Eigenschaften von Blockcodes und Trellisdarstellung

Danach haben wir alle bisher kennengelernten Schranken sowie die McEliece-RodemichRumsey-Welch-Schranke asymptotisch dargestellt. Für die Varshamov-Schranke ergab sich die Unsicherheitsfunktion, d. h. es können gute Codes existieren. Aus der HammingSchranke ergab sich die Kanalkapazität. Wir haben lineare Blockcodes durch ein Trellis beschrieben, das minimale Trellis definiert und Methoden seiner Konstruktion angegeben. Es wurde bewiesen, dass das Syndromtrellis minimal ist, und dass die trellisorientierte Generatormatrix ebenfalls ein minimales Trellis ergibt. Ferner wurde gezeigt, dass ein minimales Trellis sowohl minimale Knotenanzahl |V| als auch minimale Zweiganzahl |E| sowie eine minimale zyklomatische Zahl Z(T ) = |E| − |V| + 1 aufweist. Die Decodierung eines Blockcodes kann mit Hilfe des Trellis erfolgen (vergleiche Kapitel 7). Es sei nochmals erwähnt, dass für eine feste Reihenfolge der Stellen des Codes ein minimales Trellis konstruiert werden kann. Permutiert man die Stellen, so kann man erneut ein minimales Trellis mit gegebenenfalls wesentlich geringerer Komplexität erhalten. Unter allen Permutationen existieren solche, bei denen das minimale Trellis eine minimale Knotenanzahl besitzt. Dieses wird als optimales Trellis bezeichnet. Dazu werden derzeit noch Forschungsarbeiten durchgeführt. Einige Algorithmen und Überlegungen hierzu findet man u. a. in [Ksc96] und [EBMS96]. Die Geschichte der Theorie über das minimale Trellis von Blockcodes ist recht jung. Die Beschreibung von Blockcodes mittels Trellis geht zurück auf das Jahr 1974. Bahl, Cocke, Jelinek und Raviv [BCJR74], Wolf [Wolf78] und Massey [Mas78] haben diese Beschreibung eingeführt. Erst 1988 lebte das Interesse an dieser Darstellung wieder auf, bedingt durch die Arbeiten von Forney [For88b] und Muder [Mud88], die die Definition eines minimalen Trellisses eingeführt haben. Erst im Jahre 1993 wurde durch Zyablov, Sidorenko [ZS94] und Kot, Leung [KL93] bewiesen, dass die Trellisdefinitionen von Bahl et al. [BCJR74], Wolf [Wolf78] und Massey [Mas78] für lineare Codes minimal sind. Die Benutzung einer trellisorientierten Generatormatrix wurde auch in [For88b] durch Forney vorgeschlagen. Kschischang, Sorokine [KS95] und Sidorenko et al. [SMH96] haben dann das Shannon-Produkt eingeführt, um das Trellis eines Blockcodes zu konstruieren. Die Theorie zu trellisorientierten Generatormatrizen sowie die Methoden, dadurch ein minimales Trellis zu erhalten, wurde von McEliece in [McE96] beschrieben. Des weiteren wird darin bewiesen, dass das minimale Trellis eines linearen Blockcodes minimales |E| besitzt. Dass das minimale Trellis zudem minimales |E| − |V| + 1 besitzt, wurde dann sowohl in [KS95], als auch in [Sid97] bzw. [SMH97] bewiesen. Die Theorie zum minimalen Trellis wurde in den Arbeiten [FT93, Ksc96, KS95, Sid97, SMH97] und [VK96] auf Gruppen-Codes und separierbare Codes erweitert. Weitere Ergebnisse findet man in [DRS93] und [Sid96].

6.9 Übungsaufgaben

6.9

163

Übungsaufgaben

Aufgabe 6.1 Zeigen Sie, dass der Viterbi-Decodieralgorithmus2 angewendet auf ein Codetrellis T = (V, E) |E| Additionen und |E| − |V| + 1 binäre Vergleiche erfordert. Aufgabe 6.2 Wählen Sie eine Prüfmatrix H und eine Generatormatrix G und a) konstruieren Sie das Syndromtrellis; b) konstruieren Sie das minimale Trellis unter Benutzung der Generatormatrix des Codes. Aufgabe 6.3 Geben Sie ein Beispiel für einen Code an, für den bezüglich der Anzahl der Knoten |Vt | in der Tiefe t eines minimalen Trellisses |Vt | < 2min{k,n−k}

∀t

gilt. ` ´ ` ´ Aufgabe 6.4 T (C) sei das minimale Trellis eines linearen Codes C, und T C ⊥ = V ⊥ , E ⊥ sei das minimale Trellis des dualen Codes C ⊥ . Zeigen Sie, daß gilt |Vt | = |Vt⊥ |. Aufgabe 6.5 Gegeben sei ein binärer linearer (n, k)-Code C. Betrachten Sie die 2n−k Cosets des Codes C1 = C, C2 , . . . , C2n−k . Schlagen Sie eine Verallgemeinerung des Viterbi-Algorithmus vor, die es erlaubt, für ein empfangenes Wort y das Wort mit geringster Hamming-Distanz zu y aus C1 = C, C2 , . . . , C2n−k gleichzeitig zu finden (gleichzeitige ML-Decodierung von Cosets). Aufgabe 6.6 Stellen Sie mit Hilfe einer Generatormatrix ein minimales Trellis eines (8, 4)Reed-Muller-Codes auf, wobei jeweils 2 aufeinanderfolgende Symbole einen Zweig bezeichnen sollen.

2 Der

Viterbi-Algorithmus wird in Kapitel 7 eingeführt

7

Weitere Decodierverfahren

In diesem Kapitel werden wir die Decodierung von Blockcodes erörtern. Dazu benötigen wir zusätzliche Kanalmodelle, die wir in Abschnitt 7.1 definieren werden. Eine für die Decodierung wesentliche Beziehung zwischen (Code-)Vektoren ist ihr Abstand zueinander. Daher werden wir Distanzmaße oder Metriken einführen, die es erlauben, den Abstand von Vektoren zu messen. Explizit werden die Hamming-Metrik und die euklidische Metrik definiert. Im Anhang B sind neben der formalen mathematischen Definition einer Metrik noch die Lee-, Mannheim-, Manhattan- und die kombinatorische Metrik beschrieben. Welche Metrik zur Decodierung verwendet wird ist dabei u. a. abhängig vom betrachteten Kanalmodell. In Abschnitt 7.2 werden allgemein die fundamentalen Decodierprinzipien Maximum-Likelihood- (ML-) und Maximum-a-posteriori- (MAP-) Decodierung vorgestellt. Anschließend werden diese Decodierprinzipien auf den Fall binärer Symbole übertragen. Dabei ist die Zuverlässigkeit einer Entscheidung von zentraler Bedeutung für die Decodierung. Verfahren zur Signalschätzung können Zuverlässigkeitsinformation zur Verfügung stellen. Der Begriff der Zuverlässigkeit wird anhand einiger Beispiele erläutert. Danach werden die Decodierregeln für die ML- und MAP-Decodierung mit und ohne Zuverlässigkeitsinformation hergeleitet. Ein Nachteil dieser Decodierprinzipien ist ihre exponentiell mit der Codelänge ansteigende Decodierkomplexität. Daher wird in Abschnitt 7.2.3 über den Satz von Evseev gezeigt, dass näherungsweise ML-Decodierung bei wesentlich geringerer Komplexität möglich ist. In Abschnitt 7.2.4 wird beschrieben, was es aus Systemsicht bedeutet, Redundanz zu verwenden. Wir werden den Codiergewinn definieren, sowohl unter Berücksichtigung der aufgewendeten Sendeenergie, als auch der Netto-Datenrate (Informationsdatenrate). Die eigentlichen Decodieralgorithmen sind in drei Abschnitte gegliedert. Im ersten Abschnitt 7.3 werden Decodierverfahren ohne Zuverlässigkeitsinformation beschrieben, die wir als Hard-Decision-Decodierung bezeichnen wollen. Entsprechend werden dann in Abschnitt 7.4 die Decodierverfahren, die Zuverlässigkeitsinformation verwenden, SoftDecision-Decodierung genannt. In Abschnitt 7.5 wird die Decodierung als Optimierungsproblem formuliert und mit den dort üblichen Algorithmen gelöst (es handelt sich hierbei auch um Soft-Decision-Decodierung). Zur Hard-Decision-Decodierung: Neben dem algebraischen Decodierverfahren mit Berlekamp-Massey- oder Euklidischem Algorithmus zur Lösung der Schlüsselgleichung (Abschnitt 3.2) existieren noch weitere Decodierverfahren, deren Notwendigkeit unter anderem durch die Geschwindigkeit der Decodierung und ihre Komplexität begründet werden kann. Es ist eine Erfahrungstatsache, dass die Berechnung des Syndroms, das über die DFT definiert ist, einen großen Teil der Decodierzeit in Anspruch nimmt. Wir werden die Permutationsdecodierung und die Mehrheits-Decodierung (majority-logic decoding) erläutern. Danach werden wir noch den Algorithmus DA beschreiben, der in der Lage ist auch bestimmte Fehler mit Gewicht größer als die halbe Mindestdistanz zu decodieren.

166

7 Weitere Decodierverfahren

Zur Soft-Decision-Decodierung: Hier werden wir zwei Grundkonzepte unterscheiden, nämlich die Decodierung basierend auf Codesymbolen, sowie die Decodierung basierend auf Codeworten. Als Beispiele für die symbolweise Decodierung werden wir den BahlCocke-Jelinek-Raviv- (BCJR-) Algorithmus zur MAP-Decodierung basierend auf einem Trellisdiagramm, die gewichtete Mehrheitsdecodierung oder APP-Decodierung (APP, a posteriori probability) nach Massey und die iterative APP-Decodierung als deren Verallgemeinerung vorstellen. Diese Verfahren liefern neben der harten Decodierentscheidung auch noch eine Zuverlässigkeitsinformation über diese Entscheidung, was für die Decodierung verketteter Codes (siehe Kapitel 9) von großer Bedeutung ist. Für die Hard-Decision-Decodierung wurde eine ML-Decodierung bereits in Kapitel 1 als Standard-Array-Decodierung eingeführt. Eine wesentlich kompaktere Darstellung des Codes ist die durch ein minimales Trellis. Das bekannteste Verfahren zur MaximumLikelihood-Decodierung basierend auf einem Trellisdiagramm ist dabei der Viterbi-Algorithmus, der in Abschnitt 7.4.3 vorgestellt wird. Bei den iterativen Verfahren wird der believe propagation Algorithmus eingesetzt. Wir werden die Generalized-MinimumDistance-Decodierung (GMD-Decodierung) sowie die Algorithmen von Chase beschreiben. Der Dorsch Algorithmus wurde weiterentwickelt und ist unter ordered statistics decoding bekannt. Ein weiteres Soft-Decision-Decodierverfahren speziell für Reed-MullerCodes findet man in Abschnitt 9.6. In Abschnitt 7.5 wird die Decodierung von Codes als Optimierungsproblem formuliert, und die bekannten Verfahren wie der Simplex-Algorithmus, das Branch-and-Bound- und das Gradienten-Verfahren werden auf ihre Verwendbarkeit zur Decodierung untersucht. Es werden sich dabei zahlreiche Parallelen zu den Listen-Decodierverfahren ergeben.

7.1

Kanalmodelle und Metriken

Zur Konzeptionierung von digitalen Übertragungssystemen werden Modelle benötigt, die alle wesentlichen Komponenten des Systems hinreichend gut beschreiben. Anhand eines Systemmodells können dann durch Simulation die Parameter der einzelnen Komponenten entsprechend den Anforderungen an das System optimiert werden. Bild 7.1 zeigt ein vereinfachtes Schema einer digitalen Übertragungsstrecke. Der Informationsvektor i wird vom Codierer in ein Codewort c abgebildet. In diesem Kapitel beschränken wir uns dabei auf Blockcodes der Länge n, Dimension k und Mindestdistanz d. Die Codesymbole werden vom Modulator in Signale x abgebildet. Dann erfolgt die Übertragung der Signale über den Kanal. Unter einem Kanal verstehen wir dabei das physikalische Medium, das verwendet wird, um ein Signal vom Sender zum Empfänger zu übertragen, d. h. der freie Raum, ein Kupferkabel, etc. Das Sendesignal wird bei der Übertragung über einen beliebigen Kanal zufällig gestört. Die gestörten Signale y gelangen zum Empfänger und werden dort demoduliert bzw. detektiert. i

Codierer

c

Modulator

x

y Kanal

Demodulator

Decodierer

ˆi

Abb. 7.1: Senden von binären Symbolen.

Bei der Modellierung einer digitalen Übertragungsstrecke ist das Kanalmodell, das reale Kanäle, wie z. B. Satellit-Erdstation, Schiff-Heimathafen, Mobilteil-Basisstation, Tele-

7.1 Kanalmodelle und Metriken

167

fonleitung zwischen Modems, usw. nachbildet, sehr wichtig. Die Modulation und Codierung bzw. Demodulation und Decodierung müssen so gewählt werden, dass sie den Kanal entsprechend den Anforderungen an das System möglichst effizient nutzen. Es werden mathematische Modelle verwendet, die die Störungen auf dem Kanal möglichst getreu nachbilden. Hat man ein Modell gefunden, das eine Übertragungssituation hinreichend gut beschreibt, so ist man durch Simulation verschiedener Modulations- und Kanalcodierungsschemata in der Lage, dasjenige zu bestimmen, das die Anforderungen an das Übertragungssystem am besten erfüllt. Im Folgenden werden wir die für die Analyse von Decodierverfahren gebräuchlichsten Kanalmodelle beschreiben. Bei gedächtnisfreien Kanälen sind die Störungen im Kanal unabhängig von der Vergangenheit. Dazu wollen wir das Modell des q-nären symmetrischen Kanals und das Modell des Kanals mit additivem weißen Gaußschen Rauschen (AWGN) sowie seine Erweiterung auf einen zeitvarianten Fading-Kanal beschreiben. Sowohl das AWGN-Kanalmodell als auch das Modell des q-nären symmetrischen Kanals werden häufig für die Decodierung mit Zuverlässigkeitsinformation benutzt. Ein Beispiel für ein gedächtnisbehaftetes Kanalmodell ist das Gilbert-Elliot-Modell. Es wird zur Nachbildung eines Kanals mit Bündelstörungen verwendet.

7.1.1

q-närer symmetrischer Kanal

Das Kanalmodell des q-nären symmetrischen Kanals ist charakterisiert durch die q Eingangssymbole αj ∈ GF (q), die übertragen werden sollen, die Q Ausgangssymbole yi und die entsprechenden Kanalübergangswahrscheinlichkeiten P (yi | αj ), i ∈ [1, Q], j ∈ [1, q]. Symmetrisch bedeutet, dass die Wahrscheinlichkeit einer korrekten Übertragung für alle Zeichen gleich groß ist. Ebenfalls ist die Fehlerwahrscheinlichkeit für alle Zeichen gleich groß. Bild 7.2 zeigt das Kanalmodell, das im wesentlichen eine Erweiterung des BSC nach Bild 1.2 darstellt. P (yi |αj )

α1

y1

y2

α2 .. . αq

.. .

.. . yQ

Abb. 7.2: q-närer symmetrischer Kanal.

Wir wollen zwei Fälle unterscheiden: Im ersten Fall sei das Alphabet der zu übertragenden Zeichen αj gleich dem der empfangenen Zeichen yi (q = Q). Der Empfänger übergibt dem Decodierer also nur Zeichen aus dem für den Code zulässigen Alphabet. Mit diesem Modell werden Kanäle beschrieben,

168

7 Weitere Decodierverfahren

bei denen keine Zuverlässigkeitsinformation aus der Signalschätzung verwendet wird, d. h. ein empfangenes Symbol kann nur korrekt oder falsch sein. Im zweiten Fall ist das Alphabet des Empfängers größer als das des Senders (q < Q). So wird z. B. häufig das Alphabet des Empfängers um ein Symbol, die Auslöschung (⊗), erweitert. Die Auslöschungskorrektur wurde bereits in Abschnitt 3.2.7 erläutert. Durch ein erweitertes Alphabet des Empfängers kann noch darüber hinaus gehende Zuverlässigkeitsinformation (siehe Abschnitt 7.2.2) in das Kanalmodell integriert werden, was die Decodierfähigkeit erheblich verbessert.

7.1.2

Additives weißes Gaußsches Rauschen (AWGN)

Zur Beschreibung von kontinuierlichen, zeitinvarianten Kanälen wird das AWGN-Modell (additive white Gaussian noise) verwendet. Es stellt das weitaus wichtigste Kanalmodell zum Vergleich von Codierverfahren dar. Ein klassisches Beispiel für den AWGN-Kanal ist die Weltraumkommunikation (deep space communication). Zur Anwendung des kontinuierlichen Kanalmodells ist zunächst der Übergang von den diskreten Zahlenräumen (den Galoisfeldern) auf reelle Zahlenräume nötig. Mit Hilfe der Signalraumdarstellung [Kam, Bos12] werden den unterschiedlichen Codesymbolen Punkte in einem ein- oder mehrdimensionalen reellen Raum (Rn ) zugeordnet. Die Kanalstörung besteht aus der additiven Überlagerung von weißem, mittelwertfreiem, normalverteiltem (Gaußschem) Rauschen der Varianz σ 2 = N0 /2, wobei N0 die einseitige spektrale Rauschleistungsdichte darstellt. Die Störungen sind dabei von Symbol zu Symbol unkorreliert, so dass zur vollständigen Beschreibung die Wahrscheinlichkeitsdichte ausreicht. Im Falle eines additiven weißen Gaußschen Rauschkanals wird also der Sendevektor x durch einen additiven Zufallsprozeß n gestört. Das empfangene Signal ist somit: yi = xi + ni ,

i ∈ [1, n] .

Die Wahrscheinlichkeitsdichtefunktion der Zufallsvariablen ni ist in Bild 7.3 für ein festes Signal-Rauschleistungsverhältnis dargestellt. Es sei Es die mittlere Energie pro empfangenem Zeichen und N0 die einseitige Rauschs leistungsdichte des Zufallsprozesses n. Dann nennt man E σ 2 das empfangene SignalRauschleistungsverhältnis. Der AWGN-Kanal ist gedächtnislos und vollständig durch seine Übergangswahrscheinlichkeitsdichte p(y | x) =

n Y l=1

p(yl | xl ) ,

p(yl | xl ) = √

√   (yl ± Es xl )2 · exp − 2σ 2 2πσ 2 (7.1) 1

√ beschrieben. Der Erwartungswert ± Es für den Signalanteil wird üblicherweise auf ±1 normiert.

7.1 Kanalmodelle und Metriken

169

p(x)

1

0.5

−3

−2

−1

0 x

1

2

3

Abb. 7.3: Gaußverteilte Wahrscheinlichkeitsdichte.

7.1.3

Zeitvariante Kanäle

Kanäle, die ihre Eigenschaften wie Bitfehlerrate oder Signal-Rauschleistungsverhältnis während der Übertragung mit der Zeit verändern, bezeichnet man als zeitvariant. Ein Beispiel hierfür sind Mobilfunkkanäle. Die exakte Beschreibung ist dabei recht schwierig und aufwendig und hängt von vielen Parametern ab. Für die Kanalcodierung begnügt man sich daher mit stark vereinfachten Modellen, die nur noch die wesentlichen Merkmale beschreiben. Das ist zum einen die Verteilung der Empfangsamplitude und zum anderen deren zeitliche Korrelation, d. h. die Art des Gedächtnisses des Kanals. Anhand der Beschreibung der Amplitudenverteilung lassen sich die Modelle wieder in kontinuierliche, z. B. den Rayleigh-Kanal, und diskrete Modelle, z. B. das Gilbert-Elliot-Modell, einteilen. Rayleigh-Kanal Der Rayleigh-Kanal stellt einen AWGN-Kanal mit zeitlich variierender Signalamplitude dar: yi = ai · xi + ni . Zu der additiven Rauschstörung ni kommt die multiplikative Störung ai hinzu, die Rayleigh-verteilt ist: 2

fa (a) = 2 a e−a ,

a > 0.

Damit ergibt sich die Kanalbeschreibung zu:   1 (y − a x)2 √ f (y | a, x) = exp − , N0 π N0

(7.2)

170

7 Weitere Decodierverfahren

wobei hier die bedingte Übergangswahrscheinlichkeitsdichte von zwei Parametern, dem Sendesignal x und der Kanalamplitude a, abhängt. Aufgrund der Zeitvarianz wird der Rayleigh-Kanal über das mittlere Signal-Rauschleistungsverhältnis (Es /N0 bzw. Eb /N0 ) charakterisiert. Da die mittlere Energie E{a2 } des Rayleigh-Prozesses auf eins normiert ist, ergibt sich das mittlere Es /N0 bzw. Eb /N0 nach der gleichen Definition wie beim AWGN-Kanal. Bezüglich der Bitfehlerrate sind Kanäle mit variierender Amplitude, wie der Rayleigh-Kanal, bei gleichem mittleren Signal-Rauschleistungsverhältnis stets schlechter als ein Kanal mit konstanter Amplitude. Der Grund liegt darin, dass bei zeitvarianten Kanälen die Zeitabschnitte mit kleiner Kanalamplitude maßgeblich die Bitfehlerrate bestimmen. Verwendet man den Rayleigh-Kanal als Modell für den Mobilfunk, so sind aufeinanderfolgende Kanalamplituden ai korreliert, wobei man in der Regel ein Jakes-Leistungsdichtespektrum annimmt [Kam, Bos12]. Um Codierverfahren unabhängig von der Geschwindigkeit der Kanaländerungen (Breite des Jakes-Spektrums) und dem verwendeten Interleaver testen zu können, verwendet man in Simulationen mitunter auch einen Rayleigh-Prozeß mit unkorrelierten Werten ai . In diesem Falle spricht man vom optimal interleavten Rayleigh-Kanal (vergleiche zu Interleaving Abschnitt 8.4.4). Bei der Decodierung ist zu unterscheiden, ob die Kanalamplitude ai dem Empfänger bekannt ist oder nicht. Bei Kenntnis dieser Kanalzustandsinformation (channel state information, CSI) kann diese bei der Decodierung zur Verbesserung des Ergebnisses miteinbezogen werden, dies wird Soft-Decision-Decodierung genannt. Gilbert-Elliot-Modell Das Gilbert-Elliot-Modell beschreibt Bündelfehler dadurch, dass der Kanal zwei Zustände annehmen kann, einen guten und einen schlechten, mit G und B in Bild 7.4 bezeichnet. Der gute Zustand (G) stellt einen BSC mit geringer Bitfehlerwahrschein1 − pg pg

G

B

pB

1 − pB Abb. 7.4: Gilbert-Elliot-Modell.

lichkeit pg und der schlechte (B) einen mit hoher Bitfehlerwahrscheinlichkeit pb dar, in dem dann sehr viele Fehler dicht hintereinander, d. h. Bündelfehler, auftreten. Mit der Wahrscheinlichkeit pG bleibt der Kanal im guten Zustand, und mit 1 − pG wechselt er vom guten in den schlechten (Bild 7.4). Die Wahrscheinlichkeit, dass sich der Kanal im guten Zustand befindet sei pgood , und pbad = 1 − pgood sei die Wahrscheinlichkeit, dass er sich im schlechten Zustand befindet. Damit ergibt sich: pgood = pgood · pG + pbad · (1 − pB ) =

1 − pB . 2 − pG − pB

Für die mittlere Bitfehlerrate des Kanals errechnet man: pbit = pgood · pg + (1 − pgood ) · pb =

pg (1 − pB ) + pb (1 − pG ) . 2 − pG − pB

7.1 Kanalmodelle und Metriken

171

Es ist bekannt, dass ein Kanal mit Gedächtnis eine größere Kapazität besitzt als ein Kanal ohne Gedächtnis [Gil60], d. h., dass es Codes gibt, die mit weniger Redundanz die gleiche Restbitfehlerwahrscheinlichkeit erzielen wie über einen gedächtnislosen Kanal mit gleicher mittlerer Restbitfehlerwahrscheinlichkeit (siehe z. B. [Bre97]).

7.1.4

Hamming- und euklidische Metrik

Ein wichtiges Kriterium für die Decodierung ist die zugrunde liegende Metrik. Eine Metrik ist ganz allgemein ein Maß für die Entfernung (den Abstand) zwischen Elementen einer Menge. Bei der Decodierung ist diese Menge gegeben durch die Empfangsvektoren, d. h. im Folgenden werden zur Decodierung Metriken verwendet, die den Abstand zwischen einem Codewort und einem beliebigen anderen Vektor aus dem Empfangsalphabet beschreiben. Die formale Definition der Metrik ist im Anhang B gegeben. An dieser Stelle werden lediglich die Metriken eingeführt, die für die in diesem Abschnitt beschriebenen Decodierverfahren für binäre Blockcodes relevant sind, nämlich die Hamming-Metrik und die euklidische Metrik. Weitere Metriken, wie z. B. Lee-, Manhattan- und Mannheim-Metrik, die kombinatorische Metrik und die translatorischbzw. zyklisch-kombinatorische Metrik und ihre Anwendungen werden ebenfalls in Anhang B beschrieben. Die Hamming-Metrik haben wir schon in Kapitel 1 eingeführt. Wir wollen sie hier jedoch nochmals formal definieren. Sie ist besonders geeignet für den binären Fall, d. h. bei Verwendung von Elementen aus GF (2) bzw. Vektoren aus Fn2 mit Komponenten aus GF (2). Im nichtbinären Fall (etwa GF (2m )) kann man mit Hilfe der Hamming-Metrik nur zwischen Fehler und Nichtfehler unterscheiden, selbst wenn nur eines der m Bits falsch ist. Seien x und y zwei Symbole des Alphabets GF (q), so ist die Hamming-Metrik wie folgt definiert:  0, x = y dH (x, y) = 1 , x 6= y. Die Hamming-Distanz zweier Vektoren x, y ist die Anzahl der unterschiedlichen Stellen von x und y: dH (x, y) =

n X j=1

dH (xj , yj ) = wH (x − y).

(7.3)

Das Hamming-Gewicht oder die Hamming-Norm eines Vektors x gibt die Anzahl der von Null verschiedenen Stellen von x an: wH (x) =

n X

dH (xj , 0) = dH (x, 0).

j=1

Die euklidische Metrik ist für x, y ∈ R definiert zu: p dE (x, y) = (x − y)2 .

172

7 Weitere Decodierverfahren

Für den n-dimensionalen Fall ergibt sich die euklidische Distanz zu: p dE (x, y) = (x1 − y1 )2 + · · · + (xn − yn )2 .

(7.4)

Die euklidische Metrik ist geeignet für Signale bzw. wenn jedes Symbol eines Codewortes als Signal beschrieben wird. Für die Norm kxk von x gilt: wE (x) = kxk = dE (x, 0). Anmerkung: Man beachte folgende Metrik: dE (x, y) = p p Eigenschaft der euklidischen p (x1 − y1 )2 + · · · + (xn − yn )2 6= (x1 − y1 )2 + · · · + (xn − yn )2 . Diese Eigenschaft kann zu Problemen führen, wenn z. B. der zweidimensionale Raum als kartesisches Produkt von zwei eindimensionalen Räumen beschrieben werden soll. Daher benutzt man bei der Verkettung von Codes häufig die quadratische euklidische Distanz, bei der dieses Problem nicht auftritt (vergleiche hierzu Kapitel 10). Jedoch ist die quadratische euklidische Distanz keine Metrik, da die Dreiecksungleichung nicht erfüllt ist (siehe Anhang B).

7.2

Decodierprinzipien, Zuverlässigkeit, Komplexität und Codiergewinn

Wir nehmen an, das Codewort x wird übertragen und der Vektor y wird empfangen. Vom Kanalmodell kennen wir die bedingten Wahrscheinlichkeiten P (y | x) =

7.2.1

n Y

i=1

P (yi | xi ).

MAP- und ML-Decodierung

Prinzipiell kann man eine Entscheidung über ein ganzes Codewort oder über ein einzelnes Symbol (unter der Annahme, dass dieses Symbol Teil eines Codewortes ist) treffen. In beiden Fällen kann man ML- oder MAP-Decodierung durchführen. Die Decodierˆ entscheiden unter der ung sollte auf das am wahrscheinlichsten gesendete Codewort x Annahme, dass y empfangen wurde, also     P (y | x)P (x) ˆ = arg max P (x | y) = arg max x , x∈C x∈C P (y) wobei wir die Regel von Bayes angewendet haben. Die Wahrscheinlichkeit P (y) ist konstant und kann daher bei der Maximierung weggelassen werden. Maximum-a-Posteriori-Decodierung (MAP)   ˆ = arg max P (x | y)P (x) . x x∈C

7.2 Decodierprinzipien, Zuverlässigkeit, Komplexität und Codiergewinn

173

Wenn man die a-priori Wahrscheinlichkeit P (x) nicht kennt oder alle Codeworte gleichwahrscheinlich sind kann diese auch weggelassen werden. Maximum-Likelihood-Decodierung (ML)   ˆ = arg max P (x | y) . x x∈C

Die Codewortfehlerwahrscheinlichkeit ergibt sich zu (vergleiche auch Abschnitt 1.4): X PBlock = P (ˆ x 6= x | y) P (y). (7.5) y

MAP- und ML-Decodierer bestimmen also das am wahrscheinlichsten gesendete Codewort, ersterer unter Einbeziehung der a-priori Wahrscheinlichkeit, und erreichen dadurch die minimale Codewortfehlerwahrscheinlichkeit. Eine Entscheidung eines Symbols xˆi summiert die Wahrscheinlichkeiten aller Codeworte, die an der Stelle xi einen bestimmten Wert besitzen. Im binären Fall teilen wir den (0) Code C in zwei Teilmengen auf, wobei die Stelle i bei allen Codeworten in Ci gleich (0) null ist und in Ci gleich eins. Symbolweise Maximum-a-posteriori-Decodierung (s/s-MAP)      X  X xˆi = arg max P (x | y)P (x), P (x | y)P (x) .    (0)  (1) x∈Ci

(7.6)

x∈Ci

Bei der symbolweisen ML-Decodierung wird die a-priori Wahrscheinlichkeit weggelassen. Ist ein Empfangsvektor y gegeben, wird also für jede Position i das am wahrscheinlichsten gesendete Codesymbol bestimmt. Dieses Decodierprinzip liefert minimale Codesymbolfehlerwahrscheinlichkeit. Anmerkung: Im Falle einer nichtsystematischen Codierung muss das Ergebnis der symbolweisen Decodierung aller n Stellen nicht notwendigerweise ein Codewort sein. Das Ergebnis der Decodierung ist lediglich für jede einzelne Stelle des Empfangsvektors die optimale Entscheidung, nicht aber für alle n Stellen gemeinsam als Codewort. Es kann also ein Decodierversagen vorliegen, falls kein gültiges Codewort erreicht wurde. In diesem Fall kann die Information nicht berechnet werden. Anders im Falle einer systematischen Codierung. Hier entscheidet man nur die k Informationsstellen und diese bestimmen damit auch das entsprechende Codewort (somit kann in diesem Fall kein Decodierversagen auftreten). Allerdings ist dieses Codewort nicht notwendigerweise identisch mit dem Soft-Decision-Maximum-Likelihood (SDML)-Codewort, siehe nächster Abschnitt.

7.2.2

Zuverlässigkeit für die binäre Übertragung

Wir wollen zur Erläuterung des Begriffes Zuverlässigkeitsinformation den einfachen Fall annehmen, dass binäre Symbole über einen AWGN-Kanal (siehe Abschnitt 7.1.2) übertragen werden. Der Fall höherwertiger Symbolalphabete ist aus dem binären entsprechend ableitbar.

174

7 Weitere Decodierverfahren

Wir nehmen an, zur Modulation wird binäre Phasenumtastung (binary phase shift keying, BPSK [Kam, Bos12]) verwendet, d. h. die Codesymbole ci ∈ {0, 1} werden in Modulationssymbole xi ∈ {+1, −1} abgebildet, entsprechend der Vorschrift: xi = (−1)ci , i ∈ [1, n].

Die Bezeichnungen c und x werden im Folgenden synonym verwendet. Nach der Übertragung über den AWGN-Kanal erhalten wir entsprechend Gleichung (7.1) folgende (im Bild 7.5 dargestellte) Verteilung für die Empfangssymbole yi : p(yi | xi = ±1) = √

1 2πσ 2

· e−

(yi ∓1)2 2σ 2

.

(7.7)

Wir nehmen an, die yi -Achse in Bild 7.5 ist in Intervalle der Breite ∆yi eingeteilt, da in praktischen Anwendungen sehr häufig nur mit quantisierten Werten gerechnet wird. 1

0.5

−3

I−2

I−1

I1

−2

−1

I2

I3

I4

p(y|0)

I−3

p(y|1)

yi

I−4

0 x

1

2

3

Abb. 7.5: Wahrscheinlichkeitsdichtefunktion für yi .

Nehmen wir weiter an, dass ein empfangener Wert yi im Intervall I2 (Bild 7.5) liege, so ist die Wahrscheinlichkeit, dass dieser Wert durch eine gesendete +1 empfangen wurde: Z p(yi | xi = +1)dyi = b hellgraue Fläche in Bild 7.5 , I2

bzw. dass er durch eine gesendete −1 entstanden ist: Z p(yi | xi = −1)dy = b dunkelgraue Fläche in Bild 7.5. I2

Liegt also ein empfangener Wert yi im Intervall I2 , so ist eine gesendete +1 viel wahrscheinlicher als eine gesendete −1. Da obige Integrationen über das gleiche Intervall I2

7.2 Decodierprinzipien, Zuverlässigkeit, Komplexität und Codiergewinn

175

erfolgen, gilt ebenso, dass p(yi | xi = +1) groß ist im Vergleich zu p(yi | xi = −1). Um ein Maß für die Zuverlässigkeit eines Empfangswerteszu erhalten,genügt es den Betrag p(yi | xi =+1) von yi zu betrachten, da nach Gleichung (7.7) gilt: ln p(y ∼ sign(yi ) · |yi |. Der i | xi =−1) Betrag von yi kann also als Zuverlässigkeitsinformation interpretiert werden, während das Vorzeichen von yi der Entscheidung (Hard-Decision) entspricht. Gelingt es, diese zusätzliche Information in ein Decodierverfahren zu integrieren, so spricht man von Soft-Decision-Decodierung, wodurch sich die Decodierfähigkeit erheblich verbessert. L-Werte für den BSC und AWGN-Kanal In vielen Fällen ist es nützlich, anstatt der obigen Wahrscheinlichkeiten ihr Log-Likelihood-Verhältnis zu betrachten (im Folgenden kurz „L-Wert“ genannt). Hagenauer hat in [HOP96] die sogenannte Log-Likelihood-Algebra zur Berechnung von Zuverlässigkeiten eingeführt. An dieser Stelle werden lediglich die Log-Likelihood-Wahrscheinlichkeitsverhältnisse für den BSC sowie für den AWGN-Kanal berechnet. Die Wahrscheinlichkeit für das Auftreten des (Informations-) Symbols xi vor der Übertragung ist durch die a-priori-Wahrscheinlichkeit Pa (xi ) gegeben. Das Log-LikelihoodVerhältnis La (xi ) der Variablen xi ist dann:   Pa (xi = +1) La (xi ) = ln . (7.8) Pa (xi = −1) Das a-posteriori Log-Likelihood-Verhältnis erhält man nach der Regel von Bayes:   P (xi = +1 | yi ) L(ˆ xi ) = L(xi , yi ) = L(xi | yi ) = ln P (xi = −1 | yi )     p(yi | xi = +1) Pa (xi = +1) = ln + ln p(yi | xi = −1) Pa (xi = −1) = L(yi | xi ) + La (xi ).

Das Vorzeichen von L(xi | yi ) entspricht der harten Entscheidung und der entsprechende Betrag |L(xi | yi )| der Zuverlässigkeit dieser Entscheidung. Der Wert L(yi | xi ) ist dabei abhängig vom zugrunde liegenden Kanalmodell. • Symmetrischer Binärkanal (BSC):

   1−p   für yi = 0 + ln  p  Mit ci ∈ {0, 1} gilt: L(yi | ci ) = 1−p   − ln für yi = 1. p

• AWGN-Kanal und BPSK-Modulation: Nach Gleichung (7.1) gilt:   p(yi | xi = +1) 2 L(yi | xi ) = ln = 2 · yi = Lch · yi p(yi | xi = −1) σ

mit σ 2 = N0 /2 und N0 als einseitiger Rauschleistungsdichte. Der Term Lch ist ein konstanter Faktor, der nur vom Signal-Rauschleistungsverhältnis abhängt.

176

7 Weitere Decodierverfahren • Zeitvarianter Kanal: Der Term Lch wird mit einem Amplitudenfaktor ai multipliziert [HOP96]: L(yi | xi ) = ai ·

2 · yi = ai · Lch · yi . σ2

Maximum-Likelihood-Decodierung für binäre Übertragung Entsprechend Abschnitt 7.2.1 bedeutet ML-Decodierung die Bestimmung des am wahrscheinlichsten gesendeten Codewortes. Im Folgenden wird dieses Prinzip für die Übertragung von binären Symbolen über einen BSC sowie über einen AWGN-Kanal detailliert angegeben. Hard-Decision-Maximum-Likelihood-Decodierung (HDML): Es sei der Empfangsvektor r ∈ GF (2)n gegeben. Für einen BSC mit der Fehlerwahrscheinlichkeit p ist die Wahrscheinlichkeit, dass sich r von dem gesendeten Codewort c in genau t = dH (r, c) Stellen unterscheidet, gegeben durch: P (r | c) = pt (1 − p)n−t . Die Anwendung des Logarithmus (der streng monoton wachsend ist) auf eine zu maximierende Größe verändert das maximale Argument nicht, ln P (r | c) = −t · ln

1−p + n · ln(1 − p). p

Daraus folgt: Ein Maximieren der Likelihoodfunktion ist gleichbedeutend mit der Minimierung der Hamming-Distanz zwischen der empfangenen Folge r (bzw. yH ) und einem zulässigen Codewort c. Aus diesem Grund wird ein ML-Decodierer für einen BSC auch als Minimum-Distance-Decodierer bezeichnet. Soft-Decision-Maximum-Likelihood-Decodierung (SDML): Es wird erneut BPSK-Übertragung über einen AWGN-Kanal betrachtet. Des weiteren wird angenommen, dass alle Codeworte gleichwahrscheinlich sind. Da der AWGN-Kanal gedächtnislos ist, gilt: n Y p(y | x) = p(yl | xl ) . l=1

Man erhält das SDML-Codewort: ( ˆ = arg max x x∈C

2πσ

 n 2 −2

 )! n 1 X · exp − 2 (xl − yl )2 2σ

   2 = arg min dE (x, y) , x∈C

l=1

(7.9)

Pn 2 wobei d2E (x, y) = l=1 |xl − yl | die quadratische euklidische Distanz zwischen dem Codewort x und dem Empfangsvektor y ist. Folglich hat das SDML-Codewort minimale quadratische euklidische Distanz zum Empfangsvektor.

7.2 Decodierprinzipien, Zuverlässigkeit, Komplexität und Codiergewinn

177

Für die quadratische euklidische Distanz zwischen einem Codewort x und dem Empfangsvektor y gilt: d2E (x, y) =

n X l=1

n X

x2l − 2 ·

xl yl +

l=1

n X l=1

yl2 = n + const − 2 ·

n X

xl yl . (7.10)

l=1

Daraus folgt, dass die Minimierung der quadratischen euklidischen Distanz gleich der Maximierung des Skalarproduktes von x und y ist. Eine weitere Sichtweise ergibt sich, wenn man das Skalarprodukt wie folgt schreibt: n X l=1

xl yl =

n n X X |yl | − 2 · |yl |. l=1

(7.11)

l:xl 6=ylH

Damit minimiert ein SDML-Decodierer die Summe der Zuverlässigkeiten |yl | an den zu korrigierenden Stellen. Symbolweise MAP-Decodierung für BPSK-Übertragung über einen AWGN-Kanal Entsprechend Abschnitt 7.2.1 bedeutet symbolweise MAP-Decodierung die Bestimmung des am wahrscheinlichsten gesendeten Codesymbols. Im Fall eines AWGN-Kanals kann die MAP-Wahrscheinlichkeit wie folgt berechnet werden. Wir partitionieren den Code C bezüglich Position i, (±1)

Ci

= {x ∈ C | xi = ±1},

(+1)

C = Ci

(−1)

∪ Ci

(+1)

Ci

,

(−1)

∩ Ci

= ∅.

und erhalten die MAP-Wahrscheinlichkeit für Position i in Form eines Log-LikelihoodVerhältnisses:   n P Q p(y | x ) · P (x ) l l a l      x∈Ci(+1) l=1  P (xi = +1 | y)   L(ˆ xi ) = ln = ln  P Q n  P (xi = −1 | y)  p(yl | xl ) · Pa (xl )  (−1)



x∈Ci

P

l=1 n Q



p(xl , yl )    x∈Ci(+1) l=1   . = ln  n  P Q   p(xl , yl )  (−1)

x∈Ci

(7.12)

l=1

Man beachte, dass weiterhin gilt: P (xi = +1 | yi ) + P (xi = −1 | yi ) = 1. Damit erhält man nach einigen Umformungen: 1

P (xi = ±1 | yi ) =

1 e− 2 ·L(xi ,yi ) · e 2 ·L(xi ,yi )·xi . −L(x ,y ) i i 1+e

178

7 Weitere Decodierverfahren

Gleichung (7.12) kann in drei voneinander unabhängige Terme zerlegt und folgendermaßen interpretiert werden: Kanal-L-Wert: a-priori-L-Wert:

extrinsischer L-Wert:



 p(yi | xi = +1) 2 Lch · yi = ln = 2 · yi , (7.13) p(yi | xi = −1) σ   Pa (xi = +1) La (xi ) = ln , (7.14) Pa (xi = −1)   P Q n p(xl , yl )  x∈C (+1) l=1    i l6=i   Lext,i (C) = ln  P Q n   p(xl , yl )  (−1)

x∈Ci



P

l=1 l6=i n Q

1

e 2 ·L(xl ,yl )·xl



 x∈C (+1) l=1    i l6=i  . = ln  P Q n  1 ·L(x ,y )·x   l l l e2 (−1)

x∈Ci

(7.15)

l=1 l6=i

Der extrinsische L-Wert Lext,i ist der Teil der Zuverlässigkeit der Stelle i aus Sicht der anderen Stellen. Im Jahr 1976 berechneten Hartmann und Rudolph [HR76] die MAP-Wahrscheinlichkeit einer Position i mittels des dualen Codes durch diskrete Fourier-Transformation von Gleichung (7.12). Hagenauer, et al. [HOP96] interpretierten dieses Resultat als einen intrinsischen Anteil und einen extrinsischen Anteil und erhielten für letzteren:    bl n P Q L(xl ,yl ) tanh 2   b∈C ⊥ l=1   l6 = i   Lext,i (C ⊥ ) = ln  . (7.16)   n bl  Q  P  (−1)bi tanh L(x2l ,yl )   b∈C ⊥

l=1 l6=i

Die symbolweise MAP-Decodierung bietet inhärent zwei interessante Möglichkeiten: • Nach der symbolweisen MAP-Decodierung hat man nicht nur den entschiedenen Wert eines Symboles zur Verfügung, sondern auch die Zuverlässigkeit dieser Entscheidung. Diese Soft-Output-Decodierung führt in verketteten Codierungsschemata, in denen diese Soft-Output-Information als Eingangsinformation eines folgenden Decodierers verwendet wird, zu einer deutlichen Verbesserung des Decodierergebnisses. • Eine weitere mögliche Anwendung der Soft-Output-Decodierung ist die symbolweise iterative Decodierung. Ein Beispiel dafür wird in Abschnitt 7.4.4 gegeben.

7.2 Decodierprinzipien, Zuverlässigkeit, Komplexität und Codiergewinn

7.2.3

179

Decodierkomplexität und der Satz von Evseev

Wir setzen eine binäre Übertragung über einen BSC voraus, c ∈ C sei gesendet und r = c + e empfangen, e ist der Fehlervektor. Eine ML-Decodierung wird entsprechend Abschnitt 7.2.2 erreicht, wenn man einen Fehler f mit kleinstem Gewicht findet, so dass gilt: r − f ∈ C. Das bedeutet, ein denkbarer Algorithmus zur ML-Decodierung ist  n das Probieren aller möglichen Fehlervektoren; zuerst f = 0, dann alle Fehler vom 1  Gewicht 1, dann alle n2 Fehler vom Gewicht 2, usw. Eine andere Möglichkeit der MLDecodierung ist die Standard-Array-Methode 1.3 auf Seite 14. Man sucht das Coset, ˆ. Evseev [Evs83] hat im in dem r liegt, und der Cosetleader sj entspricht dem Fehler e Jahre 1983 die folgende Überlegung durchgeführt. Sei S die Menge aller 2n−k Cosetleader. Die Menge V sind die Vektoren vj innerhalb einer Kugel um ein Codewort mit Radius t. Wir limitieren die Kardinalität zu |V| = 2n−k , indem wir alle Fehler vom Gewicht < t in die Menge V schreiben und mit Fehlern vom Gewicht t auffüllen. Damit gilt t   X n |V| ≤ . i i=0 Sei dv die Varshamov-Gilbert-Mindestdistanz eines linearen (n, k, d)-Codes, die mittels der Schranke (Abschnitt 6.3 auf Seite 141) definiert wird: dX v −1  i=0

n i





2n = 2n−k = 2n(1−R) , 2k

denn dv − 2 ist die größte Zahl, bei der die Summe noch kleiner als 2n−k ist.

Ein denkbarer suboptimaler Decodieralgorithmus Ψ(C) für einen binären Code C bei empfangenem Vektor r sei wie folgt definiert: Algorithmus 7.1: Algorithmus Ψ(C). Teste für alle f ∈ V : r − f ∈ C ? Ergebnis: 1. Decodierversagen.

ˆ = r − f. 2. r − f ∈ C =⇒ Entscheidunga : c a Falls

mehrere Lösungen existieren, wird die mit kleinstem Gewicht ausgewählt.

Die ML-Decodierfehlerwahrscheinlichkeit PM L ist die Wahrscheinlichkeit, dass der Fehler e kein Cosetleader ist PM L = P (e ∈ / S) = 1 − P (e ∈ S). Entsprechend ist die Decodierfehlerwahrscheinlichkeit PΨ = P (e ∈ / V) oder aber PΨ = 1 − P (e ∈ S) +P (e ∈ S \ (V ∩ S)) − P (e ∈ V \ (S ∩ V)). | {z } =PM L

Für PM L < 1/2 gilt: P (e ∈ S \ (V ∩ S)) − P (e ∈ V \ (S ∩ V)) < PM L = 1 − P (e ∈ S). Denn es gilt −P (e ∈ V \ (S ∩ V)) < 1 − P (e ∈ S) − P (e ∈ S \ (V ∩ S)), da P (e ∈ S \ (V ∩ S)) ≤ P (e ∈ S) < 1/2 ist. Damit haben wir den folgenden Satz bewiesen.

180

7 Weitere Decodierverfahren

Satz 7.1 (Satz von Evseev) Gegeben sei ein binärer Code C(n, k, d), der mit dem Algorithmus Ψ(C) decodiert wird. Die sich ergebende Restblockfehlerwahrscheinlichkeit (Decodierversagen eingeschlossen) sei PΨ . Die Restblockfehlerwahrscheinlichkeit bei einer ML-Decodierung sei PM L , dann gilt: PΨ ≤ 2 · PM L . Die wesentliche Aussage des Satzes von Evseev ist, dass man bei nur näherungsweiser ML-Decodierung erheblich an Decodieraufwand einspart. In [Evs83] wurde gezeigt, dass für große Längen n die Anzahl der Vektoren, die getestet werden müssen, ∼ 2n(1−R) ist. Weiterhin wissen wir von der Wolf-Schranke (siehe etwa [Dum96]), dass die Komplexität von ML-Decodierung im Trellis [Wolf78] mit 2n·min{R,(1−R)} abgeschätzt werden kann. Jedoch erlaubt der Satz 7.1 Algorithmen mit geringerer Komplexität zu konstruieren, wie u. a. in [Kro89] und [Dum96] beschrieben. Wir wollen im Folgenden als Beispiel ein Verfahren aus [Evs83] beschreiben, dessen Komplexität geringer, nämlich 2n·R·(1−R) , ist. Zur Vereinfachung der Beschreibung nehmen wir einen C(n = l · k, k, d)-Code an, und beliebige k aufeinanderfolgende Stellen bestimmen ein Codewort (z. B. einen zyklischen Code). Der Empfangsvektor r kann in l Teilvektoren der Länge k aufgeteilt werden, d. h. r = (r1 , r2 , . . . , rl ). Gemäß Satz 7.1 müssen wir alle möglichen Fehler bis zum Gewicht dv testen, um eine Blockfehlerrate kleiner oder gleich der doppelten ML-Blockfehlerrate zu erreichen. Das sogenannte Dirichlet-Prinzip sagt jedoch aus, dass wenn dv Fehler in l Kästen verteilt werden, es mindestens einen Kasten (d. h. Teilvektor der Länge k) gibt, in dem höchstens dv /l Fehler sind. Dies bedeutet, dass wir in jedem der l Teilvektoren der Länge k nur bis zu dv /l Fehler testen müssen. Da k Stellen ein Codewort bestimmen, können wir die Decodierung wie folgt durchführen: ˆ, ri − fi =⇒ c

ˆ) , dist(r, c

i = 1, . . . , l.

Dabei wird die Tatsache ausgenutzt, dass nur diejenigen getesteten Fehler relevant sind, die zu einem Codewort führen, da nur diese als potentielle Lösungen in Frage kommen. Die Komplexität des beschriebenen Verfahrens entspricht l · |Vdv /l | =

1 · |Vdv /l | ≈ 2n·R·(1−R) R

für n −→ ∞. Damit haben wir den folgenden Satz bewiesen. Satz 7.2 (Evseev-Algorithmus) Die Decodierkomplexität des Algorithmus Ψ(C) geht asymptotisch für n → ∞ gegen 2n·R·(1−R) und die Blockfehlerrate (inklusive Decodierversagen) ist kleiner oder gleich der doppelten ML-Blockfehlerrate. Dieser Satz und der entsprechende Algorithmus stellen die Grundlage dar für eine Reihe von Algorithmen zur näherungsweisen ML-Decodierung mit geringer Komplexität. Einige Varianten sind u. a. in [Kro89] und [Dum96] zu finden. Der Evseev-Algorithmus wurde hier vorweggenommen, um zu motivieren, dass eine näherungsweise ML-Decodierung nicht unmöglich ist.

7.2 Decodierprinzipien, Zuverlässigkeit, Komplexität und Codiergewinn

7.2.4

181

Codiergewinn

Die Verwendung eines Codes der Rate R = k/n hat zwei Konsequenzen. Erstens müssen mehr Symbole übertragen werden (n statt k) und zweitens muss mehr Energie aufgewendet werden (n · E statt k · E, wenn E die Energie eines Symboles ist). Um Codierverfahren unterschiedlicher Rate gerecht miteinander vergleichen zu können, gibt man die Signalenergie in Form von Energie pro Informationsbit Eb (anstelle von Energie pro Sendesymbol Es ) an. Durch die Normierung1 auf die Energie Eb eines Informationsbits ist gewährleistet, dass für die Übertragung einer Nachricht gegebener Länge, unabhängig von der Rate des verwendeten Codes, stets gleichviel Energie aufgewendet wird, was einen fairen Vergleich ermöglicht. Es gilt: k · Eb = n · Es

=⇒

Eb = Es /R.

Die Verwendung eines Codes verschlechtert zunächst die Symbolfehlerrate am Empfänger, da weniger Energie Es pro Symbol aufgewendet wird. Nach dem Decodierer hat man jedoch in der Regel eine kleinere Bitfehlerrate als bei uncodierter Übertragung, d. h. die Symbolfehlerrate ist kleiner als diejenige beim Empfänger, wenn entsprechend mehr Energie Eb pro Informationssymbol aufgewendet wird. Die Verbesserung bezeichnet man als Codiergewinn, wie in Bild 7.6 dargestellt.

Pbit

¨ uncodierte Ubertragung

¨ codierte Ubertragung mit Decodierung

¨ codierte Ubertragung ohne Decodierung

Codiergewinn Eb [dB] N0

Abb. 7.6: Veranschaulichung des Codiergewinns.

Will man die Informationsdatenrate konstant halten, so gibt es zwei Möglichkeiten: Höhere Übertragungsdatenrate: Dieser Fall scheidet in der Regel aus, da er größeren Bandbreitenbedarf bedeutet. 1 Auch zum Vergleich von Modulationsarten mit unterschiedlichem Alphabet ist eine Energienormierung pro Informationsbit notwendig.

182

7 Weitere Decodierverfahren

Größeres Modulationsalphabet: Wenn man statt 1 bit/Symbol 2 bit/Symbol überträgt, kann man einen Code der Rate R = 1/2 verwenden, ohne dass sich die Informationsdatenrate oder die notwendige Bandbreite ändert. Auch hier verschlechtert die Verwendung eines Codes zunächst die Übertragungssituation, da ein größeres Modulationsalphabet verwendet werden muss (siehe z. B. [Kam, Bos12]). Nach der Decodierung jedoch ergibt sich insgesamt eine Verbesserung, d. h. ein Codiergewinn entsprechend der Energiebetrachtung (Bild 7.6).

7.3

Hard-Decision Decodierung

Decodierverfahren, die keine Zuverlässigkeitsinformation benutzen, nennt man HardDecision-Decodierverfahren (hard decision decoding). Dazu zählt die in Kapitel 3 beschriebene algebraische Decodierung. Wir setzen hier binäre Codes und eine Übertragung über den symmetrischen Binärkanal (binary symmetric channel, BSC) wie in Bild 1.2 voraus. Eine gesendete 0 wird mit der Wahrscheinlichkeit p bei der Übertragung in eine 1 verfälscht und mit der Wahrscheinlichkeit 1 − p korrekt übertragen und umgekehrt. Dies entspricht auch einem AWGN-Kanal, bei dem man die zusätzliche Information über die Zuverlässigkeit der einzelnen Stellen nicht benutzt. Ein Codewort c wird gesendet und der Vektor r empfangen. Das Decodierproblem ist, aus dem empfangen Vektor r den Fehler f oder das gesendete Codewort c zu berechˆ. Falls c ˆ = c ist, wurde korrekt decodiert, nen. Das Ergebnis der Decodierung sei c ˆ 6= c ist, wurde falsch decodiert, und falls keine Lösung gefunden wurde liegt falls c Decodierversagen vor.

7.3.1

Permutationsdecodierung

Um bei einem Code C mit der Mindestdistanz d bis zur halben Mindestdistanz zu korrigieren, benötigt man bei der Permutationsdecodierung eine Menge von  Automor phismen φj , j = 1, . . . , J (siehe Abschnitt 6.2), die beliebige t ≤ e = d−1 Stellen 2 eines Codewortes auf die Redundanzstellen abbilden (permutieren).

Um das Prinzip zu erläutern, nehmen wir an φi sei eine Permutation, die alle aufgetretenen Fehler eines bestimmten Fehlermusters auf die Redundanzstellen abbildet. Berechnen wir nun aus den Informationsstellen des mit φi permutierten empfangenen ˆ, so gilt: Wortes r durch erneutes Codieren das Codewort c wt(φ−1 c) + r) ≤ e. i (ˆ Um die Permutationsdecodierung als Algorithmus zu beschreiben, können wir ohne Beschränkung der Allgemeinheit annehmen, die Prüfmatrix H des Codes habe die Form H = (I | A), (I ist die Einheitsmatrix). Die Matrixform wird gewählt, da man mit der Permutationsdecodierung auch Codes decodieren kann, die nicht zyklisch, sondern „nur“ linear sind. Wir wollen zur Permutationsdecodierung den folgenden Satz beweisen, der aussagt: Ist der Informationsteil fehlerfrei, so entspricht das Gewicht des Syndroms dem Gewicht des Fehlers.

7.3 Hard-Decision Decodierung

183

Satz 7.3 (Permutationsdecodierung) Sei r = c + f empfangen, wt(f ) ≤ e, so gilt mit s = H · rT : wt(s) ≤ e

und

wt(s) = wt(f ),

wenn die Informationssymbole rn−k , rn−k+1 , . . . , rn−1 fehlerfrei sind. Die Koordinaten des Fehlers f sind dann: f0 = s0 , f1 = s1 , . . . , fn−k−1 = sn−k−1 . Beweis: Falls fi = 0, i = n − k + 1, . . . , n gilt:

s = (I | A) · f T = (f1 , f2 , . . . , fn−k )T

und damit auch wt(s) ≤ e.

2

Algorithmus 7.2 beschreibt eine mögliche Realisierung für einen Permutationsdecodierer, die im folgenden Beispiel zur Decodierung eines Hamming-Codes verwendet wird. Algorithmus 7.2: Permutationsdecodierung. Gegeben sei ein Code C mit der Mindestdistanz d und der Prüfmatrix¨H =˝ (I | A) und eine Menge von Automorphismen φj , j = 1, . . . , J, die beliebige t ≤ e = d−1 Stellen des Codes auf 2 die Redundanzstellen abbilden. Empfangen sei r = c + f . Schritt 1: x = r, i = 1

Schritt 2: Falls wt(H · (φi (x))T ) ≤ e, s = H · (φi (x))T dann Schritt 4. Schritt 3: i = i + 1, (i > J: erfolgloser Abbruch) Schritt 2. Schritt 4: Decodiere r als φ−1 i (φi (x) − (s1 , s2 , . . . , sn−k , 0, 0, . . . , 0)). Beispiel 7.1 (Permutationsdecodierung) Sei C der Hamming-Code der Länge n = 7, d. h. die Codewörter haben die Form: c0 c1 c2 | {z }

Redundanz

| c3 c4 c5 c6 | {z }

Information

Die Menge der Automorphismen φi (c) sei: φ1 (c) = c ,

φ2 (c) = x3 · c ,

φ3 (c) = x6 · c.

Damit ergeben sich also explizit die folgenden Permutationen: φ1 (c) : φ2 (c) : φ3 (c) :

Redundanz Information c0 c1 c2 c3 c4 c5 c6 c4 c5 c6 c0 c1 c2 c3 c1 c2 c3 c4 c5 c6 c0

Es ist ersichtlich, dass jede beliebige Stelle durch eine der drei Permutationen auf eine Redundanzstelle abgebildet werden kann. Somit kann ein Fehler korrigiert werden. 

184

7.3.2

7 Weitere Decodierverfahren

Mehrheitsdecodierung (majority logic decoding)

Der duale Code (siehe Abschnitt 6.1) kann zur Decodierung von Blockcodes verwendet werden. Dazu betrachtet man einen binären Code C und den zugehörigen dualen Code C ⊥ . Entsprechend Definition 1.4 gilt für das Skalarprodukt von c ∈ C, b ∈ C ⊥ : hc, bi =

n X i=1

ci · bi = 0 mod 2.

(7.17)

Wir nennen einen Vektor b ∈ C ⊥ einen Prüfvektor und das Skalarprodukt mit b Prüfsumme s(b). Wählen wir eine Menge MJ von J Vektoren aus den Codewörtern von C ⊥ , so können wir damit überprüfen, ob ein empfangenes Wort r = c + e ein Codewort aus C ist, denn unter der Annahme, dass diese Vektoren den dualen Code aufspannen (d. h. Rang n − k besitzen), müssen alle Skalarprodukte Null ergeben (dies entspricht der Multiplikation mit der Prüfmatrix H). Somit gilt mit s(b) = hr, bi = he, bi für den Wertebereich der Summe aller durch MJ möglichen Prüfsummen X s(b) ∈ [0, J], b∈MJ

da |MJ | = J. Die Mehrheitsdecodierung basiert auf der Überlegung, dass die Mehrheit der Prüfsummen eine fehlerhafte Stelle mittels einer 1 anzeigt. Definition 7.4 (Mehrheitsentscheidung) Gegeben sei eine Menge von Prüfvektoren MJ des linearen binären Codes C, die den dualen Code C ⊥ aufspannen, sowie ein Empfangsvektor r ∈ GF (2)n . Dann ist eine Mehrheitsdecodierung einer Position i ∈ [1, n] definiert durch:    r ⊕ 1, falls P hr, bi mod 2 > J i 2 cˆi = (7.18) b∈MJ  ri , sonst. Die Anzahl der mit Mehrheitsdecodierung korrigierbaren Fehler hängt entscheidend von den kombinatorischen Eigenschaften der Menge MJ ab. Besonders geeignet für die Mehrheitsdecodierung sind dabei die orthogonalen Prüfvektoren.

Definition 7.5 (Orthogonale Prüfvektoren) Eine Menge MJ von Prüfvektoren bj ∈ C ⊥ , j = 1, . . . , J, heißt orthogonal zu einer Stelle i, falls gilt: Position i ist in jedem Vektor bj , j = 1, . . . , J, enthalten (das bedeutet gleich 1) und alle weiteren Stellen l 6= i, l = 1, . . . , n, sind in höchstens einem bj , j = 1, . . . , J, enthalten (gleich 1).

Die Anzahl der mit Mehrheitsdecodierung basierend auf orthogonalen Prüfvektoren korrigierbaren Fehler ist durch folgenden Satz gegeben. Satz 7.6 (Mehrheitsdecodierung mit orthogonalen Prüfvektoren) Seien   J Vektoren bj orthogonal zur Stelle i und sei f der aufgetretene Fehler, wt(e) ≤ J2 , so ist der Wert des Fehlers der Stelle i gleich dem Wert der Mehrheit der J Skalarprodukte hbj , ei.

7.3 Hard-Decision Decodierung

185

¨ ˝ Beweis: Die Stelle i sei korrekt, d. h. ei = 0, dann gibt es mindestens J2 Gleichungen (Skalarprodukte), die den Wert 0 ergeben, da jede Fehlerstelle höchstens eine Gleichung beeinflussen kann. Sei die Stelle i fehlerhaft, d. h. ei = 1,¨ dann beeinflusst diese Stelle alle J Gleichungen ˝ und die restlichen Fehler können höchstens J2 − 1 Gleichungen beeinflussen. 2

Es können somit umso mehr Fehler korrigiert werden, je mehr orthogonale Prüfvektoren existieren. Aber die Anzahl dieser Prüfvektoren ist entsprechend dem folgenden Satz begrenzt.   Satz 7.7 (Anzahl orthogonaler Prüfvektoren) Es können höchstens dn−1 Vek⊥ −1 ⊥ ⊥ toren bj ∈ C , wt(bj ) = d existieren, die Definition 7.5 erfüllen. Beweis: Wählt man eine Stelle i, so hat man noch n − 1 Stellen, aus denen man jeweils d⊥ − 1 verschiedene auswählen kann. Keine Stelle – außer i – darf doppelt gewählt werden. 2

Die LDPC Code (Abschnitt 5.5) Konstruktion mit EG(m, q) liefert genau γ Prüfvektoren für jede der n Stellen. EG(m, q) von Satz 5.19 auf Seite 129 liefert γ Prüfvektoren (Linien), die an einer Stelle eine Eins besitzen (die Linien schneiden sich nur in einem Punkt). An allen anderen Stellen besitzt nur ein Prüfvektor eine Eins (Linien besitzen keine anderen Schnittpunkte). Damit kann man mit der Mehrheitsdecodierung γ/2 Fehler korrigieren. Entsprechend liefert die P G(m, q) Konstruktion ebenfalls Prüfvektoren, die orthogonal zu einer Stelle sind. Für zyklische Codes braucht man nur eine Menge von Prüfvektoren, die orthogonal zu einer Stelle sind. Für die anderen Stellen ergibt sich die Menge einfach durch zyklisches Verschieben. Dieses Decodierverfahren wird dann auch häufig Meggitt-Decodierung genannt. Mehrschritt-Mehrheitsdecodierung: Mehrheitsdecodierung kann erweitert werden, indem man eine Menge von Vektoren definiert, die orthogonal zu einer Menge von Stellen sind. Analog dem beschriebenen Gedankengang kann man dann entscheiden, ob die Menge der Stellen fehlerfrei ist. Hat man die fehlerbehafteten Mengen gefunden, so kann man diese wiederum in Teilmengen aufteilen, die man überprüfen kann, ob sie fehlerfrei sind, usw. Diese Decodiermethode wird Mehrschritt-Mehrheitsdecodierung genannt und am folgenden Beispiel erklärt. Beispiel 7.2 (Mehrschritt-Mehrheitsdecodierung) Gegeben sei der Hamming-Code der Länge n = 7, Dimension k = 4 und Mindestdistanz d = 3. Der duale Code C ⊥ hat die ⊥ ⊥ Mindestdistanz ¨ ˝d = 4 und die Dimension k = n − k = 3. Gemäß Satz 7.7 gibt es damit höchstens 7−1 = 2 Prüfvektoren, die orthogonal zu einer Stelle sind. Die Prüfmatrix H sei: 4−1 0 1 0 1 1 1 1 0 1 0 0 h1 H = @0 1 1 1 0 1 0A = b @h2 A , 0 0 1 1 1 0 1 h3 und damit lauten alle Codewörter des dualen Codes (außer dem Codewort 0):

h1 = 1110100, h2 = 0111010, h3 = 0011101, h4 = 1001110, h5 = 0100111, h6 = 1010011, h7 = 1101001, mit h4 = h1 + h2 , h5 = h2 + h3 , h6 = h1 + h2 + h3 und h7 = h1 + h3 .

186

7 Weitere Decodierverfahren

Wir finden keine zwei Prüfvektoren hi , hj , i 6= j, die orthogonal zur Stelle 0 sind, d. h. da dieser Code zyklisch ist, gibt es keine zwei Prüfvektoren orthogonal zu irgendeiner Stelle i. Wir werden aber eine 2-Schritt-Mehrheitsdecodierung durchführen: • h1 und h7 sind orthogonal zu den Stellen 0 und 1. • h1 und h6 sind orthogonal zu den Stellen 0 und 2. d. h. wir können entscheiden ob die Stellen 0 und 1 und/oder die Stellen 0 und 2 fehlerhaft sind; sind beide Mengen, {0, 1} und {0, 2}, fehlerhaft, so ist die Stelle 0 fehlerhaft. 

7.3.3

DA-Algorithmus

Wir wollen in diesem Abschnitt ein Decodierverfahren (DA) beschreiben, das in der Lage ist, binäre Codes aus allen Klassen, die wir bisher kennengelernt haben, zu decodieren und das außerdem bestimmte Fehler vom Gewicht größer als die halbe Mindestdistanz decodieren kann. Sei C(n, k, d) ein binärer Code und C ⊥ (n, n − k, d⊥ ) der dazu duale Code, so definieren wir die Menge der Decodiervektoren als: B = {b | b ∈ C ⊥ , wt(b) = d⊥ }. Es gilt damit: hc, bi = 0, c ∈ C, b ∈ B ⊆ C ⊥ . Weiterhin definieren wir das Syndromgewicht eines Vektors r = c + f zu X WT(B, r) = 0 + WT(B, f ) = hb, f i. b∈B

Das Decodierverfahren beruht auf der Beobachtung, dass in der Regel für zwei verschiedene Fehler f1 , f2 , mit wt(f1 ) < wt(f2 ) gilt: WT(B, f1 ) < WT(B, f2 ). Der entsprechende Algorithmus 7.3 beschreibt eine mögliche Decodierung, die auf dieser Beobachtung beruht. Algorithmus 7.3: Algorithmus DA. Schritt 1: v = r, (r = c + f empfangen). Berechne X = WT(B, v). Schritt 2: Falls X = 0 dann Schritt 6. Schritt 3: Berechne εi = WT(B, v + ei ), i = 1, 2, . . . , n, ei : i-ter Einheitsvektor. Schritt 4: Suche j ∈ {1, 2, . . . , n} mit εj = mini=1,2,...,n {εi }. Schritt 5: v = v + ej , X = εj

Schritt 2.

Schritt 6: Decodiere r als v.

Wir wollen nun anhand einer Plausibilitätsbetrachtung die Decodierfähigkeit des Verfahrens erklären:

7.3 Hard-Decision Decodierung

187

Sei Yl = {f | wt(f ) = l} die Menge aller Fehler vom Gewicht l, so können wir die Ergebnisse der Skalarprodukte mit einem Vektor b ∈ B abzählen. Dies gelingt, da alle Vektoren vom Gewicht l verwendet werden. Es ergibt sich:  ⊥    ⊥   X d n − d⊥ d n − d⊥ hf , bi = · + · + · · · + q, 1 l−1 3 l−3 f ∈Yl

wobei   ⊥   d n − d⊥   · , l ungerade  l 0  q=  ⊥    d n − d⊥   · , l gerade. l−1 1

Im Mittel wird dann pro Fehler mit Gewicht l β(n, l, d⊥ ) =

1 X  hf , bi n · l

f ∈Yl

als Beitrag zum Syndromgewicht erreicht, d. h. wir können das durchschnittliche Syndromgewicht für |B| Vektoren berechnen: WD(B, l) = |B| · β(n, l, d⊥ ).

  WD steigt mit l bei den meisten Codes an und zwar auch noch für l > d−1 , was 2 ein Hinweis darauf ist, dass man mit dem Verfahren decodieren kann. Eine notwendige und hinreichende Bedingung, dass man mit DA alle Fehler bis zu einem bestimmten Gewicht decodieren kann, ist die folgende: Satz 7.8 (Korrekturfähigkeit von DA) Mit dem angegebenen Decodierverfahren können alle Fehler f vom Gewicht t ≤ l korrigiert werden, wenn gilt:





wt(f )≤l i∈supp(f )

: WT(B, f + ei )
1 y˜i , |˜ yi | ≤ 1 yi = (7.19)  −1, y˜ < −1. i Die Idee dabei ist, dass ein Rauschwert ni , mit sign ni = sign xi , keinen Fehler erzeugen kann, jedoch zur euklidischen Distanz beiträgt. Deshalb werden Werte |˜ yi | > 1 abgeschnitten, um eine Distanz zu erhalten, die stärker mit Fehlern verknüpft ist.

192

7 Weitere Decodierverfahren

Definition 7.10 (Verallgemeinerte Distanz)Die Distanz eines Codewortes x zum Pn Empfangsvektor y, |yi | ≤ 1 ist δ(x, y) = i=1 δi (xi , yi ) mit  1 − |yi |, sign(xi ) = sign(yi ) δi (xi , yi ) = 1 + |yi |, sign(xi ) 6= sign(yi ). Die verallgemeinerte Distanz zwischen zwei Codeworten ist damit δ(x1 , x2 ) ≥ 2d. Denn zwei Codeworte unterscheiden sich in mindestens d Stellen, haben also dort unterschiedliche Vorzeichen und daher ist δi = 2. An den Stellen, an denen sie übereinstimmen, ist δi = 0. Anders ausgedrückt, die verallgemeinerte Mindestdistanz δmin ist gleich der doppelten Hammingdistanz d, also δmin = 2d. Alle Fehler mit verallgemeinerter Distanz < d können deshalb eindeutig einem Codewort zugeordnet werden. Um die Eigenschaften der verallgemeinerten Mindestdistanz noch genauer zu verstehen, betrachten wir die zwei möglichen Fälle der Übertragung von xi = 1 und xi = −1. Wir berücksichtigen dabei, dass wegen dem Abschneiden in Gleichung (7.19) gilt: |yi | ≤ 1. Deshalb verwenden wir nur solche ni , bei denen ein Abschneiden nicht notwendig ist. Für den Fall xi = 1 und yi = 1 + ni gilt:  1 − |1 + ni |, sign(xi ) = sign(yi ) ⇒ −1 < ni ≤ 0 δi (1, 1 + ni ) = 1 + |1 + ni |, sign(xi ) 6= sign(yi ) ⇒ −2 ≤ ni < −1. (7.20) Um einen Fehler zu erzeugen, muss |ni | > 1 sein. Da in der zweiten Zeile ni < −1 ist, erhält man: 1 + |1 + ni | = −ni = |ni |, da ni < 0 ist.

Für den Fall xi = −1 und yi = −1 + ni gilt:  1 − | − 1 + ni |, sign(xi ) = sign(yi ) ⇒ 0 ≤ ni < 1 δi (−1, −1 + ni ) = 1 + | − 1 + ni |, sign(xi ) 6= sign(yi ) ⇒ 1 < ni ≤ 2. (7.21) Auch hier muss |ni | > 1 sein, um einen Fehler zu erzeugen. Da hier in der zweiten Zeile ni > 1 ist, erhält man: 1 + | − 1 + ni | = ni = |ni |. Um zu beweisen, dass ein Decodierer alle Fehler bis zu einer bestimmten Distanz decodieren kann, kann man folgende Methode verwenden. Man nimmt an, der Kanal spielt gegen den Decodierer. Seine Strategie ist, mit der Distanz, die er zur Verfügung hat, Fehler zu erzeugen. Kann er Fehler erzeugen, die der Decodierer nicht korrigieren kann, hat er gewonnen. Schafft er es dagegen nicht, so ist bewiesen, dass der Decodierer alle Fehler bis zu einer bestimmten Distanz decodieren kann. Satz 7.11 (Decodierradius von GMD) Mit GMD Decodierung (Algorithmus 7.5) können alle Fehler n mit verallgemeinerten Distanz δ(x, x + n) < d korrigiert werden. Beweis: Wir nehmen an, der Kanal verfolgt die Strategie, die verallgemeinerte Distanz < d so zu verteilen, damit möglichst viele Fehler entstehen, so dass der GMD-Algorithmus 7.5 falsch korrigiert. Wir gehen davon aus, dass der Kanal sign(ni ) 6= sign(xi ) wählt, da gemäß Gleichung (7.19) abgeschnitten wird. Der Kanal muss die Regel befolgen, keine Distanz zu vergeuden und |ni | > 1 wählen. Denn entsprechend Gleichungen (7.20) und (7.21) führt ein Wert |ni | < 1 zu keinem Fehler, trägt

7.4 Soft-Decision Decodierung

193

jedoch einen Term > 0 zur verallgemeinerten Distanz bei. Es ist einsichtig, dass jede Strategie des Kanals, die keine Distanz vergeudet besser ist als eine, die Distanz vergeudet. Denn zu jedem n mit t Fehlern und vergeudeter Distanz können wir die vergeudete Distanz benutzen, um ein n0 mit t0 ≥ t zu erzeugen. Damit können wir voraussetzen, dass der Kanal |ni | > 1 verwenden muss. Der Kanal wählt t Werte |ni | = 1 + , mit  > 0 und kann deshalb maximal t = d − 1 Fehler erzeugen, da gelten muss: t(1+) < d und t < 1. Wir wählen ein ν, so dass (d−1)(1+)+ν < d möglichst nahe bei d ist. Damit besitzen d−2 Fehler |yi | =  und ein Fehler |yi | = +ν (der Fall t = d − 1 Fehler |yi | =  und ein Nicht-Fehler |yi | = 1 − ν braucht wegen der Regel, dass keine Distanz vergeudet wird, nicht betrachtet werden). Bei allen anderen Stellen ist wegen der Regel nicht vergeudeter Distanz |yi | = 1. Somit sind die Fehlerstellen nach der Sortierung eindeutig an den unzuverlässigsten Stellen. Diese werden im letzten Schritt bei GMD alle ausgelöscht. Da d − 1 Auslöschungen korrigiert werden können, kann der GMD-Algorithmus diesen Fall korrigieren. Damit der Kanal nun einen Fehler mit |yi | = 1 im nicht-ausgelöschten Teil (an zufälliger Stelle) „verstecken“ kann, benötigt er |ni | = 2 (wegen dem Abschneiden in Gleichung (7.19)). Dazu muss er eine der d−1 Distanzen |ni | = 1+ aufgeben (zu null machen). Eine weitere Stelle kann damit zu |ni | = 2 gemacht werden, wobei 2 übrig bleiben. Mit der verallgemeinerten Distanz 2 kann kein weiteres |yi | =  aus dem unzuverlässigen Teil in den zuverlässigen Teil verschoben werden, denn 3 < 1. Damit sind nach Sortierung ρ = d − 3 Fehler an den unzuverlässigsten Stellen und τ = 1 zufällige Fehler. Es gilt 2τ + ρ = d − 2 < d und der GMD-Algorithmus kann diesen Fall im vorletzten Schritt decodieren. Diese Überlegung kann entsprechend für weitere Stellen durchgeführt werden, wobei der Kanal jedes Mal 2 gewinnt. Da diese Verschiebung höchstens (d − 1)/2 mal durchgeführt werden kann, kann der Kanal höchsten 2(d − 1)/2 gewinnen, was gemäß Bedingung (d − 1) < 1 nicht ausreicht, um eine weitere Stelle in die zuverlässigen zu verschieben. 2

Es existieren zahlreiche Varianten der GMD-Decodierung bei denen die Anzahl der Auslöschungen variiert werden. Man kann zum Beispiel bezüglich des erzielbaren Decodierradius (wie in diesem Abschnitt geschehen) optimieren oder aber bezüglich der erzielbaren Restfehlerrate. Weiter kann man die Anzahl der Decodierversuche beschränken und unter dieser Randbedingung das optimale Verfahren herleiten [WAG03]. Die GMD-Decodierung lässt sich weiter verbessern, wenn die Auslöschungsstratgie adaptiv, d.h. abhängig vom jeweiligen Empfangsvektor, gewählt wird [Kov86]. In der Arbeit von Senger [Sen11] wurde gezeigt, welche Verbesserungen durch Einsatz von Interleaved RSCodes, Power Decodierung und algebraischer Listendecodierung (siehe Abschnitt 3.3) erzielt werden können.

7.4.2

Chase- und Dorsch-Algorithmen

Die Algorithmen von Chase [Cha72] und Dorsch [Dor74] basieren ebenfalls auf einem algebraischen Decodieralgorithmus Ψ. Ausgangspunkt für die Decodierung ist – wie beim GMD-Algorithmus – ein gemäß seiner Zuverlässigkeiten sortierter Empfangsvektor y (siehe Bild 7.9). Im Gegensatz zum GMD-Decodieralgorithmus werden nun Varianten des Empfangsvektors nicht durch Auslöschung, sondern durch „flippen“ bestimmter Positionen generiert. Dazu wird eine Menge T von sogenannten Testmustern erzeugt. Es handelt sich dabei um binäre Vektoren v ∈ GF (2)n , die auf den Hard-Decision

194

7 Weitere Decodierverfahren

Empfangsvektor yH = r ∈ F2n modulo 2 aufaddiert werden. Die so veränderten Empfangsvektoren werden mit Ψ decodiert, und man erhält eine Liste von möglichen Decodierergebnissen. Verwendet man also beispielsweise alle Testmuster bis zum HammingGewicht i, so werden alle Codeworte mit Hamming-Distanz t + i zum Empfangswort decodiert, wobei t = b d2 c ist. Aus der so entstandenen Liste von Test-Codeworten wird dasjenige als Decodierergebnis ausgegeben, das die geringste euklidische Distanz zum Empfangsvektor aufweist. Ist die Liste leer, so liegt Decodierversagen vor. Je mehr Testmuster verwendet werden, umso mehr Fehler lassen sich korrigieren. Gleichzeitig nimmt aber auch die Komplexität zu. Die Testmuster sollten demnach so gewählt werden, dass sie möglichst wahrscheinlichen Fehlermustern entsprechen. Daher bietet es sich an, die Fehler an den unzuverlässigen Stellen anzunehmen. Für die Berechnung der Testmuster schlägt Chase drei unterschiedliche Varianten vor. Variante 1: Die Menge der Testmuster T ist gegeben durch alle binären Vektoren vom Pb d2 c n Gewicht ≤ b d2 c, d. h. |T | = i=0 i .

Variante 2: Die Menge der Testmuster T ist gegeben durch alle binären Vektoren, die an Positionen 1 ≤ i ≤ b d2 c eine beliebige Kombination aus „0“ und „1“ aufweisen, d an allen übrigen Stellen jedoch gleich „0“ sind, d. h. |T | = 2b 2 c . Variante 3: Die Menge der Testmuster T wird analog zum GMD-Algorithmus gewählt, d. h. die Testmuster vi ∈ T besitzen in Positionen i, i = 0, 2, . . . , d − 1, falls d gerade bzw. i = 1, 3, . . . , d − 1, falls d ungerade, eine „1“, d. h. |T | = b d4 c. Für alle drei Varianten kann eine Decodierung mit dem Algorithmus 7.6 durchgeführt werden. Entsprechende Simulationsergebnisse sind in Bild 7.10 dargestellt. Algorithmus 7.6: Chase-Decodieralgorithmen. Initialisierung: Berechne die Menge der Test-Vektoren T gemäß einer der Varianten 1–3. ˜ das Decodierergebnis. Es sei x Es sei i = 0, L = ∅ und max = 0. ˆ. Schritt 1: Decodiere ˆ r = r ⊕ vi , vi ∈ T , mit Ψ zu x Liegt Decodierversagen vor, dann Schritt 3. Schritt 2: Gilt hˆ r, yi > max, dann max = hˆ r, yi und L = {ˆ x}. Schritt 3: Falls i < |T |, setze i = i + 1, sonst Schritt 4. ˜ = Schritt 4: Bestimme das Decodierergebnis gemäß x

(

ˆ, x r,

falls L = 6 ∅ sonst .

Anmerkungen: • Der Chase-1-Algorithmus (Variante 1) liefert die beste Restfehlerwahrscheinlichkeit, da er alle Codeworte im Abstand t + bd2 c decodiert. Jedoch   besitzt er eine n n n sehr hohe Komplexität. Insgesamt werden 0 + 1 + · · · + b d c Testmuster ver2 wendet, womit ebenso viele algebraische Decodierungen notwendig sind. Damit ist Algorithmus 1 für große n und t > 1 praktisch nicht mehr anwendbar.

7.4 Soft-Decision Decodierung

195

• Beim Chase-2-Algorithmus (Variante 2) wird eine Teilmenge der Testmuster des Algorithmus 1 verwendet, weshalb auch nur eine Teilmenge der Codeworte, die beim Algorithmus 1 berechnet wurden, gefunden werden. Die nicht mehr verwendeten Testmuster entsprechen aber Fehlern an zuverlässigen Stellen, also unwahrscheinlichen Fehlern. Deshalb verschlechtern sich im allgemeinen die Decodierergebnisse im Vergleich zu Algorithmus 1 auch nur geringfügig. Gleichzeitig hat sich jedoch der Decodieraufwand durch die Einschränkung der Testmuster auf d 2b 2 c algebraische Decodierungen verringert. • Der Chase-3-Algorithmus (Variante 3) ist zwar am wenigsten komplex, jedoch ist seine Restfehlerwahrscheinlichkeit deutlich höher als bei den anderen beiden Varianten. Andererseits ist der Algorithmus 3 aber immer noch besser als der GMD-Algorithmus, da durch die Auslöschungskorrektur nur eine Teilmenge der Codeworte des Algorithmus gefunden wird. Bei dem Dorsch-Algorithmus werden die Testmuster für die k zuverlässigsten Stellen generiert. Die Idee dabei ist, dass in den zuverlässigen Stellen sehr wenige Fehler sind. Man nimmt an, dass ` = 0, 1, . . . Fehler in den k zuverlässigsten Stellen sind und benötigt dann jeweils k` Testvektoren. Im Gegensatz zum Chase-Algorithmus kann man mit diesen k Stellen systematisch codieren (siehe auch Permutationsdecodierung Abschnitt 7.3.1, Seite 182) und die euklidische Distanz des neu codierten Codewortes zu dem Empfangsvektor berechnen. Fossorier und Lin [FL95, FL96, FL97, FLS97] haben die beiden Konzepte für die SoftDecision-Decodierung von Blockcodes untersucht und verglichen und ordered statistics Decodierung genannt. Die Grundidee ist die i-te geordnete Statistik [BaCo] der Empfangswerte auszunutzen. Entsprechend der Zuverlässigkeit wird eine zuverlässigste Basis (most reliable basis, MRB) und eine unzuverlässigste Basis (least reliable basis, LRB) erzeugt. Die Decodierung der Ordnung ` bedeutet dabei, dass Testmuster bis zu Gewicht ` verwendet werden, entweder bei den k Stellen der MRB oder bei den n − k Stellen der LRB. Bild 7.10 zeigt einen Vergleich der bisher beschriebenen Decodieralgorithmen am Beispiel des (15, 7, 5)-BCH-Codes. Man erkennt, dass der GMD-Algorithmus keine wesentliche Verbesserung gegenüber der BMD-Decodierung erzielt. Dagegen erreicht der Chase-3-Algorithmus bis auf 0.5 dB die SDML-Kurve. Eine Verbesserung des ChaseAlgorithmus wurde von Kaneko in [KNIH94] angegeben. Bild 7.11 veranschaulicht für den (64, 42, 8)-Reed-Muller-Code, dass bereits bei der Decodierung der Ordnung 2 annähernd die SDML-Kurve erreicht wird. Weitere Simulationsergebnisse findet man in [BBLK97].

7.4.3

Listen-Viterbi-Algorithmus

Bei der Soft-Decision-Decodierung wird die Zuverlässigkeitsinformation der Symbole verwendet. Im trivialen Fall wird aus der vollständigen Liste aller Codeworte dasjenige ausgewählt, das die geringste euklidische Distanz zum Empfangsvektor besitzt. Ein solches Vorgehen ist nur bei Codes kleiner Dimension praktikabel. Ähnlich wie bei der symbolweisen Decodierung können aber auch hier Trellisdiagramme gemäß Abschnitt 6.7 zur kompakten Repräsentation des gesamten Codes (d. h. der vollständigen Liste) und

7 Weitere Decodierverfahren

10

−1

10

−2

10

−3

10

−4

P

Bit

196

BMD GMD Chase−3 Chase−2 Chase−1 Kaneko (SDML) 0

1

2

3 E /N [dB] b

4

5

6

0

Abb. 7.10: Vergleich von GMD-, Chase- und Kaneko-Algorithmus für den (15, 7, 5)-BCH-Code.

−1

10

−2

10

−3

10

−4

10

−5

P

Bit

10

Ordnung−0 Ordnung−1 Ordnung−2 SDML 1

1.5

2

2.5

3 3.5 Eb/N0 [dB]

4

4.5

5

Abb. 7.11: Vergleich von Decodierung der Ordnungen 0, 1 und 2 mit SDML für den (64, 42, 8)-RM-Code.

damit zur effizienten Berechnung des SDML-Codewortes verwendet werden. Bekanntestes Beispiel hierfür ist der im Viterbi-Algorithmus, der bereits in Abschnitt 7.3.4 zur Hard-Decision-Maximum-Likelihood-Decodierung verwendet wurde. Einzige Änderung für eine SDML-Decodierung bildet die Berücksichtigung von Zuverlässigkeitsinformation, die im Folgenden beschrieben werden soll. Nach der Übertragung des Codewortes x über einen AWGN-Kanal wird y = x+n empfangen. Weiterhin sei ein Codetrellis T für den Code C gegeben. Wir verwenden erneut die bei der Beschreibung des BCJR- und des Hard-Decision-Viterbi-Algorithmus eingeführte Notation, mit dem Unterschied, dass als Zweigmetrik Λ(e) = yl verwendet wird.

7.4 Soft-Decision Decodierung

197

Jeder Zweig e ist somit wiederum durch ein 4-Tupel e = (ϑ ∈ Vi−1 , x(e), Λ(e), ϑ0 ∈ Vi ) beschrieben. Weiterhin sei Ei die Menge aller Zweige mit Anfangsknoten in der Tiefe i − 1 und Endknoten in der Tiefe i, d. h. Ei = {e | i(e) = ϑ ∈ Vi−1 , x(e), Λ(e) = yi , f (e) = ϑ0 ∈ Vi } .

Nun kann der Viterbi-Algorithmus 7.7 zur SDML-Decodierung im Codetrellis T formuliert werden. Algorithmus 7.7: Soft-Input Viterbi-Algorithmus. Initialisierung: i = 1, α(ϑA ) = 0. Schritt 1: Bilde

∀e ∈ Ei :

α(f (e)) = α(i(e)) + Λ(e) · x(e) .

Schritt 2: Endet mehr als ein Pfad in ϑ0 ∈ Vi , wähle den Pfad mit dem maximalen α(f (e)) als Survivor und ordne diesem Knoten diese Metrik zu (sind die Metrikwerte aller ankommenden Pfade gleich groß, so wird ein Survivor zufällig ausgewählt). i = i + 1, falls i ≤ n Schritt 1, sonst Schritt 3 ˆ diejenige aus, die dem Survivorpfad im Endknoten Schritt 3: Wähle als decodierte Codefolge x ϑB entspricht.

Beispiel 7.4 (Viterbi-Decodierung des (7, 4, 3)-Codes (Soft-Decision)) Bild 7.12 zeigt ein minimales Trellis des (7, 4, 3)-Hamming-Codes und die Vektoren c, f und y. Die Zahlen (l) an den Knoten stellen die entsprechenden Metrikwerte Λli dar. Um die Metrikwerte der Tiefe i + 1 zu berechnen, wurde die Survivor-Metrik der Tiefe i benutzt. c : −1 −1 −1 +1 +1 +1 +1 f : −0.3 +0.4 0.0 +0.2 −1.4 +0.9 −1.1 y : −1.3 −0.6 −1.0 +1.2 −0.4 +1.9 −0.1 −1.3

−1.9

−0.7

+1.9

−2.9

+4.1

−1.7

+2.9

−0.9

+2.1

+0.3

+1.5

+2.9

+3.7

+5.6

+5.5

−0.5

+0.6

+5.3

+1.7

+0.9

+1.3

+0.7

−0.3

+2.1 +1.7 +0.5

+2.5

−0.3

+3.3

+0.1

+1 −1

+1.1

−0.7

−0.2

+5.2

−0.9

Abb. 7.12: Minimales Trellis für den (7, 4, 3)-Hamming-Code. Anmerkung: Im Hard-Decision-Fall wären zwei Fehler aufgetreten, die nicht decodiert werden können. 

Auch hier gilt, dass der Viterbi-Algorithmus nur auf relativ kurze Codes, bzw. Codes kleiner Dimension angewendet werden kann, da das Trellis sonst zu komplex wird. Jedoch liegt der Unterschied in der Komplexität zwischen Hard-Decision- und SoftDecision-Decodierung nur in der Berechnung der Metrik eines Zweiges.

198

7 Weitere Decodierverfahren

Listen-Viterbi-Algorithmus: Eine Erweiterung des Viterbi-Algorithmus auf ein Listendecodierverfahren, das neben der besten Entscheidung auch noch die L nächstbesten Entscheidungen liefert, erhält man durch folgende Modifikation [SSZB04]. Bei der Entscheidung an jedem Knoten muss man sich die Differenz δ(νi , l) der Metrik des Survivors zu dem zweitbesten Pfad merken. Hat man sich am Ende für den ML-Pfad entschieden, so kennt man den Vektor (δ(ν1 , l1 ), δ(ν2 , l2 ), . . . , δ(νn , ln )), in dem die Differenzen der Entscheidungen an den Knoten auf dem ML-Pfad stehen. Der zweitbeste Pfad beginnt an dem Knoten νj = min{δ(νi , li )} auf dem ML-Pfad und läuft von diesem Knoten aus rückwärts. +5.5 +5.3 −1.7 +1.7

+1.3

Abb. 7.13: Listen-Viterbi für (7, 4, 3)-Hamming-Code.

Die Idee dabei ist, dass der zweitbeste Pfad sich irgendwann mit dem besten Pfad (ML) vereinigen muss, spätestens im Endzustand3 (ganz rechts im Trellis). Der zweitwahrscheinlichste Pfad ist nun genau derjenige, der sich mit dem wahrscheinlichsten Pfad bei der unsichersten (kleinsten) Entscheidung, also beim kleinsten δ(νi , li ), vereinigt. Von diesem Zustand aus wird rückwärts der wahrscheinlichste Pfad ausgewählt. Dieser wird sich wieder mit dem ML-Pfad vereinigen, spätestens jedoch im Startzustand (ganz links im Trellis). Nun hat man den zweitbesten Pfad und hat auch für diesen den Vektor der Entscheidungsdifferenzen (δ(νa , la ), . . . , δ(νj , lj )). Diese Werte müssen nun korrigiert werden, da sich dieser Pfad im Knoten νj mit dem ML-Pfad vereinigt und folglich einen Offset von δ(νj , lj ) besitzt. Bevor man also erneut das Minimum aller Differenzen sucht, muss man diesen Offset korrigieren und δ(νj , lj )) zu den Werten addieren. Der Knoten νa liegt auch auf dem ML-Pfad (denn er vereinigt sich spätestens im Startknoten ganz links im Trellis mit dem ML-Pfad). Für den drittbesten Pfad sucht man nun das Minimum aus den zwei Vektoren und geht von diesem Knoten aus wieder rückwärts, usw. Das folgende Beispiel soll diesen Algorithmus veranschaulichen. Beispiel 7.5 (Listen-Vierbi-Algorithmus)Wir betrachten erneut das Beispiel entsprechend Bild 7.12. Der ML-Pfad ist (−1, −1, −1, 1, 1, 1, 1) (durchgezogener Pfad in Bild 7.13). Der 3 Bei

Faltungscodes wird Terminierung vorausgesetzt.

7.4 Soft-Decision Decodierung

199

Vektor der Differenzen auf diesem Pfad ist (∗, ∗, 5.8, ∗, 4.2, 5.0, 0.2), wobei ∗ angibt, dass keine Verzweigung vorliegt. Das Minimum ist die letzte Stelle und der zweitbeste Pfad startet daher vom Endknoten aus rückwärts. Er lautet (−1, 1, −1, 1, −1, 1, −1) (punktierter Pfad in Bild 7.13) und vereinigt sich mit dem ML-Pfad einen Zustand rechts vom Startknoten. Das Skalarprodukt der ML-Entscheidung mit dem empfangenen Vektor y ist genau die Metrik des Pfades und kann aus dem Trellis abgelesen werden zu 5.5 für den ML- und 5.3 für den zweitbesten Pfad. Es war also eine sehr knappe Entscheidung. Um den drittbesten Pfad zu berechnen, benötigen wir die Metrikdifferenzen auf dem zweitbesten Pfad. Diese sind (∗, ∗, 3.4+0.2, ∗, 4.0+0.2, 5.4+0.2, ∗), wobei die Korrektur des Offsets um 0.2 berücksichtigt ist. Das Minimum der beiden Differenzenvektoren ist 3.6 und damit ist der drittbeste Pfad (1, −1, 1, 1, −1, 1, −1) (strichpunktierter Pfad in Bild 7.13). Sein Skalarprodukt mit y ist 1.9, was dem Skalarprodukt des ML-Pfades minus dem Offset, also 5.5 − 3.6 = 1.9 entspricht. 

7.4.4

Iterative Verfahren

Das Schlüsselelement der symbolweisen iterativen Decodierung ist die Bestimmung von extrinsicher Information (Gleichung (7.15)) mit korrektem Vorzeichen. Bezüglich des Vorzeichens ist die MAP-Entscheidung Gleichung (7.6) und damit ebenso das Vorzeichen der aus ihr ableitbaren extrinsischer Information optimal. Allerdings ist die Berechnung der optimalen MAP-Entscheidung i. a. zu aufwändig, so dass für die iterative Decodierung Näherungen benutzt werden, unterschiedliche Qualität besitzen. Das folgende einführende Beispiel soll zunächst das Grundprinzip der iterativen Decodierung veranschaulichen. Beispiel 7.6 (Iterative Decodierung) Gegeben sei der (3, 2, 2)-Parity-Check Code. Es ˆ (0) = (0.6, −0.5, 0.8) empfangen wurde. wird angenommen, dass x = (1, 1, 1) gesendet und y ˆ (0),H = (0, 1, 0), kein Codewort. Ein Offensichtlich ist die Hard-Decision des Empfangsvektors, y Codewort des dualen Codes ist h = (111). Die entsprechende Prüfgleichung lautet c0 +c1 +c2 = 0. Die extrinsische Information für die Stelle 0 ist damit c0 = c1 + c2 . Für das BPSK (±1) modulierte Codewort lautet die Prüfgleichung x0 x1 x2 = 1 und entsprechend gilt x0 = x1 x2 . Anschaulich ist die extrinsische Information die „Meinung“ der anderen Stellen über eine Stelle. Die extrinsische Information wird deshalb wie folgt berechnet: (i)

(i)

(i)

Lext,1 = yˆ2 · yˆ3 ,

(i)

(i)

(i)

Lext,2 = yˆ1 · yˆ3 ,

(i)

(i)

(i)

Lext,3 = yˆ1 · yˆ2 .

Damit erhält man nach der ersten Iteration ˆ (1) = y ˆ (0) + L(0) = (0.6, −0.5, 0.8) + (−0.4, 0.48, −0.3) = (0.2, −0.02, 0.5) . y Man erkennt, dass Position 2 weiterhin fehlerhaft ist und zugleich hat sich die Zuverlässigkeit der Positionen 1 und 3 verringert. Andererseits haben die Positionen 1 und 3 die Zuverlässigkeit von Position 2 „verbessert“. Die nächste Iteration liefert ˆ (2) = y ˆ (1) + L(1) = (0.2, −0.02, 0.5) + (−0.01, 0.1, −0.004) = (0.19, 0.08, 0.496) . y ˆ (2),H = (0, 0, 0), d. h. die iterative Decodierung hat den Fehler in Position 2 korrigiert Nun gilt y und das gesendete Codewort gefunden. Weitere Iterationen verändern das Codewort nicht, wie in Satz 7.12 gezeigt wird.

200

7 Weitere Decodierverfahren

Wir wählen nun eine andere Näherung der extrinsischen Zuverlässigkeit, nämlich für die erste Stelle (entsprechend für die anderen Stellen) n o (i) (i) (i) (i) (i) Lext,1 = sign(ˆ y2 · yˆ3 ) · min |ˆ y2 |, |ˆ y3 | . Die Idee hierbei ist, dass die Zuverlässigkeit der Kombination von zwei Zuverlässigkeiten nur so gut sein kann, wie die geringste Zuverlässigkeit der kombinierten Werte. Mit dieser Zuverlässigkeit berechnen wir ˆ (1) = y ˆ (0) + L(0) = (0.6, −0.5, 0.8) + (−0.5, 0.6, −0.5) = (0.1, 0.1, 0.3) . y 

Die Decodierung erfolgt mit der besseren Näherung in einem Schritt.

(j)

(j)

(j)

(j)

ˆ (j+1) = (ˆ y y1 , . . . , yˆn ) + (Lext,1 , . . . , Lext,n ) j>0 (0)

(0)

ˆ (0) = (ˆ y y1 , . . . , yˆn )

Decodierergebnis

iterativer Decodieralgorithmus

(Stop-Kriterium erfüllt) ∨ (j = Θ)

Abb. 7.14: Symbolweiser iterativer Decodierer.

Symbolweise iterative Decodierung Die symbolweise iterative Decodierung basiert auf Algorithmen, die sowohl Zuverlässigkeitsinformation als Eingabe (soft input) verwenden, wie auch Zuverlässigkeitsinformation über das Decodierergebnis (soft output) liefern. Dies ermöglicht eine wiederholte (iterative) Decodierung desselben Empfangsvektors. In der ersten Iteration verwendet der Decoder dabei nur die Kanalzuverlässigkeitsinformation und berechnet eine neue Zuverlässigkeitsinformation für die einzelnen Empfangssymbole. Dabei wird angenommen, dass diese neue Zuverlässigkeitsinformation einer extrinsischen Information entspricht, d. h. unabhängig von dem jeweils betrachteten Symbol ist. Die iterative Decodierung wird solange fortgesetzt, bis die maximal erlaubte Anzahl von Iterationen überschritten oder ein bestimmtes Stop-Kriterium erfüllt ist. Bild 7.14 veranschaulicht das Prinzip eines symbolweisen iterativen Decodierers. Zur symbolweisen iterativen Decodierung kann dann Algorithmus 7.8 verwendet werden. Man beachte, dass das Decodierergebnis ˆr nicht notwendigerweise ein Codewort sein muss. Betrachten wir eine fehlerhafte Koordinate i, d. h. sign(yi ) ist nicht korrekt. Diese Koordinate kann korrigiert wer(0) (0) den, wenn sign(ˆ yi ) = − sign(Lext,i ), und zwar in einem Iterationsschritt, wenn gilt (0)

(0)

|Lext,i | > |ˆ yi |. Der Fehler wird dann korrigiert, wenn in irgend einem Iterationsschritt (j)

das Vorzeichen von yˆi gekippt wird. Umgekehrt gilt für eine richtig empfangene Ko(j) ordinate i, dass das Vorzeichnen von yˆi richtig bleibt, solange für Iterationen l ≥ j, (l) (l) Lext,i nicht das Vorzeichen von yˆi ändert. Die optimale extrinsische Information ergibt sich für den ersten Iterationsschritt nach den Gleichungen (7.15) bzw. (7.16). In den weiteren Iterationsschritten gibt es bereits statistische Abhängigkeiten, so dass die Werte nicht mehr optimal sein können. Der Rechenaufwand ist jedoch nur für relativ kurze Codes realistisch.

7.4 Soft-Decision Decodierung

201

Algorithmus 7.8: Allgemeine Definition eines iterativen Decodieralgorithmus. (0)

• Setze yˆi

Initialisierung:

(0)

= Lch yi , Lext,i = 0, i ∈ [1, n], Iterations-Index j = 0.

• Definiere die maximale Anzahl an Iterationen Θ. ` ´ Schritt 1: Falls gilt: (Stop-Kriterium nicht erfüllt) und (j < Θ) berechne: addiere:

(j)

Lext,i , i = 1, . . . , n .

(j+1)

yˆi

(j)

= yˆi

(j)

+ Lext,i , i = 1, . . . , n .

j = j + 1, Schritt 1. ˆ Schritt 2: ˆ r=y

(j),H

ˆ (j) ), stop. (Hard-Decision von y

Prinzipiell kann jeder Soft-Output Decodierer wie etwa der BCJR-Algorithmus (Abschnitt 8.5, Seite 282) verwendet werden. Dieser wird bei der Decodierung von mit Faltungscodes konstruierten Turbo-Codes (Abschnitt 9.4.5) verwendet. Bei Blockcodes verwendet man eine Teilmenge Bi ⊂ C ⊥ der Codeworte des dualen Codes als Prüfvektoren. Bei LDPC-Codes (Abschnitt 5.5, Seite 126) werden Prüfvektoren konstruiert, die möglichst kleines Gewicht besitzen. Es kann gezeigt werden [LBB98], dass die iterative APP-Decodierung als Verallgemeinerung der gewichteten Mehrheitsdecodierung interpretiert werden kann. Nach [LBB98] und [BH86] impliziert dies, dass vor allem minimalgewichtige Prüfvektoren für eine Näherung der MAP-Wahrscheinlichkeit geeignet sind (vergleiche auch Algorithmus DA aus Abschnitt 7.3.3). Sei Bi die Menge der minimalgewichtigen Prüfvektoren für eine Position i, Bi = {b | i ∈ supp(b), ∀ b ∈ B}, und Ii (b) die Menge der Koordinaten, an denen b eine Eins besitzt, außer der Koordinate i selber, d. h. Ii (b) = {l | l ∈ supp(b) ∧ l 6= i}, dann ist in vielen Fällen die extrinsische Information, berechnet durch Lext,i (Bi ) =

X

Y

tanh(yl ),

(7.22)

b∈Bi l∈Ii (b)

eine Näherung von Lext,i (C ⊥ ), die die obigen Anforderungen für die iterative Decodierung erfüllt. Damit erhalten wir einen iterativen Decodieralgorithmus 7.9. Algorithmus 7.9: Symbolweiser iterativer Decodieralgorithmus (IDA). Initialisierung:

(0)

• Setze yˆi

(0)

= yi , Lext,i = 0, i = 1, . . . , n, Iterationsindex j = 0.

• Definiere die maximale Anzahl von Iterationen Θ. ` (j),H ´ ˆ Schritt 1: falls y 6∈ C) und (j < Θ) P Q (j) (j) (a) für i = 1, . . . , n berechne: Lext,i (Bi ) = tanh(ˆ yl ) . b∈Bi l∈Ii (b)

(b) für i = 1, 2, . . . , n addiere: (c) j := j + 1, Schritt 1.

ˆ (j),H , stop. Schritt 2: ˆ r=y

(j+1) yˆi

=

(j) yˆi

(j)

+ Lext,i .

202

7 Weitere Decodierverfahren

Man beachte, dass ˆr nicht notwendigerweise ein Codewort sein muss. Die Wahl des Stop-Kriteriums basiert auf folgendem Satz. ˆ ∈ C die harte Entscheidung von y ˆ (j) in Iteration Satz 7.12 (Stop-Kriterium) Es sei c j. Dann gilt für alle folgenden Iterationen l > j, dass deren harte Entscheidung ebenfalls ˆ ist. gleich c ˆ ∈ C ist, gilt c ˆ · b = 0 mod 2 für alle b ∈ Bi , i ∈ [1, n]. Für die Notation Beweis: Da c (j) (j) bi ∈ {+1, −1} kann man dies schreiben als sign(ˆ yi ) = sign(Lext,i (b)), für alle b ∈ Bi , i ∈ [1, n]. Dies impliziert (j)

(j)

sign(ˆ yi ) = sign(Lext,i (Bi )), i ∈ [1, n]. (j+1)

Gemäß Schritt (b) addiert man yˆi chung (7.23), dass für i ∈ [1, n] gilt:

(j)

= yˆi

(j+1)

sign(ˆ yi

(7.23)

(j)

+ Lext,i , i ∈ [1, n], und somit folgt nach Glei(j)

) = sign(ˆ yi ).

ˆ (j+1),H = c ˆ, und offensichtlich y ˆ (l),H = c ˆ, l > j + 1. Folglich gilt y

2

Anmerkungen: IDA kann als iterativer APP-Decodieralgorithmus verstanden werden, der eine Verallgemeinerung der Algorithmen von Gallager und Battail et al. darstellt ([Gal62], [BDG79]). Die erste Iteration des IDA kann als Approximation der optimalen MAP-Entscheidung für jede Position interpretiert werden. Nach der ersten Iteration bestehen statistische Abhängigkeiten zwischen berechneten a-posteriori-Werten, so dass eine iterative Decodierung nur heuristisch motiviert ist. Man beachte, dass IDA hauptsächlich in Codeworte konvergiert. Es konnten aber auch Punkte klassifiziert werden, für die keine Konvergenz in Codeworte gegeben ist [LBB98]. Allerdings ist die Auftrittswahrscheinlichkeit dieser Punkte sehr klein. Somit liefert IDA in den meisten Fällen eine suboptimale Sequenzschätzung. Eine weitergehende Analyse des IDA hinsichtlich der Wahl der Prüfvektoren, Konvergenz sowie einer effizienten Implementierung findet man in [Luc97]. Beispiel 7.7 (Simulationsergebnisse und Komplexität für IDA) In Bild 7.15 ist die Bitfehlerwahrscheinlichkeit für MAP-Decodierung und iterative Decodierung (IDA) für den (15, 7, 5)-BCH-Code bzw. (31, 21, 5)-BCH-Code dargestellt. Man erkennt, dass mit IDA für diese Codes nahezu die optimale Bitfehlerwahrscheinlichkeit erzielt wird. Aus Bild 7.16 ist zu erkennen, dass man mit der iterativen Decodierung des (273, 191, 18)-Codes im Vergleich zu „klassischer“ 1-Schritt-Mehrheitsdecodierung einen Gewinn von 2.2 dB bei PBit = 10−3 erreicht. Weiterhin ist das Ergebnis der SDML-Decodierung eines Faltungscodes der Rate 2/3 gezeigt (Abschnitt 8.1), der durch Punktierung des Faltungscodes der Rate 1/2 mit den Generatorpolynomen g1 = 561 und g2 = 753 und der Gesamteinflußlänge ν = 9 konstruiert wurde. Man beachte, dass die Decodierkomplexität für den Faltungscode und IDA in diesem Fall annähernd gleich sind. Obwohl der (273, 191, 18)-Code nur suboptimal decodiert wird, erzielt man ab Eb /N0 = 3 dB ein besseres Ergebnis. 

Gewichtete Mehrheitsdecodierung (threshold decoding ) Im Jahr 1963 wurde von Massey [Mas] die Mehrheitsdecodierung basierend auf orthogonalen Prüfvektoren (siehe Abschnitt 7.3.2, Seite 184) durch Berücksichtigung von

10

−1

10

−2

10

−3

10

−4

203

BCH(15,7), IDA BCH(15,7), MAP BCH(31,21), IDA BCH(31,21), MAP

P

Bit

7.4 Soft-Decision Decodierung

0

1

2

3 E /N [dB] b

4

5

6

0

Abb. 7.15: Vergleich von MAP-Decodierung und IDA für den (15, 7)-BCH- und den (31, 21)-BCH-Code. 1−Schritt−Mehrheitsdec. Faltungscode Rate 2/3 IDA

−1

10

−2

PBit

10

−3

10

−4

10

−5

10

0

1

2

3 Eb/N0 [dB]

4

5

6

Abb. 7.16: Decodierung des (273, 191, 18)-Code mit IDA im Vergleich zur Viterbi-Decodierung eines Faltungscodes der Rate 2/3.

symbolweiser Zuverlässigkeitsinformation auf die sogenannte gewichtete Mehrheitsdecodierung (oder auch threshold decoding, a posteriori probability (APP) decoding) erweitert. Der Empfangsvektor nach Übertragung über einen AWGN-Kanal sei y = x + n. Für einen Prüfvektor b ∈ C ⊥ des linearen binären Codes C ist das Syndrom s(b) gegeben durch: s(b) = hyH , bi =

n X l=1

ylH · bl =

X

l∈supp(b)

ylH mod 2 ∈ {0, 1}.

204

7 Weitere Decodierverfahren

Ersetzt man den Hard-Decision-Wert ylH durch sign(yl ), erhält man als äquivalenten Ausdruck: Y s(b) = sign(yl ) ∈ {+1, −1}. l∈supp(b)

Man beachte, dass s(b) genau dann gleich +1 (−1) ist, wenn sich in den durch den Träger von b indizierten Koordinaten l eine gerade (ungerade) Anzahl von −1-en befindet. Um nun ein Zuverlässigkeitsmaß für diese beiden Ereignisse zu erhalten, muss die entsprechende APP-Wahrscheinlichkeit bestimmt werden. Nehmen wir an, dass der duale Code nur das Nullcodewort und den Vektor b enthält, so ergibt Gleichung (7.16) die MAPWahrscheinlichkeit für obige Ereignisse in Form eines Log-Likelihood-Verhältnisses:    Q 1+ tanh L(x2l ,yl )   Peven l∈supp(b)   L(s(b)) = ln = ln  (7.24) Q  . Podd 1− tanh L(x2l ,yl ) l∈supp(b)

Der Wert L(s(b)) ist eine reelle Zahl, deren Vorzeichen die harte Entscheidung liefert, während der Betrag ein Maß für die Zuverlässigkeit dieser Entscheidung darstellt. Bei gegebenem Prüfvektor bi wird folgende Notation verwendet: ( 0, L(s(bi )) ≥ 0 H si = L (s(bi )) = und wi = |L(s(bi ))|. 1, sonst, Für eine Menge MJ von Prüfvektoren, die bezüglich Position i orthogonal sind (Definition 7.5 auf Seite 184), sind die Empfangssymbole zur Berechnung der L-Werte nach Gleichung (7.24) statistisch unabhängig. Daher können „Syndrom-L-Werte“ nach Gleichung (7.24), die auf orthogonalen Prüfvektoren basieren, aufsummiert werden. Entsprechend Abschnitt 7.3.2 kann somit für MJ eine gewichtete Mehrheitsentscheidung definiert werden zu:  J J P P r , wl sl < 12 wl i cˆi = (7.25) l=1 l=1  ri ⊕ 1, sonst, wobei ri die Hard-Decision des Empfangswertes yi ist.

Anmerkung: Ersetzt man die Menge MJ durch den gesamten Code bzw. dualen Code und berechnet die L-Werte nach Gleichung (7.15) bzw. (7.16), so erhält man die MAP-Entscheidung für Position i. Daher kann die gewichtete Mehrheitsdecodierung für Position i basierend auf orthogonalen Prüfvektoren als Näherung der entsprechenden MAP-Wahrscheinlichkeit angesehen werden. Die Berechnung dieser Näherung ist wesentlich weniger komplex, da nur ein sehr kleiner Teil des gesamten dualen Codes verwendet wird. Allerdings ist die erzielte Restbitfehlerwahrscheinlichkeit i. a. deutlich schlechter als für MAP-Decodierung. Identisch sind beide Decodierverfahren im Fall von Parity-Check-Codes bzw. Wiederholungscodes [LBB98].

7.4 Soft-Decision Decodierung

205

Belief-Propagation (Message-Passing, Sum-Product) Eine Menge von Prüfgleichungen kann entsprechend Bild 5.4 auf Seite 127 als bipartiter Graph (Tanner-Graph) dargestellt werden. Die iterative Decodierung wird dann als Belief-Propagation-, Message-Passing oder auch Sum-Product-Algorithmus bezeichnet. Speziell die Decodierung von LDPC-Codes wird häufig auf diese Art beschrieben. Da wir die iterative Decodierung bereits beschrieben haben, werden wir nachfolgend nur einen Iterationsschritt des Believe-Propagation-Algorithmus skizzieren. Eine Codestelle wird durch einen variable node repräsentiert und eine Prüfgleichung durch einen check node. Analysen der Decodierung von LDPC-Codes mit Varianten von Believe-Propagation findet man u.a. in [Ric09, RU08]. Iterationschritt: 1. Im ersten Schritt sendet jeder variable node seinen Kanal-Zuverlässigkeitswert Lch (yi ) an alle check nodes

ci Lch (yi ) 2. Im ersten Teilschritt einer Iteration berechnet jeder check node aus den empfangenen Werten die entsprechenden extrinsischen Werte und sendet diese an die variable nodes zurück

L(z ⊕ y)

L(x)

L(x)

L(x ⊕ y)

L(z)

L(z) L(x ⊕ z)

L(y)

L(y)

3. Im zweiten Teilschritt einer Iteration berechnet jeder variable node einen neuen Zuverlässigkeitswert und sendet diesen zurück an die check nodes

L(c ⊕ b) L(b)

L(c)

L(a) L(a ⊕ c)

L(c)

L(a) L(b) L(a ⊕ b)

Häufig wird hierbei folgende Näherung verwendet: L(a ⊕ b) = ln

1 + eL(a) eL(b) ≈ sign (L(a) · L(b)) · min {|L(a)| , |L(b)|} . eL(a) + eL(b)

206

7.5

7 Weitere Decodierverfahren

Decodierung als Optimierungsproblem

In diesem Abschnitt wird die Soft-Decision-Decodierung als Optimierungsproblem betrachtet. Wir wollen dabei der Vorgehensweise in [BBLK97] folgen. Es wird gezeigt, dass Algorithmen aus der Optimierungstheorie grundsätzlich zur Soft-Decision-Decodierung verwendet werden können. Zielfunktion der Optimierung (Decodierung) ist die Minimierung der quadratischen euklidischen Distanz. Nach Gleichung (7.10) ist dies äquivalent zur Maximierung des Innenproduktes zwischen einem Codewort x und der Empfangssequenz y: max {hx, yi} , x

x ∈ C ⇔ cHT = 0 mod 2.

(7.26)

Ein verwandtes Optimierungsproblem, das durch den Simplex-Algorithmus ([NeWo]) gelöst wird, ist das folgende: Bestimme einen Vektor z, der die Zielfunktion F (z) = hc, zi unter der Nebenbedingung zA = b, z ∈ Rn+ , minimiert, wobei A eine (n × m)-Matrix mit m < n ist. Vergleicht man diese Aufgabenstellung mit der Decodieraufgabe (Gleichung (7.26)), so sind beide identisch, bis auf die Modulo-Rechnung und die Forderung nach einer ganzzahligen Lösung im Falle der Decodieraufgabe (man beachte, dass die Lösung eines Minimierungsproblems durch einen Vorzeichenwechsel in die Lösung eines Maximierungsproblems überführt werden kann). Die Idee des Simplex-Algorithmus ist: Setze n − Rang(A) Koordinaten in z zu Null und löse zA = b mit den verbleibenden Koordinaten. Die zu Null gesetzten Koordinaten werden Basisvariablen genannt, die anderen entsprechend Nicht-Basisvariablen. Es wird nun genau dann eine Basisvariable mit einer Nicht-Basisvariable vertauscht, wenn dadurch die Lösung z0 von z0 A = b die Zielfunktion verbessert, d. h. F (z0 ) < F (z). Dieser Austausch wird solange wiederholt, bis keine Verbesserung mehr möglich ist. Man beachte, dass die durch den Simplex-Algorithmus gefundene Lösung das globale Optimum darstellt. Ein dem Simplex-Algorithmus sehr ähnlicher Algorithmus, der die Modulo-Rechnung ebenso wie die Forderung nach einer ganzzahligen Lösung berücksichtigt, ist die in Abschnitt 7.4 vorgestellte Ordered-Statistics-Decodierung im dualen Code. Daher wird dieser Algorithmus an dieser Stelle wiederholt, um die Verwandtschaft zum SimplexAlgorithmus herauszustellen. Es sei c bzw. x das gesendete Codewort. Der zugehörige Empfangsvektor sei y und dessen harte Entscheidung sei r. Die Prüfmatrix des Codes C sei H. Mit r = c ⊕ f erhalten wir das Syndrom zu s = f · HT mod 2. Eine zu Gleichung (7.26) P äquivalente Zielfunktion ist die Minimierung der gewichteten Hamming-Distanz l∈supp(f ) |yl |, f · HT = s. Für die Ordered-Statistics-Decodierung nehmen wir nun an, dass die Koordinaten des Empfangsvektors y so sortiert sind, dass in den Positionen k + 1, . . . , n diejenigen Positionen liegen, die die geringste Zuverlässigkeit besitzen und deren entsprechende Spalten in der Prüfmatrix linear unabhängig sind. Die zugehörige Prüfmatrix hat die Form H = (Ak |In−k ), wobei Ak eine ((n − k) × k)-Matrix und In−k eine

7.5 Decodierung als Optimierungsproblem

207

((n − k) × (n − k))-Einheitsmatrix ist. Die Koordinaten n − k, . . . , n können in Analogie zum Simplex-Algorithmus als Basisvariablen interpretiert werden. Die OrderedStatistics-Decodierung der Ordnung 1 berechnet nun den Vektor f 0 derart, dass alle Nicht-Basisvariablen e01 . . . e0k gleich Null sind mit Ausnahme von e0m = 1, 1 ≤ m ≤ k. Die Basisvariablen werden anschließend so berechnet, dass f 0 HT = s gilt. Nach Be0 rechnung aller möglichen Vektoren ob eine Variante einen Gewinn in P f wird überprüft, P der Zielfunktion erzielt, d. h. l∈supp(f 0 ) |yl | < l∈supp(f ) |yl |. Man beachte, dass mindestens eine Basisvariable mit e0l = 0, el = 1, k + 1 ≤ l ≤ n, existiert, weil ansonsten keine Verbesserung der Zielfunktion möglich ist. Existieren mehrere Varianten, die die Zielfunktion verbessern, so wird diejenige, die den größten Gewinn erzielt, ausgewählt. Anschließend werden in f 0 und y die l-te Koordinate gegen die m-te Koordinate ausgetauscht. Ebenfalls wird in der Prüfmatrix die l-te Spalte und die m-te Spalte vertauscht und wieder in die Form H = (A0k |In−k ) gebracht. Anschließend wird f durch f 0 ersetzt. Diese Suche wird fortgesetzt, bis keine weitere Verbesserung der Zielfunktion mehr möglich ist. Aufgrund der Modulo-Rechnung bzw. der durch f · HT = s mod 2 gegebenen NichtLinearität der Decodieraufgabe findet die Ordered-Statistics-Decodierung nicht immer das globale Optimum. Nichtsdestoweniger zeigt dieses Beispiel, dass Verfahren aus der klassischen Optimierungstheorie nach entsprechender Anpassung zur Decodierung verwendet werden können. Im Folgenden wird dies verdeutlicht, indem der SimplexAlgorithmus derart in ein klassisches Optimierungsverfahren integriert wird, dass ein SDML-Decodieralgorithmus entsteht. Zunächst wird die Modulo-Rechnung und die damit verbundene Nicht-Linearität der Decodieraufgabe aufgelöst, indem cHT = 0 mod 2 ersetzt wird durch 12 cHT − q = 0, wobei q ein Vektor mit ganzzahligen Koordinaten der Länge n − k ist. Die Restriktion, dass die Koordinaten von c Element von GF (2) sein müssen, lässt sich auch schreiben als c + r = 1n , wobei 1n der All-Einsen-Vektor der Länge n und r = yH die HardDecision des Empfangsvektors y ist. Dabei sind sowohl cj als auch rj nicht-negativ, wie für den Simplex-Algorithmus gefordert. Mit z = (c, q, r) und   − 12 H In−k 0 A= In 0 In können beide Restriktionen zusammengefaßt werden in zAT = (0n−k , 1n ), wobei In , In−k n- bzw. (n−k)-dimensionale Einheitsmatrizen und 0n−k der Null-Vektor der Länge n − k ist. Die Zielfunktion ist dann gegeben durch:  min F (z) = (y0 , . . . , yn−1 , 0, . . . , 0)zr . (7.27) z

Gleichung (7.27) repräsentiert ein klassisches ganzzahliges Optimierungsproblem, das beispielsweise mit Verzweigungsalgorithmen [NeWo] (branch and bound ) gelöst werden kann. Das Flußdiagramm eines Verzweigungsalgorithmus ist in Bild 7.17 dargestellt. Dabei wird das Optimierungsproblem zunächst ohne Berücksichtigung der Ganzzahligkeit gelöst. Ist die gefundene Lösung z0 nicht ganzzahlig in allen Koordinaten, so wird das Optimierungsproblem in zwei unabhängige Teilprobleme aufgespalten. Die Restriktion zj ≤ bzj0 c stellt das erste Teilproblem und zj ≥ bzj0 c das zweite Teilproblem dar.

208

7 Weitere Decodierverfahren

Start Simplex-Algorithmus: L¨ ose Optimierungsproblem ohne Beachtung der Ganzzahligkeit. L¨ osung ganzzahlig?

ja

STOP; L¨ osung ist optimal.

nein Spalte Optimierungsproblem in 2 Probleme durch neue Restriktionen zj ≤ ⌊zj′ ⌋ bzw. zj ≥ ⌊zj′ ⌋. Erg¨ anze beide Probleme zur Liste. Simplex-Algorithmus: W¨ ahle ein Problem der Liste und l¨ ose es ohne Beachtung der Ganzzahligkeit. nein

L¨ osung ganzzahlig? ja

Ist die nein L¨ osung die beste? ja Speichere neue L¨ osung. L¨ osche alle Probleme mit schlechterer Zielfunktion. Liste der Probleme leer? ja

nein

STOP; gespeicherte L¨ osung ist optimal.

Abb. 7.17: Flußdiagramm eines Verzweigungsalgorithmus.

Dabei kann zj0 ein beliebiges der nicht-ganzzahligen Elemente von z0 sein. Anschließend werden beide Teilprobleme zur Liste der ungelösten Probleme hinzugefügt. Wenn eine ganzzahlige Lösung gefunden wird, so hat man eine obere Schranke für das globale Optimum der Zielfunktion gefunden. Teilprobleme, deren (eventuell nicht-ganzzahlige) Lösung diese obere Schranke überschreitet, werden aus der Liste gestrichen. Diese Vorgehensweise findet offensichtlich immer das globale Optimum. Allerdings kann der Aufwand in ungünstigen Fällen sehr hoch sein. Eine Analyse der Decodierkomplexität sowie effiziente Varianten dieses Verzweigungsalgorithmus findet man in [BBLK97].

7.6 Anmerkungen

209

Zusammenfassend hat dieser Abschnitt gezeigt, dass die Anpassung des Simplex-Algorithmus, der zur Lösung von linearen, nicht-ganzzahligen Optimierungsaufgaben verwendet wird, auf ein ganzzahliges Optimierungsproblem auf die Ordered-StatisticsDecodierung im dualen Code führt.

7.6

Anmerkungen

Das Problem der Soft-Decision-Decodierung von Blockcodes wurde zunächst durch die Arbeiten von Gallager [Gal62] (low-density parity-check codes) und Massey [Mas] (threshold decoding) behandelt, die inzwischen wieder durch die iterative Decodierung hoch aktuell sind. Heute ist man aufgrund der Verfügbarkeit von leistungsfähigen Rechnern in der Lage, die Qualität dieser Ideen zu beurteilen. Aus der gleichen Zeit stammt Forneys GMD-Algorithmus [For66b], der inzwischen erheblich verbessert und verallgemeinert wurde. In den siebziger Jahren sind dann zur Listendecodierung die Algorithmen von Weldon [Wel71], Chase [Cha72] und Dorsch [Dor74] entstanden, wobei der Weldon- als Spezialfall des Chase-Algorithmus aufgefasst werden kann. Alle drei sind Vorläufer der Ordered-Statistics-Decodierung, wobei der Dorsch-Algorithmus im dualen Code arbeitet. Die optimale symbolweise MAP-Decodierung wurde durch Bahl et al. [BCJR74] und Hartmann und Rudolph [HR76] eingeführt. Des weiteren haben Battail et al. in ihrer Arbeit [BDG79] die Ideen von Massey erneut aufgegriffen und damit einen weiteren Schritt in Richtung iterativer Decodierung getan. Neben Bahl et al. hat auch Wolf [Wolf78] die Trellisbeschreibung von Blockcodes ausgenutzt, allerdings nicht zur MAP-, sondern zur SDML-Decodierung mit dem Viterbi-Algorithmus. Ein anderer erwähnenswerter graphentheoretischer Ansatz ist die SDML-Decodierung durch den sogenannten Dijkstra-Algorithmus [HHC93]. Zu Beginn der achtziger Jahre hat Evseev [Evs83] gezeigt, dass die Komplexität bei näherungsweiser ML-Decodierung von Blockcodes wesentlich reduziert werden kann. Als eine Näherung der MAP-Decodierung kann das Verfahren von Bossert [BH86] betrachtet werden, das eine erhebliche Komplexitätsreduktion bewirkt. Weitere Arbeiten zur SoftDecision-Decodierung und SDML-Akzeptanzkriterien stammen z. B. von Enns [Enns87], Krouk [Kro89] und Snyders und Be’ery [BS86]. Verfahren zur Soft-Decision-Decodierung findet man in [Omu70] und in [SB89] die verallgemeinerte Wagner-Decodierung (generalized Wagner decoding). In [Sny91] und [LBT93] sind effiziente Implementierungen für die verallgemeinerte Wagner-Decodierung publiziert. Weitere Arbeiten von Fossorier und Lin [FL95] zur Ordered-StatisticsDecodierung im Coderaum und im Raum des dualen Codes. Zur iterativen Decodierung haben Hagenauer et al. [HOP96] und Lucas et al. [LBB96, LBBG96] Arbeiten veröffentlicht. In [KNIH94] haben Kaneko et al. den Chase-Algorithmus auf ein ML-Decodierverfahren verallgemeinert. Akzeptanzkriterien für eine Decodierentscheidung findet man in[Enns87] [KKT+ 96][TP91] Wie die Soft-Decodierung als Optimierungsproblem behandelt werden kann, wurde durch Breitbach et al. in [BBLK97] untersucht. In diesem Kapitel haben wir die Decodierung von Blockcodes beschrieben. Dabei haben wir zunächst Kanalmodelle kennengelernt, wie etwa den q-nären symmetrischen Kanal, den Gaußschen Kanal und das Gilbert-Elliot-Modell, das geeignet ist Bündelfehler zu

210

7 Weitere Decodierverfahren

beschreiben. Danach haben wir die Metrik eingeführt, um ein Abstandsmaß zur Verfügung zu haben. Dabei war für unsere Zwecke die Hamming- und die euklidische Metrik ausreichend. Einige Aspekte zur Komplexität und zum Codiergewinn vervollständigen die vorbereitenden Abschnitte. Danach folgen die Verfahren, die keine Zuverlässigkeitsinformation benutzen. Zur Permutationsdecodierung wird eine Menge von Automorphismen mit bestimmten Eigenschaften verwendet. Erweiterungen der Permutationsdecodierung sind covering polynomials und error trapping [McWSl], bei denen eine Menge von Polynomen mit bestimmten Eigenschaften verwendet wird. Die Einschritt- bzw. MehrschrittMehrheitsdecodierung benötigt eine Menge von Prüfvektoren — Codewörter aus dem dualen Code — die orthogonal zu einer Stelle bzw. Menge von Stellen des Codes sind. Der Spezialfall der Permutationsdecodierung, das error trapping, war geeignet, um Bündelfehler zu korrigieren, dagegen ungeeignet, um Fehler zu korrigieren, die beliebig verteilt sein dürfen. Der DA-Algorithmus ist in der Lage, auch bestimmte Fehler mit Gewicht größer als die halbe Mindestdistanz zu korrigieren. Weiterhin wurde in diesem Kapitel die Decodierung mit Zuverlässigkeitsinformation erläutert (Soft-Decision). Die Präsentation dieser Verfahren haben wir wie folgt strukturiert: Codeworte oder Codesymbole, und optimal oder nicht optimal. Zusätzlich haben wir das Prinzip der Listendecodierung zur vereinheitlichten Darstellung vieler bekannter Algorithmen benutzt. Abschließend haben wir noch den Zusammenhang der Optimierungsalgorithmen und der Decodierung erläutert. Dabei wurde auf den Simplex-Algorithmus und die Verzweigungsverfahren eingegangen.

7.7

Übungsaufgaben

Aufgabe 7.1 Die Standard-Array-Decodierung ist ein Maximum-Likelihood-Decodierverfahren. a) Erstellen Sie ein Standard-Array für den Wiederholungscode der Länge 4. b) Wie viele Vektoren würde das Standard-Array für den Hamming-Code der Länge 7 enthalten? Geben Sie alle Cosetleader an. Aufgabe 7.2 Lösen Sie folgende Aufgaben: a) Entwerfen Sie einen Permutationsdecodierer für den zyklischen einfehlerkorrigierenden Hamming-Code (n = 15, k = 11) mit dem Generatorpolynom g(x) = x4 + x + 1. b) Decodieren Sie das empfangene Polynom r(x) = 1 + x + x7 + x9 + x12 . Aufgabe 7.3 Kann der Golay-Code G23 durch Einschritt-Mehrheitsdecodierung bis zur halben Mindestdistanz decodiert werden? Aufgabe 7.4 Gegeben sei ein zweifehlerkorrigierender RS-Code C der Länge n = 15. a) Wie viele Fehler und/oder Auslöschungen kann man korrigieren, wenn zwei Redundanzzeichen nicht gesendet werden?

7.7 Übungsaufgaben

211

b) Verkürzen Sie den Code auf die Länge n∗ = 8 und entwerfen Sie einen Permutationsdecodierer für C ∗ . Aufgabe 7.5 Gegeben sei ein zweifehlerkorrigierender BCH-Code der Länge n = 15 und den Parametern k = 7, d = 5. Die Menge B der Decodiervektoren sind alle zyklischen Verschiebungen des Polynoms b(x). Decodieren Sie mit dem Decodierverfahren (DA) für binäre lineare Codes den empfangenen Vektor r(x). Es sei: b(x) = x7 + x11 + x13 + x14

und

r(x) = x5 + x10 .

8

Faltungscodes

Faltungscodes (convolutional codes) sind neben Blockcodes die zweite große Gruppe von Codes zur Fehlerkorrektur. Faltungscodes gehen ebenfalls aus einer linearen Abbildung einer Menge von Informationswörtern auf eine Menge von Codewörtern hervor. Konzeptionell sind Informations- und Codewörter dabei unendlich lang und werden deshalb meist als Informations- und Codesequenzen bezeichnet. Die Existenz eines MaximumLikelihood-Decodierverfahrens, welches mit realisierbarem Aufwand durchgeführt werden kann, ist der Grund für den weit verbreiteten Einsatz von Faltungscodes. Eine wichtige Rolle spielt dabei auch die Möglichkeit, dass bei der Decodierung von Faltungscodes auf sehr einfache Weise sowohl Soft-Input verwendet, als auch Soft-Output erzeugt werden kann. Zunächst werden wir im Abschnitt 8.1 auf elementare Grundlagen eingehen. Unter anderem werden unterschiedliche Beschreibungsformen von Faltungscodes vorgestellt. Betrachten wir die Erzeugung eines Codewortes, so geschieht dies mit Hilfe eines zeitund wertdiskreten (digitalen) linearen zeitinvarianten (LTI) Systems: dem Faltungscodierer. Dessen systemtheoretische Beschreibung führt zur Generatormatrix, also der Impulsantwort der Schaltung im Zeitbereich, bzw. der Systemfunktion im Bildbereich. Damit erhalten wir die mathematische Beschreibung einer konkreten Zuordnungsvorschrift von Informations- und Codewörtern. Da ein digitales LTI-System endlich viele Zustände besitzt, kann dieses auch in Form eines Graphen beschrieben werden: dem Zustandsdiagramm. Von diesem wird über den Codebaum das sogenannte Trellis abgeleitet, ebenfalls eine Darstellung in Form eines Graphen, allerdings mit einer speziellen Struktur. Das Trellis bildet die Grundlage bei der ML- und MAP-Decodierung von Faltungscodes. Am Ende des ersten Abschnitts werden wir noch auf die Punktierung von Faltungscodes eingehen. Dabei handelt es sich um ein Verfahren, welches einerseits eine große Flexibilität in der Wahl der Rate eines Faltungscodes, als auch den Entwurf von Systemen mit mehrstufigem Fehlerschutz (unequal error protection) ermöglicht. Im Abschnitt 8.2 werden einige Aspekte der algebraischen Beschreibung vorgestellt. Dabei wird deutlich, dass zwischen den folgenden Begriffen sorgfältig unterschieden werden muss: • Code: Die Menge aller Codesequenzen, die mit einer linearen Abbildungsvorschrift erzeugt werden können. • Generatormatrix: Eine Zuordnungsvorschrift zur Abbildung von Informations- auf Codesequenz. Eine gegebene Abbildung kann durch unterschiedliche Zuordnungsvorschriften realisiert werden. • Codierer: Die Realisierung einer Generatormatrix als digitales LTI-System.

214

8 Faltungscodes

Entsprechend wird streng zwischen Codeeigenschaften, Eigenschaften der Generatormatrix und Form der Realisierung einer Generatormatrix unterschieden. So kann zum Beispiel ein Faltungscode von verschiedenen Generatormatrizen erzeugt werden. Darunter befinden sich unter anderem systematische und katastrophale Generatormatrizen. Somit ist Systematik und Katastrophalität eine Eigenschaft der Generatormatrix und nicht des Codes. Im Abschnitt 8.3 werden die wichtigsten Distanzmaße für Faltungscodes bzw. für deren Generatormatrizen vorgestellt. Die Decodierung von Faltungscodes mit dem Viterbi-Algorithmus (VA) werden wir in Abschnitt 8.4 vorstellen. Dabei spielt die Darstellung des Codes in Trellisstruktur eine entscheidende Rolle. Des weiteren werden wir den sogenannten Soft-Output-ViterbiAlgorithmus (SOVA) beschreiben, welcher am Ausgang zusätzlich Zuverlässigkeitsinformation bzgl. der getroffenen Entscheidungen ausgibt. Im Abschnitt 8.5 stellen wir einen Symbol-by-Symbol-MAP-Algorithmus vor, den BCJRAlgorithmus. Dieser liefert ebenfalls Zuverlässigkeitsinformationen am Ausgang und kommt deshalb bevorzugt in verketteten und iterativen Systemen zum Einsatz. Auch diese Art der Decodierung basiert im wesentlichen auf der Trellisdarstellung des Codes. Einen, im Vergleich zu den beiden vorherigen Abschnitten, völlig unterschiedlichen Ansatz besprechen wir im Abschnitt 8.6: die sequentielle Decodierung, die nicht im Trellis sondern im Codebaum durchgeführt wird. Dazu werden wir den Fano- und ZigangirovJelinek-(ZJ)-Algorithmus vorstellen. Im Abschnitt 8.7 werden wir ein Verfahren diskutieren, das es ermöglicht mit Hilfe der Theorie von Blockcodes eine spezielle Klasse von Faltungscodes zu konstruieren: (Partial)-Unit-Memory-Codes. Für diese (P)UM-Codes kann ein BMD-Decodierverfahren angegeben werden. Im Abschnitt 8.8 sind einige Tabellen guter Faltungscodes zu finden.

8.1

Grundlagen von Faltungscodes

Eine binäre Informationssequenz u wird in Blöcke ui zu k Bits unterteilt, und jeder Informationsblock wird durch den Codierer auf einen Codeblock vi , bestehend aus n Bit abgebildet. Dabei hängt der i-te Codeblock vi nicht nur vom i-ten Informationsblock ui ab, sondern zusätzlich von m vorherigen Informationsblöcken, d. h. der Codierer hat die Gedächtnisordnung (memory) m. Oft wird m auch als Gedächtnis des Codierers bezeichnet. u = u0 , u1 , u2 , . . .

−→

v = v0 , v1 , v2 , . . . ,

mit vt = fkt (ut−m , . . . , ut ) und ut ∈ GF (2)k , vt ∈ GF (2)n .

(8.1) (8.2)

Der entsprechende Faltungscode mit der Coderate R = k/n ist die Menge aller möglichen Sequenzen, die mit einem (n, k, [m])-Faltungscodierer generiert werden kann und wird mit C(n, k, [m]) bezeichnet.

8.1 Grundlagen von Faltungscodes

8.1.1

215

Codierung durch sequentielle Schaltkreise

Der Codierer kann als sequentieller Schaltkreis mit k Eingängen, n Ausgängen und einer Anzahl von Speicherelementen realisiert werden. Hierzu folgen drei Beispiele: Beispiel 8.1 (Faltungscodierer eines C(2, 1, [2])-Codes) Bild 8.1 zeigt einen (2, 1, [2])Codierer, der aus einem Schieberegister der Länge m = 2, aus n = 2 linearen Verknüpfungen

v(1) u

v v(2)

Abb. 8.1: Generierung eines C(2, 1, [2])-Faltungscodes. der Gedächtnisinhalte des Schieberegisters und dem aktuellen Eingangssymbol besteht. Die Informationsfolge u = (u0 , u1 , u2 , . . .) wird bitweise (k = 1) in den Codierer geschoben, das bedeutet im Zeittakt t das Bit ut . Es ergeben sich die n = 2 Ausgangssequenzen (1)

(1)

(1)

v(1) = (v0 , v1 , v2 , . . .)

und

(2)

(2)

(2)

v(2) = (v0 , v1 , v2 , . . .),

aus welchen die Codesequenz (1)

(2)

(1)

(2)

(1)

(2)

v = ((v0 v0 ), (v1 v1 ), (v2 v2 ), . . .) = (v0 , v1 , v2 , . . .) 

gebildet wird.

Beispiel 8.2 (Faltungscodierer eines C(2, 1, [3])-Codes) Bild 8.2 zeigt einen Codierer eines C(2, 1, [3])-Codes. Die Gedächtnisordnung ist hier m = 3. 

v(1) u

v v(2)

Abb. 8.2: Generierung eines C(2, 1, [3])-Faltungscodes.

Im dritten Beispiel wollen wir einen Codierer für k > 1 betrachten, d. h. es wird pro Zeittakt t mehr als ein Bit in den Codierer geschoben. Beispiel 8.3 (Faltungscodierer eines C(3, 2, [1])-Codes) In Bild 8.3 ist ein Codierer eines C(3, 2, [1])-Codes zu sehen. Die Informationssequenz u wird in Blöcke zu je k = 2 Bit aufgeteilt

216

8 Faltungscodes v(1) u(1) v(2)

u

v

u(2) v(3) Abb. 8.3: Generierung eines C(3, 2, [1])-Faltungscodes. und in zwei parallelen Eingangssequenzen in den Codierer geschoben. Es ist zweckmäßig, die folgende Notation zu verwenden: (1)

(1)

(1)

(2)

(2)

(2)

u(1) = (u0 , u1 , u2 , . . .) und u(2) = (u0 , u1 , u2 , . . .). Damit lautet die Informationssequenz (1)

(2)

(1)

(2)

u = ((u0 u0 ), (u1 u1 ), . . .) = (u0 , u1 , u2 , . . .) (1)

(2)

mit ui = (ui ui ). Jede der beiden Eingangssequenzen u(i) wird in ein Register der Länge m = 1 geschoben. 

Ist ein Schaltkreis vorgegeben, so ist der Code definiert als die Menge aller Codesequenzen, die sich bei Eingabe aller möglichen Informationssequenzen ergibt. Sowohl Informations- als auch Codesequenzen werden dabei als unendlich lang angenommen. Dieses Annahme gilt für alle weiteren theoretischen Betrachtungen. Bei praktischen Anwendungen werden in der Regel endliche Codesequenzen benötigt, was wir in Abschnitt 8.1.7 beschreiben werden. Für die Initialisierung der Speicherelemente des Codierers besteht die Konvention, dass diese zu Beginn der Codierung zu Null gesetzt sind.

8.1.2

Impulsantwort und Faltung

Systemtheoretisch lassen sich die in den Beispielen 8.1–8.3 vorgestellten Codierer als lineare zeitinvariante (LTI-) Systeme beschreiben (siehe z. B. [BoFr]). Allgemein kann jeder Faltungscodierer, wie in Bild 8.4 dargestellt, als zeitdiskretes LTI-System mit k-dimensionalem Eingang und n-dimensionalem Ausgang beschrieben werden. Die j-te der n Ausgangsfolgen v(j) erhält man durch Faltung der Eingangssequenzen mit der jeweiligen Impulsantwort des Systems: (j)

(j)

(j)

v(j) = u(1) ∗ g1 + u(2) ∗ g2 + · · · + u(k) ∗ gk =

k X i=1

(j)

u(i) ∗ gi .

(8.3)

8.1 Grundlagen von Faltungscodes

u(1) u(i)

217

.. .

.. . .. .

v(1) v(j)

Faltungscodierer

.. .

u(k)

v(n)

Abb. 8.4: Faltungscodierer als LTI-System. (j)

Daher stammt auch der Name Faltungscode. Die Impulsantwort gi des i-ten Eingangs auf den j-ten Ausgang ergibt sich am j-ten Ausgang durch Anregung des Codierers mit dem diskreten Impuls (1, 0, 0, . . . ) am i-ten Eingang. An allen übrigen Eingängen liegt dabei die Nullsequenz (0, 0, 0, . . . ) an. Die Impulsantworten werden oft auch Generatorsequenzen des Codierers genannt. Beispiel 8.4 (Codesequenzen durch Faltung) Zunächst betrachten wir den Fall k = 1. Für den Codierer in Bild 8.1 ergeben sich die zwei Impulsantworten bzw. Generatorsequenzen zu: g(1) = (1, 1, 1, 0, . . .) und g(2) = (1, 0, 1, 0, . . .) (da k = 1 ist können wir den Index (1) (2) 1 bei g1 und g1 weglassen). Entsprechend erhält man für den Codierer in Bild 8.2 die Impulsantworten: g(1) = (1, 1, 1, 1) und g(2) = (1, 0, 1, 1). Beide Generatorsequenzen g(1) und g(2) sind konzeptionell unendlich lang, jedoch wird hier und bei weiteren Betrachtungen nur der von Null verschiedene erste Teil der Sequenz betrachtet. Die Codiergleichungen für beide Codierer lauten: v(1) = u ∗ g(1) und v(2) = u ∗ g(2) . Die Informationssequenz u = (1, 0, 1, 1, 1, 0, 0, . . .) wird vom Faltungscodierer in Bild 8.2 auf die beiden Ausgangssequenzen v(1) = (1, 0, 1, 1, 1, 0, 0, . . .) ∗ (1, 1, 1, 1) = (1, 1, 0, 1, 1, 1, 0, 1, 0, 0, . . .) v(2) = (1, 0, 1, 1, 1, 0, 0, . . .) ∗ (1, 0, 1, 1) = (1, 0, 0, 0, 0, 0, 0, 1, 0, 0, . . .) abgebildet, die wiederum die Codesequenz v = (11, 10, 00, 10, 10, 10, 00, 11, 00, 00, . . .) ergeben. Konkret bedeutet dabei die diskrete Faltung eine Multiplikation, wobei die Komponenten modulo 2 gerechnet werden: 1 0 1 0 1 1 1 + 1 0 1 + 1 0 = 1 0 2 2 2

1 1 1 ∗ 1 0 1 1 =10000001 1 1 1 1 1 2 2 1

mod 2



218

8 Faltungscodes

Beispiel 8.5 (Generatorsequenzen des (3, 2, [1])-Faltungscodierers) Analog zu dem vorherigen Beispiel können auch für den Codierer aus Bild 8.3 Generatorsequenzen definiert werden. Für jede der beiden Eingangssequenzen (k = 2) existieren drei Generatorsequenzen (n = 3), d. h. für jeden Ausgang eine Sequenz, (j)

gi

(j)

(j)

(j)

= (gi,0 , gi,1 , . . . , gi,m ) für i ∈ [1, 2] und j ∈ [1, 3].

Konkret ergeben sich für diesen Codierer die Generatorsequenzen: (1)

(2)

(3)

g1 = (1 1), g1 = (0 1), g1 = (1 1) (1) (2) (3) g2 = (0 1), g2 = (1 0), g2 = (1 0). Die Codiergleichungen ergeben sich zu: (1)

(1)

v(1) = u(1) ∗ g1 + u(2) ∗ g2 (2)

(2)

v(2) = u(1) ∗ g1 + u(2) ∗ g2 v

8.1.3

(3)

(1)

= u



(3) g1

(2)

+u

(3)

∗ g2 .



Einflusslänge, Gedächtnisordnung und Gesamteinflusslänge

Die drei bisher vorgestellten Faltungscodierer sind FIR- (finite impulse response) Systeme, d. h. alle Generatorsequenzen haben endliche Länge. Die maximale Länge der Impulsantworten ist m + 1 und bestimmt die Gedächtnisordnung m des Codierers. Für den Fall k = 1 werden im Codierer m Bit gespeichert. Die Gedächtnisordnung m entspricht damit der Anzahl der Speicherelemente im Codierer, weshalb m auch oft als Gedächtnis des Codierers bezeichnet wird. Für den Fall k > 1 benötigen wir weitere Definitionen. Einflusslänge: Betrachten wir zunächst nur den i-ten Eingang, dann werden νi der hier (j) einlaufenden Bits im Codierer gespeichert. Die zugehörigen Generatorsequenzen gi , j ∈ [1, n], haben die maximale Länge νi + 1. Deshalb wird νi auch als Einflusslänge (constraint length) der i-ten Eingangssequenz bezeichnet. Die Einflusslängen verschiedener Eingangssequenzen müssen nicht gleich groß sein, daher sollten die folgenden Definitionen benutzt werden. Gedächtnisordnung: oder (memory) m des Codierers ist m = max νi i

und entspricht damit der größten aller k Einflusslängen. Gesamteinflusslänge: Die Anzahl der Speicherelemente ν eines Codierers ist ν=

k X

νi

i=1

und wird als Gesamteinflusslänge (overall constraint length) bezeichnet.

(8.4)

8.1 Grundlagen von Faltungscodes

219

Der Begriff Gedächtnis eines Codierers wird oft zweideutig verwendet: entweder als die Anzahl der Speicherelemente, also die Gesamteinflusslänge ν, oder aber als die Anzahl der Informationsblöcke von denen ein Codeblock abhängt, also die Gedächtnisordnung m. Für k = 1 ist die Gesamteinflusslänge gleich der Gedächtnisordnung (ν = m) und die Unterscheidung braucht nicht gemacht werden. Für k > 1 sollte man jedoch die exakten Bezeichnungen verwenden. Deshalb soll ab jetzt die neue Notation C(n, k, [ν]) statt C(n, k, [m]) benutzt werden. Beispiel 8.6 (Einflusslängen νi des (4, 3, [ν = 3])-Faltungscodierers) Der (4, 3, [ν = 3])-Codierer1 aus Bild 8.5 ist aus k = 3 Schieberegistern unterschiedlicher Länge aufgebaut. Die Einflusslänge der ersten Eingangssequenz u(1) ist ν1 = 0 (damit ist kein Schieberegister für diese Eingangssequenz nötig!), die Einflusslänge der zweiten Eingangssequenz u(2) ist ν2 = 1

v(1) u(1) v(2) u(2) v(3) u(3) v(4) Abb. 8.5: Generierung eines C(4, 3, [ν = 3])-Faltungscodes. und die der dritten Eingangssequenz u(3) ist ν3 = 2. Die Gedächtnisordnung des Codierers ist gegeben durch dessen längstes Schieberegister und ist damit m = 2. Die Gesamteinflusslänge ist ν = 3 und entspricht der Anzahl der Gedächtniselemente des Codierers. 

Prinzipiell können Faltungscodes auch IIR- (infinite impulse response) Systeme sein, die eine unendlich lange Impulsantwort besitzen. Diese werden wir in Abschnitt 8.1.8 betrachten. Aufteilen der Informationssequenz u in k parallele Eingangssequenzen u(i) , i ∈ [1, k], und die Erzeugung der seriellen Ausgabe der Codesequenz v aus den n parallelen Codesequenzen v(j) , j ∈ [1, n], wird in dieser und allen folgenden Darstellungen weggelassen. 1 Das

220

8.1.4

8 Faltungscodes

Generatormatrix im Zeitbereich

Statt der Faltung kann man die Codiergleichungen auch durch eine Matrixmultiplikation beschreiben. Hierzu werden die Generatorsequenzen geeignet in einer halbunendlichen Matrix G angeordnet, die Generatormatrix genannt wird. Bei Betrachtung der bisherigen Beispiele bildet ein (n, k, [ν])-Faltungscodierer eine Informationssequenz, die in Blöcke zu k Bit sortiert ist, u = (u0 , u1 , u2 , . . . , ut , . . .),

(1)

(2)

(k)

mit ut = (ut , ut , . . . , ut ) ∈ GF (2)k ,

auf eine Codesequenz aus Blöcken von n Bit ab: v = (v0 , v1 , v2 , . . . , vt , . . .),

(1)

(2)

(n)

mit vt = (vt , vt , . . . , vt ) ∈ GF (2)n .

Man kann sich auch die Informationssequenz in k parallele Eingangssequenzen aufgeteilt denken, d. h.: (i)

(i)

(i)

u(i) = (u0 , u1 , u2 , . . .),

i ∈ [1, k].

Jede dieser k Sequenzen läuft in ein Schieberegister. Diese können im allgemeinen unterschiedlich lang sein. Die Gedächtnisordnung m des Faltungscodierers entspricht der Anzahl der Speicherelemente des längsten Schieberegisters. Ausgehend von den aktuellen Bits der Eingangssequenzen und den Registerinhalten werden mittels linearer Schaltungslogik n parallele Ausgangssequenzen, (j)

(j)

(j)

v(j) = (v0 , v1 , v2 , . . .),

j ∈ [1, n],

generiert, deren serielle Ausgabe die Codesequenz ergibt. Die Abbildung von Informations- auf Codesequenz, kann durch eine Multiplikation mit der Generatormatrix definiert werden: v = u G. Dabei hat die Generatormatrix  G0 G1 G2 G0 G1  G= G0 

die Form  . . . Gm . . . Gm−1 Gm  , . . . Gm−2 Gm−1 Gm  .. .. . .

mit den (k × n)-dimensionalen Untermatrizen Gl ,  (1) (2)  (n) g1,l g1,l . . . g1,l  (1) (2) (n)  g   2,l g2,l . . . g2,l  Gl =  .  , für l ∈ [0, m].  .. ... ...    (1) (2) (n) gk,l gk,l . . . gk,l

8.1 Grundlagen von Faltungscodes

221

(j)

Die Elemente gi,l , für i ∈ [1, k] und j ∈ [1, n], ergeben sich aus den Impulsantworten (Gleichung (8.3)) des i-ten Eingangs auf den j-ten Ausgang (j)

gi

(j)

(j)

(j)

(j)

= (gi,0 , gi,1 , . . . , gi,l , . . . , gi,m ).

Beispiel 8.7 (Generatormatrix eines (2, 1, [3])-Codierers) Für den Codierer von Bild 8.2 sind die Generatorsequenzen g(1) = (1, 1, 1, 1) und g(2) = (1, 0, 1, 1). Diese werden wie folgt in eine Matrix geschrieben: 0

(1)

(2)

B g0 g0 B B B B G=B B B B @

g1 g1

(1)

(2)

g2 g2

(1)

(2)

(1) g0

(2) g0

(1) g1

(2) g1

(1)

(2)

g0 g0

... ...

(1)

1

(2)

g m gm (1) gm−1

(2) gm−1

(1)

(2)

(1) gm

(2) gm

(1)

(2)

(1)

(2)

. . . gm−2 gm−2 gm−1 gm−1 gm gm ..

..

.

.

C C C C C C. C C C A

d. h., die Codierung der Informationssequenz u = (1, 0, 1, 1, 1, 0, . . .) ergibt in Analogie zu Beispiel 8.4 die Codesequenz: v = uG

0

1 11 10 11 11 B C 11 10 11 11 B C B C 11 10 11 11 B C = (1, 0, 1, 1, 1, 0, . . .) B C 11 10 11 11 B C B C 11 10 11 11 @ A .. .. . .



= (11, 10, 00, 10, 10, 10, 00, 11, . . .).

Beispiel 8.8 (Generatormatrix eines (3, 2, [2])-Codierers) Hier soll der (3, 2, [2])-Faltungscodierer aus Bild 8.3 betrachtet werden. Die Informationssequenz u wird in Blöcken zu je k = 2 Bit in den Codierer geschoben. Die so einlaufenden Informationsblöcke werden dann in zwei parallele Eingangssequenzen aufgeteilt: (1)

(1)

(1)

(2)

(2)

(2)

u(1) = (u0 , u1 , u2 , . . .) und u(2) = (u0 , u1 , u2 , . . .). Damit lässt sich die Informationssequenz schreiben als: (1)

(2)

(1)

(2)

(1)

(2)

u = (u0 u0 , u1 u1 , . . .) = (u0 , u1 , u2 , . . .), mit ui = (ui ui ). Jede der beiden Eingangsequenzen u(i) läuft in ein Schieberegister der Länge m = 1. Analog zu den vorherigen Beispielen können auch hier Generatorsequenzen definiert werden. Für jede der beiden Eingangssequenzen existieren drei Generatorsequenzen, für jede Ausgangssequenz eine, d. h.: (j)

gi

(j)

(j)

(j)

= (gi,0 , gi,1 , . . . , gi,m ), für i ∈ [1, k] und j ∈ [1, n].

222

8 Faltungscodes

Aus Beispiel 8.5 wissen wir, dass gilt: (1)

(2)

(3)

g1 = (1 1), g1 = (0 1), g1 = (1 1) (1) (2) (3) g2 = (0 1), g2 = (1 0), g2 = (1 0). Analog zum vorherigen Beispiel sollen die Codiergleichungen auch hier in Matrixschreibweise angegeben werden. Allgemein ist die Generatormatrix eines (3, 2, [ν])-Codierers gegeben durch 0

(1)

(2)

(3)

B g1,0 g1,0 g1,0 B B (1) (2) (3) B g2,0 g2,0 g2,0 B B B G=B B B B B B @

(1)

(2)

(3)

(1)

(2)

(3)

1

(1)

(2)

(3)

(1)

(2)

(3)

(1)

(2)

(3)

(1)

(2)

(3)

(1)

(2)

(3)

(1)

(2)

(3)

(1)

(2)

(3)

(1)

(2)

(3)

g1,1 g1,1 g1,1 . . .

g1,m g1,m g1,m

g2,1 g2,1 g2,1 . . .

g2,m g2,m g2,m

g1,0 g1,0 g1,0 . . . g1,m−1 g1,m−1 g1,m−1 g1,m g1,m g1,m g2,0 g2,0 g2,0 . . . g2,m−1 g2,m−1 g2,m−1 g2,m g2,m g2,m ..

..

.

.

C C C C C C C C. C C C C C A

Die beiden ersten Zeilen wiederholen sich jeweils um drei Stellen nach rechts verschoben. Für den von uns betrachteten Codierer gilt damit 0 1 101 111 B011 100 C B C B C 1 0 1 1 1 1 B C B C 0 1 1 1 0 0 G=B  C B C 1 0 1 1 1 1 B C B C 011 100 @ A .. .. . .

Allgemein kann das Vorgehen zur mathematischen Beschreibung der in den Bildern 8.1– 8.3 und 8.5 gegebenen Faltungscodierer in folgende Schritte zusammengefasst werden: (j)

• Bestimmung der Generatorsequenzen gi

anhand des Faltungscodierers.

• Die Generatorsequenzen bilden die (k ×n)-Generatoruntermatrizen Gi , i ∈ [0, m]. Die Teilmatrizen bestimmen dann die Generatormatrix.

8.1.5

Zustandsdiagramm, Codebaum und Trellis

Bisher haben wir zur Darstellung eines Faltungscodierers sequentielle Schaltkreise mit linearer Logik verwendet. Alternativ zu dieser realisationsbezogenen Darstellung kann ein Faltungscodierer, bzw. die von diesem erzeugten Codesequenzen, auch mittels Graphen beschrieben werden, von denen wir drei im Folgenden vorstellen wollen. Zustandsdiagramm: Ein Faltungscodierer besitzt eine endliche Anzahl ν an Gedächtniselementen und damit auch eine endliche Anzahl 2ν an Gedächtniszuständen σ. Somit kann ein Codierer auch als endlicher Zustandsautomat aufgefasst werden: Die Ausgabe eines Codeblocks vt zum Zeitpunkt t erfolgt in Abhängigkeit des Gedächtniszustandes σt und des Informationsblocks ut . Zum nachfolgenden Zeitpunkt t + 1 befindet sich der Codierer im Zustand

8.1 Grundlagen von Faltungscodes

223

σt+1 . Mit jeder Zustandsänderung σt → σt+1 ist die Eingabe eines Informationsblocks und die Ausgabe eines Codeblocks verbunden. Zeichnet man nun einen Graphen, dessen Knoten den möglichen Zuständen des betrachteten Faltungscodierers entsprechen, und beschriftet alle möglichen Zustandsübergänge mit den entsprechenden Ein- und Ausgaben (ut / vt ), dann erhält man das Zustandsdiagramm (state diagram) des Faltungscodierers, wie folgendes Beispiel veranschaulicht. Beispiel 8.9 (Zustandsdiagramm) Der (2, 1, [2])-Faltungscodierer mit ν = m = 2 Gedächtniselementen aus dem Beispiel 8.1 und 8.4 führt zu dem in Bild 8.6 dargestellten Zustandsdiagramm. Der Codierer hat 2ν = 4 Gedächtniszustände σ ∈ {(00), (10), (01), (11)}. Betrachten 1 / 10

v(1)

1 / 01

11

0 / 01

0 / 10

u

10

01

1 / 00

v(2) 1 / 11

0 / 11

00

0 / 00

Abb. 8.6: Zustandsdiagramm des (2, 1, [2]) Faltungscodierers. wir z. B. den Zustandsübergang (10) → (01), der mit 0 / 10 beschriftet ist, d. h. der entsprechende Informationblock ist ut = (0) und der ausgegebene Codeblock ist vt = (10). Da der Gedächtnisinhalt durch ein Eingabebit beispielsweise nicht von Zustand (00) nach Zustand (11) springen kann, gibt es Zustände zwischen welchen kein Zustandsübergang existiert. 

Es besteht ein Zusammenhang zwischen Codesequenz und Zustandssequenz, der mit Hilfe von Gleichung (8.2) wie folgt dargestellt werden kann: vt = fkt (ut−m , . . . , ut ) = fkt (σt , ut ) .

(8.5)

Dies bedeutet, dass der Zustand eines Codierers die Abhängigkeit von den m vorherigen Informationsblöcken beinhaltet. Da an jedem der k Eingänge des Codierers entsprechend der Einflusslänge νi Bits gespeichert werden, ist der Zustand des Codierers als ν-Tupel dieser k Gedächtnisinhalte darstellbar: (1)

(1)

(2)

(2)

(k)

(k)

σt = ( (ut−1 . . . ut−ν1 ), (ut−1 . . . ut−ν2 ), . . . , (ut−1 . . . ut−νk ) ).

(8.6)

Diesen Vektor aus ν Bits interpretieren wir als binäre Darstellung einer Dezimalzahl und können so jeden Zustand eindeutig mit einer Zahl σ ∈ {0, 2ν − 1} beschreiben. Als Zustandssequenz (state sequence) bezeichnet man die Sequenz S = (σ0 , σ1 , σ2 , . . . , σt , . . .),

224

8 Faltungscodes

wobei die Initialisierung des Codierers gemäß Konvention σ0 = 0 ist. Jede Codesequenz entspricht genau einer Zustandssequenz, falls keine parallelen Übergänge im Zustandsdiagramm existieren. Codebaum: Ein Faltungscode ist die Menge aller Codesequenzen bzw. Codewörter, die mit einem Faltungscodierer erzeugt werden können. Diese Codewörter sollen nun als Graph in Form eines Baumdiagramms (tree diagram) entsprechend dem folgenden Beispiel dargestellt werden. Das Baumdiagramm wird dann als Codebaum bezeichnet. Beispiel 8.10 (Codebaum) Der in Bild 8.6 dargestellte (2, 1, [2])-Faltungscodierer erzeugt den in Bild 8.7 dargestellten Codebaum. Zweige nach oben entsprechen einem Informationsbit 0, die Zweigen nach unten einer 1. Betrachtet man z. B. die Informationssequenz u = 00 00 00

11

11 10 01 11

11

10

00 0

01

00 01 10 00

1

11 11

10

00

11 10 01 11

01

01

10

00 01 10

Abb. 8.7: Codebaum des C(2, 1, [2])-Faltungscodes. (1, 0, 1, 1, · · · ) so ergibt sich die Codesequenz v = (11, 10, 00, 01, · · · ). Diese entspricht dem im Codebaum fett hervorgehobenen Pfad. 

Im Gegensatz zum Zustandsdiagramm besitzt der Codebaum eine zeitliche Struktur. Zu jedem Zeitpunkt t, der auch Eindringtiefe genannt wird, besteht der Baum aus 2kt Knoten. Die mit t exponentiell anwachsende Komplexität des Codebaums macht diese Art der Darstellung unpraktikabel. Eine genaue Betrachtung des Codebaums ergibt, dass er aus sich periodisch wiederholenden Teilbäumen zusammengesetzt ist. Jedem Knoten im Baum kann ein Zustand σt

8.1 Grundlagen von Faltungscodes

225

zugeordnet werden. Dieser Zustand ist gemäß Gleichung (8.6) definiert und ergibt sich eindeutig aus dem Pfad, der zu dem betrachteten Knoten führt. Mit derart beschrifteten Knoten ist erkennbar, dass von gleichen Zuständen immer die gleichen Zweige abgehen. Diese Übergänge von Knoten mit gleichen Zuständen können für Eindringtiefen t > m zusammengefasst werden, und man gelangt zum sogenannten Trellis (Netzdiagramm). Trellis: Analog zum Codebaum sind auch im Trellis alle Codesequenzen eines Faltungscodes als Pfade enthalten. Hier teilen sich die einzelnen Codesequenzen jedoch Knoten mit gleichen Zuständen. Damit erhält man nach anfänglichem exponentiellen Anwachsen einen Graphen mit einer konstanten Anzahl an 2ν Knoten zu jedem Zeitpunkt t ≥ m. Diese Art der Darstellung wird vor allem bei der ML-Decodierung von Faltungscodes durch den Viterbi-Algorithmus benutzt (vergleiche Abschnitt 8.4). Beispiel 8.11 (Trellis) Der Faltungscodierer aus Bild 8.6 hat das im Bild 8.8 dargestellte Trellis. Alle Knoten mit gleichem Zustand sind in einer Ebene angeordnet. Dabei ist es üblich Knoten im Nullzustand in die oberste Ebene zu legen. Die gemäß Gleichung (8.6) aus ν Bits bestehenden Zustände können auch als binäre Zahlen interpretiert werden. Jeder Zustand entspricht somit einer ganzen Zahl σ ∈ {0, 1, 2, . . . , 2ν − 1}. σ = (00) = 0

00

00

00

00

00

00

00

10

11 10

11 10

11 10

11 10

11 10

11

01 11

01 11

01 11

01 11

01 11

01

00 01

00 01

00 01

00 01

00 01

10

10

10

10

10

σ = (01) = 1 11

σ = (10) = 2 σ = (11) = 3

Abb. 8.8: Trellis des (2, 1, [2])-Faltungscodierers. Des weiteren ist jeder Zweig mit dem ihm entsprechenden Codeblock beschriftet. Um eine übersichtliche Darstellung zu erhalten, wurde die Beschriftung in Bild 8.8 am rechten Ende der Zweige vorgenommen. Gestrichelte Zweige entsprechen einem vom Informationsbit 0 ausgelösten Zustandsübergang (durchgezogenen Zweige entsprechen einem Informationsbit 1). Wie im Codebaum Bild 8.7 ist die Codesequenz v = (11, 10, 00, 01, . . .) mit dickeren Übergängen gekennzeichnet. σ=0 σ=1 σ=2 σ=3

00 11 10 01 11 00 01 10

Abb. 8.9: Teiltrellis des (2, 1, [2])-Faltungscodierers.

226

8 Faltungscodes

Das in Bild 8.9 dargestellte Teiltrellis zeigt die Struktur des Trellis nach dem „Einschwingen“. Betrachten wir Gleichung (8.5) gemeinsam mit diesem Teiltrellis, so ergibt sich: Der Knoten enthält jeweils die Information aus der Vergangenheit, also den Zustand σt des Codierers, während die von ihm ausgehenden Übergänge den aktuellen Informationsbits entsprechen. Die Beschriftung der Zweige ergibt dann das zugeordnete Codewort. 

Alle drei in diesem Abschnitt besprochenen Darstellungsformen eines Faltungscodierers sind Graphen, bestehend aus beschrifteten Zweigen und Knoten. Diese Darstellungsweise gibt einerseits Einblick in die Struktur von Faltungscodes und ermöglicht andererseits die Anwendung einer Vielzahl von Methoden und Verfahren aus der Graphentheorie auf Faltungscodes. Eine mögliche Anwendung wollen wir im folgenden Abschnitt vorstellen.

8.1.6

Freie Distanz und Distanzfunktion

Die Beschreibung der Distanzverhältnisse erweist sich bei Faltungscodes, im Vergleich zu Blockcodes, als wesentlich aufwändiger. Das Problem ist die Definition geeigneter Distanzmaße, denn ein Faltungscode besteht aus unendlich vielen und unendlich langen Codesequenzen. Deshalb ist es nicht möglich, wie bei linearen Blockcodes, die gesamten Distanzeigenschaften in Form einer Distanzverteilung (bzw. Gewichtsverteilung) zu beschreiben. Statt dessen werden wir Untermengen aus der Menge aller Codesequenzen definieren und dann die Distanzeigenschaften dieser Untermengen beschreiben. Freie Distanz: Die freie Distanz eines Faltungscodes ist die minimale Hamming-Distanz zwischen zwei beliebigen Codesequenzen des Codes: df = min dist(v0 , v00 ), 0 00 v 6=v

mit v0 , v00 ∈ C. Aufgrund der Linearität gilt auch bei Faltungscodes df = min wt(v) v6=0

(8.7)

mit v ∈ C. Die freie Distanz ist eine Codeeigenschaft, hängt also nicht von der Abbildung der Informations- auf die Codesequenz ab. Die Berechnung der freien Distanz nach Gleichung (8.7) erscheint schwierig, da unendlich viele Codesequenzen existieren. Betrachtet man allerdings das Zustandsdiagramm des Codes, so kann die freie Distanz relativ einfach abgelesen werden. Dies wollen wir anhand eines Beispiels zeigen. Beispiel 8.12 (Freie Distanz des C(2, 1, [2])-Faltungscodes) Bild 8.10 zeigt eine modifizierte Version des bereits im Beispiel 8.9 vorgestellten Zustandsdiagramms des (2, 1, [2])Faltungscodierers. Übergänge sind dabei mit einem Operator W beschriftet, dessen Potenz dem Hamming-Gewicht des zum entsprechenden Übergang gehörenden Codeblocks entspricht. Alle möglichen Codesequenzen des Codes starten definitionsgemäß zum Zeitpunkt t = 0 im Zustand σ0 = (00) und durchlaufen eine beliebige Sequenz von Zuständen S = (σ0 , σ1 , . . .). Multipliziert man die Beschriftung aller durchlaufenen Übergänge, dann ergibt die Potenz von W das Hamming-Gewicht der entsprechenden Codesequenz. Um die Gleichung (8.7) auszuwerten, kann nun die Zahl der zur Berechnung notwendigen Codesequenzen eingeschränkt werden:

8.1 Grundlagen von Faltungscodes

227

W

W

11

W

W 10

01 1

W2

W2

00

1

Abb. 8.10: Modifiziertes Zustandsdiagramm des (2, 1, [2]) Faltungscodierers. • Es müssen nur solche Codesequenzen betrachtet werden, die zum Zeitpunkt t = 0 den Nullzustand verlassen. Alle anderen Codesequenzen sind dann nur zeitverzögerte Versionen. • Um nur Codesequenzen mit endlichem Gewicht zu betrachten, müssen diese wieder im Nullzustand enden. Zustandsdiagramme mit Nullschleifen, außer der vom Nullzustand auf den Nullzustand, werden wir im Abschnitt 8.1.9 besprechen und deshalb hier ausschließen. • Des weiteren können Codesequenzen ausgeschlossen werden, die den Nullzustand mehrmals verlassen, denn dann existiert immer eine andere Codesequenz mit kleinerem Gewicht. • Alle Codesequenzen die sich nach t > 2m Zustandsübergängen nicht im Nullzustand befinden können ebenfalls ausgeschlossen werden. Diese müssen mindestens einen Zustand σ 6= 0 zweimal durchlaufen und bilden damit eine Schleife im Zustandsdiagramm. Dann existiert immer eine andere Codesequenz mit kleinerem Gewicht. Die freie Distanz dieses C(2, 1, [2])-Codes ergibt sich also aus der Betrachtung aller Codesequenzen die zum Zeitpunkt t = 0 den Nullzustand verlassen und spätesten nach t = 4 zum erstenmal wieder in den Nullzustand übergehen. Betrachtet man Bild 8.10, dann erfüllen nur die beiden folgenden Zustandssequenzen diese Einschränkungen: S1 = ( (00), (10), (01), (00), (00), . . . )

und

S2 = ( (00), (10), (11), (01), (00), (00), . . . ). Es gibt keine parallelen Zustandsübergänge, und somit existieren auch nur zwei Codesequenzen mit diesen Zustandssequenzen. Die Multiplikation der Beschriftung durchlaufener Übergänge ergibt W 5 = W 2 · W 1 · W 2 und W 6 = W 2 · W 1 · W 1 · W 2 für S1 bzw. S2 . Damit ist die freie Distanz des betrachteten Codes df = 5. 

Die freie Distanz ist eines der wichtigsten Distanzmaße für Faltungscodes. Deshalb erfolgt die Klassifizierung von Faltungscodes in der Regel anhand ihrer Rate R, der Gesamteinflusslänge ν und ihrer freien Distanz df (vergleiche Abschnitt 8.8).

228

8 Faltungscodes

Distanzfunktion: Es existieren weitere Distanzeigenschaften eines Faltungscodes, nämlich die sogenannte Distanzfunktion bzw. die erweiterte Distanzfunktion [JZ99]. Zunächst wollen wir anhand zweier Beispiele die Berechnung dieser Funktionen erläutern und danach deren Interpretationsmöglichkeiten besprechen. Analog zum obigen Beispiel 8.12 liegt der Berechnung der Distanzfunktionen eine Untermenge aus der Menge aller möglichen Codesequenzen zugrunde. Diese Untermenge besitzt die Eigenschaft, dass der Nullzustand zum Zeitpunkt t = 0 verlassen wird, und die Zustandssequenz nach erneutem Erreichen des Nullzustands im Nullzustand bleibt. Es werden also alle Codesequenzen betrachtet, deren Zustandssequenzen folgenden Verlauf besitzen S = (0, σ1 , σ2 , . . . , σl−1 , 0, 0, . . .),

(8.8)

mit σt 6= 0 für t ∈ [1, l − 1], wobei immer l > m gilt, da der Nullzustand frühestens nach m + 1 Übergängen erreicht werden kann. Beispiel 8.13 (Distanzfunktion) Zur Berechnung der Distanzfunktion verwendet man ein aus der Signalflusstheorie bekanntes Verfahren. Dazu wird das im Beispiel 8.12 vorgestellte Zustandsdiagramm (Bild 8.10) im Nullzustand aufgeschnitten. Das sich so ergebende Signalflussdiagramm ist in Bild 8.11 dargestellt. Den linken Knoten betrachtet man als Quelle und den rechten als Senke. W ξ2 11

W

W

W 00

W2

10

01 1

ξ1

W2

00

ξ3

Abb. 8.11: Signalflussdiagramm des (2, 1, [2]) Faltungscodierers. Weist man den zwischen Quelle und Senke liegenden Knoten die Hilfsvariablen ξi für i ∈ [1, 3] zu, dann lassen sich folgende Gleichungen aufstellen ξ1 = 1 · ξ3 + W 2 ξ2 = W · ξ1 + W · ξ2 ξ3 = W · ξ1 + W · ξ2

und

T (W ) = W 2 · ξ3 .

Das entsprechende ξi ergibt sich durch Addition aller auf einen Knoten gerichteter Zweige, wobei die Gewichtung der Zweige mit der Hilfsvariablen multipliziert wird, von der der Zweig ausgeht. Das entsprechende lineare Gleichungssystem lautet in Matrixschreibweise: 0

10 1 0 2 1 1 0 −1 ξ1 W @ −W 1 − W 0 A @ ξ2 A = @ 0 A . −W −W 1 ξ3 0

8.1 Grundlagen von Faltungscodes

229

Die Lösung dieses Gleichungssystems, in T (W ) = W 2 · ξ3 eingesetzt, ergibt die geschlossene Form der Distanzfunktion: T (W ) =

W5 = W 5 + 2W 6 + . . . + 2j W j+5 + . . . . 1 − 2W

Diese kann nach positiven Potenzen von W in eine Reihe entwickelt werden, von deren Koeffizienten wir direkt die Anzahl der Codesequenzen eines bestimmten Gewichts ablesen können. So existieren z. B. eine Codesequenz mit Gewicht 5, zwei mit Gewicht 6 und allgemein 2j mit Gewicht j + 5. Der Grad des ersten Glieds dieser Reihe entspricht der freien Distanz des Codes. Wie schon in Beispiel 8.12 berechnet, ergibt sich df = 5.  Beispiel 8.14 (Erweiterte Distanzfunktion) Oft sind zusätzliche Informationen erwünscht, wie etwa: Welche Gewichtsverteilung besitzen Codesequenzen einer bestimmten Länge? Dabei bedeutet „Länge“ die Anzahl der Zustandsübergänge, bevor die Sequenz wieder in den Nullzustand übergeht. Das in Bild 8.12 dargestellte erweiterte Signalflussdiagramm entspricht dem in Bild 8.11, allerdings mit veränderter Beschriftung der Übergänge. Der zusätzliche Operator L ist zum Zählen der Zustandsübergänge, und die Potenz von H erfasst das Hamming-Gewicht des zu einem Übergang gehörenden Informationsblocks. Stellt man, analog zum vorigen BeiW LH ξ2 11

W LH

WL

WL 00

W 2 LH

10

01 LH

ξ1

W 2L

00

ξ3

Abb. 8.12: Erweitertes Signalflußdiagramm eines (2, 1, [2])-Faltungscodierers. spiel, das entsprechende lineare Gleichungssystem auf und löst dieses, erhält man die geschlossene Form der erweiterten Distanzfunktion: T (W, H, L) =

W 5 HL3 . 1 − W H(1 + L)L

Wir können verschiedene Reihenentwicklungen durchführen, z. B. ergibt die Reihenentwicklung nach W : T (W, H, L) = L3 H W 5 + L4 (1 + L)H 2 W 6 + · · ·

+ L3+j (1 + L)j H j+1 W 5+j + · · · .

Betrachtet man den Koeffizient H 2 L4 +H 2 L5 bei W 6 , so ergibt die erweiterte Distanzfunktion, dass es zwei Codesequenzen mit Gewicht 6 gibt, beide gehen aus einer Informationssequenz mit Gewicht 2 hervor, wobei eine davon die Länge 4 und die andere die Länge 5 hat, usw. 

Generell ist die erweiterte Distanzfunktion in Form einer Reihe in drei Variablen darstellbar: XXX T (W, H, L) = N (l, h, w) Ll H h W w . (8.9) w

h

l

230

8 Faltungscodes

Die Koeffizienten N (l, h, w) dieser Reihe geben dann die Anzahl der Codesequenzen mit Hamming-Gewicht w, Informationsgewicht h und der Länge l an. Die Länge ist dabei die Anzahl der Zustandsübergänge bevor die Codesequenz wieder in den Nullzustand läuft. Es ist zu beachten, dass die hier getroffenen Aussagen für die Untermenge gemäß Gleichung (8.8) gelten. Gleichung (8.9) kann nun unterschiedlich interpretiert bzw. ausgewertet werden: • Die Distanzfunktion ergibt sich als Spezialfall X T (W, 1, 1) = T (W ) = N (w)W w ,

(8.10)

w

wobei N (w) die Anzahl von Codesequenzen mit Gewicht w ist. N (w) wird auch als Distanzspektrum (distance spectrum) des Faltungscodes bezeichnet. Dabei handelt es sich um eine Codeeigenschaft. Aus dem Distanzspektrum erhält man die freie Distanz des Codes zu: df = arg min N (w) w,N (w)6=0

• Die Gewichtsverteilung aller Pfade der Länge l X Al (W ) = N (l, w)W w

(8.11)

w

erhält man aus T (W, 1, L) =

XX l

w

N (l, w) W w Ll =

X

Al (W ) Ll .

l

Die Distanzfunktion bzw. auch die erweiterte Distanzfunktion eines Faltungscodes besitzen vor allem konzeptionellen Wert. Ihre Bedeutung ist aus praktischer Sicht aufgrund des mit der Gedächtnislänge ν des Faltungscodierers exponentiell ansteigenden Aufwands zur Berechnung sehr begrenzt. Prinzipiell muss ein ( (2ν − 1) × (2ν − 1) )dimensionales lineares Gleichungssystem gelöst werden. In Abschnitt 8.3 werden wir weitere Distanzmaße von Faltungscodes ableiten.

8.1.7

Terminierung, Truncation und Tail-Biting

Die Codesequenzen eines Faltungscodes sind unendlich lang. In praktischen Anwendungen werden fast ausschließlich Codesequenzen mit endlicher Länge verwendet. Dazu verwendet man Terminierung, Truncation oder Tail-Biting. Diese Methoden werden wir im Folgenden erläutern. Terminierung: Um einen Faltungscode zu terminieren, wird die Informationssequenz so ergänzt, dass die Speicherelemente im Codierer am Ende der Eingangssequenz alle mit Null belegt sind und somit das Gedächtnis des Codierers dem initialisierten Nullzustand entspricht.

8.1 Grundlagen von Faltungscodes

231

Im Falle eines Codierers mit Gedächtnisordnung m, der als FIR-System beschreibbar ist, werden der Informationssequenz endlicher Länge k · m Nullen angehängt. Die Rate eines terminierten Faltungscodes verringert sich im Vergleich zum ursprünglichen Code um den sogenannten Fractional-Rate-Loss L/(L + m), und man erhält RT =

kL L =R , n(L + m) L+m

wobei L der Anzahl codierter Informationsblöcke entspricht. Ist L genügend groß, kann RT ≈ R angenommen werden. Die terminierten Codesequenzen ergeben sich aus v[L+m] = u[L] Gr[L] , wobei die Generatormatrix nach der L-ten Zeile (r steht für row ) abgeschnitten ist:

Gr[L]



G0 G1 G0  = 

 . . . Gm G1 . . . Gm  . .. ..  . . G0 G1 . . . Gm

(8.12)

Anmerkung: Als rekursiv werden Faltungscodierer bezeichnet, die als IIR-Systeme darstellbar sind (vergleiche Abschnitt 8.1.8). Müssen rekursive Codierer terminiert werden, dann ist dies ebenfalls mittels k · m Terminierungsbits möglich. Allerdings hängen die Terminierungssequenzen hier vom jeweiligen Zustand des Codierers ab und werden üblicherweise in Tabellen gespeichert. Da die Terminierungssequenzen von Null verschieden sind, erhöht sich die Anzahl der Zeilen in der Generatormatrix um k · m, die Anzahl der Spalten bleibt gleich. Beispiel 8.15 (Terminierung) Wird der in Beispiel 8.1 vorgestellte Codierer des C(2, 1, [2])-Faltungscodes mit Rate R = 1/2 nach L = 8 Informationsblöcken terminiert, so erhalten wir aus der halbunendlichen Codiermatrix G die (8 × 20)-dimensionale Generatormatrix 0

Gr[8]

1 11 10 11 11 10 11 B C B C 11 10 11 B C B C 11 10 11 B C =B C. 11 10 11 B C B C 11 10 11 B C @ A 11 10 11 11 10 11

Der Fractional-Rate-Loss beträgt L/(L + m) = 0.8, und die Rate des terminierten Faltungscodes ist RT = 0.4 < 0.5. 

Truncation: Eine zweite Möglichkeit, endliche Codesequenzen zu erhalten, besteht darin die Ausgabe des Codierers für t > L einfach zu beenden, unabhängig davon in welchem Zustand

232

8 Faltungscodes

sich dieser befindet. Obwohl also noch Codeblöcke vt 6= 0 für t ≥ L existieren, wird die Codesequenz nach L Codeblöcken abgeschnitten, d. h. für den letzten codierten Informationsblock uL−1 wird noch der entsprechende Codeblock vL−1 ausgegeben, alle weiteren jedoch nicht mehr. Dadurch kommt es zu keinem Ratenverlust, wie dies bei der Terminierung der Fall war. Nach Diskussion der Decodierung von Faltungscodes (Abschnitt 8.4-8.6) wird allerdings klar werden, dass bei diesem Verfahren die am Ende eines Blockes übertragenen Informationsbits einen wesentlich schlechteren Schutz vor Fehlern aufweisen. Die abgeschnittenen Codesequenzen ergeben sich aus v[L] = u[L] Gc[L] , wobei die Generatormatrix nach der L-ten Spalte (c steht für column) abgeschnitten ist:   G0 G1 . . . Gm G0 G1 . . . Gm     .. ..   . .     G0 Gm  . Gc[L] =  (8.13)   .. ..   . .    G0 G1  G0

Beispiel 8.16 (Truncation) Analog zum vorigen Beispiel soll derselbe C(2, 1, [2])-Code nun nach L = 8 Informationsblöcken abgeschnitten werden. Somit erhält man die (8 × 16)dimensionale Generatormatrix 0 1 11 10 11 11 10 11 B C B C 11 10 11 B C B C 11 10 11 B C c G[8] = B C. 11 10 11 B C B C 11 10 11 C B @ 11 10 A 11 Eine Plausibilitätserklärung für den geringeren Schutz des zuletzt übertragenen Informationsbits u7 : Dieses beeinflusst nur den Codeblock v7 , während z. B. das Informationsbit u0 zu Beginn der Informationsfolge zusätzlich zum entsprechenden Codeblock v0 zwei weitere Codeblocks v1 und v2 beeinflusst, entsprechend der Einflusslänge ν1 = 2 (Abschnitt 8.1.3). Tritt ein Bitfehler im Codeblock v7 auf, so kann dies bereits zu einem Fehler bei der Decodierung von u7 führen. Wie wir in Beispiel 8.12 gezeigt haben, ist die freie Distanz des nicht abgebrochenen Codes df = 5. Somit kann dieser immer e = b(df − 1)/2c = 2 Fehler korrigieren, während beim abgeschnittenen Code schon ein Bitfehler im letzten Codeblock zu einem Decodierfehler führen kann. 

Tail-Biting: Eine dritte Möglichkeit, um endliche Codesequenzen mittels Faltungscodierung zu erhalten, ist das sogenannte Tail-Biting. Die Grundidee ist, dass der Faltungscodierer

8.1 Grundlagen von Faltungscodes

233

bereits in dem Zustand startet, in dem er nach der Eingabe von L Informationsblöcken später gestoppt wird. Dies setzt die Kenntnis der gesamten Informationssequenz u[L] vor Beginn der Codierung voraus. Damit kann der Endzustand des Codierers berechnet und dieser zur Initialisierung verwendet werden. So ist ein gleichmäßiger Schutz aller Informationsbits des gesamten Blocks möglich. Der so erzeugte Code ist ein sogenannter quasi-zyklischer Blockcode. Die Codiergleichungen in Matrixschreibweise lauten ˜c , v[L] = u[L] G [L] wobei die Generatormatrix nach der L-ten Spalte abgeschnitten und geeignet ergänzt werden muss:   G0 G1 . . . Gm G0 G1 . . . Gm     .. ..   . .     c G G  . ˜ 0 m G[L] =   . ..   . . .  Gm  .  .. .  . . G0 G1 G1 . . . Gm G0 Die in den letzten k · m Zeilen abgeschnittenen Untermatrizen werden entsprechend am Zeilenanfang ergänzt.

Beispiel 8.17 (Tail-Biting) Analog zu den obigen Beispielen wird der C(2, 1, [2])-Code nach L = 8 abgebrochen. Die entsprechende Codiermatrix ergibt sich zu 0 1 11 10 11 11 10 11 B C B C 11 10 11 B C B C 11 10 11 B C c ˜ [8] = B G C. 11 10 11 B C B C 11 10 11 C B @ 11 11 10 A 10 11 11

Wie zu sehen ist, beeinflussen die letzten beiden Informationsbits bereits die zuerst erzeugten Codebits. Anhand des Faltungscodierers in Bild 8.1 erkennt man, dass diese Codiermatrix durch einen entsprechend vorinitialisierten Faltungscodierer realisiert werden kann. Der Startzustand ergibt sich hier aus u6 und u7 . 

Zusammenhang von Block- und Faltungscodes: In den hier vorgestellten Verfahren einen Faltungscode mit Codesequenzen endlicher Länge zu erzeugen, ist auch der Dualismus zwischen Block- und Faltungscodes zu erkennen: • Ein Faltungcode bildet analog zu Blockcodes Informationsblöcke der Länge k auf Codeblöcke der Länge n ab. Dabei besitzt diese lineare Abbildung Gedächtnis,

234

8 Faltungscodes denn der Codeblock hängt von m vorherigen Informationsblöcken ab. Bei dieser Betrachtungsweise sind Blockcodes ein Spezialfall von Faltungscodes, nämlich Faltungscodes ohne Gedächtnis. • Andererseits haben Faltungscodes in praktischen Anwendungen Codesequenzen endlicher Länge. Betrachtet man die endliche Generatormatrix des so entstandenen Codes im Zeitbereich, dann hat diese eine ganz spezielle Struktur. Da die Generatormatrix eines Blockcodes entsprechender Dimension aber im allgemeinen keine bestimmte Form besitzten muss, können Faltungscodes endlicher Länge als ein Spezialfall von Blockcodes betrachtet werden.

8.1.8

Generatormatrix im transformierten Bereich

In der Systemtheorie können zeitdiskrete LTI-Systeme und daher auch Faltungscodes durch Differenzengleichungen beschrieben werden. Wie in Gleichung (8.3) dargestellt, (j) (j) erhalten wir die j-te Ausgangssequenz v(j) = (v0 , v1 , . . .) aus der Faltung der k (j) Eingangssequenzen u(i) mit den entsprechenden Impulsantworten gi des Codierers: (j)

(j)

(j)

v(j) = u(1) ∗ g1 + u(2) ∗ g2 + · · · + u(k) ∗ gk =

k X i=1

(j)

u(i) ∗ gi .

(8.14)

Die den Codiergleichungen zugrunde liegenden Differenzengleichungen lauten (j)

vt

=

k X m X

(i)

(j)

ut−l gi,l =

i=1 l=0

k X (i) (j) (i) (j) (i) (j) (ut gi,0 + ut−1 gi,1 + · · · + ut−m gi,m ). i=1

(8.15)

Diese können wir mit der Z-Transformation [BoFr] in den Bildbereich (oft auch FreP+∞ quenzbereich) transformieren. Die Z-Transformierte Z{x} = t=0 xt z −t einer Folge x = (x0 , x1 , x2 , . . .) ist definiert als X(z). Für die Beschreibung von Faltungscodes ist es üblich, den Verzögerungsoperator (delay operator ) D = z −1 einzuführen und wir P+∞ erhalten X(D) = t=0 xt Dt . Die Eingangs- und Ausgangssequenzen sind damit im Bildbereich gegeben durch: u(i) b

rb Ui (D) =

+∞ X

(i)

ut Dt ,

t=0

v(j) b

rb Vj (D) =

+∞ X

(j)

vt D t .

t=0

Übertragungsfunktion: Entsprechend der Systemtheorie werden die transformierten Impulsantworten Übertragungsfunktionen genannt: (j)

gi

b

rb Gij (D) =

+∞ X t=0

(j)

gi,t Dt .

(8.16)

8.1 Grundlagen von Faltungscodes

235

Des weiteren benutzt man den Faltungsatz der Z-Transformation Z{x ∗ y} = X(D) · Y (D), um die Faltung in Gleichung (8.14) im transformierten Bereich in eine Multiplikation zu überführen, Vj (D) =

k X i=1

Ui (D) · Gij (D),

(8.17)

bzw. die Differenzengleichungen (8.15) zu lösen. Beispiel 8.18 (Übertragungsfunktionen eines (2, 1, [3])-Codierers) Zunächst wollen wir einen Codierer mit k = 1, nämlich den in Bild 8.2 dargestellten (2, 1, [3])-Codierer, betrachten. Dessen Generatorsequenzen sind (1)

g1 = (1, 1, 1, 1)

(2)

g1 = (1, 0, 1, 1).

und

Die entsprechenden Transformierten sind: G11 (D) = 1 + D + D2 + D3

G12 (D) = 1 + D2 + D3 .

und

Die entsprechenden Differenzengleichungen lauten: (1)

vt

(2)

= ut + ut−1 + ut−2 + ut−3 und vt

= ut + ut−2 + ut−3 .

Aus den Differenzengleichungen können wir direkt die Transformierten ableiten V1 (D) =

+∞ X

(ut + ut−1 + ut−2 + ut−3 ) Dt

t=0

=

+∞ X t=0

=

+∞ X

ut D t +

+∞ X

ut−1 Dt +

t=0

ut D t + D

t=0

+∞ X

+∞ X

ut−2 Dt +

t=0

ut D t + D 2

t=0

= U1 (D)(1 + D + D2 + D3 )

+∞ X

ut−3 Dt

t=0

+∞ X t=0

ut D t + D 3

+∞ X

ut D t

t=0

= U1 (D)G11 (D). Es gilt für die Informationsbits ut = 0 mit t < 0.



Generatormatrix: Faßt man die k Eingangs- und die n Ausgangssequenzen im transformierten Bereich in einen Vektor zusammen, U(D) = (U1 (D), . . . , Uk (D)) V(D) = (V1 (D), V2 (D), . . . , Vn (D)) , dann lautet Gleichung (8.17) in Matrixschreibweise V(D) = U(D)G(D) mit den Matrixelementen Gij (D) aus Gleichung (8.16). Die Matrix G(D) ist die Generatormatrix im Bildbereich.

236

8 Faltungscodes

Beispiel 8.19 (Generatormatrix eines (3, 2, [2])-Codierers) Die Generatorsequenzen (j) gi des (3, 2, [2])-Codierers (Beispiel 8.5, Bild 8.3) ergeben die Generatorpolynome Gij (D) im transformierten Bereich. Diese sind, in Analogie zur Betrachtung im Zeitbereich, die Übertragungsfunktion der i-ten Eingangssequenz Ui (D) auf den j-ten Ausgang Vj (D). Die Transformierten der Generatorsequenzen im Bildbereich ergeben sich zu: G11 (D) = 1 + D, G12 (D) = D, G13 (D) = 1 + D, G21 (D) = D, G22 (D) = 1, G23 (D) = 1. Diese Generatorpolynome lassen sich nun in der (k × n)-Generatormatrix darstellen: G(D) =

=

1+D D 1+D D 1 0 1 0 1 1

1 !

1

!

1 1 1

+

1 0 0

!

D

= G0 + G1 D, wobei aus der letzten Gleichung der Zusammenhang mit den im Zeitbereich definierten Untermatrizen G0 und G1 (vergleiche Beispiel 8.8) zu erkennen ist. 

Alle bisherigen Betrachtungen waren auf FIR-Systeme bezogen. Nun können wir mit Hilfe der Darstellung im transformierten Bereich auch IIR-Systeme beschreiben, die durch eine unendlich lange Impulsantwort gekennzeichnet sind. Dazu betrachten wir zunächst ein Beispiel. Beispiel 8.20 (IIR-System) In Bild 8.13 ist ein IIR-System dargestellt. Wendet man die Methodik der Impulsantwort zur Beschreibung dieses Codierers an, so ist das Problem eine unendlich lange Impulsantwort: (1)

g1

= (1)

(2) g1

= (1, 1, 1, 0, 1, 1, 0, 1, 1, 0, . . .).

Obwohl der Codierer nur endlich viele Gedächtniselemente ν1 = 2 besitzt, ist die zweite Generatorsequenz unendlich lang. Dies ist auf die rekursive Struktur des Codierers zurückzuführen: So wird eine Linearkombination der Gedächtnisinhalte des Codierers an dessen Eingang rückgekoppelt. Um die Betrachtung im transformierten Bereich durchzuführen, beschreiben wir den Codierer zunächst mittels Differenzengleichungen:

(1)

vt (2)

vt

(2)

(2)

(1)

= ut

(1)

+ vt−1 + vt−2 = ut

(1)

+ ut−2 .

8.1 Grundlagen von Faltungscodes

237 v(1)

u

x

v(2) Abb. 8.13: Rekursiver (2, 1, [2])-Faltungscodierer. Die zweite Gleichung ergibt sich durch das Einführen der Hilfsvariablen x, d. h. aus xt = (2) ut + xt−1 + xt−2 und vt = xt + xt−2 . Wenden wir nun die Z-Transformation auf diese Gleichung an, dann ergibt sich: +∞ X

(2)

vt D t +

t=0

+∞ X

(2)

vt−1 Dt +

t=0

+∞ X

(2)

vt−2 Dt =

t=0

+∞ X

(1)

ut D t +

t=0

+∞ X

(1)

ut−2 Dt

t=0

2

2

V2 (D) + DV2 (D) + D V2 (D) = U1 (D) + D U1 (D). Die im Zeitbereich nur rekursiv lösbare Differenzengleichung ist also im Bildbereich in eine polynomielle Gleichung in D übergegangen und es ergibt sich die Übertragungsfunktion: V2 (D) =

1 + D2 U1 (D) = G12 (D)U1 (D). 1 + D + D2

Berücksichtigt man die Übertragungsfunktion V (1) (D) = U1 (D) der Eingangssequenz auf den ersten Ausgang, also G11 (D) = 1, erhält man die Generatormatrix des Faltungscodierers G(D) =



1

1+D 2 1+D+D 2



. (2)

Zur Kontrolle kann die Impulsantwort durch G12 (D) = Z −1 (g1 ), die inverse Abbildung der Übertragungsfunktion, berechnet werden. Dies geschieht durch formale Reihenentwicklung in ansteigenden Potenzen von D ˛ ∂ l G12 (D) ˛˛ (2) g1,l = , ˛ ∂Dl D=0 (2)

und man erhält die Impulsantwort g1 = (1 110 110 110 . . .), wie schon zu Beginn des Beispiels. Die Berechnung dieser Reihenentwicklung kann als einfache Polynomdivision realisiert werden. 

Systeme mit Rückkopplung sind aufgrund ihrer unendlich langen Impulsantworten sehr ungünstig im Zeitbereich zu beschreiben. Stellt man zunächst die Differenzengleichungen des Systems auf und transformiert diese, erhält man eine Beschreibung der Übertragungsfunktionen durch gebrochen-rationale Funktionen in D. Auf diese Weise lässt

238

8 Faltungscodes

sich die Abbildung von Informations- auf Codesequenz für beliebige lineare Systeme, also FIR- und IIR-Systeme, im transformierten Bereich durch eine Matrixmultiplikation darstellen: v(D) = u(D) G(D). Die Generatormatrix G(D) ergibt sich dann zu: 

G1,1 (D) G1,2 (D) . . . G1,n (D)



 G2,1 (D) G2,2 (D) . . . G2,n (D)    , G(D) =  .. .. ..     . . . Gk,1 (D) Gk,2 (D) . . . Gk,n (D)

wobei die Matrixelemente Gij (D) die Übertragungsfunktionen des i-ten Eingangs auf den j-ten Ausgang beschreiben. Diese sind im allgemeinen gebrochen-rationale Funktionen Gij (D) =

p0 + p1 D + · · · + pm Dm . 1 + q1 D + · · · + qm Dm

Tabelle 8.1 zeigt eine Zusammenfassung der Beschreibung im Bild- und Zeitbereich.

8.1.9

Systematische und katastrophale Generatormatrizen

Die Generatormatrix G(D) eines Faltungscodierers beschreibt die Abbildung von Informations- auf Codesequenzen. Wir werden in Abschnitt 8.2 u. a. die algebraischen Eigenschaften von Generatormatrizen behandeln, dennoch sollen bereits hier zwei wichtige Typen von Generatormatrizen vorgestellt werden. Systematische Generatormatrix: Ebenso wie bei Blockcodes kann auch bei Faltungscodes die Informationssequenz unverändert ein Teil der Codesequenz sein, und der entsprechende Codierer heißt dann systematisch: u(D) = (U1 (D), U2 (D), . . . , Uk (D)) → v(D) = (U1 (D), U2 (D), . . . , Uk (D), Vk+1 (D) . . . , Vn (D)) .

(8.18)

Eine Generatormatrix, die eine systematische Zuordnung von Informations- auf Codesequenz erfüllt, besitzt die folgende Form: 

  G(D) =   

= (Ik

1

G1,k+1 (D) . . . .. .

1 ..

G1,n .. .

. 1 Gk,k+1 (D)

| R(D)) ,

Gk,n (D)

     

(8.19)

8.1 Grundlagen von Faltungscodes

239

Tabelle 8.1: Zusammenfassung: Bild- und Zeitbereich. u b i-te Eingangssequenz (i)

u

=

(i) (i) (i) (u0 , u1 , u2 , . . .),

i-te Eingangssequenz für i ∈ [1, k]

Informationssequenz u= (1) (k) (1) (k) ((u0 , . . . , u0 ), (u1 , . . . , u1 ), . . .)

j-te Ausgangssequenz (j)

(i)

(i)

(i)

Ui (D) = u0 + u1 D + u2 D2 + . . ., für i ∈ [1, k] Informationssequenz u(D) = (U1 (D), U2 (D), . . . , Uk (D))

v b (j)

rb u(D)

rb v(D) j-te Ausgangssequenz

(j)

(j)

(j)

(j)

v(j) = (v0 , v1 , v2 , . . .), für j ∈ [1, n]

Vj (D) = v0 + v1 D + v2 D2 + . . ., für j ∈ [1, n]

Codesequenz v= (1) (n) (1) (n) ((v0 , . . . , v0 ), (v1 , . . . , v1 ), . . .)

Codesequenz v(D) = (V1 (D), V2 (D), . . . , Vn (D))

G b Generatormatrix für FIR-Systeme 0 1 G0 . . . Gm B C G0 . . . Gm G=@ A, .. .. . . mit den (k × n)-dimensionalen Untermatrizen Gl für l ∈ [0, m]

Generatormatrix für FIR-Systeme G(D) = G0 + G1 D + · · · + Gm Dm

G b Generatormatrix für IIR-Systeme 0 1 G0 G1 . . . B G0 G1 . . . C, G=@ A .. . mit den (k × n)-dimensionalen Untermatrizen ˛ Gl = ∂/∂Dl G(D)˛D=0 für l ∈ [0, +∞[

rb G(D)

rb G(D) Generatormatrix für IIR-Systeme 0 1 G1,1 (D) . . . G1,n (D) B C .. ... G(D) = @ A, . Gk,1 (D) . . . Gk,n (D) mit p + p1 D + · · · + pm D m Gij (D) = 0 1 + q1 D + · · · + qm Dm

240

8 Faltungscodes

wobei Ik eine (k×k)-Einheitsmatrix und R(D) eine ( k×(n−k) )-Matrix mit gebrochenrationalen Elementen ist. Systematische Codierer können sowohl FIR- als auch IIRSysteme sein. Selbstverständlich müssen die Eingangssequenzen nicht, wie in Gleichung (8.18) gezeigt, den ersten k Ausgangssequenzen entsprechen, es sind alle SpaltenPermutationen von G(D) erlaubt. Entsprechend verändert sich dann auch die Generatormatrix (8.19). Beispiel 8.21 (Systematischer Codierer) Der in Bild 8.13 dargestellte Faltungscodierer ist systematisch. 

Katastrophale Generatormatrix: Eine weitere Klasse von Generatormatrizen sind katastrophale Generatormatrizen. Diese müssen unter allen Umständen vermieden werden, da sie eine Abbildung von Informationssequenzen mit unendlichem Hamming-Gewicht auf Codesequenzen mit endlichem Hamming-Gewicht durchführen. Damit können durch eine endliche Anzahl an Übertragungsfehlern unendlich viele Fehler in der decodierten Informationssequenz entstehen. Methoden, um eine Generatormatrix auf Katastrophalität zu testen, werden wir in Abschnitt 8.2.6 erörtern. Des weiteren existiert eine Vielzahl spezieller Generatormatrizen, deren Nicht-Katastrophalität immer gewährleistet ist, z. B. sind systematische Generatormatrizen nie katastrophal. Eine notwendige und hinreichende Bedingung, dass eine Generatormatrix katastrophal ist, ist eine Schleife im Zustandsdiagramm des Codierers, die die Nullfolge als Ausgabe ut =0 −→ 0t+1 im Nullzustand nicht berücksichtigt wird. besitzt, wobei die Schleife 0t −−− Dabei ist Schleife allgemeiner zu verstehen, d. h., eine Schleife ist ein geschlossener Pfad im Zustandsdiagramm, möglicherweise über mehrere Zustände. Beispiel 8.22 (Katastrophaler Codierer) Der in Bild 8.14 dargestellte Faltungscodierer ist katastrophal. Betrachtet man den Zustandsübergang (111) → (111), dann ist der entsprechende v(1) 1 / 00

u 111

v(2)

Abb. 8.14: Katastrophaler Codierer. Codeblock (00). Damit hat dieser Codierer eine Nullschleife im Zustandsdiagramm und ist katastrophal. 

Die Existenz einer Nullschleife im Zustandsdiagramm ist zwar eine sehr anschauliche Bedingung für Katastrophalität, hat aber unter praktischen Gesichtspunkten eine untergeordnete Bedeutung, da andere effektive Verfahren zur Bestimmung der Katastrophalität einer Codiermatrix existieren, die wir später beschreiben werden.

8.1 Grundlagen von Faltungscodes

8.1.10

241

Punktierte Faltungscodes

Die Menge der punktierten Faltungscodes (punctured convolutional codes) ist eine Untermenge der Menge aller Faltungscodes. Bevor wir die Anwendungen und Vorzüge dieser Art von Codes besprechen, werden wir zunächst das Verfahren beschreiben. Muttercode, Streichmuster und punktierter Code: Punktierte Faltungscodes werden von sogenannten Muttercodes abgeleitet. Dies geschieht durch periodisches Streichen (Punktieren) bestimmter Codebits in der Codesequenz des Muttercodes: S(p,w)

Cm (nm , km , [νm ])

−−−−→

Cp (np , kp , [νp ]).

(8.20)

Das Muster S, mit welchem gestrichen wird (deletion map), ist dabei durch seine Periodizität p und der Anzahl p − w der pro Periode punktierten Bits charakterisiert. Der Parameter w entspricht also der Anzahl nicht-punktierter Bits pro Periode. Damit ist die Rate des punktierten Codes Rp =

p Rm . w

(8.21)

Diese ist immer größer als die des Muttercodes und muss immer kleiner als eins sein. Somit gilt: Rm ≤ Rp ≤ 1. Abhängig von der Rate des Muttercodes und der gewünschten Rate des punktierten Codes sind verschiedene Darstellungsmöglichkeiten für das Streichmuster denkbar. Muttercodes der Rate Rm = 1/nm und Punktierungsmatrix: Werden punktierte Faltungscodes der Rate Rp = kp /np von einem Muttercode der Rate Rm = 1/nm abgeleitet, kann das Streichmuster S(p, w) als (nm × kp )-dimensionale Punktierungsmatrix P dargestellt werden, deren Matrixelemente pij ∈ {0, 1} sind. Eine „0“ bedeutet das Entfernen eines Bits und eine „1“, dass die Stelle in der punktiertenPSequenz erhalten bleibt. Die Anzahl der Einsen in der Punktierungsmatrix w = i,j pij = np ergibt sich aus den Gleichungen (8.20) und (8.21) und der Periodizität p = kp · nm mit der punktiert wird. Beispiel 8.23 (Punktierung von Faltungscodes) Der Codierer aus Bild 8.1 mit der Generatormatrix G(D) = (1 + D + D2 1 + D2 ) wird zur Codierung eines Muttercodes Cm der Rate Rm = 1/2 mit Gedächtnisordnung mm = 2 verwendet. Zur Erzeugung eines auf die Rate Rp = (np − 1)/np = 6/7 punktierten Codes soll die (2 × 6)-dimensionale Punktierungsmatrix P=



1 0 0 0 0 1 1 1 1 1 1 0

«

verwendet werden. Der Faltungscodierer des Muttercodes generiert zu jedem Zeitpunkt t einen (1) (2) Codeblock vt = (vt vt ) aus 2 Codebits, von denen die (t modulo 6)-te Spalte der zyklisch

242

8 Faltungscodes

durchlaufenen Punktierungsmatrix angibt, welche dieser beiden Bits gestrichen werden. So ergibt sich die punktierte Codesequenz wie folgt: (1) (2)

(1) (2)

(1) (2)

(1) (2)

(1) (2)

vm = ((v0 v0 ), (v1 v1 ), (v2 v2 ), (v3 v3 ), (v4 v4 ), . . .) (1) (2) (2) (2) (2) (2) (1)

(1) (2) (2)

vp = ((v0 v0 v1 v2 v3 v4 v5 ), (v6 v6 v7 . . .), . . .). Der punktierte Code hat also, wie oben zu sehen ist, die Codeblocklänge np = 7. Danach wiederholt sich das durch die Punktierungsmatrix festgelegte Streichmuster. 

Ein punktierter Code fester Rate kann natürlich von völlig unterschiedlichen Muttercodes abgeleitet werden. Des weiteren existieren für einen Muttercode unterschiedliche Permutationen des Streichmusters. Gute punktierte Codes: Gute punktierte Codes werden üblicherweise mittels computergestützter Suche ermittelt. Mit der Bezeichnung „gut“ sind dabei solche Codes Cp (np , kp , [νp ]) gemeint, die unter allen anderen punktierten Codes gleicher Rate Rp = kp /np und gleicher Gesamteinflusslänge νp die größte freie Distanz df besitzen. Da bei Raten Rp → 1 sehr viele Codes dieselbe freie Distanz haben, wird als zusätzliches Kriterium die Anzahl der existierenden Pfade mit freier Distanz bzw. deren Informationsgewicht verwendet. Betrachtet man die erweiterte Distanzfunktion in Gleichung (8.9), so ergibt sich das Informationsgewicht I(w) der Pfade mit Codegewicht w aus X ∂ T (W, H, L = 1) = I(w)W w . ∂H H=1 w Das Informationsgewicht aller Pfade mit Hamming-Gewicht gleich der freien Distanz ist somit I(df ). Unter Informationsgewicht versteht man das Hamming-Gewicht der zu einer Codesequenz gehörenden Informationssequenz.

Wie das Informationsgewicht zur Berechnung einer oberen Schranken der Bitfehlerrate des entsprechenden Codes verwendet werden kann, zeigen wir im Abschnitt 8.4.3 auf Seite 277 in Gleichung (8.46). Anmerkung: Zur praktischen Berechnung des Wertes I(df ) wird nicht die erweiterte Distanzfunktion, sondern das Trellis des Muttercodes verwendet. Um nun einen punktierten Code mit größtmöglicher freier Distanz df und kleinstmöglichem Informationsgewicht I(df ) zu finden, werden zunächst die besten bekannten Codes als Muttercodes gewählt. Dies begründet sich darin, dass die Distanzeigenschaften eines punktierten Codes nie besser sein können als die des Muttercodes. Dann werden alle möglichen punktierten Codes fester Rate untersucht, die sich durch ein Streichmuster S(p, w) einer bestimmten Periodizität ergeben. Da die Kombination aus Generatormatrix des Muttercodes und Punktierung zu einem katastrophalen Codierer führen kann, muss zuerst auf Katastrophalität geprüft werden. Ist die Nicht-Katastrophalität sichergestellt, wird die freie Distanz und das entsprechende Informationsgewicht bestimmt.

8.1 Grundlagen von Faltungscodes

243

Beispiel 8.24 (Generatormatrix eines punktierten Faltungscodes) Die Untersuchung auf Katastrophalität des Codierers wird anhand eines Tests durchgeführt, für den die Generatormatrix des Codierers benötigt wird (vergleiche Abschnitt 8.2.6). In diesem Beispiel werden wir die Generatormatrix des punktierten Codes der Rate Rp = 6/7 berechnen, den wir in Beispiel 8.23 beschrieben haben. Die Generatormatrix des Muttercodes C(2, 1, [2]) im Zeitbereich lautet 0 1 11 10 11 B C 11 10 11 G=@ A. .. .. . . Betrachtet man die Matrixmultiplikation v = uG, dann ergibt sich das l-te Codebit der Codesequenz v aus der Multiplikation der Informationssequenz u mit der l-ten Spalte der Generatormatrix. Wird das l-te Codebit entfernt, kann also auch alternativ die entsprechende Spalte der Generatormatrix des Muttercodes gestrichen werden. 11 01 01 01 01 10 11 01 01 01 01 10 11 10 10 10 11 10 11 11 10 11 11 10 11 11 10 11 11 10 11 11 10 11 11 10 11 11 10 11 11 10 11 11 10 11 11 10 11 11 10 11 11 10 11 11 10 11 .. .. . .

In der obersten Zeile ist die zyklisch wiederholte Punktierungsmatrix P dargestellt, darunter ist die Generatormatrix des Muttercodes. Spalten, die nicht gestrichen werden, sind durch fetten Druck gekennzeichnet. Damit erhält man die Generatormatrix des punktierten Codes 0 1 1 1 0 1 B C 1 0 1 B C B C 1 0 1 B C B C 1 0 1 B C B C 1 1 1 1 Gp = B C, B C 1 1 0 1 B C B C 1 1 0 1 B C B C 1 0 1 @ A .. .. . . welche aus den beiden (6 × 7)-dimensionalen Untermatrizen 0

1 B0 B B0 G0 = B B0 @0 0

1 0 0 0 0 0

0 1 0 0 0 0

1 0 1 0 0 0

0 1 0 1 0 0

0 0 1 0 1 0

1 0 0C C 0C C 1C 1A 1

und

0

0 B0 B B0 G1 = B B0 @1 1

0 0 0 0 1 0

0 0 0 0 0 1

0 0 0 0 0 0

0 0 0 0 0 0

0 0 0 0 0 0

1 0 0C C 0C C 0C 0A 0

244

8 Faltungscodes

aufgebaut ist. Die Generatormatrix im Bildbereich ist dann G(D) = G0 +DG1 . Der punktierte Code hat die Gedächtnisordnung mp = 1. Diese ist kleiner als die des Muttercodes. Dagegen ist die Gesamteinflusslänge νm = νp = 2 gleich geblieben. 

Allgemein gilt der Zusammenhang νp ≤ νm , wobei erfahrungsgemäß für alle guten punktierte Codes Gleichheit angenommen werden kann. Die Gründe für die Einführung von punktierten Codes sind: • Die Möglichkeit, hochratige punktierte Codes mit der Decodierkomplexität, des niederratigen Muttercodes zu decodieren. Wie wir später in Abschnitt 8.4 sehen werden, nimmt die Decodierkomplexität der Viterbi-Decodierung mit anwachsender Rate des Faltungscodes stark zu. • Die Konstruktion neuer Faltungscodes, basierend auf bereits bekannten Codes mit guten Distanzeigenschaften. Dies ist sehr wichtig, da es im Gegensatz zu Blockcodes kaum Verfahren zur Konstruktion guter Faltungscodes gibt. Die Anwendungsbereiche von punktierten Faltungscodes sind beispielsweise: • Der Einsatz extrem hochratiger Codes in verketteten Codeschematas (vergleiche Kapitel 9). • Flexibler Fehlerschutz bei unverändertem Decodierer durch die Klasse der sogenannten RCPC-Codes (rate compatible punctured convolutional codes). Punktierte Faltungscodes sind von großer praktischer Relevanz und kommen in vielen Bereichen zum Einsatz. Tabellen, bzw. Referenzen auf die besten bekannten punktierten Codes sind in Abschnitt 8.8 zu finden. Anmerkung: Prinzipiell ist jetzt die Viterbi-Decodierung von Faltungscodes verständlich, d. h., ein Leser, der zunächst nicht an der algebraischen Struktur und den Distanzmaßen interessiert ist, kann mit Abschnitt 8.4, Seite 267 fortfahren.

8.2

Algebraische Beschreibung

Im vorherigen Abschnitt haben wir die wesentlichen Begriffe und Eigenschaften von Faltungscodes eingeführt. In diesem Abschnitt wollen wir diese mathematisch ableiten und beweisen. Wir betrachten hierbei nur Codes mit unendlich langen Codesequenzen. Dabei werden wir uns an die Notation von [JZ99] halten, wo auch weitergehende Aussagen getroffen werden. Wir wollen uns jedoch hier auf das Notwendigste beschränken, um in die algebraische Beschreibung einzuführen. Es wird gezeigt, wie äquivalente Generatormatrizen erzeugt werden können. Ferner werden die wichtigsten Vertreter, nämlich die systematischen und katastrophalen Generatormatrizen, Basisgeneratormatrizen und minimale Basisgeneratormatrizen diskutiert. Des weiteren wird die Prüfmatrix eines Codes und der duale Code beschrieben.

8.2 Algebraische Beschreibung

8.2.1

245

Code, Generatormatrix und Codierer

Hier wollen wir drei Definitionen angeben, die klar zwischen Code, Generatormatrix und deren Realisierung als Codierer trennen. Definition 8.1 (Faltungscode) Die Menge aller Codesequenzen, die aus einer linearen Abbildungsvorschrift hervorgeht, werden als Faltungscodes bezeichnet. In dieser Definition wird bewusst der Begriff Informationssequenz vermieden. Natürlich werden Informations- auf Codesequenzen abgebildet, aber genau diese Zuordnung zwischen beiden spielt bei der Definition des Codes keine Rolle. Als Code betrachtet man nur die Menge aller möglichen Codewörter V(D) = (V1 (D), V2 (D), . . . , Vn (D)), wie die Codesequenzen auch genannt werden. Ein Faltungscode besteht also aus unendlich vielen Codewörtern. Definition 8.2 (Generatormatrix) Eine (k × n)-dimensionale Matrix G(D) vom Rang k, wobei die Matrixelemente Gij (D) gebrochen-rationale Funktionen sind, bezeichnet man als Generatormatrix. Die Generatormatrix G(D) legt die Zuordnung zwischen Informationswörtern (Informationssequenzen) U(D) = (U1 (D), U2 (D), . . . , Uk (D)) und den Codewörtern V(D) fest. Es handelt sich um eine konkrete Zuordnungsvorschrift einer linearen Abbildung. Da diese Abbildung umkehrbar sein soll, muss G(D) vollen Rang haben. Definition 8.3 (Faltungscodierer) Ein Faltungscodierer der Rate R = k/n ist die Realisierung einer (k×n)-dimensionale Generatormatrix G(D) als sequentieller linearer Schaltkreis. Diese Definition macht keinerlei konstruktive Aussagen bezüglich der konkreten Realisierung des Codierers. Es sind beliebige Schaltungsentwürfe aus Speicherelementen mit linearer Schaltungslogik denkbar. Eine Generatormatrix kann also mit unterschiedlichen Codierern realisiert werden. Im weiteren wird streng zwischen diesen drei Begriffen unterschieden. Jede Aussage bezieht sich damit entweder auf eine Eigenschaft des Codes, eine Eigenschaft der Generatormatrix oder eine Eigenschaft des Codierers.

8.2.2

Faltungscodierer in Steuer- und Beobachterentwurf

Die Elemente Gij (D) einer Generatormatrix G(D) sind i. a. gebrochen-rationale Übertragungsfunktionen. Wir wollen uns dabei auf realisierbare Übertragungsfunktionen beschränken, die wie folgt definiert sind: Realisierbare Übertragungsfunktion: Eine gebrochen-rationale P Übertragungsfunktion H(D) = P (D)/Q(D) besteht Pm aus dem m Zählerpolynom P (D) = i=0 pi Di und dem Nennerpolynom Q(D) = i=0 qi Di mit pi , qi ∈ {0, 1}. Gilt q0 = 1, so wird H(D) realisierbar genannt, und das Nennerpolynom Q(D) heißt verzögerungsfrei. Es gilt Y (D) = X(D)H(D) mit H(D) =

p0 + p1 D + · · · + pm Dm . 1 + q1 D + · · · + qm Dm

(8.22)

246

8 Faltungscodes

Aus der Systemtheorie sind generell zwei wichtige Schaltungen einer realisierbaren Übertragungsfunktion bekannt. Dies sind der Steuerentwurf (controller canonical form) und der Beobachterentwurf (observer canonical form). Steuerentwurf: In Bild 8.15 ist die Realisierung der Übertragungsfunktion aus Gleichung (8.22) im Steuerentwurf zu sehen. Die Eingangssequenz X(D) läuft in ein Schieberegister der Länge m. Die Beschaltung des Schieberegisters entspricht den Koeffizienten des Zählerund Nennerpolynoms der Übertragungsfunktion H(D). Y (D)

... p0

p1

p2

pm

X(D)

... q1

q2

qm

...

Abb. 8.15: Steuerentwurf einer realisierbaren Übertragungsfunktion.

Beobachterentwurf: In Bild 8.16 ist die Realisierung der Übertragungsfunktion aus Gleichung (8.22) im Beobachterentwurf zu sehen. Die einzelnen Speicherelemente sind hier nicht in einem Schieberegister angeordnet. Die Berechnung der Übertragungsfunktion H(D) anhand dieser Schaltung erfolgt in zwei Schritten. Zunächst erhalten wir direkt aus dem Schaltungsaufbau Y (D) = X(D) (p0 + p1 D + · · · + pm Dm ) + Y (D) (q1 D + · · · + qm Dm ). Durch Umformung dieser Beziehung ergibt sich die Übertragungsfunktion aus Gleichung (8.22). ... X(D) pm

p2

p1

Y (D)

... qm

p0

q2

q1

...

Abb. 8.16: Beobachterentwurf einer realisierbaren Übertragungsfunktion.

8.2 Algebraische Beschreibung

247

Realisierungsformen einer Generatormatrix: Analog zum Konzept des Steuer- bzw. Beobachterentwurfs einer realisierbaren Übertragungsfunktion kann nun auch eine Generatormatrix mittels dieser beiden Formen realisiert werden. Dabei muss G(D) realisierbar sein, d. h. alle Elemente Gij (D) = Pij (D)/Qij (D) sind realisierbare Übertragungsfunktionen. Dann kann das folgende Konzept zum Schaltungsentwurf angewandt werden: • Generatormatrix im Steuerentwurf: Alle k Eingangssequenzen Ui (D), für i ∈ [1, k], werden unabhängig voneinander betrachtet, d. h. jede dieser Sequenzen läuft in ein eigenes Schieberegister (vergleiche Bild 8.15). Die Rückkopplung des i-ten Schieberegisters erhalten wir aus dem kleinsten gemeinsamen Vielfachen (kgV) der entsprechenden Nennerpolynome Qi (D) = kgV(Qi1 (D), Qi2 (D), . . . , Qin (D)). ˜ ij (D) = Erweitert man die k Übertragungsfunktionen Gij (D) der i-ten Zeile auf G ˜ Pij (D)/Qi (D), für j ∈ [1, n], dann erhalten wir die Beschaltung der Schieberegister im „Vorwärtszweig“. Jedes der k Schieberegister besitzt also für jede der n Ausgangssequenzen genau eine Beschaltung. • Generatormatrix im Beobachterentwurf: Jede einzelne der n Ausgangssequenzen Vj (D), für j ∈ [1, n], besitzt eine von den anderen Ausgangssequenzen unabhängige Speichereinheit (vergleiche Bild 8.16). Die Beschaltung der Speicherelemente dieser Speichereinheit im „Rückwärtszweig“ erhalten wir aus Qj (D) = kgV(Q1j (D), Q2j (D), . . . , Qkj (D)). Analog zum Steuerentwurf erweitern wir die n Übertragungsfunktionen Gij (D) ˜ ij (D) = P˜ij (D)/Qj (D), für i ∈ [1, k], und erhalten die Beder j-ten Spalte auf G schaltung der Speicherelemente im „Vorwärtszweig“. Jede der n Speichereinheiten besitzt also für jede der k Eingangssequenzen genau eine Beschaltung. Faltungscodierer können natürlich auch in beliebiger Form entworfen werden. Es existieren u. a. Verfahren zur Realisierung eines Codierers mit der kleinstmöglichen Anzahl an Speicherelementen bei gegebener Generatormatrix. Solche Minimierungstechniken sind vor allem bei der Realisierung sehr großen Schaltungen wichtig. Wir sind allerdings an strukturellen Eigenschaften interessiert und werden uns auf den Steuer- und Beobachterentwurf beschränken. Beispiel 8.25 (Steuer- und Beobachterentwurf [JZ99]) Die Generatormatrix mit gebrochen-rationalen Elementen, ! G(D) =

1 1+D+D 2 D2 1+D 3

D 1+D 3 1 1+D 3

1 1+D 3 1 1+D

,

ist in den Bildern 8.17 und 8.18 jeweils im Steuerentwurf und im Beobachterentwurf dargestellt. Der Steuerentwurf besteht aus k = 2 Schieberegistern, deren Rückkopplungen Q1 (D) = Q2 (D) = 1 + D3 sind. Die Beschaltung der beiden Register im Vorwärtszweig ist jeweils auf der Ebene der Ausgangssequenzen zusammengefasst. Der Beobachterentwurf besteht aus n = 3 Speichereinheiten. Auch deren Rückkopplungen sind alle gleich Q1 (D) = Q2 (D) = Q3 (D) = 1 + D3 . Die Beschaltung in den Vorwärtszweigen erhält man wie oben beschrieben. 

248

8 Faltungscodes v(1)

u(1)

v(2)

u(2)

v(3)

Abb. 8.17: Steuerentwurf eines Faltungscodierers der Rate R = 2/3.

8.2.3

Äquivalente Generatormatrizen

Eine Generatormatrix kann durch unterschiedliche Faltungscodierer realisiert werden. Des Weiteren kann ein Faltungscode mit unterschiedlichen Generatormatrizen erzeugt werden. Definition 8.4 (Äquivalente Generatormatrizen) Zwei Generatormatrizen G(D) und G0 (D) werden als äquivalent bezeichnet, wenn beide denselben Code erzeugen. Satz 8.5 (Äquivalente Generatormatrizen) Zwei Generatormatrizen G(D) und G0 (D) sind äquivalent, wenn eine (k × k)-dimensionale Scrambler-Matrix T(D) existiert, so dass gilt: G0 (D) = T(D) G(D), wobei die Determinante det( T(D) ) 6= 0 ist. Damit hat auch die äquivalente Generatormatrix G0 (D) vollen Rang. Beweis: Nach Definition 8.4 müssen beide Generatormatrizen denselben Code generieren, also die gleiche Menge an Codewörtern erzeugen. Das gleiche Codewort V(D) = U(D) G0 (D) = U(D) T(D) G(D) | {z } U0 (D)

0

= U (D) G(D)

kann sowohl mit G0 (D) als auch mit G(D) erzeugt werden. Da T(D) nicht singulär ist, kann also immer ein Paar von Informationswörtern gefunden werden, so dass gilt: U0 (D) = U(D) T(D). Beide erzeugen dasselbe Codewort. 2

Die Menge der äquivalenten Generatormatrizen eines Faltungscodes enthält eine Untermenge, die Menge der polynomiellen Generatormatrizen, die als FIR-System realisiert werden können und die somit von besonderem Interesse sind.

8.2 Algebraische Beschreibung

249

v(1)

u(1) v(2)

u(1) v(3)

Abb. 8.18: Beobachterentwurf eines Faltungscodierers der Rate R = 2/3.

Satz 8.6 (polynomielle Generatormatrix) Jede gebrochen-rationale Generatormatrix besitzt eine äquivalente polynomielle Generatormatrix. Beweis: Allgemein ist G(D) = ( Gij (D) ) mit Gij (D) = Pij (D)/Qij (D) für i ∈ [1, k] und j ∈ [1, n] eine Matrix, deren Elemente gebrochen-rationale Funktionen in D sind. Das kleinste gemeinsame Vielfache der Nennerpolynome T (D) = kgV ( Q11 (D), . . . , Qij (D), . . . , Qkn (D) ) dient zur Berechnung einer äquivalenten Generatormatrix: G0 (D) = T(D) G(D). Die ScramblerMatrix ergibt sich aus T(D) = T (D)Ik . Die Elemente G0ij (D) lassen sich damit so kürzen, dass alle polynomiell sind. 2

Alle weiteren Untersuchungen werden sich ausschließlich auf polynomielle Generatormatrizen beziehen, mit Ausnahme der Diskussion systematischer Generatormatrizen. Die in Abschnitt 8.1.3 anhand der Generatorsequenzen eines nicht-rekursiven Faltungscodierers vorgestellten Einflusslängen können nun allgemein als Eigenschaften der Generatormatrix definiert werden. Definition 8.7 (Gedächtnis) Sei G(D) eine polynomielle (k × n)-dimensionale Generatormatrix, dann bezeichnet man νi = max {deg Gij (D)}, 1≤j≤n

(8.23)

als deren i-te Einflusslänge (constraint length). Die Gedächtnisordnung (memory) der Generatormatrix ist definiert als m = max {νi }, 1≤i≤k

und die Gesamteinflusslänge (overall constraint length) ist gegeben durch: ν=

k X i=1

νi .

250

8 Faltungscodes

Anmerkung: Die Definition von Einflusslängen für gebrochen-rationale Generatormatrizen ist ebenfalls möglich, soll aber hier nicht eingeführt werden, da die dazu notwendigen Grundlagen wesentlich umfangreicher sind. Beispiel 8.26 (Äquivalente polynomielle Generatormatrix) Wir wollen hier die Realisierungen des Faltungscodierers der Rate R = 2/3 aus Bild 8.17 und 8.18 mit einer äquivalenten polynomiellen Generatormatrix beschreiben und eine Realisierung im Steuerentwurf angeben. v(1) u(1) v(2) u(2) v(3)

Abb. 8.19: Faltungscodierer der Rate R = 2/3. Die zugrunde liegende gebrochen-rationale Generatormatrix ist ! G(D) =

1 1+D+D 2 D2 1+D 3

D 1+D 3 1 1+D 3

1 1+D 3 1 1+D

.

Eine äquivalente, polynomielle Generatormatrix erhält man durch die Multiplikation des kleinsten gemeinsamen Vielfachen aller im Nenner auftretenden Polynome, ´ ` T (D) = kgV 1 + D + D2 , 1 + D3 , 1 + D = 1 + D3 , mit der gebrochen-rationalen Generatormatrix 0

3

G (D) = (1 + D )

1 1+D+D 2 D2 1+D 3

D 1+D 3 1 1+D 3

1 1+D 3 1 1+D

!

=



1+D D 1 D2 1 1 + D + D2

Eine Realisierung dieser Generatormatrix im Steuerentwurf ist in Bild 8.19 gegeben.

8.2.4

«

.



Smith-Form einer Generatormatrix

Nach Definition 8.2 besitzt eine (k × n)-dimensionale Generatormatrix G(D) immer vollen Rang. Damit existiert immer eine rechte Inverse G−1 (D), die eine (n × k)dimensionale Matrix ist. Die zu V(D) = U(D)G(D) inverse Abbildung ist U(D) = V(D)G−1 (D). Es gilt Ik = G(D)G−1 (D), wobei Ik die (k × k)-dimensionale Einheitsmatrix ist. Zur Berechnung der rechten Inversen G−1 (D) verwenden wir ein aus der linearen Algebra bekanntes Verfahren, das die Generatormatrix in der sogenannten Smith-Form darstellt.

8.2 Algebraische Beschreibung

251

Satz 8.8 (Smith-Form) Sei G(D) eine polynomielle (k × n)-dimensionale Generatormatrix, dann kann sie in folgender Form dargestellt werden: G(D) = A(D) Γ(D)B(D),

(8.24)

wobei A(D) eine (k × k)-Matrix und B(D) eine (n × n)-Matrix ist, die beide Determinante 1 besitzen, d. h. Scramblermatrizen sind. Die (k × n)-Matrix Γ(D) wird als Smith-Form der Generatormatrix G(D) bezeichnet und hat die Diagonalform 

 Γ(D) = 

γ1 (D) ..

. γk (D) 0 . . . 0



 .

(8.25)

Die Diagonalelemente γi (D), 1 ≤ i ≤ k, heißen invariante Faktoren von G(D). Für diese gilt folgender Zusammenhang: γi (D)

|

γi+1 (D),

(8.26)

für i = 1, 2, . . . , k − 1. d. h., das erste Diagonalelement teilt alle anderen, usw. Des weiteren gilt für den größten gemeinsamen Teiler ∆i (D) der Determinanten aller (i×i)dimensionalen Untermatrizen von G(D) ∆i (D) = γ1 (D) · . . . · γi−1 (D) · γi (D).

(8.27)

Beweis: Der Beweis dieses Satzes ist ein konstruktiver Beweis, d. h., es wird ein Algorithmus zur Berechnung der Smith-Form beschrieben und anhand des Algorithmus gleichzeitig die Gültigkeit der in den Gleichungen (8.24)–(8.27) dargestellten Zusammenhänge gezeigt. Da jedoch selbst eine einfache Beschreibung des Algorithmus relativ umfangreich ist, wollen wir an dieser Stelle auf [JZ99] oder [McE97] verweisen. 2

Die Smith-Form spielt eine zentrale Rolle in der Diskussion der strukturellen Eigenschaften der Generatormatrizen. Mit Gleichung (8.24) und (8.25) lautet die rechte Inverse der Generatormatrix: G−1 (D) = B−1 (D)Γ−1 (D)A−1 (D),

(8.28)

wobei die (n × k)-Matrix Γ−1 (D) definiert ist zu: 

    −1 Γ (D) =     

γ1−1 (D)

   γk−1 (D)  .  ... 0   ..  . ..

0 .. . 0



.

...

(8.29)

0

Die Inversen der quadratischen Scramblermatrizen A−1 (D) und B−1 (D) existieren, da sowohl A(D) als auch B(D) die Determinante 1 besitzen.

252

8 Faltungscodes

Beispiel 8.27 (Smith-Form [JZ99]) Die polynomielle Generatormatrix „ « 1+D D 1 G(D) = D + D2 + D3 + D4 1 + D + D2 + D3 + D4 1 + D + D2 hat die Smith-Form G(D) = A(D)Γ(D)B(D), mit « 1 0 2 1+D+D 1 „ « 1 0 0 Γ(D) = 0 1+D 0 0 1 1+D D 1 2 3 2 3 B(D) = @ 1 + D + D 1 + D + D + D 0 A . D + D2 1 + D + D2 0

A(D) =



Die invarianten Faktoren sind also γ1 = 1 und γ2 = 1 + D. Für die rechte Inverse erhalten wir mit Gleichung (8.28) und (8.29): 0 1 1 + D2 + D4 1 + D + D2 1 −1 4 2 @ D+D A. D+D G (D) =  1+D D3 + D4 1 + D2

8.2.5

Basisgeneratormatrix

Die Menge der äquivalenten polynomiellen Generatormatrizen eines Faltungscodes kann bezüglich ihrer Gesamteinflusslänge ν untersucht werden. Ziel ist es, Generatormatrizen mit der kleinstmöglichen Gesamteinflusslänge zu finden. Dies führt zur geringsten Zustandskomplexität im Trellis, welche die Decodierkomplexität beeinflusst (vergleiche Abschnitt 8.4 und 8.5). Zunächst betrachten wir polynomielle Generatormatrizen G(D), die eine polynomielle rechte Inverse G−1 (D) besitzen. Definition 8.9 (Basisgeneratormatrix und minimale Basisgeneratormatrix) Eine polynomielle Generatormatrix deren invariante Faktoren γi (D), für i ∈ [1, k], alle Eins sind, wird Basisgeneratormatrix Gb (D) genannt. Da die Determinanten der Scramblermatrizen aus der Smith-Form det(A(D)) = 1 und det(B(D)) = 1 sind, und für die k invarianten Faktoren einer Basisgeneratormatrix γi = 1 für i ∈ [1, k] gilt, sind alle drei Inversen B−1 (D), Γ−1 (D) und A−1 (D) in Gleichung (8.28) polynomiell und damit auch deren Produkt. Jede Basisgeneratormatrix Gb (D) besitzt damit eine polynomielle rechte Inverse. Betrachten wir die Smith-Form (Gleichung (8.24)) einer beliebigen polynomiellen Generatormatrix G(D), so erhalten wir eine zu dieser Matrix äquivalente Basisgeneratormatrix Gb (D) aus den ersten k Zeilen der Scrambler-Matrix B(D): G(D) = A(D)Γ(D)B(D) =

8.2 Algebraische Beschreibung 

 = A(D) 

253

γ1 (D) ..

. γk (D)

= T(D)Gb (D).

   |

1 ..

. 1 0 ··· 0 {z Gb (D)



  B(D) }

In der Menge aller äquivalenten Basisgeneratormatrizen befinden sich diejenigen Generatormatrizen mit minimaler Gesamteinflusslänge. Definition 8.10 (Minimale Basisgeneratormatrix) Eine Basisgeneratormatrix Gb (D), deren Gesamteinflusslänge minimal unter allen äquivalenten Basisgeneratormatrizen ist, wird als minimale Basisgeneratormatrix Gmb (D) bezeichnet. Ausgehend von einer Basisgeneratormatrix Gb (D) können wir eine dazu äquivalente minimale Basisgeneratormatrix Gmb (D) berechnen. Dazu definiert man zunächst die Matrix [G(D)]h mit den Elementen [Gij (D)]h , die entweder 0 oder 1 sind. Eine 1 wird an der Stelle ij eingetragen, wenn der Grad von Gij (D) gleich der i-ten Einflusslänge (Gleichung (8.23)) ist. Falls der Grad kleiner ist, wird eine 0 eingetragen. Eine Basisgeneratormatrix ist genau dann minimal, wenn [Gb (D)]h vollen Rang hat. Ist dies nicht der Fall, dann kann durch eine Reihe von elementaren Zeilenoperationen eine äquivalente minimale Basisgeneratormatrix aus Gb (D) berechnet werden, wie folgendes Beispiel zeigt. Beispiel 8.28 (Minimale Basisgeneratormatrix [JZ99]) Die polynomielle Generatormatrix G(D) aus Beispiel 8.27 wurde, wie bereits gezeigt, in Smith-Form zerlegt, wobei 0 1 1+D D 1 2 3 2 3 B(D) = @ 1 + D + D 1 + D + D + D 0 A D + D2 1 + D + D2 0 war. Aus den ersten k Zeilen dieser Matrix erhalten wir eine äquivalente Basisgeneratormatrix „ « 1+D D 1 Gb (D) = . 2 3 2 3 1+D +D 1+D+D +D 0 Damit ergibt sich die Matrix „ « 1 1 0 [Gb (D)]h = , 1 1 0 deren Zeilen linear abhängig sind. Damit hat [Gb (D)]h nicht vollen Rang. Addiert man jedoch die mit 1 + D + D2 multiplizierte erste Zeile zur zweiten, dann erhält man die äquivalente Matrix „ « 1+D D 1 Gmb (D) = , D2 1 1 + D + D2 mit [Gb (D)]h =



1 1 0 1 0 1

«

,

die vollen Rang, Rang([Gmb (D)]h ) = 2, hat und damit minimal ist. Eine Realisation dieser Generatormatrix im Steuerentwurf ist in Bild 8.19 dargestellt. 

254

8 Faltungscodes

Die Realisierung einer minimalen Basisgeneratormatrix im Steuerentwurf führt zu einem Faltungscodierer mit der kleinsten Anzahl an Gedächtniselementen unter allen möglichen Codierern des betrachteten Faltungscodes. Ein Codierer mit dieser Eigenschaft wird auch minimal genannt. Anmerkung: Es existieren noch andere minimale Codierer, allerdings sind diese dann in einer beliebigen Form realisiert. Generatormatrizen, die sich mit einem minimalen Codierer realisieren lassen, nennt man kanonisch, und diese können i. a. auch gebrochenrational sein. Es existieren also auch kanonische Codierer mit Rückkopplung (IIRSystem).

8.2.6

Katastrophale Generatormatrizen

In der Menge aller äquivalenten polynomiellen Generatormatrizen gibt es katastrophale Generatormatrizen. Diese müssen unter allen Umständen vermieden werden. Definition 8.11 (Katastrophale Generatormatrix) Eine Generatormatrix G(D) ist katastrophal, wenn eine Informationssequenz mit unendlichem Gewicht auf eine Codesequenz mit endlichem Gewicht abgebildet wird. Beispiel 8.29 (Katastrophale Generatormatrix) Die polynomielle Generatormatrix G(D) aus Beispiel 8.27 ist katastrophal. Um dies zu zeigen, betrachten wir die inverse Abbildung G−1 (D) und zeigen, dass eine Codesequenz mit endlichem Gewicht auf eine Informationssequenz mit unendlichem Gewicht abgebildet wird. Betrachten wir die in Beispiel 8.28 berechnete minimale Basisgeneratormatrix Gmb (D) des Codes, so wird beispielsweise das Informationswort U(D) = (0, 1) mit dem Hamming-Gewicht wt(U(D)) = 1 auf das Codewort V(D) = (D2 , 1, 1 + D + D2 ) mit dem Hamming-Gewicht wt(V(D)) = 5 abgebildet. Die Begriffe Informations- und Codewort werden gleichbedeutend zu Informations- und Codesequenz verwendet. Andererseits kann dieses Codewort auch durch eine äquivalente Generatormatrix erzeugt worden sein. Hierzu verwenden wir als Rückabbildung die rechte Inverse aus Beispiel 8.27: U(D) = V(D) G−1 (D) 1 = (D + D2 + D3 , 1) 1+D = ( D + D3 + D4 + D5 + D6 + . . . , 1 + D + D2 + D3 + D4 + D5 + D6 + . . .) Die Informationssequenzen ergeben sich aus der geschlossenen Form durch eine formale Reihenentwicklung nach positiven Potenzen von D. Es wird also eine Informationssequenz mit unendlichem Gewicht auf eine Codesequenz mit endlichem Gewicht abgebildet. Eine endliche Anzahl an Übertragungsfehlern kann so zu unendlich vielen Fehlern in der geschätzten Informationssequenz führen. 

Folgender Satz ermöglicht es, eine Generatormatrix auf Katastrophalität zu testen: Satz 8.12 (Test auf Katastrophalität von Massey-Sain) Eine polynomielle Generatormatrix G(D) ist genau dann nicht-katastrophal, wenn gilt ∆k (D) = Ds , s ≥ 0, wobei ∆k der größte gemeinsame Teiler der Determinanten aller (k × k)-dimensionalen Untermatrizen von G(D) ist.

8.2 Algebraische Beschreibung

255

Beweis: Der größte gemeinsame Teiler ∆k der Determinanten aller (k × k)-dimensionalen Untermatrizen einer Generatormatrix G(D) entspricht nach Satz 8.8 (Gleichung (8.27)) dem Produkt der Invarianten γ1 ·γ2 ·. . .·γk der Generatormatrix. Aufgrund ihrer Reihenentwicklung kennzeichnen die Nennerpolynome 1/∆k der Inversen Γ−1 (D) mit einem Faktor der Form Ds · (1 + Dr + . . .) eine katastrophale Generatormatrix. 2

Eine unmittelbare Folge des obigen Satzes ist, dass alle Basisgeneratormatrizen nichtkatastrophal sind und somit auch alle minimalen Basisgeneratormatrizen. Da die invarianten Faktoren γi für i ∈ [1, k] alle eins sind, besitzen diese Matrizen eine polynomielle rechte Inverse oder dazu äquivalent gilt ∆k = 1. Generell sind alle Generatormatrizen mit polynomieller rechten Inversen nicht-katastrophal, da dann bei der Rückabbildung keine endlichen Codewörter auf unendliche Informationswörter abgebildet werden können. Beispiel 8.30 (Test auf Katastrophalität) Wie oben bereits gezeigt, ist die polynomielle Generatormatrix aus Beispiel 8.27 katastrophal. Der Test auf Katastrophalität gemäß Satz 8.12 für die drei Determinanten d1 , d2 und d3 der (2 × 2)-dimensionalen Untermatrizen von G(D) ergibt ˛ ˛ ˛ ˛ 1+D D ˛ ˛ d1 = ˛ D + D2 + D3 + D4 1 + D + D2 + D3 + D4 ˛ = 1 + D2 + D3 + D4 = (1 + D + D3 )(1 + D), ˛ ˛ ˛ ˛ D 1 ˛ d2 = ˛˛ 2 3 4 2 ˛ 1+D+D +D +D 1+D+D = 1 + D4 = (1 + D)4 und ˛ ˛ ˛ ˛ 1+D 1 ˛ d3 = ˛˛ 2 3 4 2 ˛ D+D +D +D 1+D+D

= 1 + D + D2 + D4 = (1 + D2 + D3 )(1 + D).

Der größte gemeinsame Teiler ist ∆2 = ggT(d1 , d2 , d3 ) = 1 + D 6= Ds und dies zeigt damit die Katastrophalität der Generatormatrix an. Betrachten wir die Smith-Form dieser Generatormatrix in Beispiel 8.27, so ergibt das Produkt der invarianten Faktoren ∆2 = γ1 · γ2 = 1 + D. Dieser Term taucht als Nennerpolynom zunächst in Γ−1 (D) und dann auch wieder in der rechten Inversen der Generatormatrix auf. Somit werden Codewörter mit endlichem Gewicht auf Informationswörter mit unendlichem Gewicht abgebildet.  Beispiel 8.31 (Basisgeneratormatrizen und Katastrophalität) Der in Bild 8.14 dargestellte Faltungscodierer der Rate R = 1/2 mit der Generatormatrix ` ´ G(D) = 1 + D3 1 + D + D2 + D3 ist katastrophal, wie bereits in Beispiel 8.22 anhand einer Nullschleife im Zustandsdiagramm des Codierers gezeigt wurde. Alternativ dazu erhalten wir mit obigem Test ∆1 = ggT(1 + D3 , 1 + D + D2 + D3 ) = ggT( (1 + D + D2 )(1 + D), (1 + D)3 ) = 1 + D.

256

8 Faltungscodes

Klammert man diesen Faktor aus, so ergibt sich dann mit T(D) = 1/(1 + D) die äquivalente Generatormatrix ` ´ G0 (D) = 1 + D + D2 1 + D2 .

Eine Realisation von G0 (D) im Steuerentwurf ist in Bild 8.1 dargestellt. Diese ist nichtkatastrophal, denn ∆1 = 1. Des weiteren gilt γ1 = 1 und Rang([G(D)]h ) = 1. Somit ist G0 (D) eine minimale Basisgeneratormatrix. 

Katastrophalität ist eine Eigenschaft der Generatormatrix und nicht des Faltungscodes. Jeder Faltungscode besitzt sowohl katastrophale als auch nicht-katastrophale Generatormatrizen. Ein katastrophaler Faltungscode existiert nicht!

8.2.7

Systematische Generatormatrizen

Hier werden wir zeigen, dass jeder Faltungscode systematisch codiert werden kann und eine systematische Generatormatrix aus einer gegebenen Generatormatrix berechenbar ist. Definition 8.13 (Systematische Generatormatrizen) Die Generatormatrix eines Faltungscodes der Rate R = k/n wird systematisch genannt, wenn alle k Informationssequenzen Ui (D) unverändert in den n Codesequenzen Vj (D) auftreten. Beispiel 8.32 (Systematische Generatormatrix) Betrachtet man die minimale Basisgeneratormatrix ` ´ Gmb (D) = 1 + D + D2 1 + D2

aus Beispiel 8.31, dann erhält man eine äquivalente systematische Generatormatrix Gsys (D) =

“ 1 · Gmb (D) = 1 2 1+D+D

1+D 2 1+D+D 2



.

Der Faltungscodierer im Steuerentwurf zu dieser Generatormatrix ist in Bild 8.13 angegeben. 

Im allgemeinen benötigt man für die Berechnung einer systematischen Generatormatrix eine Basisgeneratormatrix Gb (D) des Codes. Diese hat eine (k × k)-dimensionale −1 invertierbare Untermatrix T (D) mit einer verzögerungsfreien polynomiellen Deter−1 minanten, d. h. det T (D) D=0 = 1. Gegebenenfalls durch Vertauschen der Spalten kann für einen äquivalenten Code erreicht werden, dass Gsys (D) = T(D) Gb (D) = ( Ik

R(D) ).

Anmerkung: Die Menge aller äquivalenten Faltungscodes erhält man durch Permutation der n Ausgangssequenzen Vj (D) in der Codesequenz V = (V1 (D), V2 (D), . . . , Vn (D)).

8.2 Algebraische Beschreibung

257

Beispiel 8.33 (Systematische Generatormatrix [JZ99]) Die ersten zwei Spalten der minimalen Basisgeneratormatrix aus Beispiel 8.28, „ « 1+D D −1 T (D) = D2 1 hat die verzögerungsfreie Determinante det( T−1 (D) ) = 1 + D + D3 . Somit erhält man die systematische Generatormatrix Gsys (D) = T(D) Gmb (D) „ «„ « 1 1 D 1+D D 1 = 2 D2 1 1 + D + D2 1 + D + D3 D 1 + D 0 1 2 +D 3 1 0 1+D+D 3 1+D+D A. = @ 2 +D 3 0 1 1+D 1+D+D 3 ~u(1)

~v (1)

~u(2)

~v (2) ~v (3)

Abb. 8.20: Systematischer Faltungscodierer mit R = 2/3. Die Realisierung dieser systematischen Generatormatrix im Steuerentwurf führt zu einem Faltungscodierer mit zwei Schieberegistern, die jeweils drei Speicherelemente lang sind. Die in Bild 8.20 dargestellte Realisation im Beobachterentwurf benötigt hingegen insgesamt nur drei Speicherelemente. Ebensoviele wie die Realisation der entsprechenden äquivalenten minimalen Basisgeneratormatrix im Steuerentwurf (Bild 8.19). 

Eigenschaften systematischer Generatormatrizen: • Jede systematische Generatormatrix kann durch einen minimalen Codierer realisiert werden, der allerdings nicht notwendigerweise Steuer- oder Beobachterform besitzt. • Eine systematische Generatormatrix ist nicht-katastrophal und besitzt immer eine polynomielle rechte Inverse. • Jeder Faltungscode besitzt eine systematische Generatormatrix, deren Elemente polynomiell sein können, aber in der Regel gebrochen-rational sind. Eine gleichzeitig polynomielle und systematische Generatormatrix stellen eine starke Einschränkung dar, so dass sich damit im allgemeinen nur Codes mit „schlechteren“ Distanzeigenschaften ergeben.

258

8.2.8

8 Faltungscodes

Prüfmatrix und dualer Code

Analog zu Blockcodes kann auch für Faltungscodes eine Prüfmatrix und damit ein dualer Code definiert werden. Definition 8.14 (Prüfmatrix) Gilt für jedes Codewort V(D) eines Faltungscodes C der Rate R = k/n V(D) HT (D) = 0, dann heißt die ( n × (n − k) )-dimensionale Matrix HT (D) Prüfmatrix oder SyndromT former des Faltungscodes. Die Elemente Hij (D) für i ∈ [1, n] und j ∈ [1, n − k] sind im allgemeinen realisierbare gebrochen-rationale Übertragungsfunktionen. Da die Zeilen der Generatormatrix auch Codewörter des Codes sind, folgt unmittelbar aus dieser Definition: G(D) HT (D) = 0. Zur Berechnung einer Prüfmatrix kann die Smith-Form einer polynomiellen Generatormatrix des Codes, G(D) = A(D)Γ(D)B(D), verwendet werden. Betrachten wir die (n × n)-dimensionale rechte Inverse der Scrambler-Matrix   Gb (D) B(D) = , ( H−1 (D) )T so erhalten wir:  T B−1 (D) = G−1 b (D) H (D) .

Wie bereits im Abschnitt 8.2.5 gezeigt, sind die ersten k Zeilen von B(D) eine zu G(D) äquivalente Basisgeneratormatrix G(D) = T(D)Gb (D). Betrachtet man In = B(D)B−1 (D) = =

Gb (D)G−1 b (D)

Gb (D)HT (D)

−1 (H−1 (D))T G−1 (D))T HT (D) b (D) (H

!

=



Ik 0 0 In−k



,

so erkennt man, dass aus den letzten n − k Zeilen der Scrambler-Matrix B(D) eine Prüfmatrix für Gb (D) berechnet werden kann. Diese ist dann auch eine Prüfmatrix für die ursprüngliche Generatormatrix: G(D)HT (D) = T(D)Gb (D)HT (D) = 0. Verwendet man nun die ( (n − k) × n)-dimensionale Prüfmatrix H(D) zur Codierung eines Codes der Rate R = (n−k)/n, dann sind die transponierten Codewörter VT (D) = (U(D)H(D))T des so erzeugten Faltungscodes orthogonal zu den Codewörtern V0 (D) = U0 (D)G(D) des ursprünglichen Codes: V0 (D) VT (D) = U0 (D)G(D) (U(D)H(D))T = U0 (D) G(D)HT (D) UT (D) = 0.

8.3 Distanzmaße

259

Definition 8.15 (Dualer Code) Der duale Code C ⊥ der Rate R⊥ = (n − k)/n eines Faltungscodes C der Rate R = k/n ist die Menge aller Codesequenzen, die mit der transponierten Prüfmatrix H(D) des Codes C erzeugt werden kann. Beispiel 8.34 (Prüfmatrix) Die Generatormatrix des in Bild 8.17 dargestellten Faltungscodierers wurde in Beispiel 8.27 in Smith-Form dargestellt. Die Scrambler-Matrix B(D) ergab sich zu: 0 1 1+D D 1 B(D) = @ 1 + D2 + D3 1 + D + D2 + D3 0 A . D + D2 1 + D + D2 0 Invertiert man diese, so erhält man: 0 1 0 1 + D + D2 1 + D + D2 + D3 −1 2 2 3 A, 1+D +D B (D) = @ 0 D + D 1 1 + D2 1 + D + D3 und die Prüfmatrix ist:

1 1 + D + D2 + D3 H (D) = @ 1 + D2 + D3 A . 1 + D + D3 T

0



Es kann gezeigt werden, dass die Gesamteinflusslänge einer minimalen Basisgeneratormatrix Gmb (D) eines Faltungscodes C und die Gesamteinflusslänge einer ebenfalls minimalen Basisgeneratormatrix Hmb (D) des dualen Codes C ⊥ gleich sind. Dieser Zusammenhang wird später bei der Abschätzung der ML-Decodierkomplexität eines Faltungscodes benutzt werden.

8.3

Distanzmaße

Generell existieren zwei unterschiedliche Arten von Distanzmaßen, die entweder Eigenschaft des Codes oder Eigenschaft der Generatormatrix, d. h. des Codierers sind. Dies wurde bereits im Abschnitt 8.1.6 deutlich: Die Distanzfunktion ist eine Eigenschaft des Codes, während die erweiterte Distanzfunktion eine Eigenschaft der Generatormatrix ist. Die Definitionen und die Berechnung aller hier vorgestellten Distanzmaße haben eines gemeinsam: Zunächst wird eine Untermenge aus der Menge aller möglichen Codesequenzen definiert. Dies geschieht durch die Einschränkung der zur Codierung verwendeten Informationssequenzen. Die Distanzen in dieser Untermenge können dann, aufgrund der Linearität von Faltungscodes, aus der Gewichtsverteilung der entsprechenden Codesequenzen bzw. der Gewichtsverteilung von Segmenten dieser Codesequenzen berechnet werden.

8.3.1

Spalten- und Zeilendistanz

Spaltendistanz (column distance) und Zeilendistanz (row distance) wurden in [Cos69] eingeführt. Aus der Spaltendistanz lassen sich eine Reihe weiterer Distanzmaße ableiten: die minimale Distanz, das Distanzprofil und die freie Distanz.

260

8 Faltungscodes

Spaltendistanz: Die Spaltendistanz ist eine Eigenschaft der Generatormatrix und nicht des Codes. Sie ist wie folgt definiert: Definition 8.16 (Spaltendistanz) Die Spaltendistanz dcj der Ordnung j einer Generatormatrix G(D) ist die minimale Hamming-Distanz der ersten j + 1 Codeblöcke 0 zweier Codewörter v[j+1] = (v0 , v1 , . . . , vj ) und v[j+1] = (v00 , v10 , . . . , vj0 ), wobei sich die beiden zur Codierung verwendeten Informationssequenzen u[j+1] = (u0 , u1 , . . . , uj ) und u0[j+1] = (u00 , u01 , . . . , u0j ) im ersten Informationsblock unterscheiden, also u0 6= u00 gilt. Die Spaltendistanz ist aufgrund der Linearität von Faltungscodes gleich dem Minimum der Hamming-Gewichte aller Sequenzen v[j+1] , dcj = min wt(v[j+1] ), u0 6=0

wobei v[j+1] = (v0 , v1 , . . . , vj ) die ersten j + 1 Codeblöcke aller möglichen Codesequenzen mit u0 6= 0 sind. Es werden also nicht Codesequenzen betrachtet, sondern Segmente von Codesequenzen. Betrachten wir nun die halbunendliche Generatormatrix G des Codes (vergleiche Tabelle 8.1), so erhalten wir dcj = min wt(u[j+1] Gc[j+1] ), u0 6=0

mit der ( k(j + 1) × n(j + 1) )-dimensionalen Generatormatrix Gc[j+1]



G0 G1 . . . G0  = ..  .

 Gj Gj−1  . ..  . G0

Ist die Generatormatrix G(D) des Codes polynomiell, dann entspricht Gc[j+1] der im Abschnitt 8.1.7 für Truncation in Gleichung (8.13) definierten Generatormatrix und es gilt Gj = 0 für j > m. Nun werden wir zwei weitere Distanzmaße aus der Spaltendistanz ableiten: Definition 8.17 (Distanzprofil der Generatormatrix) Die ersten m + 1 Werte der Spaltendistanz d = (dc0 , dc1 , . . . , dcm ) einer gegebenen Generatormatrix G(D) mit Gedächtnisordnung m bezeichnet man als das Distanzprofil dieser Generatormatrix. Ein schnelles Anwachsen des Distanzprofils ist vor allem bei der sequentiellen Decodierung (Abschnitt 8.6) wichtig. Definition 8.18 (Minimale Distanz) Als minimale Distanz dm bezeichnet man die Spaltendistanz der m-ten Ordnung dcm einer gegebenen Generatormatrix G(D) mit Gedächtnisordnung m.

8.3 Distanzmaße

261

Man beachte, dass die minimale Distanz der Generatormatrix eines Faltungscodes mit der minimalen Distanz eines Blockcodes nur den Namen gemeinsam hat! Betrachten wir das Zustandsdiagramm der Generatormatrix G(D), dann verlassen die der Berechnung von dcj zugrunde liegenden Pfade der Länge j + 1 zum Zeitpunkt t = 0 den Nullzustand σ0 = 0 und befinden sich nach j + 1 Zustandsübergängen in einem beliebigen Zustand σj+1 ∈ (0, 1, . . . , 2ν − 1). Damit sind die für j = 0 betrachteten Pfade ein Teil der für j = 1 betrachteten Pfade, usw. D. h., alle für die Ordnung j betrachteten Pfade entsprechen den um einen weiteren Zustandsübergang verlängerten Pfaden, die für die Berechnung der Spaltendistanz der Ordnung j −1 betrachtet wurden. Somit ist die Spaltendistanz eine mit j monoton ansteigende Funktion, und es gilt: dc0 ≤ dc1 ≤ · · · ≤ dcj ≤ · · · ≤ dc∞ ,

(8.30)

wobei ein endlicher Grenzwert dc∞ für j → ∞ existiert. Anschaulich wird dies durch die Nullschleife im Nullzustand des Zustandsdiagramms. Da jeder Pfad der Länge 2ν + 1 mindestens eine Schleife im Zustandsdiagramm durchläuft, ist der Pfad mit minimalem Hamming-Gewicht spätestens nach j ≥ 2ν in eine Nullschleife gelaufen und bleibt dort. Zeilendistanz: Auch die Zeilendistanz ist eine Eigenschaft der Generatormatrix und nicht des Codes. Sie ist folgendermaßen definiert: Definition 8.19 (Zeilendistanz) Die Zeilendistanz drj der Ordnung j einer Generatormatrix G(D) mit Gedächtnisordnung m ist die minimale Hamming-Distanz der 0 j + m + 1 Codeblöcke zweier Codewörter v[j+m+1] = (v0 , v1 , . . . , vj+m ) und v[j+m+1] = 0 0 0 (v0 , v1 , . . . , vj+m ), wobei sich die beiden zur Codierung verwendeten Informationssequenzen u[j+m+1] = (u0 , u1 , . . . , uj+m ) sowie u0[j+m+1] = (u00 , u01 , . . . , u0j+m ) für die gilt (uj+1 , . . . , uj+m ) = (u0j+1 , . . . , u0j+m ) mindestens im ersten der j + 1 Informationsblöcke unterscheiden. Anschaulich ist drj die minimale Distanz zwischen allen Pfaden im Trellis der Generatormatrix, die im Nullzustand auseinander laufen und zum Zeitpunkt j + m + 1 durch den gleichen Zustand gehen, welcher nicht unbedingt der Nullzustand sein muss. Analog zur Spaltendistanz kann auch die Zeilendistanz als Minimum der Hamming-Gewichte aller Sequenzen v[j+m+1] berechnet werden, drj = min wt(v[j+m+1] ), u0 6=0

wobei v[j+m+1] = (v0 , . . . , vj , . . . , vj+m ) terminierte Codesequenzen der Länge j +m+1 sind (Abschnitt 8.1.7). So erhalten wir drj = min wt(u[j+m+1] Gr[j+m+1] ), u0 6=0

262

8 Faltungscodes

mit der Informationssequenz u[j+m+1] = (u0 , . . . , uj , uj+1 , . . . , uj+m ), wobei (uj+1 , . . . , uj+m ) der Terminierungssequenz entspricht. Die ( k·(j+1)×n·(j+m+1) )-dimensionale Generatormatrix Gr[j+m+1] ist gegeben durch 

Gr[j+m+1]

 G0 G1 . . . Gj . . . Gj+m G0 Gj+m−1     .. ..   . .   = . G0 . . . Gm−1      . . ..   . . G0

Ist die Generatormatrix G(D) des Codes polynomiell und ist (uj+1 , . . . , uj+m ) = 0 die Terminierungssequenz, so gilt Gj = 0 für j > m. Betrachten wir nun in Analogie zur Spaltendistanz das Zustandsdiagramm der Generatormatrix G(D), dann verlassen die der Berechnung der Zeilendistanz drj zugrundeliegenden Pfade der Länge j + m + 1 zum Zeitpunkt t = 0 den Nullzustand σ0 = 0 und befinden sich nach j + m + 1 Zustandsübergängen wieder im Nullzustand σj+m+1 = 0. Da dieser gegebenenfalls auch schon vorher erreicht werden kann, und die darauf folgenden Übergänge dann in der dortigen Nullschleife bleiben können, sind die betrachteten Pfade für drj−1 eine Teilmenge der zur Berechnung von drj betrachteten. Damit ist die Zeilendistanz eine monoton mit j fallende Funktion, und es gilt: dr0 ≥ dr1 ≥ · · · ≥ drj ≥ · · · ≥ dr∞ ,

(8.31)

wobei für den Grenzwert j → ∞ gilt: dr∞ > 0. Da jeder Pfad der Länge 2m + 1 mindestens eine Schleife im Zustandsdiagramm durchläuft, ist der Pfad mit minimalem Hamming-Gewicht spätestens nach j = 2m + 1 wieder im Nullzustand und bleibt in diesem. Die zur Berechnung der Spaltendistanz dc∞ betrachteten Pfade im Zustandsdiagramm laufen vom Nullzustand in diejenige Nullschleife, die bzgl. dem Hamming-Gewicht der dazu benötigten Zustandsübergängen „am nächsten“ liegt. Andererseits ist die Zeilendistanz dr∞ das minimale Hamming-Gewicht aller Pfade im Zustandsdiagramm vom Nullin den Nullzustand und damit in die dortige Nullschleife. Mit der Anzahl von m + 1 Zustandsübergängen kann jedoch jeder beliebige andere Knoten ebenfalls erreicht werden. Es gilt dr∞ ≥ dc0 und wir erhalten mit den Gleichungen (8.30) und (8.31): dc0 ≤ dc1 ≤ · · · ≤ dcj ≤ · · · ≤ dc∞ ≤ dr∞ ≤ · · · ≤ drj ≤ · · · ≤ dr0 .

Satz 8.20 (Grenzwert der Zeilen- und Spaltendistanz) Ist G(D) eine nichtkatastrophale Generatormatrix, dann gilt für die Grenzwerte der Zeilen- und Spaltendistanz dc∞ = dr∞ . Beweis: Bei der Herleitung von Gleichung (8.30) wurde gezeigt, dass der mit dc∞ verbundene Pfad in eine Nullschleife des Zustandsdiagramms läuft und dort bleibt. Für eine nichtkatastrophale Generatormatrix existiert nur eine Nullschleife, nämlich die vom Null- auf den

8.3 Distanzmaße

263

Nullzustand. Damit ist dc∞ das minimale Hamming-Gewicht eines Pfades aus dem Nullzustand in den Nullzustand und entspricht, wie bei der Herleitung von Gleichung (8.31) gezeigt wurde, der Zeilendistanz dr∞ . 2

Freie Distanz: Die freie Distanz ist, wie bereits in Abschnitt 8.1.6 erwähnt, eine Eigenschaft des Codes. Definition 8.21 (Freie Distanz) Die freie Distanz df eines Faltungscodes C der Rate R = k/n ist definiert als die minimale Distanz zweier beliebiger Codewörter, df = min0 dist(v, v0 ), v6=v

des betrachteten Codes. Auch hier kann aufgrund der Linearität das Problem der Berechnung von Distanzen auf die Berechnung von Hamming-Gewichten abgebildet werden. Konkret muss eine beliebige Generatormatrix des Codes zugrunde liegen. Alle äquivalenten Generatormatrizen dieses Codes führen zum selben Ergebnis. Satz 8.22 (Zeilen-, Spaltendistanz und freie Distanz) Ist G(D) eine nichtkatastrophale Generatormatrix, dann gilt für die Grenzwerte der Zeilen- und Spaltendistanz: dc∞ = dr∞ = df .

(8.32)

Beweis: Eine mögliche Berechnung der freien Distanz wurde in Beispiel 8.12 anhand des Zustandsdiagramms vorgestellt. Aus der Beschreibung von Spalten- und Zeilendistanz im Zustandsdiagramm folgt direkt Gleichung (8.32). 2 Beispiel 8.35 (Zeilen- und `Spaltendistanz) Bild 8.21 zeigt ´die Spalten- und Zeilendistanz der Generatormatrix G(D) = 1 + D + D2 + D3 1 + D2 + D3 eines Faltungscodes der Rate R = 1/2 mit m = 3. Ein Codierer dieser Generatormatrix im Steuerentwurf ist in Bild 8.2 angegeben. 

8.3.2

Erweiterte Distanzmaße

Die im vorigen Abschnitt definierten traditionellen Distanzmaße ermöglichen in vielen Fällen keine ausreichende Beschreibung der Distanzeigenschaften von Faltungscodes bzw. deren Generatormatrizen. Aus diesem Grund wurden sogenannte erweiterte Distanzmaße eingeführt, die sich mit der Länge der betrachteten Codesequenz ändern. Allen hier vorgestellten Distanzmaßen liegt dasselbe Prinzip zugrunde: Es werden Segmente von Codesequenzen betrachtet, wobei die Menge der betrachteten Codesequenzen eine Untermenge des Codes darstellt. Die Definition dieser Untermenge erfolgt durch Einschränkung möglicher Zustandssequenzen. Deshalb lassen sich die betrachteten Segmente besonders gut im Trellis der Generatormatrix veranschaulichen und auch praktisch bestimmen. Das entsprechende Distanzmaß ist dann das minimale HammingGewicht dieser Segmente. Des weiteren sind alle hier vorgestellten erweiterten Distanzen Eigenschaften der Generatormatrix. Hier werden wir ausschließlich polynomielle Generatormatrizen betrachten.

264

8 Faltungscodes 8

Zeilen−, Spaltendistanz

7 drj

6

d∞

5 dcj

4 3 2 1 0

0

2

4

6

j

8

10

Abb. 8.21: Zeilen- und Spaltendistanz.

Erweiterte Spaltendistanz: Die erweiterte Spaltendistanz (extended column distance) dec j ist das minimale Hamming-Gewicht der Segmente v[j+1] = (v0 , v1 , . . . , vj ) der Länge j + 1, wobei die Menge der Codeworte v durch die erlaubten Zustandssequenzen S = (σ0 , . . . , σt , . . . , σj , σj+1 ) mit σ0 = 0 und σt 6= 0 für 1 ≤ t ≤ j definiert ist. D. h. es werden nur solche Codesegmente v[j+1] betrachtet, die im Trellis den Nullzustand zum Zeitpunkt t = 0 verlassen und in den darauf folgenden j Zustandsübergängen den Nullzustand nicht durchlaufen. Der Zustand σj+1 nach dem (j + 1)-ten Informationsblock vj ist dann beliebig und beinhaltet auch den Nullzustand. Definition 8.23 (Erweiterte Spaltendistanz) Gegeben sei die Generatormatrix G mit Gesamteinflusslänge ν eines Faltungscodes C der Rate R = k/n. Dann ist die erweiterte Spaltendistanz der Ordnung j n  o dec min wt (u0 , u1 , . . . , uj ) Gc[j+1] , j = u0 6=0 σ0 =0,σt 6=0,0 b(w − 1)/2c = 3 Bitfehler an den entsprechenden 7 Positionen aufgetreten, dann kommt es zu einem Decodierfehler. Ein mögliches Fehlermuster, welches zu einem Decodierfehler führt, ist z. B. e[6] = (01, 00, 01, 00, 10, 11). Es tritt mit der Wahrscheinlichkeit P (e[6] ) = (1 − p)7 · p5 auf, wobei p die Bitfehlerrate des Kanals ist. 

Wahrscheinlichkeit eines Fehlerbündels: In Abhängigkeit vom Gewicht eines möglichen fehlerhaften Codesegments v[l] mit Hamminggewicht w = wt(v[l] ) kann allgemein eine obere Schranke für die Wahrscheinlichkeit eines entsprechenden Decodierfehlers angegeben werden. Dazu müssen zunächst e > b(w − 1)/2c Bitfehler an den entsprechenden Stellen der Sequenz auftreten. Betrachtet man nur diese Stellen, dann ist die Wahrscheinlichkeit  w  P w e w−e  für w ungerade   e p (1 − p) e=(w+1)/2 pw = w  w/2  P  w e 1 w w/2 w−e  + für w gerade  2 w/2 p (1 − p) e p (1 − p) e=w/2+1

(8.43)

8.4 Maximum-Likelihood (Viterbi-) Decodierung

277

eine obere Schranke, dass es bezüglich des betrachteten Codesegments v[l] zu einem Decodierfehler kommt, d. h. es ist sichergestellt, dass es mit pw zur Decodierung eines fehlerhaften Segments kommt, wobei aber nicht notwendigerweise auf das betrachtete Segment decodiert wird. Die Wahrscheinlichkeit pw aus Gleichung (8.43) kann durch die obere Schranke  p w pw < 2 p(1 − p) (8.44) ersetzt werden. Dies wird im Folgenden eine kompakte Darstellung weiterer Ergebnisse ermöglichen.

Union-Bound: Wir können eine obere Schranke für die Wahrscheinlichkeit der fehlerhaften Decodierung eines bestimmten Codesegments angeben. Dies kann nun für jedes mögliche Codesegment v[l] durchgeführt werden. Da die derart bestimmten Ereignisse Ei nicht exklusiv P sind, verwenden wir die sogenannte Union-Bound P (∪i Ei ) ≤ i P (Ei ), um eine obere Schranke für die Wahrscheinlichkeit eines Fehlerbündels der Länge l herzuleiten. Mit P (Ew ) = pw gilt dann X PF (l) ≤ N (l, w) · pw , w

wobei N (l, w) die Koeffizienten der in Gleichung (8.11) definierten Gewichtsverteilung Al (W ) sind. Mit Hilfe der erweiterten Distanzfunktion kann also die Anzahl N (l, w) aller Pfade mit Gewicht w und Länge l berechnet werden, die als mögliche Decodierfehler in Frage kommen. Summieren wir über alle möglichen Längen X PF ≤ PF (l), l

dann erhält man eine obere Schranke für die Wahrscheinlichkeit, dass es an einem beliebigen Zustand im Trellis zu einem Fehlerereignis kommt, unabhängig von der Länge des Fehlers, die sogenannte First-Event-Probability. Damit erhalten wir ∞ X PF ≤ N (w) · pw = T (W ) , (8.45) √ W =2

w

p(1−p)

wobei N (w) das Distanzspektrum (vergleiche Gleichung (8.10)) des Codes ist und T (W ) die in Abschnitt 8.1.6 definierte Distanzfunktion des Codes. Diese sehr kompakte Schranke der First-Event-Probability wird auch Viterbi-Bound genannt. Während bei guten Kanälen, d. h. mit kleiner Bitfehlerrate, diese Schranke fast mit den erzielbaren Werte übereinstimmt, ergibt sich bei schlechten Kanälen doch ein recht großer Unterschied. Anhand der oben hergeleiteten Schranke lässt sich auch eine obere Schranke für die Bitfehlerwahrscheinlichkeit PBit berechnen. In Abhängigkeit der Wahrscheinlichkeit pw erhalten wir (ohne Herleitung): 1 X 1 ∂ T (W, H, L = 1) PBit < I(w) · pw = , (8.46) W =2√p(1−p) k k ∂H w

H=1

278

8 Faltungscodes

wobei T (W, H, L) die erweiterte Distanzfunktion aus Gleichung (8.9) auf Seite 229 ist, und für pw die Näherung aus Gleichung (8.44) verwendet wurde. Der Term I(w) wird als Informationsgewicht bezeichnet und P ergibt sich aus der erweiterten Distanzfunktion durch ∂T (W, H, L = 1)/∂H|H=1 = w I(w)W w . Außerdem können alle hier getroffenen Aussagen auf AWGN-Kanäle erweitert werden. In diesem Fall erhält man analog zur Gleichung (8.43) und (8.44) (ohne Herleitung) ! r Eb Eb pw = erfc 2R w < e−R N0 w , N0 √ R +∞ 2 mit der komplementären Error-Funktion erfc(z) = 1/ 2π z e−η /2 dη. Damit können die in den Gleichungen (8.45) und (8.46) gegebenen Schranken auch auf AWGNKanäle erweitert werden. Beispiel 8.41 (Näherung für Bitfehlerwahrscheinlichkeit) Eine gute Näherung für die Bitfehlerwahrscheinlichkeit PBit erhält man, wenn wir die in Gleichung (8.46) gegebene Reihe nach den ersten Gliedern abbrechen. Dann muss die erweiterte Distanzfunktion nicht im ge-

(5,7) Simulation (5,7) Schranke (133,171) Simulation (133,171) Schranke

−1

10

−2

10

PBit

−3

10

−4

10

−5

10

−6

10

0

1

2

3 4 Eb/N0 [dB]

5

6

7

Abb. 8.30: Näherung der Bitfehlerwahrscheinlichkeit. schlossener Form berechnet werden, sondern nur die ersten Koeffizienten der entsprechenden Reihenentwicklung. Diese Berechnung kann auf sehr viel effizientere Weise durchgeführt werden. Mit diesem Vorgehen erhält man zwar keine obere Schranke mehr, aber für praktische Anwendungen eine ausreichend gute Abschätzung. In Bild 8.30 sind die Näherungen und die simulierten Bitfehlerkurven für den (5, 7)- und (133, 171)-Code zu sehen. In beiden Kurven wurde die Reihe nach vier Termen, also für w = df + 3 abgebrochen. 

8.4.4

Interleaving

Der im vorherigen Abschnitt beschriebene Viterbi-Algorithmus und die Betrachtung zu Fehlerbündeln zeigen, dass Faltungscodes gut statistisch unabhängige Einzelfehler korrigieren können, wie sie etwa beim BSC oder dem AWGN-Kanal auftreten. Liegt ein Kanal vor, der Bündelfehler erzeugt, wie sie z. B. mit dem Gilbert-Elliot-Modell

8.4 Maximum-Likelihood (Viterbi-) Decodierung

279

aus Abschnitt 7.1.3 beschrieben werden können, so stellt dies einen für die Decodierung ungünstigen Fall dar. Eine Methode um aus den Bündelfehlern Einzelfehler zu erhalten, ist eine Permutation der Stellen zu verwenden, die Interleaving genannt wird. Prinzipiell können wir einen Interleaver als einen Code der Rate R = 1 definieren, der einen stochastischen Prozeß, welcher Bündelfehler generiert, auf einen Prozeß abbildet, der unabhängige Einzelfehler erzeugt. Für ein gegebenes System einen geeigneten Interleaver zu finden ist eine nicht-triviale Aufgabe. Zunächst muss der stochastische Prozeß am Eingang des Interleavers beschrieben werden. Dazu sind Kenntnisse über die Eigenschaften des zugrunde liegenden Kanalmodells notwendig, womit es möglich ist die Größe des Interleaving-Bereichs anzugeben. Dabei muss ein Abtausch (trade off ) stattfinden zwischen der vom Interleaving verursachten Verzögerung und dem Mittelungseffekt, der durch Interleaving eintritt. Anschließend muss eine geeignete Permutation gefunden werden. In vielen Fällen wird ein Blockinterleaver verwendet. Dieser schreibt die Eingangssequenz zeilenweise in eine Matrix ein und liest die Ausgangssequenz spaltenweise aus. Es sind aber beliebige andere Interleaver-Konstruktionen denkbar!

8.4.5

Soft-Output-Viterbi-Algorithmus (SOVA)

Der Viterbi-Algorithmus in der bisher beschriebenen Form liefert „hart“ entschiedene Werte am Ausgang. Oftmals ist es jedoch wünschenswert eine Information über die Zuverlässigkeit der getroffenen Entscheidungen zu haben. Dies kann mit Hilfe eines Soft-Output-Viterbi-Algorithmus oder kurz SOVA erreicht werden. Um eine Aussage über die Zuverlässigkeit einer getroffenen Entscheidung machen zu können, müssen wir mögliche Alternativen betrachten. Wie in Gleichung (8.33) und (8.34) dargestellt, wird über die Wahrscheinlichkeit P (x)P (y | x) aller Codesequenzen x und damit über alle Pfade im Trellis in Abhängigkeit der empfangenen Sequenz y maximiert. Betrachten wir die Berechnung der Metrik bzw. der Teilmetriken (vergleiche Gleichungen (8.35)–(8.38)) im Trellis, dann gilt: x

P (x)P (y | x) ∼ eΛ

/2

bzw. für ein Segment der Codesequenz x[t] der Länge t gilt: x

P (x[t] )P (y[t] | x[t] ) ∼ eΛt /2 . Der Faktor 1/2 ist auf die Wahl der multiplikativen Konstanten c1 = 2 bei der Berechnung der Teilmetrik λxt in Gleichung (8.36) zurückzuführen. Der nach der MLDecodierung entschiedene Pfad xopt ist die am wahrscheinlichsten gesendete Codesequenz. Mögliche Alternativen zu dieser Entscheidung werden bei der Decodierung zu jedem Zeitpunkt t > m dadurch verworfen, dass an jedem Zustand σt nur der Survivor weiterverfolgt wird. Nehmen wir einen Faltungscode der Rate R = 1/n an, dann sind an dieser Entscheidung 0 zwei Pfade betroffen. In Abhängigkeit der Metriken Λxt des Survivors x[t] und Λxt des

280

8 Faltungscodes

verworfenen Pfades x0[t] kann die Wahrscheinlichkeit für eine fehlerhafte Entscheidung berechnet werden: P (x0[t] )P (y[t] | x0[t] )

P (x0[t] )P (y[t] | x0[t] ) + P (x[t] )P (y[t] | x[t] ) x0

=

eΛt e

0 Λx t /2

/2

+ eΛt /2 x

=

1 x0 )/2

1 + e(Λt −Λt x

=

1 σ , 1 + e ∆t

wobei die Differenz der Metriken von Survivor und verworfenem Pfad am Zustand σt zum Zeitpunkt t 0

∆σt = (Λxt − Λxt )/2 ist. Die mit jeder dieser Entscheidungen verbundenen Fehlerwahrscheinlichkeit lässt sich nun angeben als: pf (∆σt ) =

1 σ 1 + e ∆t

Mit dieser Wahrscheinlichkeit wird also am Zustand σt eine fehlerhafte Entscheidung getroffen und der korrekte Pfad verworfen. Basierend auf der Wahrscheinlichkeit pf (∆σt ) wird im Folgenden die Zuverlässigkeit einzelner Bits der geschätzten Informationssequenz berechnet. Betrachten wir zunächst ein Beispiel: Beispiel 8.42 (SOVA) In Bild 8.31 ist ein Ausschnitt aus dem Prozeß der Viterbi-Decodierung dargestellt. Wie bereits erwähnt, wird zu jedem Zeitpunkt t für jeden Zustand σt ein Survivor bestimmt. Von diesem Prozess ist in Bild 8.31 nur die Berechnung des Survivors am Zustand σ11 = 1 zu sehen und die beiden in diesen Zustand laufenden Pfade x[11] und x0[11] . Sei ∆111 die Metrikdifferenz dieser beiden Pfade, dann wird also mit der Wahrscheinlichkeit pf (∆111 ) an dieser Stelle eine fehlerhafte Entscheidung getroffen.

0 1 2 3

00

0

1

2

3

4

5

6

7

8

9

10

11

11 10 01 11 00 01 10

Abb. 8.31: Iterative Berechnung der Zuverlässigkeit am Ausgang des Viterbi-Decodierers. Nehmen wir an, der Pfad xopt läuft (wie sich gegebenenfalls erst später herausstellt) durch diesen Zustand, dann ist von der hier getroffenen Entscheidung nur ein Teil der geschätzten Informationssequenz betroffen. Betrachten wir diese (gestrichelte Übergänge entsprechen einem Informationsbit 0 und durchgezogene Übergänge einer 1), so ergibt sich: u[11] = u0[11] =

(1 (1

1 1

0 0

1 1

1 0

1 0

0 0

1 0

1 0

1 1

0) 0)

8.4 Maximum-Likelihood (Viterbi-) Decodierung

281

Damit sind von der am Zustand 111 getroffenen Entscheidung nur Informationsbits ut im Bereich 4 ≤ t ≤ 8 betroffen. Einerseits sind beide Pfade in den ersten vier Übergänge gleich und es gilt ui = u0i für i ∈ {0, 3}, andererseits sind die letzten m = 2 Informationbits ui = u0i für i ∈ {9, 10} der beiden Codesequenzen x[11] und x0[11] ebenfalls gleich. Ansonsten würden sich die beiden Codesequenzen nicht im gleichen Zustand treffen! Betrachtet man nun den fehlerhaften Bereich, dann müssen sich die beiden Informationssequenzen darin nicht unbedingt unterscheiden, so ist u6 = u06 , aber ui 6= u0i für i ∈ {4, 5, 7, 8}. 

Wie dieses Beispiel zeigt, sind von einer Entscheidung am Zustand σt+1 die e Informationsbits ui 6= u0i ,

i ∈ {i1 , . . . , ie }

des Survivors betroffen. Die entsprechenden Stellen müssen anhand der jeweiligen Informationssequenz des Survivors und des verworfenen Pfades ermittelt werden. Damit kann die Wahrscheinlichkeit pσt+1 (i) für ein fehlerhaft entschiedenes Bit ui berechnet werden. ( 0 0 pσt (i)(1 − pf (∆σt+1 )) + (1 − pσt (i)) · pf (∆σt+1 ) i ∈ {i1 , . . . , ie } σ pt+1 (i) = 0 pσt (i) sonst, (8.47) 0

wobei pσt (i) die Wahrscheinlichkeit eines fehlerhaften Bits aus vorhergehenden Entscheidungen ist, die zu dem betrachteten Survivor führten. Dabei ist zu beachten, dass σt0 der Zustand des Survivors zum vorherigen Zustand ist. Gleichung (8.47) kann folgendermaßen interpretiert werden: • Unterscheiden sich die Informationsbits von Survivor und verworfenem Pfad nicht, so wird deren Fehlerwahrscheinlichkeit nicht von der getroffenen Entscheidung beeinflusst. • Sind die entsprechenden Informationsbits von der Entscheidung betroffen, dann wird deren Fehlerwahrscheinlichkeit beeinflusst und wir erhalten zwei Terme: Der erste Term ist die Wahrscheinlichkeit einer korrekten Entscheidung (1 − pf (∆σt )) 0 multipliziert mit der Wahrscheinlichkeit pσt (i), dass es bereits bei vorhergehenden Entscheidungen für den Survivor zu Fehlern gekommen ist. Der zweite Term geht von einer fehlerhaften Entscheidung aus und die entsprechende Wahrscheinlichkeit 0 pf (∆σt ) wird mit der Wahrscheinlichkeit (1 − pσt (i)) multipliziert, dass das Bit in vorhergehenden Entscheidungen richtig entschieden wurde. Diese Prozedur muss nun zu jedem Zeitpunkt t > m und für jeden Zustand σt durchgeführt werden. Verschmelzen alle Survivor, oder am Ende einer Blocklänge bei terminierten Faltungscodes kann aus den so berechneten Fehlerwahrscheinlichkeiten p(i) die Zuverlässigkeit für das geschätzte Bit u ˆi berechnet werden, und man erhält: L(ˆ ui ) = ln

1 − p(i) . p(i)

282

8 Faltungscodes

Alternativ zur Berechnung über Wahrscheinlichkeiten, kann diese Zuverlässigkeit auch direkt während der Durchführung des Viterbi-Algorithmus berechnet werden. Dies geschieht durch Modifikation von Gleichung (8.47), d. h. anstatt der Wahrscheinlichkeit einer fehlerhaften Entscheidung pσt (i) berechnen wir unter Verwendung der L-Algebra die entsprechende Zuverlässigkeit mit:  σ0 σ   ln 1 + eLt (i)+∆t für i ∈ {i , . . . , i } 0 1 e σ σ Lσt+1 (i) = e∆t + eLt (i)  0  Lσ (i) sonst. t Verwendet man die in der L-Algebra übliche Näherung   0  min Lσt (i), ∆σt i ∈ {i1 , . . . , ie } Lσt+1 (i) =  Lσ0 (i) sonst, t

dann erhalten wir eine Berechnungsvorschrift, die sich aufgrund der geringen Komplexität für eine Realisierung des SOVA besonders gut eignet. Die Viterbi-Listendecodierung wird in Abschnitt 7.4.3 auf Seite 195 beschrieben, und kann auch für Faltungscodes verwendet werden.

8.5

Soft-Output-Decodierung

Die Soft-Output-Decodierung liefert neben einer Entscheidung auch noch deren Zuverlässigkeit, was sowohl bei der Decodierung von verketteten Codes, als auch zur Fehlerverdeckung verwendet werden kann. Dabei kann unter Code auch Modulation oder auch Entzerrung verstanden werden (siehe Kapitel 10). Im ersten Fall wird die Zuverlässigkeitsinformation zur Fehlerverdeckung verwendet. Z. B. werden unzuverlässige Sprachblöcke nicht berücksichtigt, die unangenehme „Knack“-Geräusche hervorrufen würden. Im zweiten Fall dient die Soft-Output-Decodierung des inneren Decodierers als Soft-Input-Information des äußeren Decodierers. Im vorigen Abschnitt haben wir eine Modifikation des Viterbi-Algorithmus, den SOVA, erläutert, der zur Soft-Output-Decodierung verwendet werden kann. In diesem Abschnitt werden wir den MAP-Decodierer behandeln, der sowohl Soft-Input-Werte verarbeitet, als auch Soft-Output-Information liefert. Der Algorithmus minimiert die Symbolfehlerwahrscheinlichkeit und berechnet zusätzlich die Zuverlässigkeit der Entscheidung eines Symbols. BCJR-Algorithmus Im Gegensatz zur Schätzung der Gesamtsequenz mit dem Viterbi-Algorithmus, wird im Folgenden ein Verfahren vorgestellt, das eine Schätzung eines einzelnen Symbols durchführt, unter Berücksichtigung der gesamten empfangenen Sequenz. Dazu wird der symbol-by-symbol-MAP-Algorithmus gemäß [BCJR74] für die Trellisdarstellung eines Codes (Block- oder Faltungscodes) verwendet. Im Folgenden wollen wir den BCJR-Algorithmus für binäre Faltungscodes wiederholen. Generell kann die Beschreibung des BCJR-Algorithmus auf der Basis von Wahrscheinlichkeiten oder mit Log-Likelihood-Werten erfolgen. Während wir bei Blockcodes die L-Werte verwendet haben, wollen wir im Folgenden Wahrscheinlichkeiten benutzen. Zur Vereinfachung

8.5 Soft-Output-Decodierung

283

betrachten wir nur terminierte Faltungscodes der Rate 1/n. Außerdem wird in [Rie98] gezeigt, wie ein Faltungscode über seinen dualen Code MAP-decodiert werden kann. Wir setzen den Empfangsvektor y bei BPSK-Modulation und einem AWGN-Kanal entsprechend Abschnitt 7.1.2 voraus. Der Zustand des Codierers zum Zeitpunkt t sei σt ∈ {0, 1, . . . , 2ν − 1}. Das Informationsbit ut korrespondiert mit dem Zustandsübergang zwischen den Tiefen t − 1 und t. Mit Hilfe des BCJR-Algorithmus soll die A-posteriori-Wahrscheinlichkeit (a posteriori probability, APP) für jedes einzelne Informationsbit ut berechnet werden. Als Zuverlässigkeitsinformation entsprechend Abschnitt 7.2.2 kann der Logarithmus des Verhältnisses der APP benutzt werden. Man dividiert dabei die APP eines Informationsbits ut = 0 durch die mit ut = 1. D. h. es ergibt sich:

L(ˆ ut ) = ln

P

σt−1 ,σt

αt−1 (σt−1 ) · γ0 (yt , σt−1 , σt ) · βt (σt )

σt−1 ,σt

αt−1 (σt−1 ) · γ1 (yt , σt−1 , σt ) · βt (σt )

P

.

(8.48)

Die Parameter werden im Folgenden erläutert: Die Vorwärts-Rekursionswerte sind X

αt (σt ) =

σt−1 ,i=0,1

α0 (σ0 ) =



1 0

αt−1 (σt−1 ) · γi (yt , σt−1 , σt ) ;

(8.49)

für σ0 = 0 sonst

und die Rückwärts-Rekursionswerte βt (σt ) =

X

σt+1 ,i=0,1

βl (σl ) =



1 0

γi (yt+1 , σt , σt+1 ) · βt+1 (σt+1 ) ;

für σl = 0 sonst

(8.50)

.

Die Zweig-Übergangs-Wahrscheinlichkeiten sind gegeben durch: γi (yt , σt−1 , σt ) = q(ut = i|σt , σt−1 ) · p(yt |ut = i, σt , σt−1 ) · Pa (σt |σt−1 ) . Der Wert von q(ut = i|σt , σt−1 ) ist entweder 1 oder 0, je nachdem, ob ein Übergang mit Informationsbit i vom Zustand σt−1 zum Zustand σt existiert oder nicht. Dies bedeutet, dass die Funktion q(·) aus einem voll-vermaschten Trellis die im Codetrellis existierenden Zweige auswählt. Der Term Pa (σt |σt−1 ) ist die a-priori-Wahrscheinlichkeit für das Bit ut (im Falle gleichwahrscheinlicher Bits ist diese gleich 0.5). Diese Beschreibungsform des BCJR-Algorithmus ist ausschließlich für terminierte Faltungscodes der Blocklänge l verwendbar. Die Implementierung erfolgt auf Basis des Trellisdiagramms, entsprechend dem folgenden Beispiel.

284

8 Faltungscodes

Beispiel 8.43 (BCJR-Algorithmus) Für das folgende Beispiel wird ein Code mit den Parametern k = 1, n = 3 und Gesamteinflusslänge ν = 2 verwendet. Die drei Generatorpolynome (1) (2) (3) lauten g1 = (1, 0, 0), g1 = (1, 0, 1), g1 = (1, 1, 1) bzw. in oktaler Form (4, 5, 7). Es sollen drei Informationsbits übertragen werden. Um am Ende in den Nullzustand zu gelangen, werden zwei Terminierungsbits angehängt, so dass die Größe des Informationsblocks l insgesamt 5 ist. Da der Code die Rate R = 1/3 besitzt, resultieren daraus l = 5 Codesymbole mit insgesamt 15 Codebits. Bild 8.32 zeigt das zugehörige Trellisdiagramm. Der Pfad, der der angenommenen σ0

σ1 0/000

σt = 0

σ2 0/000

1/111

σ3 0/000

1/111

σ4 0/000

σ5 0/000

1/111 0/011

0/011

σt = 1 0/001

1/100 0/001

0/001

σt = 2 1/110

1/110 0/010

σt = 3

0/010

1/101

Abb. 8.32: Trellisdiagramm eines Codes mit Rate R = 1/3, ν = 2 und Blocklänge l = 5. Die Zweige (Trellisübergänge) sind mit den korrespondierenden Codebits bzw. Informationsbit bezeichnet. Codebitfolge entspricht, ist darin gestrichelt eingezeichnet. Die Informations- und Codebits sind an den Zweigen eingetragen. Tabelle 8.2: Informationsfolge u, Codefolge v und Empfangswerte y. ut vt ytT

t=0 1 111 −1.024 −0.169 +0.111

t=1 0 001 +0.241 −0.825 −1.044

t=2 1 100 −2.143 +0.796 +0.560

t=3 0 001 −0.260 +1.101 −0.006

t=4 0 011 +0.266 +0.244 −0.632

Betrachtet wird eine BPSK-Übertragung über einen AWGN-Kanal mit der Abbildung 0 → 1 und 1 → −1. In Tabelle 8.2 sind die Informationsbits u, die zugehörigen Codebits v und die empfangenen Werte y aufgeführt. Dabei wurde ein Signal-Rauschleistungsverhältnis von −4 dB zugrunde gelegt. Zur Vereinfachung wird angenommen, dass Nullen und Einsen gleiche Auftrittswahrscheinlichkeit besitzen, d. h. es steht keine a-priori-Information zur Verfügung, bzw. ist jeweils gleich 1/2. Um bei großen Blocklängen ein Unterschreiten des zulässigen Zahlenbereichs zu verhindern, werden zu jedem Zeitschritt t die akkumulierten P P Wahrscheinlichkeitswerte αt (σt ) und βt (σt ) normiert, so dass gilt: σt α(σt ) = 1 bzw. σt β(σt ) = 1. Damit kann der Faktor in Gleichung (7.1) vernachlässigt werden und führt für unser Beispiel zu den in Tabelle 8.3 aufgelisteten (skalierten) Übergangswahrscheinlichkeitswerten. Die skalierten Vorwärts- und Rückwärtswahrscheinlichkeitswerte gemäß den Gleichungen (8.50) und (8.51) sind in den Tabellen 8.4 und 8.5 aufgeführt. Damit ergeben sich gemäß Gleichung (8.48) die Zuverlässigkeitswerte L(ˆ ut ) für die geschätzten Bits u ˆt zu (−3.650, 2.877, −5.679, 1.0, 1.0). 

8.6 Sequentielle Decodierung

285

Tabelle 8.3: Skalierte Übergangswahrscheinlichkeitswerte aller Zustandsübergänge γi (yt , σt−1 , σt ). γi (yt , σt−1 , σt ) σ0 → σ0 σ1 → σ0 σ2 → σ1 σ3 → σ1 σ0 → σ2 σ1 → σ2 σ2 → σ3 σ3 → σ3

t=1 0.083 0.000 0.000 0.000 0.464 0.000 0.000 0.000

t=2 0.040 0.000 0.211 0.000 0.535 0.000 0.101 0.000

t=3 0.018 0.002 0.007 0.005 0.062 0.542 0.152 0.222

t=4 0.354 0.062 0.357 0.061 0.000 0.000 0.000 0.000

t=5 0.223 0.413 0.000 0.000 0.000 0.000 0.000 0.000

Tabelle 8.4: Akkumulierte Wahrscheinlichkeitswerte αt (σt ) der Vorwärtsrekursion. αt (σt ) σt = 0 σt = 1 σt = 2 σt = 3

t=0 1.000 0.000 0.000 0.000

t=1 0.152 0.000 0.848 0.000

t=2 0.017 0.508 0.230 0.244

t=3 0.004 0.008 0.747 0.241

t=4 0.006 0.994 0.000 0.000

t=5 1.000 0.000 0.000 0.000

In [RVH95] wird eine Vereinfachung des BCJR- der sogenannte Max-Log-MAP-Algorithmus beschrieben. Anmerkung: In Abschnitt 9.4.4 wird bei der verallgemeinerten Verkettung von Faltungscodes eine Variante des MAP-Algorithmus verwendet, ebenfalls in Abschnitt 10.3.4 zur SoftOutput-Demodulation.

8.6

Sequentielle Decodierung

Im Gegensatz zur Viterbi-Decodierung, bei welcher 2ν (ν ist die Gesamteinflusslänge) Survivor betrachtet werden, wird bei der sequentiellen Decodierung prinzipiell immer nur eine Codesequenz bearbeitet. Dies reduziert den zur Decodierung notwendigen Speicherbedarf erheblich. Sequentielle Decodierer sind derzeit bis zu Gesamteinflusslängen der Größenordnung ν ≈ 100 realisierbar. Allerdings ist dabei die Decodierzeit von der Anzahl der aufgetretenen Fehler abhängig, d. h. es besteht kein konstanter Verarbeitungsaufwand wie bei der Viterbi-Decodierung. So ist die Decodierkomplexität bei guten Kanälen relativ gering und steigt für schlechte Kanäle stark an. Da der Entwurf Tabelle 8.5: Akkumulierte Wahrscheinlichkeitswerte βt (σt ) der Rückwärtsrekursion. βt (σt ) σt = 0 σt = 1 σt = 2 σt = 3

t=0 1.000 0.000 0.000 0.000

t=1 0.127 0.000 0.873 0.000

t=2 0.106 0.798 0.039 0.057

t=3 0.297 0.052 0.556 0.095

t=4 0.351 0.649 0.000 0.000

t=5 1.000 0.000 0.000 0.000

286

8 Faltungscodes

eines Systems gewöhnlicherweise unter Berücksichtigung des ungünstigsten Falls (worst case) erfolgt, kann sich diese Eigenschaft als entscheidender Nachteil erweisen. Die sequentielle Decodierung lässt sich am besten mit der Darstellung des Codes im Codebaum erklären (siehe Abschnitt 8.1.5 auf Seite 224). Zunächst werden wir aber eine geeignete Metrik herleiten.

8.6.1

Fano-Metrik

Die im Abschnitt 8.4.1 für die Viterbi-Decodierung vorgestellte Metrik Λx wurde für den Vergleich von Sequenzen gleicher Länge definiert. Der sequentiellen Decodierung liegt jedoch ein anderes Prinzip zugrunde. Hier werden Pfade unterschiedlicher Länge miteinander verglichen. Entsprechend muss auch eine Metrik definiert werden, die dies berücksichtigt. Sei x[t] die gesendete Codesequenz und y[t] die empfangene Sequenz. Betrachten wir nun alle Sequenzen (1)

(2)

(n)

x[q] = (x0 , . . . , xl , . . . , xq−1 ) mit xl = (xl , xl , . . . , xl )

(8.51)

(1) (2) (n) (yl , yl , . . . , yl )

(8.52)

y[q] = (y0 , . . . , yl , . . . , yq−1 ) mit yl =

der Längen q ≤ t, dann sind wir an der am wahrscheinlichsten gesendeten Codesequenz P (x[q] ) · P (y[q] | x[q] ) P (y[q] ) x[q] ∈C,q∈[1,t] max

(8.53)

interessiert. Dazu definiert man die Fano-Metrik Λx[q] = log2

P (x[q] ) · P (y[q] | x[q] ) . P (y[q] )

(8.54) (i)

Geht man nun von einer gedächtnislosen Informationsquelle aus, d. h. P (ul = 0) = (i) P (ul = 1) = 1/2 für l ∈ [1, t] und j ∈ [1, k], erhält man für die a-priori-Wahrscheinlichkeit einer Codesequenz x[q] der Länge q P (x[q] ) =

q−1 Y

P (xl ) =

q−1 k YY

(i)

P (ul ) =

l=0 i=1

l=0

 q·k 1 = 2−R·n·q . 2

(8.55)

Entsprechend erhält man für einen gedächtnislosen, zeitinvarianten Kanal P (y[q] | x[q] ) =

q−1 Y l=0

P (yl | xl ) =

q−1 n YY

l=0 j=1

(j)

P (yl

(j)

| xl ).

(8.56)

Setzen wir Gleichung (8.56) und (8.55) in (8.54) ein, so erhalten wir: Λx[q] =

q−1 X n X l=0 j=1

λl,j

(8.57)

8.6 Sequentielle Decodierung

287

mit der sogenannten Bitmetrik (j)

λl,j = log2

P (yl

(j)

| xl )

(j)

P (yl )

− R.

(8.58)

Wie die folgenden Beispiele zeigen, ist diese Metrik sowohl für Hard- als auch für SoftDecision-Decodierung verwendbar. (j)

Beispiel 8.44 (Bitmetrik für einen symmetrischen Binärkanal) Es gilt P (yl (j) P (yl = −1) = 1/2 und 8 < (1 − p) für y (j) = x(j) l l (j) (j) P (yl | xl ) = (j) (j) :p für yl 6= xl

= +1) =

Damit ergibt sich für einen Rate R = 1/2 Code und der Bitfehlerwahrscheinlichkeit p = 2−5 die Bitmetrik λl,j zu: 8 (j) (j) < log2 (2(1 − p)) − R ≈ 0.45 → 1 für yl = xl λl,j = (j) (j) : log (2p) − R ≈ −4.5 → −10 für yl 6= xl , 2

wobei für praktische Anwendungen in der Regel auf ganze Zahlen normierte Metrikwerte verwendet werden.  Beispiel 8.45 (Wahrscheinlichkeiten für einen AWGN-Kanal) Die y-Achse sei entsprechend Bild 7.5 in Intervalle Ij der Breite ∆r eingeteilt: ri ∈ I j :

j · ∆r < ri < (j + 1) · ∆r.

Die Wahrscheinlichkeit, dass der empfangene Wert ri im Intervall Ij liegt unter der Bedingung, dass xi = ±1 gesendet wurde, ist: „ « „ « ∓1 + (j + 1) · ∆r ∓1 + j · ∆r √ √ P (ri ∈ Ij |xi = ±1) = 0.5 · erfc − 0.5 · erfc . 2·σ 2·σ Die Wahrscheinlichkeit, dass ri im Intervall Ij liegt, ist: P (ri ∈ Ij ) = 0.5 · P (ri ∈ Ij |xi = 1) + 0.5 · P (ri ∈ Ij |xi = −1) . Damit kann entsprechend Beispiel 8.44 die Bitmetrik berechnet werden.

8.6.2



Zigangirov-Jelinek (ZJ)-Decodierer

Ein sequentieller Decodier-Algorithmus wurde von Zigangirov (1966) und Jelinek (1969) vorgeschlagen. Der Decodierer wird deshalb als ZJ-Decodierer bezeichnet. Er benutzt einen Stapel (stack ), in dem die Pfade nach ihrer Metrik geordnet stehen, wobei der Pfad mit der größten Metrik ganz oben steht. Deshalb ist dieser Decodierer auch unter dem Namen Stack-Decodierer bekannt. Ein Decodierschritt besteht darin, den obersten Pfad zu entnehmen, um alle nachfolgenden Zweige vom Endknoten dieses Pfades zu berechnen und wieder in den Stapel einzusortieren.

288

8 Faltungscodes

Beispiel 8.46 (ZJ-Decodierer) Zur Veranschaulichung ist in Bild 8.33 die Vorgehensweise des Decodierers angegeben. In der empfangenen Sequenz y[4+2] sind an den beiden gekennzeichneten Stellen Übertragungsfehler aufgetreten.

v[4+2] = y[4+2] =

(11 (10

0 1

−9 −9

00 : −18 01 : −18

1 00 01

−9 −18 −18

10

−7

100 : −16

100

101 : −16

101 00 01 11

−16

101 00 01 1000 1001 11

−16 −18 −18 −25 −25 −29

1010 : −36 1011 : −14

10110 00 01 1000 1001 11

−12 −18 −18 −25 −25 −29

101100 : −10 101101 : −38

00 01 11

10111 1010

−18 −18 −29

−34 −36

10 10

00 01

01 01

01 01

11) 11)

10 : −7 11 : −29

1000 : −25

−16 −18 −18 −29

1001 : −25

1011 00 01 1000 1001 11 1010

−14 −18 −18 −25 −25 −29 −36

10110 : −12 10111 : −34

101100 00 01 1000 1001 11

−10 −18 −18 −25 −25 −29

···

10111 1010 101101

−34 −36 −38

Abb. 8.33: Vorgehensweise des ZJ-Decodierers.

8.6 Sequentielle Decodierung

289

Tabelle 8.6: Regeln für den Fano-Decodierer. Letzte Bewegung Bedingung

Schwellenänderung Bewegung

V oder S Λt−1 < T + ∆, Λt ≥ T +∆ wenn möglich∗ V † V oder S Λt−1 ≥ T + ∆, Λt ≥ T keine V† V oder S Λt < T keine S oder R‡ R Λt−1 < T −∆ V† R Λt−1 ≥ T keine S oder R‡ ∗ Addiere j · ∆ zur Schwelle, falls j die Gleichung Λt − ∆ < T + j∆ ≤ Λt erfüllt. † Bewegung vorwärts zum ersten der 2k folgenden Knoten. ‡ Bewegung seitwärts. Falls letzter der 2k Knoten ⇒ Bewegung rückwärts. Als Metrik wird die im Beispiel 8.44 für den BSC hergeleitete Bitmetrik benutzt. Haben zwei Pfade dieselbe Metrik, wird der auf 0 endende Pfad über dem auf 1 endenden Pfad einsortiert. 

Bei der Realisierung eines ZJ-Decodierers muss sowohl die Stapellänge als auch die Pfadlänge begrenzt werden. Der Pfadspeicher jedes Stapelelements wird als Schieberegister festgelegter Länge realisiert. Dabei kann es vorkommen, dass wegen des limitierten Speichers der korrekte Pfad nicht mehr berücksichtigt wird. Das Einsortieren der berechneten Pfade in den unter Umständen sehr großen Stapel erfordert einen großen Rechenaufwand. In der Praxis werden deshalb oft Fächer von Pfaden gleicher Metrik eingeführt, um den Rechenaufwand zu verkleinern. Durch Änderung der Metrik kann der ZJ-Decodierer auch vorhandene Zuverlässigkeitsinformation integrieren (siehe Beispiel 8.45).

8.6.3

Fano-Decodierer

Ein weiterer sequentieller Decodieralgorithmus ist der Fano-Decodierer. Er speichert nur einen Pfad und läuft auf den Pfaden des Codebaumes (Bild 8.7) so vor und zurück, dass die Metrik des aktuellen Pfades einen Metrikschwellwert T nicht unterschreitet. Der Metrikschwellwert T ist eine variable Größe, die vom Decodierer laufend neu berechnet wird. Tabelle 8.6 zeigt die Regeln, die der Fano-Decodierer benutzt, um die Schwelle zu berechnen und um seitwärts (S), rückwärts (R), oder vorwärts (V ) zu gehen. Einem Pfad mit der Eindringtiefe t in den Codebaum wird die Metrik Λt zugeordnet. Die Anfangswerte für die Metrik sind Λ−1 = −∞, Λ0 = 0. Der Fano-Decodierer erhöht oder erniedrigt bei Bedarf die Schwelle um den Wert ∆. Die Schwellenänderung ∆ muss in Simulationen optimiert werden, um die Anzahl der Bewegungen im Codebaum und damit die Anzahl von erforderlichen Rechenoperationen zu minimieren. Der Decodierer merkt sich zusätzlich für jeden Knoten, wie viele der abgehenden Zweige er schon ausprobiert hat. Ein Beispiel für den Fano-Decodierer wird in Aufgabe 8.2 behandelt. Der Pfadspeicher für den Fano-Decodierer kann zwar sehr groß gemacht werden, da nur ein Pfad gespeichert wird, muss aber begrenzt werden, um die resultierende Zeitverzögerung zu verringern. Für schlechte Kanäle steigt die Anzahl der Decodierschritte pro decodiertem Zeichen sehr stark an, dagegen ist die Decodierung bei guten Kanälen sehr effektiv.

290

8 Faltungscodes

8.7

(Partial-) Unit-Memory-Codes, (P)UM-Codes

In diesem Abschnitt werden wir die Darstellung von Faltungscodes als Unit-MemoryCodes (UM-Codes) bzw. Partial-Unit-Memory-Codes (PUM-Codes) vorstellen. Diese geht auf Lee [Lee76] zurück. Dabei handelt es sich um Faltungscodes C(k, n, [ν]) mit Gedächtnisordnung m = 1. Für die Gesamteinflusslänge gilt ν ≤ k. Bei Gleichheit sprechen wir von UM-, sonst von PUM-Codes. Wir werden ein Verfahren zur Konstruktion solcher (P)UM-Codes vorstellen, wobei aus der Theorie der Blockcodes bekannte algebraische Konstruktionsmethoden verwendet werden. Diese (P)UM-Codes sind dann i. a. nicht binär und besitzen üblicherweise eine sehr große Gesamteinflusslänge ν. Wegen der hohen Zustandskomplexität im Viterbi-Trellis (im q-nären Fall ist die Anzahl der Zustände q ν ) ist eine ML-Decodierung dieser Codes zu aufwändig. Wir werden jedoch einen Algorithmus zur BMD-Decodierung dieser (P)UM-Codes beschreiben, der auf [Jus93] und [Det94] zurückgeht. Dabei können prinzipiell alle in Kapitel 7 beschriebenen Decodieralgorithmen für Blockcodes benutzt werden.

8.7.1

Definition von (P)UM-Codes

Betrachten wir zunächst die Informationsfolge i, die jetzt nicht notwendigerweise binär sein muss. Deshalb haben wir hier auch die Bezeichnung i statt u verwendet. Es gilt: (1)

(2)

(k0 )

i = (i0 , i1 , . . . , it , . . .) mit it = (it , it , . . . , it

),

(8.59)

(i)

wobei it ∈ GF (q) für i ∈ [1, k0 ]. Entsprechend bezeichnen wir die Codesequenz mit c anstelle von v: (1)

(2)

(n)

c = (c0 , c1 , . . . , ct , . . .) mit ct = (ct , ct , . . . , ct ),

(8.60)

(j)

wobei ct ∈ GF (q) für j ∈ [1, n]. Ein (P)UM-Code ist ein Faltungscode, bei dem ein Codeblock der Codefolge nur vom letzten und dem aktuellen Informationsblock abhängt. Für die entsprechende Abbildung gilt also ct = fkt(it−1 , it ). Definition 8.26 (Unit-Memory-Code) Seien Ga und Gb zwei (k0 × n)-Matrizen mit Rang k0 und Matrixelementen aus GF (q). Ein U M (n, k0 )-Code ist definiert durch: ct = it · Ga + it−1 · Gb ,

(8.61)

mit i−1 = 0, wobei it ∈ GF (q)k0 und ct ∈ GF (q)n gilt. Hat die Matrix Gb nicht vollen Rang, so ergibt sich ein sogenannter Partial-UnitMemory-Code. Definition 8.27 (Partial-Unit-Memory-Code) Seien Ga und Gb zwei (k0 × n)Matrizen mit Rang k0 und k1 < k0 mit Matrixelementen aus GF (q). Ein P U M (n, k0 |k1 )Code ist definiert durch: ct = it · Ga + it−1 · Gb ,

8.7 (Partial-) Unit-Memory-Codes, (P)UM-Codes

291

wobei für die beiden Generatormatrizen     G00 G10 Ga = und Gb = G01 0

(8.62)

gilt. Die Teilmatrizen G00 und G10 sind (k1 × n)-dimensional, G01 ist ((k0 − k1 ) × n)dimensional. Dabei gilt für den Rang der Teilmatrizen Rang(G00 ) = Rang(G10 ) = k1 und Rang(G01 ) = k0 − k1 . Mit dieser Definition ergibt sich die Berechnung eines Codewortblocks zu: ct = it · Ga + it−1 · Gb = (it , it−1 ) ·



Ga Gb



  G00 = (it,0 , it,1 , it−1,0 ) · G01  G10

(k −1) (k )

(0)

(8.63)

(k −1)

mit it = (it,0 |it,1 ) = (it , . . . , it 1 |it 1 , . . . , it 0 ), d. h. it,0 ∈ GF (q)k1 und it,1 ∈ GF (q)k0 −k1 . Bevor wir die Verbindung zu Blockcodes herstellen, wollen wir noch zeigen, dass jeder Faltungscode als (P)UM-Code dargestellt werden kann. Satz 8.28 (Faltungscode als UM-Code) Jeder Faltungscode kann als PUM- oder als UM-Code dargestellt werden. ˆ n und Gedächtnisordnung Beweis: Gemäß der Codierung eines Faltungscodes mit der Rate k/ˆ m in Gleichung (8.4), ergibt sich eine Codefolge v durch die Multiplikation der Informationsˆ d. h. v = u · G. ˆ Die folge u = (u0 , u1 , u2 , . . .) mit der halbunendlichen Generatormatrix G, Generatormatrix besitzt dabei folgende Form: 0 ˆ G0 B 0 B ˆ =B G @ 0 .. .

ˆ1 G ˆ0 G 0 .. .

··· ˆ1 G ˆ0 G .. .

1 ˆm 0 G 0 0 ··· ˆm 0 0 ···C ··· G C ˆ1 ··· G ˆm 0 ···C . G A .. .. . .

Offensichtlich existiert immer die Möglichkeit, die beiden Matrizen Ga und Gb eines (P)UMCodes wie folgt zu wählen: 0 ˆ ˆ ˆ m−1 1 G 0 G1 · · · G ˆ0 ··· G ˆ m−2 C B 0 G B C Ga = B . . .. C . .. .. @ .. . A ˆ 0 0 0 G0

und

0 ˆ Gm 0 ˆ m−1 G ˆm BG B Gb = B . .. @ .. . ˆ1 G ˆ2 G

1 ··· 0 ··· 0 C C C . .. . 0 A ˆm ··· G

Bei dieser Wahl gilt für Informations- und Codebock: (1)

(2)

(m·ˆ n)

ct = (ct , ct , . . . , ct

)

und

(1)

(2)

ˆ (k·m)

it = (it , it , . . . , it

).

Selbstverständlich gibt es zahllose weitere Möglichkeiten, indem man n > m · n ˆ wählt.

2

292

8 Faltungscodes

Blockcodes in einem (P)UM-Code: Wir interpretieren die Codesequenz c als Addition einer Folge von Codeworten at = it · Ga eines Blockcodes Ca mit einer Folge von Codeworten bt = it · Gb eines Blockcodes Cb . Es gelte: c0 = a 0 c1 = a1 + b0 .. . ct = at + bt−1 .. . Der Codeblock ct kann dann entweder als Codewort des Codes Cα mit der Generatormatrix Gα = (GTa GTb )T interpretiert werden, oder als Addition zweier Blockcodewörter der Codes Ca und Cb . Nehmen wir an, es sind Informationsblöcke bekannt, so ergeben sich die folgenden Aussagen: i) it−1 bekannt: Damit kann man aus dem Codewort ct das Codewort at berechnen, ct − it−1 · Gb = at ∈ Ca ,

(8.64)

und man könnte bezüglich des Codes Ca decodieren.

ii) it bekannt: Damit kann man aus dem Codewort ct das Codewort bt berechnen, ct − it · Ga = bt ∈ Cb ,

(8.65)

und man könnte bezüglich des Codes Cb decodieren. Diese Tatsache werden wir bei der BMD-Decodierung in Abschnitt 8.7.5 ausnutzen. Prinzipiell könnte man damit einen auf L Blöcke terminierten (P)UM-Code rekursiv decodieren, da i−1 = 0 und iL = 0 gilt. Das bedeutet, vorwärts betrachtet ist jeweils it−1 , t ∈ [−1, L − 1] bekannt und von hinten nach vorne betrachtet it , t ∈ [L, 0].

8.7.2

Trellis von (P)UM-Codes

Eine weitere Darstellungsmöglichkeit von (P)UM-Codes ist das Trellis. Dabei stellen die Zustandsübergänge genau die Codeblöcke ct dar. Demnach besteht ein Trellis eines UM-Codes aus q k0 Zuständen σt zu jedem Zeitpunkt t > 0. Jeden Zustand verlassen q k0 Pfade, von denen genau einer zu jedem der q k0 Folgezuständen führt. Dagegen besteht ein Trellis eines PUM-Codes aus q k1 Zuständen in jeder Tiefe, und zwischen zwei aufeinanderfolgenden Zuständen existieren q k0 −k1 parallele Übergänge. Beispiel 8.47 (Trellis der Codes PUM(3, 2|1) und UM(3, 2)) Bild 8.34 zeigt den prinzipiellen Aufbau eines Trellis eines UM(3, 2)-Code. Er besitzt 2k0 = 4 Zustände, und jeder Zustand der Tiefe t ist mit allen Zuständen der benachbarten Tiefen verbunden.

8.7 (Partial-) Unit-Memory-Codes, (P)UM-Codes σ0

σ1

293

σ2

σ3

Abb. 8.34: Trellis des UM(3, 2)-Codes. σ0

d01

σ1

σ2

σ3

d0 dα d1

Abb. 8.35: Trellis des PUM(3, 2|1)-Codes. Ein Trellis für den PUM(3, 2|1) ist in Bild 8.35 dargestellt. Dieser besitzt 2k1 = 2 Zustände und jeweils 2k0 −k1 = 2 parallele Übergänge. Im Bild sind außerdem die Distanzmaße eingetragen, die wir im nächsten Abschnitt erläutern werden. 

Es ist offensichtlich, dass diese Darstellung von (P)UM-Codes für q > 2 und große k0 bzw. k0 − k1 zu einem sehr komplexen Trellis führt. Damit ist die eine ML-Decodierung mit dem Viterbi-Algorithmus sehr aufwändig. Wir werden deshalb in Abschnitt 8.7.5 einen Algorithmus zur BMD-Decodierung angeben.

8.7.3

Distanzmaße bei (P)UM-Codes

Die erweiterten Distanzmaße für Faltungscodes wurden ursprünglich für (P)UM-Codes eingeführt, siehe [TJ83]. Wir wollen hier die Distanzmaße einheitlich darstellen und daher die Definitionen für Faltungscodes aus Abschnitt 8.3 für (P)UM-Codes übernehmen. Dazu definieren wir im Falle eines PUM-Codes die folgenden zunächst die folgenden Blockcodes anhand ihrer Generatormatrizen und deren minimale Distanzen: T d0 = dist(Ca ) mit C0 = Ca : G0 = Ga = GT00 GT01 T d1 = dist(C1 ) mit C1 : G1 = GT01 GT10 (8.66) d01 = dist(C01 ) mit C01 : G01 = G01 T dα = dist(Cα ) mit Cα : Gα = GT00 GT01 GT10 Für UM-Codes ergeben sich die entsprechenden Definitionen. Im Trellis können die Distanzmaße gemäß Bild 8.35 wie folgt interpretiert werden: 1. d01 ist die Mindestdistanz zwischen den q k0 −k1 parallelen Zweigen. 2. d0 ist die Mindestdistanz zwischen allen Codeblöcken, die denselben Startzustand besitzen.

294

8 Faltungscodes

3. d1 ist die Mindestdistanz zwischen allen Codeblöcken, die in denselben Endzustand münden. 4. dα ist die Mindestdistanz zwischen allen Codeblöcken, die weder gleichen Start-, noch gleichen Endzustand besitzen. Erweiterte Zeilen-, Spalten- und Segmentdistanz: Die erweiterten Distanzen wurden in Abschnitt 8.3 für Faltungscodes definiert. Für (P)UM-Codes können wir nun eine untere Schranke für diese angeben: • Geschätzte erweiterte Zeilendistanz der j : der 1 = d01 der j ≥ d0 + (j − 2)dα + d1 ,

j > 1.

(8.67)

• Geschätzte erweiterte Spaltendistanz dec j : dec ≥ d0 + (j − 1)dα , j

j ≥ 1.

(8.68)

• Rückwärtige geschätzte erweiterte Spaltendistanz drec j : drec = d1 + (j − 1)dα , j

j ≥ 1.

(8.69)

• Geschätzte erweiterte Segmentdistanz des j : des ≥ j · dα , j

j ≥ 1.

(8.70)

Mit diesen unteren Schranken der erweiterten Distanzen kann die Fehlerkorrektureigenschaft von (P)UM-Codes beurteilt, und die Qualität von konstruierten Codes analysiert werden.

8.7.4

Konstruktion von (P)UM-Codes

Bei der Konstruktion von (P)UM-Codes aus Blockcodes wählt man einen bekannten Blockcode für Cα . Dieser wird dann derart in drei Teile aufgeteilt, dass die Distanzen d1 , d0 , d01 der entsprechenden Teilcodes die maximal möglichen Werte annehmen. Im allgemeinen ist die Bestimmung dieser optimalen Dreiteilung nicht einfach berechenbar. Die im Folgenden vorgestellten Konstruktionen basieren darauf, dass die Distanzmaße der ihnen zugrunde liegenden Blockcodes und deren Untercodes bekannt sind. (P)UM-Codes auf der Basis von RS-Codes: Einen auf RS-Codes basierenden (P)UM-Code der Länge n, Dimension k0 und Gesamteinflusslänge k1 wollen wir im Folgenden als RSPUM(n, k0 | k1 ) bezeichnen. Er wird wie folgt konstruiert: 1. Wähle für G00 die Generatormatrix eines RS-Codes der Länge n, für dessen transformierte Codeworte gilt: Cj = 0, für j = k1 , k1 + 1, . . . , n − 1.

8.7 (Partial-) Unit-Memory-Codes, (P)UM-Codes

295

2. Wähle für G10 die Generatormatrix eines RS-Codes der Länge n, für dessen transformierte Codeworte gilt: Cj = 0, für j = 0, . . . , k0 − 1 und j = k0 + k1 , k0 + k1 + 1, . . . , n − 1. 3. Wähle für G01 die Generatormatrix eines RS-Codes der Länge n, für dessen transformierte Codeworte gilt : Cj = 0, für j = 0, . . . , k1 −1 und j = k0 , k0 +1, . . . , n−1. Die Distanzen der Untercodes sind dann: d01 d0 d1 dα

= n − (k0 − k1 ) + 1, = n − k0 + 1, = n − k0 + 1, = n − (k0 + k1 ) + 1.

Für die freie Distanz des (P)UM Codes gilt dann folgende Abschätzung: PUM-Code: df ≥ n − (k0 − k1 ) + 1;

UM Code: df ≥ 2 · (n − k0 + 1).

Beispiel 8.48 ((P)UM-Codes auf der Basis von RS-Codes) Wir benutzen RS-Codes der Länge 7 über GF (23 ). Die entsprechenden Generatorpolynome des PUM-Codes lauten wie folgt: g00 (x) = (x − α2 ) · (x − α3 ) · (x − α4 ) · (x − α5 ) · (x − α6 ), g01 (x) = (x − α0 ) · (x − α1 ) · (x − α4 ) · (x − α5 ) · (x − α6 ),

g10 (x) = (x − α0 ) · (x − α1 ) · (x − α2 ) · (x − α3 ) · (x − α6 ) . (0)

(1)

Das Informationspolynom it (x) wird aufgespalten in it (x) und it (x), also it (x) = it,0 + (0) (1) (0) (0) (1) (1) it,1 x + it,2 x2 + it,3 x3 = it (x) + it (x) = it,0 + it,1 x + it,0 x2 + it,1 x3 . Damit lautet die Codiervorschrift: (0)

(1)

(0)

ct (x) = it (x) · g00 (x) + it (x) · g01 (x) + it−1 (x) · g10 (x) (0)

(1)

= at (x) + at (x) + bt (x) , (0)

(1)

wobei it (x) und it (x) den Grad 2 haben. Man beachte, dass aufgrund der Konstruktion (0) (1) aus einem gegeben ct (x), alle Codeworte (at (x), at (x) und bt (x)) explizit berechnet werden können; siehe hierzu auch Beispiel 9.39 und Bild 9.30 in Abschnitt 9.4.1. Der PUM-Code hat die Parameter k = 4 und k1 = 2 sowie die Distanzen df ≥ n − (k − k1 ) + 1 = 7 − (4 − 2) + 1 = 6

dα ≥ n − (k + k1 ) + 1 = 7 − (4 + 2) + 1 = 2 .

und 

(P)UM-Codes auf der Basis von BCH-Codes: Die transformierten Codeworte eines BCH-Codes enthalten nicht nur eine zusammenhängende Sequenz von Stellen gleich Null, sondern zu jeder Nullstelle noch alle konjugierten komplexen Stellen, entsprechend der Kreisteilungsklasse (Abschnitt 4.1.1). Das

296

8 Faltungscodes 0

g00 (x) g01 (x) g10 (x)

1

2

3

4

5

6

0 0 0 0 0 0 0

7

8

9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30

0 0 0

0

0 0 0 0

0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

0

0 0

0

0

0 0

0 0 0 0 0 0 0

0 0 0 0

0

0 0 0

0

0 0 0

0 0 0

0 0 0 0 0 0

Abb. 8.36: Transformierte der Generatorpolynome der RM-Codes.

Problem bei der Konstruktion eines (P)UM-Codes aus BCH-Codes ist daher, die Generatorpolynome des Codes Cα und seiner Untercodes so zu bestimmen, dass in den entsprechenden transformierten Stellen möglichst viele zusammenhängende Stellen gleich Null existieren. 1. Bilde einen BCH-Code der Länge n mit der Distanz dα durch Nullsetzen von dα −1 aufeinanderfolgende Stellen und ihrer konjugiert komplexen im transformierten Bereich. 2. Teile die Informationsstellen dieses Codes so auf die Codes C0 , C10 und C1 auf, dass die freie Distanz df maximiert wird. Aufgrund der Abhängigkeiten der zueinander konjugierten komplexen Codesymbole, lässt sich kein geschlossener Ausdruck für die freie Distanz des entstehenden Codes angeben. Beispiel 8.49 ((P)UM-Codes auf der Basis von BCH-Codes) Wir wollen PUM-Codes auf der Basis von BCH-Codes der Länge 15 konstruieren (siehe [DS92]). Entsprechend Abschnitt 4.1.1, Beispiel 4.1, seien die irreduziblen Polynome mi (x) der zugehörigen Kreisteilungsklassen Ki m0 (x), m1 (x), m3 (x), m5 (x) und m7 (x) gegeben. Wir wählen die Generatorpolynome des PUM-Codes zu: g00 (x) = m0 (x) · m1 (x) · m5 (x) · m7 (x) g01 (x) = m0 (x) · m3 (x) · m7 (x) g10 (x) = m0 (x) · m1 (x) · m3 (x) · m5 (x) . Der konstruierte PUM-Code ist C(n = 15, k = 10|k1 = 4) mit der freien Distanz df = 6. Siehe hierzu auch Beispiel 9.40 in Abschnitt 9.4.1 und Bild 9.31. 

(P)UM-Codes auf der Basis von RM-Codes: RM-Codes können als verlängerte BCH-Codes interpretiert werden. Entsprechend konstruiert man (P)UM-Codes, die auf RM-Codes basieren, indem man zunächst BCHUntercodes nach der oben beschriebenen Methode bestimmt und dann jeden der Teilcodes um eine Codestelle erweitert. Die Distanz der resultierenden RM-Codes ist dann um eins größer als die Distanz der BCH-Codes aus denen sie hervorgegangen sind. Beispiel 8.50 ((P)UM-Codes auf der Basis von RM-Codes) Wir bestimmen zunächst die Generatorpolynome von BCH-Codes der Länge 31 entsprechend Bild 8.36.

8.7 (Partial-) Unit-Memory-Codes, (P)UM-Codes

297

g00 (x) = m0 (x) · m1 (x) · m3 (x) · m5 (x) · m15 (x) g01 (x) = m1 (x) · m3 (x) · m5 (x) · m7 (x) · m11 (x) g10 (x) = m0 (x) · m1 (x) · m7 (x) · m11 (x) · m15 (x) . Anschließend verlängern wir jeden dieser Subcodes um ein Paritätsbit. Die resultierenden neuen Codes sind dann durch die Generatormatrizen G00 , G01 und G0 G01 definiert einen 10 bestimmt. 1 „ « G00 G00 R(1, 5)-Code, G0 = einen R(2, 5)-Code, und Gα = @G01 A definiert einen R(3, 5)G01 G10 Code. Der resultierende PUM-Code besitzt die Parameter n = 32, k = 16, k1 = 10, dα = 4 und df = 16. Diese Konstruktion kann nach [Jus93] für beliebige Längen n = 2m mit ungeradem m angewendet werden. 

Diese und weitere Konstruktionsmethoden kann man in [Det94, DS93] und [DS92] finden. Speziell für PUM-Codes basierend auf RM-Codes werden in [ZP91] und [Mau95] einige Konstruktionen vorgeschlagen.

8.7.5

BMD-Decodierung

Die ML-Decodierung von Faltungscodes wurde in Abschnitt 8.4 erläutert und ist, wie schon erwähnt, wegen der exponentiell anwachsenden Decodierkomplexität in der Regel nicht für (P)UM-Codes anwendbar. In [Jus93] und [Det94] wurde gezeigt, dass ein HardDecision BMD-Decodierer für (P)UM-Codes durch folgende Schritte realisiert werden kann. Dazu nehmen wir an, dass ein Codewort c eines auf L Blöcke terminierten (P)UMCodes gesendet und der Vektor r (hard decision) empfangen wurde. 0

1

2

3

4

5

6

7

8

Abb. 8.37: Schritt 1: Decodierung gemäß Cα .

Schritt 1: Decodiere jeden Block rt , t = [0, L − 1], gemäß dem Code Cα . Dabei werden die Blöcke zunächst als unabhängig voneinander betrachtet. Das Ergebnis der ˆt , t = [0, L−1]. Man beachte, dass im fehlerfreien Fall der AnfangsDecodierung sei c ˆt dem Endzustand von c ˆt−1 entspricht und außerdem der Endzustand zustand von c ˆt dem Anfangszustand von c ˆt+1 . Ein mögliches Ergebnis einer Decodierung von c bei aufgetretenen Fehlern ist schematisch in Bild 8.37 dargestellt. Drei Endzustände stimmen mit drei Startzuständen überein. Ergeben sich in Tiefe t mehrere Zustände, so kann man schließen, dass Blöcke falsch decodiert wurden, nicht jedoch welche. ˆt aus, der nicht gleich dem Anfangszustand von Schritt 2: Von jedem Endzustand von c ˆt+1 ist, decodiere rt+i , i = 1, 2, . . ., gemäß Code C0 (Gleichung (8.65)). Dies wird c solange durchgeführt, bis ein Zustand erreicht wird, der schon in Schritt 1 decodiert

298

8 Faltungscodes 0

1

2

3

4

5

6

7

8

Abb. 8.38: Schritt 2: Vorwärtsdecodierung (C0 ) und Rückwärtsdecodierung (C1 ).

wurde. Danach wird entsprechend rückwärts decodiert, d. h. von jedem Anfangsˆt aus, der nicht gleich dem Endzustand von c ˆt+1 ist, decodiere rt−i , zustand von c i = 1, 2, . . ., gemäß Code C1 (Gleichung (8.64)). Auch dies wird solange durchgeführt, bis ein Zustand erreicht wird, der schon in Schritt 1 decodiert wurde. Dies bedeutet, dass die Vorwärtsdecodierung gemäß des Codes C0 und die Rückwärtsdecodierung gemäß C1 durchgeführt wird, die beide i. a. bessere Distanzen besitzen als der Code Cα . Dies ist schematisch in Bild 8.38 dargestellt. 0

1

2

3

4

5

6

7

8

Abb. 8.39: Schritt 3: ML-Decodierung im reduzierten Trellis.

Schritt 3: Im Falle von Partial Unit Memory Codes kann als weiterer Schritt die Decodierung im Blockcode C01 durchgeführt werden. Dieser Code ist durch die Generatormatrix G01 (siehe Gleichung (8.66)) definiert. Um rt in diesem Code zu decodieren, nehmen wir an, wir kennen die ersten k1 (1) (2) (k ) Informationssybole (it , it , . . . , it 1 ) aus Schritt 1 des Decodieralgorithmus und den gesamten Informationsvektor it−1 aus Schritt 1 oder 2. Damit können wir rt wie folgt modifizieren: (1)

(2)

(k1 )

rt − (it , it , . . . , it (k1 )

= (it

(k1 +1)

, it

(1)

(2)

(k )

1 ) · G00 − (it−1 , it−1 , . . . , it−1 ) · G10

(k)

, . . . , it ) · G01 + et .

Diesen modifizierten Empfangsblock können wir nun im gemäß C01 decodieren. Dieser hat eine noch größere Mindestdistanz als C0 und C1 . Im Fall von Unit Memory Codes ist allerdings k1 = k und damit entfällt dieser Schritt. Schritt 4: Hier wird zunächst aus allen Knoten, die durch Schritt 1 und Schritt 2 entstanden sind, ein vollständiger Graph aufgebaut, d. h. alle Knoten werden miteinander verbunden. Nun wird in dem so konstruierten Trellis der Viterbi-Algorithmus

8.8 Tabellen guter Codes

299

durchgeführt und damit der beste Pfad dieses reduzierten Trellis ausgewählt. Dies ist in Bild 8.39 veranschaulicht.

U. a. in [Det94] ist bewiesen, dass dieses Hard-Decision-BMD-Decodierverfahren alle Fehler e = (e0 , e1 , . . . eL−1 ) korrigieren kann, solange für deren Gewicht gilt: j+l−1 X

wt(et ) < der (l)/2.

t=j

Die BMD-Decodierung ermöglicht es, Codes zu decodieren, die wegen der Komplexität keinesfalls mit einem Viterbi-Algorithmus decodierbar wären. Man kann das Verfahren in die Klasse der Listendecodierer (Abschnitt 7.4.3) einordnen. Betrachtet man einen Faltungscodes als (P)UM-Code und wendet darauf die BMD-Decodierung an, so ist das Ergebnis in der Regel sehr schlecht im Vergleich zu ML-Decodierung. Der Grund hierfür ist die in der Regel dabei sehr kleine Distanz dα . Zur Verwendung von Soft-Decision-Decodierverfahren für die beteiligten Blockcodes existieren wenig Veröffentlichungen. Es ist damit ein ungelöstes Problem, welche Ergebnisse die Ersetzung der Hard-Decision-Decodierung von Cα , C0 und C1 durch eine Soft-Decision-MAP-Decodierung liefern würde.

8.8

Tabellen guter Codes

Hier wollen wir einige Tabellen mit guten Faltungscodes vorstellen. Dabei handelt es sich um keine vollständige Auflistung aller guten bekannten Faltungscodes, sondern nur um eine sehr begrenzte Auswahl. Diese wurde so getroffen, dass einerseits einige der gebräuchlichsten Codes vorgestellt werden und dem Leser für den praktischen Gebrauch zur Verfügung stehen, als auch, um die Notation vorzustellen, welche für diese Codetabellen verwendet wird. Vollständige Codetabellen sind in den später zitierten Veröffentlichungen zu finden. Im Gegensatz zu Blockcodes existiert für Faltungscodes kein konstruktives Verfahren, um Klassen guter Codes zur Verfügung zu stellen. Einzige Ausnahme bildet hierbei die (P)UM-Codekonstruktion aus Abschnitt 8.7. (P)UM-Codes besitzen jedoch derzeit geringe praktische Relevanz. Üblicherweise sind alle anderen bekannten Faltungscodes mit Hilfe von computergestützten Codesuchen ermittelt worden. Die Tabellierung von Faltungscodes C(n, k, [ν]) erfolgt stets nach Rate R = k/n und Gesamteinflusslänge ν sortiert und durch Angabe einer minimalen Basisgeneratormatrix Gmb (D) des Codes. Diese (k×n)-dimensionalen Matrix stellen wir mit n oktalen Zahlen (j) OG mit j ∈ [1, n] dar. Dazu folgendes Beispiel:

300

8 Faltungscodes

Beispiel 8.51 (Darstellung von Faltungscodes durch Oktalzahlen) Die minimale Basisgeneratormatrix G(D) kann folgendermaßen dargestellt werden: „ « 1+D D 1 G(D) = = 2 2 D+D 1 1+D „ « „ « „ « 1 0 1 1 1 0 0 0 0 = +D + D2 0 1 1 1 0 0 1 0 1 = G0 + DG1 + D2 G2 Führt man nun die folgende Matrix ein, 0 1T 0 1 0 1 G0 1 0 1 1 0 1 (55)8 ˆ = @G1 A = @0 1 1 0 0 0A = @(30)8 A , G G2 1 1 0 0 0 1 (61)8 dann kann diese (2×n)-dimensionale Generatormatrix G(D) mittels den drei oktalen Nummern (55, 30, 61) dargestellt werden, wobei gegebenenfalls mit Nullen von links ergänzt wird. 

Unter guten Faltungscodes versteht man solche, die unter allen Codes gleicher Rate R = k/n und gleicher Gesamteinflusslänge ν die besten Distanzeigenschaften besitzen. Dazu betrachten wir die Distanzfunktion T (W ) =

+∞ X

N (w)W w

w=df

= N (df ) · W df + N (df + 1) · W df +1 + N (df + 2) · W df +2 + · · · bzw. das Distanzspektrum N (w) mit w ∈ [df , +∞[ des Codes (siehe Gleichung (8.10) auf Seite 230 im Abschnitt 8.1.6). Der beste Code hat demnach die maximale freie Distanz df . Existieren mehrere Codes mit gleicher freie Distanz, so wird derjenige mit dem kleineren Wert N (df ) ausgewählt. Sind die beiden Codes auch in diesem Term identisch, werden schrittweise höhere Terme N (w) betrachtet. Codes mit dieser Eigenschaft werden als Optimum-Free-Distance (OFD)-Codes bezeichnet. Diese sind die asymptotisch besten Codes gegebener Rate und Gesamteinflusslänge bei Verwendung von ML- und MAP-Decodierung. Alternativ dazu kann die Optimierung auch bzgl. des Distanzprofils (siehe Definition 8.17 auf Seite 260 im Abschnitt 8.3.1) erfolgen und man erhält die OptimumDistance-Profile (ODP)-Codes. Diese sind bei dem Einsatz von sequentiellen Decodierverfahren den OFD-Codes vorzuziehen. Einige OFD-Codes der Rate R = 1/n (Tabelle 8.7): Eine umfangreichere Liste von OFD-Codes der Rate R = 1/n ist in [Pal95] zu finden. Beim Einsatz von ML- und MAP-Decodierung beschränkt die im Trellis des Codes mit ν exponentiell anwachsende Zustandskomplexität die Auswahl auf solche Codes mit kleiner Gesamteinflusslänge: typisch sind ν ∈ [2, 8], wobei technisch allerdings auch

8.8 Tabellen guter Codes

301

Tabelle 8.7: Einige OFD-Faltungscodes der Rate R = 1/n mit n ∈ [2, 4] (aus [Pal95]). (1)

OG

(2)

OG

(3)

R

m

OG

1/2

2 3 4 5 6 7 8

5 15 23 53 133 247 561

7 17 35 75 171 371 753

1/3

2 3 4 5 6 7 8

5 13 25 47 133 225 557

7 15 33 53 145 331 663

7 17 37 75 175 367 711

1/4

2 3 4 5 6 7 8

5 13 25 53 135 235 463

7 15 27 67 135 275 535

7 15 33 71 147 313 733

(4)

OG

df 5 6 7 8 10 10 12 8 10 12 13 15 16 18

7 17 37 75 163 357 745

10 13 16 18 20 22 24

größere Werte realisierbar sind. In den meisten Anwendungen kommen derzeit die in der Tabelle 8.7 dargestellten Codes der Rate R = 1/n mit n ∈ [2, 4] zum Einsatz. Einige OFD-Codes der Rate R = k/n (Tabelle 8.8):

Üblicherweise werden Faltungscodes der Rate R = k/n für k > 1 durch Punktierung eines Muttercodes der Rate R = 1/n erzeugt (siehe Abschnitt 8.1.10 auf Seite 241). Damit lassen sich in den meisten Fällen sehr gute Distanzeigenschaften erzielen. Des weiteren ist die Decodierung im Trellis des Muttercodes, insbesondere bei sehr hochratigen punktierten Codes, weniger aufwendig als im Trellis des hochratigen Codes. Dennoch werden wir in Tabelle 8.8 einige Codes der Rate R = k/n angeben, die nicht aus der Punktierung eines Muttercodes hervorgehen. Ausführlichere Tabellen sind in [LiCo] zu finden. Einige niederratige OFD-Codes mit m = 4 (Tabelle 8.9): Niederratige Faltungscodes der Rate R = 1/n werden mit n Generatorpolynomen erzeugt. Dabei handelt es sich meist um die gleichen Polynome, die auch schon bei den entsprechenden höheren Raten zu guten Codes führten. Ausführliche Tabellen sind in [Pal95] zu finden. Berechnungsvorschrift für OFD-Codes der Rate R = 1/n mit Gedächtnisordnung m = 2 und m = 3 (Tabelle 8.10): Für diese beiden Fälle kann für die Generatorpolynome eine allgemeine Berechnungsvorschrift angegeben werden.

302

8 Faltungscodes Tabelle 8.8: Einige OFD-Codes der Rate R = 2/3 und R = 3/4 (aus [LiCo]). (1)

(2)

OG

(3)

R

m

ν

OG

2/3

1 2 2 3 3

2 3 4 5 6

13 55 56 245 266

6 30 23 150 171

16 61 65 375 367

3/4

1 2 2

3 5 6

400 442 472

630 270 215

521 141 113

(4)

OG

OG

df 3 4 5 6 7

701 763 764

4 5 6

Tabelle 8.9: Niederratige OFD-Codes mit Gedächtnisordnung m = 4 (aus [Pal95]). R 1/5 1/6 1/7 1/8 1/9 1/10

(1)

OG

25 25 25 25 25 25

(2)

OG

27 27 27 25 25 25

(3)

OG

33 33 27 27 27 25

(4)

(5)

OG

(6)

OG

35 35 33 33 33 33

OG

37 35 35 33 33 33

(7)

OG

37 35 35 35 33

37 37 35 35

(8)

OG

37 37 37

(9)

OG

37 37

(10)

OG

37

df 20 24 28 32 36 40

Tabelle 8.10: Allgemeine Berechnungsvorschrift für OFD-Codes mit m ∈ [2, 3] (aus [Pal95]). (1)

(2)

Rate R

OG

OG

1/3n 1/(3n + 1) 1/(3n + 2)

5n 5n+1 5n+1

72n 72n 72n+1

1/3n 1/(3n + 1) 1/(3n + 2)

13n 13n 13n

15n 15n+1 15n+1

(3)

OG

df 8n 8n + 2 8n + 5

17n 17n 17n+1

10n 10n + 3 10n + 6

Einige OFD-Codes mit polynomiellen systematischen Generatormatrizen (Tabelle 8.11): Selbstverständlich können alle bisher vorgestellten Codes auch systematisch codiert werden. Jedoch sind die entsprechenden Generatormatrizen i. a. gebrochen-rational (siehe Abschnitt 8.2.7 auf Seite 256). Die hier vorgestellten Codes haben zwar schlechtere Distanzeigenschaften als andere gute Codes mit gleicher Rate und Gesamteinflusslänge, besitzen allerdings eine polynomielle systematische Generatormatrix. Ausführliche Tabellen solcher Codes sind in [JZ99] zu finden. Beispiel für die Tabellierung von punktierten Codes (Tabelle 8.12): Eine bedeutende Rolle bei praktischen Anwendungen spielen punktierte Faltungscodes und die Klasse der RCPC-Codes (rate compatible punctured convolutional codes) [Hag88]. Die RCPC-Codes stellen eine Menge von punktierten Codes mit gleicher Periodizität der Punktierungsmatrix dar. Dabei kann jeder höherratige Code aus jedem

8.9 Anmerkungen

303

Tabelle 8.11: Systematische Faltungscodes der Rate R = 1/2 (aus [JZ99]). m 1 2 3 4 5 6 7 8

(2)

df

3 7 15 35 73 153 153 715

3 4 4 5 6 6 6 7

OG

Tabelle 8.12: Einige punktierte Codes (aus [Lee94]). Muttercode (1) (2) m OG OG 2

3

6

5

7

5

7

5

7

5

7

15

17

15

17

15

17

15

17

133

171

133

171

133

171

133

171

punktierter Code Punktierungsmatrix Rate R ” 1 0 1 1 “ ” 1 1 0 1 0 1 “ ” 1 0 0 1 1 1 1 0 “ ” 0 0 0 0 1 1 1 1 1 1 “ ” 1 1 0 1 “ ” 0 1 1 1 1 0 “ ” 1 1 1 0 1 0 0 1 “ ” 1 0 0 1 0 0 1 1 1 1 “ ” 1 1 1 0 “ ” 1 1 0 1 0 1 “ ” 1 1 1 1 1 0 0 0 “ ” 1 1 1 1 1 1 0 0 0 0 “

df

2/3

3

3/4

3

4/5

2

5/6

2

2/3

4

3/4

4

4/5

3

5/6

3

2/3

6

3/4

5

4/5

4

5/6

3

niederratigeren durch Punktierung erzeugt werden. Im folgenden werden wir ein Beispiel angeben, wie solche Codes tabelliert werden. Weitere Schemata sind in [Lee94] zu finden.

8.9

Anmerkungen

Faltungscodes wurden erstmals durch Elias [Eli55] im Jahre 1955 beschrieben. In [WoRe] wurde dann ein sequentielles Decodierverfahren vorgeschlagen, um Faltungscodes effizient zu decodieren. Im Jahre 1963 hat Massey in [Mas] eine suboptimale Schwellwertdecodierung (threshold decoding) für Faltungscodes eingeführt, deren Vorteil ein höchst einfacher Algorithmus war. Im selben Jahr beschrieb Fano in [Fano63] eine neue Variante der sequentiellen Decodierung, die unter dem Namen Fano-Algorithmus bekannt wurde. Ein weiterer Algorithmus zur sequentiellen Decodierung wurde im Jahre 1966 von Zi-

304

8 Faltungscodes

gangirov [Zig66] und später, im Jahre 1969, von Jelinek [Jel69] veröffentlicht. Dieser ist unter dem Namen Stack-Algorithmus bekannt und wir haben ihn als ZJ-Algorithmus bezeichnet. Damit war der Weg für praktische Anwendungen von Faltungscodes zur digitalen Datenübertragung geöffnet. Ein weiterer Decodieralgorithmus wurde im Jahre 1967 von Viterbi [Vit67] veröffentlicht. Durch Forney wurde später gezeigt ([For73], [For74]), dass dieser Algorithmus eine Maximum-Likelihood-Decodierung von Faltungscodes durchführt. Sowohl sequentielle wie auch Viterbi-Decodierung liefern eine Hard-Decision, also ein entschiedenes Symbol und keine Zuverlässigkeit für die Entscheidung. Dies stellt u. a. bei Codeverkettung eine große Einschränkung dar. Der im Jahre 1974 von Bahl, Cocke, Jelinek und Raviv vorgeschlagene BCJR-Algorithmus [BCJR74] besitzt diese Einschränkung nicht. Er liefert für jedes Symbol die Maximum-a-posteriori-Wahrscheinlichkeit. Im Jahre 1989 hat Hagenauer einen modifizierten Viterbi-Algorithmus, den sogenannten SOVA [Hag90] vorgeschlagen, der ebenfalls in der Lage ist zusätzlich zu den entschiedenen Symbolen, ein Maß für deren Zuverlässigkeit zu berechnen. Faltungscodes finden in vielen Systemen Anwendung. Um nur ein Beispiel zu nennen, werden im Europäischen Mobilfunkstandard GSM die beiden Faltungscodes (1 + D3 + D4 , 1 + D + D3 + D4 ) mit der Rate 1/2 und (1 + D2 + D4 , 1 + D + D3 + D4 , 1 + D + D2 + D3 + D4 ) mit der Rate 1/3 verwendet. Hierbei ist jeweils die Gesamteinflusslänge gleich der Gedächtnisordnung (m = ν = 4). In diesem Kapitel haben wir zunächst die elementaren Begriffe und Definitionen zu Faltungscodes angegeben. Dabei haben wir unterschieden zwischen Code, Generatormatrix und Codierer. Wir haben die Betrachtung als LTI-System beschrieben und die Darstellung als FIR- und IIR-System erläutert. Eine wichtige Klassifikation war die in systematische und katastrophale Generatormatrizen. Des weiteren haben wir die Darstellungsformen Trellis, Codebaum und Zustandsdiagramm erörtert und daraus einige Distanzmaße abgeleitet. Im zweiten Abschnitt haben wir dann die algebraische Beschreibung von Faltungscodes dargestellt. Hierbei wurden einige Begriffe aus dem ersten Abschnitt präzisiert und formal hergeleitet. Zusätzlich wurden die Basisgeneratormatrix und die minimale Basisgeneratormatrix definiert, die gewissermaßen eine normierte Darstellung der äquivalenten Generatormatrizen darstellt, nämlich die mit der geringsten Zustandskomplexität. Auch konnte hier die Prüfmatrix und der duale Faltungscode eingeführt werden. Dieser Abschnitt basiert im wesentlichen auf der Arbeit [JW93] von Johannesson und Wan bzw. auf der Vorveröffentlichung des Buches [JZ99]. Nach einem Abschnitt zu den Distanzmaßen haben wir den Viterbi-Algorithmus zur ML-Decodierung von Faltungscodes beschrieben. Dieser gehört mit zu den bekanntesten Algorithmen und kann für viele Zwecke verwendet werden, u. a. zur Entzerrung von Mehrwegekanälen. Da jedoch zunehmend nicht nur eine Symbolentscheidung, sondern auch deren Zuverlässigkeit praktische Bedeutung erlangt, werden andere Algorithmen benötigt. Dazu haben wir den SOVA und den BCJR-Algorithmus beschrieben, die beide in der Lage sind, neben der Symbolentscheidung ein Maß für die Zuverlässigkeit dieser Entscheidung zu berechnen. Eine gute Näherung des BCJR-Algorithmus stellt der MaxLog-Algorithmus dar, der weniger komplex ist und deshalb für einen praktischen Einsatz geeignet ist.

8.9 Anmerkungen

305

Die sequentielle Decodierung hat die Eigenschaft, dass der Decodieraufwand vom SignalRauschverhältnis des Kanals abhängt. Je weniger gestört ein Kanal ist, desto weniger Aufwand benötigt die Decodierung. Obwohl dies ein interessanter Aspekt für praktische Anwendungen ist, sind sequentielle Decodierverfahren nicht sehr verbreitet, auch wenn mit dem Fano- oder ZJ-Algorithmus Faltungscodes mit wesentlich größerer Gesamteinflusslänge decodiert werden können. Bei (P)UM-Codes können Methoden von Blockcodes verwendet werden, um Faltungscodes mit festgelegten Distanzeigenschaften zu konstruieren. Leider ist dann keine MLsondern nur noch eine BMD-Decodierung praktikabel, was eine Einschränkung darstellt. In Abschnitt 8.8 haben wir noch Tabellen guter Faltungscodes aufgelistet, die für den praktischen Gebrauch gedacht sind. In manchen Fällen werden Codes mit bestimmten Raten benötigt, die durch die Methode der Punktierung aus guten Faltungscodes erzeugt werden können. Einige Tabellen hierzu sind ebenfalls aufgelistet und weitere Literaturstellen sind in [Lar73, Joh75]

8.10

Übungsaufgaben

Aufgabe 8.1 Gegeben sei der folgende Faltungscodierer:

u

v

a) Geben Sie das Zustandsdiagramm des Codierers an. b) Ermitteln Sie die freie Distanz df . c) Geben Sie das Trellisdiagramm des Codierers an. d) Eine empfangene Folge sei (11 00 10 01 01 00 00 . . .). Ermitteln Sie die gesendete Folge mit Hilfe des Viterbi-Algorithmus.

306

8 Faltungscodes

Aufgabe 8.2 Gegeben sei der folgende Faltungscodierer:

v(1) u

v v(2)

Eine empfangene Folge sei 10 10 11 11 . . .. Geben Sie anhand eines Codebaums und einer Tabelle die Schritte an, die ein Fano-Decodierer durchführt, um die gesendete Codefolge zu ermitteln. Wählen Sie ∆ = 6. Die Bitfehlerwahrscheinlichkeit des Kanals beträgt p = 0.1.

9

Verallgemeinerte Codeverkettung

Die Verkettung von Codes wurde bereits im Jahre 1966 durch Forney [For66a] untersucht. Er betrachtete den sogenannten inneren Code zusammen mit dem Kanal als einen Superkanal für einen weiteren Code, der äußerer Code heißt.

außerer ¨ Codierer A

innerer Codierer B

Kanal

innerer Decodierer B

außerer ¨ Decodierer A

Superkanal

Abb. 9.1: Verkettung nach Forney.

In seiner Arbeit hat Forney schon drei wesentliche Vorteile der Codeverkettung deutlich gemacht, die auch Vorteile der verallgemeinerten Codeverkettung sind, nämlich: • Sehr lange Codes können durch die Verkettung von wesentlich kürzeren Codes konstruiert werden. • Bei verketteten Codes können gleichzeitig Bündelfehler und unabhängige Einzelfehler korrigiert werden. • Die Komplexität der Decodierung ist im Vergleich zur Decodierung des Gesamtcode geringer, da mehrere kurze Codes zu decodieren sind. Leider ist das Problem der Soft-Decision-Decodierung von verketteten Codes noch nicht zufriedenstellend gelöst.

außerer ¨ Codierer A

innerer Codierer B

Codierer CC

Kanal

innerer Decodierer B

außerer ¨ Decodierer A

Decodierer CC

Abb. 9.2: Verkettung nach Blokh-Zyablov.

308

9 Verallgemeinerte Codeverkettung

Einige Jahre später, 1974, haben Blokh und Zyablov das Konzept der verallgemeinerten Codeverkettung veröffentlicht [BZ74], das wir in diesem Kapitel ausführlich beschreiben wollen. Sie betrachten dabei den inneren und den äußeren Code – im Gegensatz zu Forney – als einen Code. Beide Betrachtungsweisen sind in den Bildern 9.1 und 9.2 veranschaulicht. Man erkennt, dass es sich um den gleichen Aufbau handelt, jedoch werden durch die geänderte Betrachtungsweise neue Möglichkeiten eröffnet. Die Betrachtungsweise nach Blokh-Zyablov erlaubt das Konzept der verallgemeinerten Verkettung von Codes, das inzwischen Einzug in viele Verfahren zur Nachrichtenübertragung gehalten hat. Basierend auf dem gleichen inneren Code und mehreren äußeren Codes lassen sich durch verallgemeinerte Verkettung Codes mit besseren Parametern konstruieren. Zu der schon erwähnten, vorteilhaften Eigenschaft, dass verallgemeinert verkettete Codes – wir wollen sie im Folgenden kurz GC-Codes nennen (generalized concatenated codes) – in der Lage sind, gleichzeitig Bündelfehler und Einzelfehler zu korrigieren, kommt noch eine weitere Eigenschaft hinzu, nämlich die Möglichkeit, Codes mit mehrstufigem Fehlerschutz, sogenannte UEP-Codes (unequal error protection codes), zu konstruieren (vergleiche hierzu auch den Abschnitt 8.1.10, Punktierung von Faltungscodes). Codes mit mehrstufigem Fehlerschutz rücken zunehmend in den Mittelpunkt der Kanalcodierung, da die zu übertragende Information etwa bei Sprache oder Musik verschiedene Wichtigkeit besitzt (z. B. least significant und most significant bit). Bemerkenswert ist, dass auch bei diesen Codes die Korrektureigenschaften erhalten bleiben. Das bedeutet, Bündelfehler und Einzelfehler können gleichzeitig korrigiert werden. Weiterhin bleibt das Decodierverfahren gleich und zusätzlich werden auch hier relativ lange Codes mittels mehrerer kurzer Codes konstruiert. Es wird sich zeigen, dass bei verallgemeinerter Codeverkettung im Vergleich zu herkömmlicher Verkettung gilt: • Bei gleicher Mindestdistanz hat der GC-Code mehr Codeworte, d. h. der GC-Code besitzt eine größere Coderate. • Bei gleich vielen Codeworten, d. h. bei gleicher Coderate, besitzt der GC-Code eine größere Mindestdistanz. Weiterhin lässt sich das Prinzip der codierten Modulation als Spezialfall der verallgemeinerten Codeverkettung auffassen, wobei das Modulationsverfahren als innerer Code betrachtet wird. Damit hat man sowohl eine elegante Beschreibung von codierter Modulation als auch Decodierverfahren dafür. Codierte Modulation werden wir im nächsten Kapitel gesondert untersuchen, da es einen wichtigen Spezialfall darstellt. Die Hard-Decision-Decodierung von verketteten Codes bis zur halben Mindestdistanz war lange Zeit nicht zufriedenstellend gelöst. Decodiert man zunächst den inneren und dann den äußeren Code, so kann man zeigen, dass man damit nicht bis zur halben Mindestdistanz des GC-Codes korrigieren kann. Wir werden jedoch einen Decodieralgorithmus für GC-Codes beschreiben, mit dem verkettete Codes bis zur halben Mindestdistanz decodiert werden können. Dabei kann der Decodieralgorithmus unverändert für Codes mit mehrstufigem Fehlerschutz (UEP-Codes) verwendet werden. Außerdem können Bündelfehler und Einzelfehler gleichzeitig korrigiert werden. Wir wollen in diesem Kapitel einige Verfahren, Methoden und Eigenschaften beschreiben, um GC-Codes für spezielle Anwendungen in der Praxis konstruieren zu können.

9 Verallgemeinerte Codeverkettung

309

Vorgehensweise: Zunächst wollen wir die Idee der verallgemeinerten Codeverkettung an einigen Beispielen beschreiben und den Unterschied zur herkömmlichen Verkettung herausarbeiten, da eine allgemein gültige Notation sehr komplex ist und mehr verwirrt, als dass sie dieses mächtige Konzept vermittelt. Danach werden wir GC-Codes definieren. Mit den beiden Codeklassen (Block- und Faltungscodes) ergeben sich vier unterschiedliche Möglichkeiten der Verkettung, je nachdem welche Klasse wir als innere und äußere Codes wählen. Die ersten GC-Codes basierten auf Blockcodes als innere und äußere Codes. Diese Konstruktion ist bisher am besten untersucht, und die Ergebnisse sollen zunächst im Abschnitt 9.2 angegeben werden. Im folgenden Abschnitt 9.4 werden wir dann den weniger gut untersuchten Fall von GC-Codes erläutern, wenn sowohl die inneren wie auch die äußeren Codes Faltungscodes sind. Hierzu können wir auf aktuelle Ergebnisse [BDS96a] aus dem Jahr 1996 zurückgreifen. Außerdem hat die Verkettung von Faltungscodes durch die Veröffentlichung [BGT93] der sogenannten Turbo-Codes im Jahre 1993, mit denen im Falle des AWGN-Kanals nahezu die Kanalkapazität erreicht werden konnte, einen enormen Aufschwung erlebt. Wir werden zeigen, dass es sich bei dieser Konstruktion um eine herkömmliche Verkettung handelt und dass lediglich das Konzept der iterativen Decodierung den Gewinn bringt. Schließlich beschreibt Abschnitt 9.5 die GC-Codes mit gemischten Codeklassen. Obwohl einige Standards in diese Kategorie fallen, sind hier noch viele Fragen offen. In Abschnitt 9.2 werden wir auf die Konstruktion und auf unterschiedliche Varianten von GC-Codes eingehen. Speziell werden wir in Abschnitt 9.2.3 einige mögliche Modifikationen der Parameter beschreiben. Ein bekanntes Prinzip, das bei Bündelfehlern angewendet wird, ist das sogenannte Interleaving [WHPH87]. In Abschnitt 9.2.3 wollen wir dieses Prinzip den GC-Codes gegenüberstellen. Schließlich wird die Konstruktion von Codes zum mehrstufigen Schutz eines Informationsblocks im Abschnitt 9.2.5 untersucht. Des weiteren werden wir zyklische Codes als GC-Codes beschreiben und auch das interessante Konzept von GC-Codes durch Codierung des Syndroms beschreiben, das zu einer Klasse von Codes mit wenig Redundanz und spezieller Fehlerkorrektureigenschaft führt. Abschnitt 9.2.4 beschreibt ein Decodierverfahren für GC-Codes, das bis zur halben Mindestdistanz decodieren kann. Dabei wird zunächst das Verfahren von Dumer, Zinoviev und Zyablov aus [DZZ81] erläutert. Anschließend wollen wir eine Modifikation dieses Algorithmus untersuchen, die es unter anderem erlaubt, beliebige Decodiermethoden zu verwenden, wie z. B. Decodierverfahren, die zusätzlich Zuverlässigkeitsinformation benutzen (soft decision decoding) oder sogar ML-Decodierung. Die Decodierung von GC-Codes ist für die Praxis ein Schlüsselproblem. Deshalb werden in diesem Kapitel Decodierverfahren angegeben und deren Leistungsfähigkeit untersucht. Oft kann die Leistungsfähigkeit der Verfahren zwar durch einfache Schranken abgeschätzt werden, für eine exakte Aussage sind allerdings Simulationen notwendig. Eine wichtige Erkenntnis für die Anwendung soll in Abschnitt 9.2.4 erläutert werden, nämlich, dass es bei GC-Codes zwei unterschiedliche Konstruktionsprinzipien gibt. Ein mögliches Konstruktionsprinzip optimiert die Mindestdistanz eines GC-Codes. Es wurde bei fast allen bisherigen Veröffentlichungen zu verketteten Codes angenommen, dass dies auch gleichbedeutend mit der Minimierung der Fehlerwahrscheinlichkeit nach der Decodierung ist. Dies trifft nicht zu. Eine Optimierung der Fehlerwahrscheinlichkeit

310

9 Verallgemeinerte Codeverkettung

nach der Decodierung führt in fast allen Fällen zu anderen Codes als eine Optimierung der Mindestdistanz. Für die verallgemeinerte Verkettung von Faltungscodes ist das zentrale Problem die Partitionierung. Auf diese werden wir in Abschnitt 9.4.3 eingehen und anschließend die Konstruktion von GC-Codes untersuchen. Nach dem Abschnitt 9.5 zur verallgemeinerten Verkettung mit Block- und Faltungscodes, werden wir noch eine natürliche Erweiterung des Konzeptes von GC-Codes, die Mehrfachverkettung in Abschnitt 9.6, untersuchen. Dies bedeutet, dass der innere Code schon ein GC-Code ist. Ein interessantes Beispiel hierfür ist die Klasse der binären ReedMuller-Codes, die als mehrfach verallgemeinert verkettete Codes (generalized multiple concatenated , GMC) beschrieben werden können. Als Konsequenz der Beschreibung von RM-Codes als mehrfach verallgemeinert verkettete Codes ergibt sich ein Decodierverfahren (GMC-Algorithmus), das eine sehr geringe Komplexität aufweist und sehr einfach Zuverlässigkeitsinformation benutzen kann. Außerdem wollen wir eine Erweiterung des GMC-Algorithmus einführen, die auf dem Konzept der Listendecodierung basiert.

9.1

Einführende Beispiele „Lang ist der Weg durch Lehren, kurz und erfolgreich durch Beispiel.“ Seneca

In diesem Abschnitt wird das Konzept der verallgemeinerten Verkettung an Beispielen mit einfachen Codes erklärt. Wir verketten erst die Codes B und A herkömmlich gemäß Forney (Bild 9.1) und anschließend verallgemeinert gemäß Blokh-Zyablov (Bild 9.2). Beispiel 9.1 (Herkömmliche Verkettung) Wir verwenden zur Verkettung als inneren Code einen Parity-Check-Code1 B(2; 4, 3, 2) der Länge 4 und als äußeren Code einen Wiederholungscode A(23 ; 8, 1, 8) über dem Alphabet GF (23 ) der Länge 8 (siehe jeweils Beispiel 1.2 und 1.3). Dazu werden 3 Informationsbits (i0 , i1 , i2 ) zuerst mit dem äußeren Code A zu a = (a0 , a1 , . . . , a7 ) codiert. Danach wird jede Stelle ai , i = 0, . . . , 7, des Codewortes a mit dem inneren Code B codiert, d. h. wir erhalten 8 Codeworte des inneren Codes. Dies ist in Bild 9.3 schematisch dargestellt. Das Codewort des verketteten Codes CC besteht aus einer (8 × 4)-Matrix, deren Zeilen Codeworte des Parity-Check-Codes B sind. Damit ist die Länge des Codes n = 4 · 8 = 32 und seine Dimension ist k = 3, da wir offensichtlich 3 Informationszeichen codiert haben. Für die Mindestdistanz gilt d = da · db = 2 · 8 = 16. Der verkettete Code hat die Parameter CC (2; 32, 3, 16).



Im folgenden Beispiel wollen wir mit denselben Codes einen verallgemeinert verketteten Code konstruieren. 1 Die gewohnte Notation für Codes B(n, k, d) wird im folgenden durch B(q; n, k, d) ersetzt, um nichtbinäre Codes unterscheiden zu können. Der Parameter q bezeichnet die Größe des Code-Alphabets.

9.1 Einführende Beispiele

311 PC i0 i1 i2 p0 ∈ B

i0 i1 i2 i0 i1 i2

i0 i1 i2 p0

i0 i1 i2 i0 i1 i2

i0 i1 i2 p0

i0 i1 i2

A

i0 i1 i2

i0 i1 i2 p0

i0 i1 i2

i0 i1 i2 p0

i0 i1 i2

i0 i1 i2 p0

i0 i1 i2

|

i0 i1 i2 p0

B

{z

i0 i1 i2 p0

}

|

{z

}

∈ CC

∈A

Abb. 9.3: Beispiel für herkömmliche Verkettung (systematisch).

Beispiel 9.2 (Verallgemeinert verketteter Code) Der innere Code ist der gleiche binäre PC-Code der Länge n = 4, der jetzt B(1) heißen soll. Diesen Code wollen wir derart in vier Untercodes mit je zwei Codeworten aufteilen (partitionieren), dass die Mindestdistanz in den Untercodes maximal ist. Im folgenden sind alle 8 möglichen Codewörter des Codes B(1) (2; 4, 3, 2) aufgelistet: (0000), (0011), (0101), (0110), (1001), (1010), (1100), (1111). Die vier Untercodes mit maximaler Mindestdistanz ergeben sich zu: (2)

B0 (2; 4, 1, 4) (2) B1 (2; 4, 1, 4) (2) B2 (2; 4, 1, 4) (2) B3 (2; 4, 1, 4)

= = = =

{ (0000), (1111) } { (0011), (1100) } { (0101), (1010) } { (0110), (1001) } .

Wir können nun ein Codewort des PC-Codes B(1) eindeutig bestimmen, wenn wir die Nummer des Untercodes (0, 1, 2, 3) und die Nummer des Codewortes im Untercode (0, 1) kennen. Dies bedeutet, um diese Partitionierung zu nummerieren, benötigen wir zwei Zahlen, nämlich: a(1) ∈ GF (2)2

und

a(2) ∈ GF (2).

Die beiden Zahlen a(1) = (10)2 = b (2)10 und a(2) = 1 würden im Beispiel das Codewort (3) (3) B210 ,1 = B10,1 = (1010) nummerieren. In Bild 9.4 ist die Partitionierung nochmals schematisch dargestellt. Die Idee ist nun, die Nummerierung der Partitionierung mit je einem äußeren Code zu schützen. Benutzen wir als äußere Codes einen Wiederholungscode A(22 ; 8, 1, 8) und einen erweiterten Hamming-Code (siehe Abschnitt 1.9) AH (2; 8, 4, 4), so wird die Codierung von 6 Informationsbits wie folgt durchgeführt: Zwei Informationsbits (i0 , i1 ) codieren wir mit dem Code A zu dem Codewort (1)

(1)

(1)

(1)

(1)

(1)

(1)

(1)

(1)

a(1) = (a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 ), ai

∈ GF (2)2 .

Die restlichen vier Informationsbits (i2 , i3 , i4 , i5 ) codieren wir mit dem Code AH zu dem Co(2) (2) (2) (2) (2) (2) (2) (2) dewort a(2) = (a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 ). Damit haben wir die zwei äußeren Co(1) (2) deworte a und a . Jede Stelle des Codewortes a(1) wählt einen Untercode von B(1) aus,

312

9 Verallgemeinerte Codeverkettung {0000, 0011, 0101, 0110, 1001, 1010, 1100, 1111} B(1) (2; 4, 3, 2)

a(1) :

00

{0000, 1111} 0

(2)

{0000} (3)

B00,0

B01 (2; 4, 1, 4)

1

0

{1111}

1

{0011}

(3)

{1100}

(3)

B00,1

(3)

B01,0

11

10

{0011, 1100}

(2)

B00 (2; 4, 1, 4)

a(2) :

01

B01,1

{0101, 1010}

{0110, 1001}

(2)

(2)

B10 (2; 4, 1, 4) 0

B11 (2; 4, 1, 4)

1

{0101} (3)

B10,0

0

{1010} (3)

B10,1

{0110} (3)

B11,0

1

{1001} (3)

B11,1

Abb. 9.4: Partitionierung des Codes B(1) (2; 4, 3, 2).

i0 i1

A

AH

i2 i3 i4 i5

i0 i0 i0 i0 i0 i0 i0 i0

|

i1 i1 i1 i1 i1 i1 i1 i1

{z

}

∈A



(2)

i2 b0 b1 b2 b3 ∈ Bi0 i1 i3 b0 b1 b2 b3 b0 b1 b2 b3 i4 i5 Abbildung b0 b1 b2 b3 b0 b1 b2 b3 p0 b0 b1 b2 b3 p1 b0 b1 b2 b3 p2 b0 b1 b2 b3 p3

|{z}

|

∈ AH

{z

}

∈ CGC

Abb. 9.5: Beispiel für verallgemeinerte Verkettung. nämlich B

(2) (1)

ai (2)

tercodes B

, i = 0, . . . , 7, und jede Stelle des Codewortes a(2) wählt ein Codewort des Un-

(1)

ai

aus, nämlich B (1)

(2)

ai , ai

(3) (1)

ai

=⇒ B

(2)

∈ B(1) , i = 0, . . . , 7:

(2)

∈ B(1) .

,ai

(3) (1)

ai

,ai

Somit ergibt sich ebenfalls eine (8×4)-Matrix, deren Zeilen Codeworte des Parity-Check-Codes B(1) sind. Der Unterschied zu Beispiel 9.1 ist, dass wir hier 6 Informationsbits codiert haben. Bild 9.5 zeigt eine schematische Darstellung der Codierung. Der verallgemeinert verkettete Code CGC hat damit die Länge n = 4·8 = 32 und die Dimension ist k = 6, da wir offensichtlich 6 Informationszeichen codiert haben. Für die Mindestdistanz überlegen wir uns, dass wir die erste Entscheidung, welchem Untercode eine empfangene Zeile zuzuordnen ist, mit der Mindestdistanz von B(1) treffen müssen, d. h. mit der Distanz 2. Diese Nummerierung ist jedoch mit der Distanz 8 des äußeren Codes A geschützt. Damit gilt d = 2 · 8 = 16. Hat man sich für einen Untercode entschieden, so steht für die Entscheidung des Codewortes im Untercode die Distanz 4 zur Verfügung. Die acht Entscheidungen sind durch einen äußeren Code der Distanz 4 geschützt. Damit gilt d = 4 · 4 = 16. Wir werden zeigen, dass gilt: d ≥ min{2 · 8, 4 · 4}. Der GC-Code hat die Parameter CGC (2; 32, 6, 16).

9.1 Einführende Beispiele

313 PC } ∈ B(2; 7, 6, 2)

|

{z

}

∈ A(26; 9, 2, 8)

|

{z

}

∈ CC1 (2; 63, 12, 16)

Abb. 9.6: Herkömmliche Verkettung mit einem äußeren Code.

Wir haben einen Code konstruiert, der bei gleicher Mindestdistanz 8 mal so viele Codeworte besitzt. Anmerkung: Dieser Code ist ein Reed-Muller-Code erster Ordnung (siehe Abschnitt 5.1). Wir werden Reed-Muller-Codes in Abschnitt 9.6 als verallgemeinert verkettete Codes beschreiben. Die Decodierung dieses Codes ist mit der Beschreibung als GC-Code besonders einfach. 

Als nächstes Beispiel untersuchen wir eine Konstruktion mit einem inneren PC-Code und äußeren RS-Codes. Beispiel 9.3 (Interleaving und GC-Code) Gegeben sei der binäre Parity-Check-Code mit Parametern B(2; 7, 6, 2). Eine herkömmliche Verkettung mit dem verkürzten RS-Code A(26 ; 9, 2, 8) ergibt den Code CC1 (2; 63, 12, 16). Zur Codierung werden die 12 Informationsbits als zwei Elemente aus GF (26 ) aufgefasst und daraus das entsprechende Codewort des RS-Codes berechnet. Danach wird jede Stelle des RS-Codewortes als die 6 Informationsbits des Codes B betrachtet und ein Paritätsbit berechnet. Dies ist in Bild 9.6 dargestellt. Eine weitere Möglichkeit der herkömmlichen Verkettung ist, zwei äußere Reed-Solomon-Codes A(1) (23 ; 9, 2, 8) zu verwenden. Es handelt sich dabei um einen zweifach erweiterten RS-Code (vergleiche Abschnitt 3.1.7, Sätze 3.11 und 3.12). Zur Codierung werden je 6 Informationsbits mit dem Code A(1) zu den Codeworten a und a0 codiert. Die entsprechenden Stellen der Codeworte (ai und a0i ) sind die 6 Informationsstellen des inneren Codes B. Die Codierung ist in Bild 9.7 schematisch dargestellt. Der verkettete Code hat die Parameter CC2 (2; 63, 12, 16). Dies kann als Interleaving von zwei RS-Codes interpretiert werden. PC

| {z }| {z } ∈ A(1) (23 ; 9, 2, 8)

|

{z

∈ B(2; 7, 6, 2)

}

∈ CC2 (2; 63, 12, 16)

Abb. 9.7: Herkömmliche Verkettung mit zwei äußeren Codes. Um einen GC-Code zu konstruieren, nutzen wir die Tatsache, dass wir den PC-Code B(1) (2; 7, 6, 2) (2) in 8 Codes Bi (2; 7, 3, 4), i = 0, . . . , 7, partitionieren können (siehe Bild 9.8). Es handelt sich dabei um Cosets des geradgewichtigen Hamming-Codes. Die Nummerierung der Partitionie-

314

9 Verallgemeinerte Codeverkettung

rung wird wieder mit je einem äußeren Code geschützt. Die äußeren Codes sind zwei RS-Codes, nämlich A(1) (23 ; 9, 2, 8) und A(2) (23 ; 9, 6, 4). B (1) (2; 7, 6, 2)

000 (2) B0 (7, 3, 4)

001

(2) B1 (7, 3, 4)

010

(2) B2 (7, 3, 4)

011 (2) B3 (7, 3, 4)

100 (2) B4 (7, 3, 4)

101

110

(2) B5 (7, 3, 4)

111

(2) B6 (7, 3, 4)

(2)

B7 (7, 3, 4)

{ 0 0 0 0 0 0 0, { 0 1 1 0 0 0 0, { 1 0 1 0 0 0 0, { 1 1 0 0 0 0 0, { 0 1 0 0 1 0 0, { 0 0 1 0 1 0 0, { 0 0 0 1 1 0 0, { 1 0 0 0 1 0 0, 1 1 1 1 0 0 0, 1 0 0 1 0 0 0, 0 1 0 1 0 0 0, 0 0 1 1 0 0 0, 1 0 0 0 0 1 0, 0 0 0 1 0 1 0, 0 0 1 0 0 1 0, 0 1 0 0 0 1 0, 1 1 0 0 1 1 0, 0 0 0 0 0 1 1, 0 0 0 0 1 0 1, 0 0 0 0 1 1 0, 0 0 0 1 0 0 1, 1 0 0 0 0 0 1, 0 1 0 0 0 0 1, 0 0 1 0 0 0 1, 0 0 1 1 1 1 0, 1 0 1 0 1 1 0, 0 1 1 0 1 1 0, 0 1 1 0 1 0 1, 1 0 1 1 1 0 0, 1 1 0 1 1 0 0, 1 1 1 0 1 0 0, 0 1 1 1 1 0 0, 1 0 1 0 1 0 1, 0 1 0 1 1 1 0, 1 0 0 1 1 1 0, 1 0 0 1 1 0 1, 0 1 1 1 0 1 0, 1 1 1 0 0 1 0, 1 1 0 1 0 1 0, 1 0 1 1 0 1 0, 0 1 0 1 1 0 1, 1 1 0 0 1 0 1, 1 1 0 0 0 1 1, 1 0 1 0 0 1 1, 1 1 1 0 0 0 1, 0 1 1 1 0 0 1, 1 0 1 1 0 0 1, 1 1 0 1 0 0 1, 0 1 1 0 0 1 1, 0 0 1 1 1 0 1, 0 0 1 1 0 1 1, 0 1 0 1 0 1 1, 0 0 1 0 1 1 1, 0 1 0 0 1 1 1, 1 0 0 0 1 1 1, 0 0 0 1 1 1 1, 1001011 } 1111011 } 1111101 } 1111110 } 1101111 } 1011111 } 0111111 } 1110111 }

Abb. 9.8: Partitionierung des inneren Codes. Bild 9.9 zeigt schematisch die Codierung von 24 Informationsbits: 6 Informationsbits werden (1) (1) (1) mit dem Code A(1) zu dem Codewort a(1) = (a0 , a1 , . . . , a8 ) codiert. Die restlichen 18 (2) (2) (2) Informationsbits werden mit dem Code A(2) zu dem Codewort a(2) = (a0 , a1 , . . . , a8 ) (2) (1) (1) codiert. Jede Stelle des Codewortes a wählt einen Untercode von B aus, nämlich B (1) , i = 0, . . . , 7, und jede Stelle des Codewortes a(2) wählt ein Codewort des Untercodes B nämlich B

(3) (1)

ai

(2)

,ai

(1)

(2) (1)

ai

ai

aus,

∈ B(1) , i = 0, . . . , 7: (2)

ai , ai

=⇒ B

(3) (1)

ai

(2)

,ai

∈ B(1) .

Ein Codewort besteht aus n = 7 · 9 = 63 Bits. Die Dimension des Codes ist k = 24 und für die Mindestdistanz gilt d = min{2 · 8, 4 · 4} = 16. Die Parameter des GC-Codes sind damit: CGC (2; 63, 24, 16). } ∈B

(2) (1)

a0

Abb.

∈ A(1) ∈ A(2) (23; 9, 2, 8) (23; 9, 6, 4)

∈ CGC (2; 63, 24, 16)

Abb. 9.9: GC-Code. Ein Vergleich der Parameter ergibt, dass der GC-Code bei gleicher Mindestdistanz 4096 mal mehr Codeworte hat als die beiden anderen Konstruktionen: CC1 (2; 63, 12, 16),

CC2 (2; 63, 12, 16)

und

CGC (2; 63, 24, 16).

Man beachte, dass der Code CGC (2; 63, 24, 16) bessere Parameter als der entsprechende BCHCode besitzt (vergleiche Tabelle 4.1 auf Seite 101). 

9.2 GC-Codes mit Blockcodes

315

Als weiteres Beispiel soll ein Code der Länge 180 konstruiert werden, der gemäß Anhang A in [McWSl] mit zu den besten bekannten Codes gehört. Beispiel 9.4 (GC-Code) Der innere Code ist ein B(2; 6, 6, 1)-Code, d. h. eigentlich kein Code. Verketten wir diesen mit dem RS-Code A(26; 30, 1, 30), so erhalten wir den Code C C(2; 180,6,30). Der Code CC kann als binäre Interpretation eines RS-Codes betrachtet werden. Offensichtlich können mehr als 14 binäre Fehler korrigiert werden, wenn diese auf ≤ 14 Symbole verteilt sind. Um einen GC-Code zu konstruieren, partitionieren wir den inneren Code B(1) (2; 6, 6, 1) in zwei (2) Codes Bi (2; 6, 5, 2), i = 0, 1. Als äußere Codes verwenden wir den binären Wiederholungscode (1) A (2; 30, 1, 30) und den RS-Code A(2) (25 ; 30, 16, 15). Eine Stelle des Codes A(1) wählt den Untercode, und die entsprechende Stelle des Codes A(2) das Codewort im Untercode. Der sich ergebende GC-Code hat die Parameter CGC (2; 180, 81, 30). 

Die Beispiele haben gezeigt, dass GC-Codes wesentlich bessere Parameter aufweisen als entsprechende herkömmliche Verkettungen. Wir können durch Verwendung von verallgemeinerter anstatt herkömmlicher Verkettung entweder: Bei gleicher Mindestdistanz einen Code mit mehr Codeworten, d. h. einen Code mit größerer Coderate, erzeugen. Oder bei gleich vielen Codeworten, d. h. bei gleicher Coderate, einen Code mit größerer Mindestdistanz erzeugen. Die Beispiele sollten auch das wesentliche Grundprinzip erläutern, nämlich die Partitionierung des inneren Codes in Untercodes mit größerer Mindestdistanz und die geeignete Verwendung von äußeren Codes. Anmerkungen zum Konzept der verallgemeinerten Verkettung: Das Konzept setzt keine linearen Codes voraus, sondern kann ganz allgemein mit Mengen von Vektoren in metrischen Räumen definiert werden. Dabei muss die innere Metrik nicht notwendigerweise gleich der äußeren Metrik sein. Entscheidend ist die Partitionierung der Menge der inneren Vektoren in geeignete Untermengen, die gemäß der inneren Metrik eine größere Mindestdistanz aufweisen als die ursprüngliche Menge. Die Nummerierung wird dann mit äußeren Mengen von Vektoren mit einer Mindestdistanz entsprechenden der äußeren Metrik geschützt. Das Ergebnis ist eine Menge von Vektoren (der GC-Code), deren Anzahl dem Produkt der Anzahl der Vektoren der äußeren Mengen entspricht. Die Mindestdistanz ergibt sich gemäß der inneren Metrik als das Minimum aus dem Produkt der entsprechenden inneren und äußeren Mindestdistanzen. Von den zahllosen möglichen Spezialfällen dieser Konstruktion interessieren uns ausschließlich Codekonstruktionen zur zuverlässigen Datenübertragung, d. h. vornehmlich wird die Hamming-, die euklidische und die Lee-Metrik verwendet. Zur Vertiefung sollen deshalb einige Spezialfälle in den folgenden Abschnitten genauer untersucht werden: Blockcodes als innere und äußere Codes, Faltungscodes als innere und äußere Codes und Blockcodes als innere und Faltungscodes als äußere Codes bzw. umgekehrt. Weiterhin wird in einem separaten Kapitel noch der wichtige Fall der codierten Modulation erörtert, wobei die Modulation als innerer Code äquivalent zu Block- oder Faltungscodes sein kann und die euklidische Metrik verwendet wird.

9.2

GC-Codes mit Blockcodes

Dieser Abschnitt ist wie folgt aufgebaut: Zunächst definieren wir GC-Codes allgemein und erörtern danach die Möglichkeiten der Partitionierung des inneren Codes. Nach

316

9 Verallgemeinerte Codeverkettung

der Diskussion einiger praktischer Gesichtspunkte beschäftigen wir uns mit der Decodierung von GC-Codes. Anschließend beschreiben wir die Spezialfälle von UEP- und zyklischen GC-Codes. Eine mögliche verbesserte Decodierung durch die Betrachtung von zyklischen Codes als GC-Codes ist noch nicht untersucht und damit ein ungelöstes Problem. Am Ende wollen wir noch auf die Konstruktion von GC-Codes durch erneute Codierung des Syndroms eingehen. Notation: Um die verallgemeinerte Verkettung auch für nichtlineare Komponentencodes beschreiben zu können, benötigen wir eine neue Notation für Codes: Ein Code B der Länge n über dem Alphabet GF (q) mit M Codewörtern und der Mindestdistanz d wird beschrieben durch: B(q; n, M, d) ⊆ GF (q)n . Für lineare Codes gilt: M = q k . Die bisherige Notation B(q; n, k, d) bzw. B(n, k, d) für q = 2 wird parallel dazu weiter verwendet. Eine Falsch-Interpretation ist in der Regel nicht möglich, da meist M > n gilt. Falls die Notation nicht eindeutig ist, wird explizit darauf hingewiesen.

9.2.1

Definition von GC-Codes

Die Idee der verallgemeinerten Codeverkettung basiert auf der Partitionierung eines Codes in Untercodes. Die Nummerierung dieser Partitionierung wird durch äußere Codes geschützt. Um GC-Codes allgemeiner zu definieren, benötigen wir zunächst eine Definition einer Partitionierung. (1)

(1)

Gegeben sei eine Partitionierung der Ordnung s eines Codes B (1) (q; nb , Mb , db ), wobei (j) Mb die Anzahl der Codeworte des Codes angibt, wie folgt: B

(1)

=

(2)

Bi1 = .. . (s) Bi1 ,i2 ,...,is−1

=

ν1 [

(2)

i1 =1 ν2 [ i2 =1

νs [

Bi1

(3)

Bi1 ,i2

(s+1)

is =1

Bi1 ,i2 ,...,is .

(2)

Dabei nummeriert i1 die Untercodes Bi1 des Codes B (1) , und i2 nummeriert die Untercodes

(3) Bi1 ,i2

des Codes (s)

(2) Bi1 ,

(s+1)

usw. Schließlich nummeriert is das Codewort Bi1 ,i2 ,...,is (j)

(j)

(j)

in dem Untercode Bi1 ,i2 ,...,is−1 . Die Codes Bi1 ,i2 ,...,ij−1 (q; nb , Mb , db ), j = 1, . . . , s, (j)

heißen innere Codes. Die Mindestdistanzen db , j = 1, . . . , s, seien bekannt. Das bedeutet, ein Codewort b ∈ B (1) wird durch die Nummerierung i1 , i2 , . . . , is eindeutig

9.2 GC-Codes mit Blockcodes

317

(s+1)

bestimmt, d. h. Bi1 ,i2 ,...,is = b stellt ein Codewort dar. Die grundsätzliche Idee von (i)

(i)

(i)

verallgemeinerter Codeverkettung ist nun, eine Menge von Symbolen a1 , a2 , . . . , aki (i)

(i)

durch sogenannte äußere Codes A(i) (q µi ; na , Ma , da ) zu schützen. Wir wollen annehmen, dass das Alphabet des entsprechenden äußeren Codes genau alle νi Untercodes der i-ten Partitionierung nummeriert, d. h. (i)

νi = q µi ,

Codesymbole: aj ∈ GF (q)µi .

Für lineare Codes gilt bezüglich der Anzahl der jeweiligen Informationssymbole (Di(i) (i) (i) (i) mension) ka und die Größe Ma des äußeren Codes (q µi )ka = Ma ; wir wollen hier annehmen, dass die entsprechenden Größen geeignet sind. Anmerkung zur Notation: Prinzipiell können wir den Informationsteil eines inneren (i) (i) Codes aj ∈ GF (q)µi als Vektor betrachten, d. h. aj schreiben, oder aber als Element (i)

von GF (q)µi , d. h. aj schreiben. Im folgenden werden wir hauptsächlich (nicht immer) (i)

die Notation aj verwenden. (i)

(i)

(i)

Wir ordnen die s Codewörter (a1 , a2 , . . . , ana ), i = 1, 2, . . . , s, von s äußeren Codes als Spalten einer (na ×s)-Matrix an. Die Information ist in den s äußeren Codes codiert:  (1) (2)  (s) a1 a1 . . . a1  (1) (2)   a2 a2 . . . a(s) 2   . (9.1) .. . . ..   . . . .   . . (1)

(2)

(s)

ana ana . . . ana (i)

Die Matrixelemente aj ∈ GF (q)µi , j = 1, 2, . . . , na , i = 1, 2, . . . , s, stellen eine Matrix mit na Zeilen dar. Jede Zeile hat die Form   (1) (2) (3) (s) aj , aj , aj , . . . , aj .

Durch jede Zeile wird entsprechend der Partitionierung eindeutig ein Codewort des Codes B (1) bestimmt. Führen wir diese Abbildung für alle Zeilen durch, so erhalten wir ein Codewort des GC-Codes CGC . Es ist eine (na × nb )-Matrix mit Elementen aus GF (q). Insbesondere ist jede Zeile ein Codewort des Codes B (1) :   c11 c12 . . . c1,nb  c21 c22 . . . c2,nb   . (9.2) .. . . ..   . . . . . . cna ,1 cna ,2 . . . cna ,nb

Damit können wir nun die GC-Codes formal einführen. Satz 9.1 (GC-Code) Ein GC-Code CGC (q; n, M, d) besteht aus s äußeren Codes (i) (i) A(i) (q µi ; na , Ma , da ) und einer Partitionierung der Ordnung s des inneren Codes

318

9 Verallgemeinerte Codeverkettung (1)

(1)

B (1) (q; nb , Mb , db ). CGC ist ein Code über dem Alphabet q und hat die Länge n = s Y na · nb , die Anzahl von Codeworten M = Ma(i) und die Mindestdistanz i=1

 (i) d ≥ min db · d(i) . a i=1,...,s

Beweis: Die Länge n = na · nb und die Anzahl der Codeworte M sind offensichtlich. Wir wollen deshalb nur die Mindestdistanz beweisen. Seien c 6= c0 zwei Codewörter eines GC-Codes. Die Matrizen (Gleichung (9.1)) für diese zwei Codeworte müssen sich mindestens in einer Spalte unterscheiden, z. B. i. Da aber A(i) die (i) Mindestdistanz da hat, unterscheiden sich die Matrizen entsprechend Gleichung (9.2) der (i) Codewörter c und c0 in mindestens da Zeilen. Unterschiedliche Zeilen sind aber jeweils in (i) mindestens db Zeichen verschieden, da sie durch unterschiedliche a(i) entstanden sind. Damit erhalten wir die Abschätzung der Mindestdistanz eines GC-Codes (vergleiche auch [Zin76]). 2

In vielen Fällen ist die wirkliche Mindestdistanz eines GC-Codes größer und nicht bekannt. (i)

Anmerkung: Das Alphabet GF (q)µi aus dem die Symbole aj des entsprechenden äußeren Codes sind, muss an die Partitionierung angepasst sein. Es gibt hierbei drei Fälle: Die Anzahl der Elemente des Alphabets ist größer, kleiner oder gleich der Anzahl der Untercodes,   > νi q µi < νi . = ν i

Sollen alle Symbole des Alphabets einem Code bzw. einem Codewort entsprechen, muss (i) (i−1) (i) q µi ≤ νi = Mb /Mb gelten. Dabei wird vorausgesetzt, dass alle Mb gleich groß µi sind, was nicht notwendigerweise erfüllt sein muss. Ist aber q kleiner als νi , bedeutet dies, dass nicht alle Untercodes zur Konstruktion des GC-Codes benutzt werden. Dies entspricht dem Fall, dass nicht alle Codewörter von B (1) benutzt werden.

Es soll nochmals erwähnt werden, dass das Konzept der verallgemeinerten Verkettung nicht auf Blockcodes als innere und äußere Codes beschränkt ist. Vielmehr muss für die Partitionierung nur gewährleistet sein, dass eine beliebige Metrik (vergleiche Abschnitt 7.1 bzw. Anhang B) in den Untercodes größer wird; dann kann das Konzept angewendet werden. Die Codes können auch nichtlinear oder als Menge von Punkten mit einer Metrik definiert sein, wie etwa bei der codierten Modulation in Kapitel 10. Verständlicherweise kann man dieses allgemeine Konzept nicht in einer einzigen Definition unterbringen.

9.2.2

Zur Partitionierung von Blockcodes

In diesem Abschnitt werden mögliche Methoden der Partitionierung von Blockcodes angegeben und einige Aspekte zu deren Eigenschaften abgeleitet. Eine Konstruktion ist notwendig, da längere Codes nicht mehr durch Auflistung aller Codeworte partitioniert werden können.

9.2 GC-Codes mit Blockcodes

319

Wir wollen nun die Partitionierung genauer untersuchen und uns dabei auf eine Partitionierung erster Ordnung (s = 1) beschränken, da eine Partitionierung höherer Ordnung durch mehrfache Anwendung konstruiert werden kann. Definition 9.2 (Partitionierung) Sei B (1) ein Code, also eine Menge von M Vektoren eines n-dimensionalen Raumes. Die Mindestdistanz der Vektoren b ∈ B (1) sei d(1) . Eine (2) Unterteilung der Menge B (1) in ν disjunkte Untermengen (Untercodes) Bi derart, dass gilt: B (1) =

ν [

i=1

(2)

Bi

(2)

heißt Partitionierung von B (1) . Jede Untermenge stellt wiederum einen Code Bi dar (2) (2) und für dessen Mindestdistanz di gilt: di ≥ d(1) , i = 1, 2, . . . , ν. Die Mindestdistanz der Untercodes wird definiert als das Minimum der Mindestdistanzen der einzelnen Untercodes:  (2) d(2) = min di . i=1,...,ν

Offensichtlich gibt es mehrere Möglichkeiten, einen Code zu partitionieren. Für die Konstruktion von GC-Codes ist es wichtig, dass von allen Möglichkeiten diejenige gewählt wird, bei der die minimale Mindestdistanz der Untercodes maximal ist. Eine Variante, um einen Code B (1) (q; n, M (1) , d(1) ) ⊆ GF (q)n zu partitionieren, ist, die Codewörter von B (1) durch Probieren in Untermengen aufzuteilen. Das bedeutet, dass Definition 9.2 direkt angewendet wird. Dies soll im Folgenden Methode 1 genannt werden und ist sicher nur auf Codes anwendbar, bei denen die Anzahl der Codewörter relativ klein ist. Methode 1: Gegeben sei ein Code B (1) (q; n, M (1) , d(1) ) ⊆ GF (q)n . Eine Partitionierung von B (1) in ν (2) (2) (2) Untercodes Bi (q; n, Mi , di ), i = 1, 2, . . . , ν, wird erreicht, wenn man die Codeworte derart sortiert, dass gilt: B (1) =

ν [

i=1

(2)

Bi . (2)

Damit ist für jedes b ∈ B (1) der Untercode Bi , zu dem b gehört, eindeutig bestimmt und es gilt: M

(1)

=

ν X

(2)

Mi

.

i=1

Um die gewählte Partitionierung zu nummerieren, werden nun jedem Codewort b ∈ B (1) zwei Symbole a(1) ∈ GF (q)µ1 und a(2) ∈ GF (q)µ2 zugeordnet. Dabei nummeriert a(1)

320

9 Verallgemeinerte Codeverkettung (2)

den Untercode Bi zu dem das Codewort b gehört, und a(2) nummeriert das Codewort (2) innerhalb des Untercodes Bi . Es gibt ν Untercodes, die mit den Zahlen 0, 1, . . . , ν − 1 zur Basis q nummeriert werden. Damit ergeben sich 3 Möglichkeiten:

• Für q µ1 < ν kann nicht jedem Untercode eine Nummer a(1) zugeordnet werden, (2) da es mehr Untercodes als Nummern gibt. Analog gilt: Für q µ2 < Mi kann nicht (2) jedem Codewort innerhalb des Untercodes eine Nummer a zugeordnet werden. • Für q µ1 > ν wird nicht jede Nummer a(1) ausgenützt, da es weniger Untercodes (2) als Zahlen gibt. Analog gilt: Für q µ2 > Mi repräsentiert nicht jede Nummer a(2) ein Codewort des Untercodes. • Für q µ1 = ν ist jedem Untercode genau eine Nummer a(1) zugeordnet, analog für (2) q µ2 = Mi . Fordern wir, dass jedes ai ∈ GF (q)µi zulässig ist, dann muss gelten: q µ1 ≤ ν

und

q µ2 ≤

max µ

i=1,...,q

1

 (2) Mi .

Damit wird eine Partitionierung durch die folgende Abbildung beschrieben:  a(1) , a(2) ⇐⇒ b ∈ B (1) (2)

a(1) ⇐⇒ i : Bi a(2) ⇐⇒ b ∈

(9.3)

(2) Bi .

Im allgemeinen benötigt man bei der Methode 1 sowohl für die Partitionierung Tabellen als auch für die Abbildung zwischen a(1) , a(2) und den Codewörtern. Selbstverständ(2) lich kann Bi erneut aufgeteilt werden, um eine Partitionierung höherer Ordnung zu erhalten. Bei der Benutzung von längeren Codes bedarf es Konstruktionsmethoden für die Partitionierung. Bei linearen Codes ist dies möglich und soll im Folgenden näher erläutert werden. Lineare Codes Ziel ist es, aus einem gegebenen Codewort die Nummer des Untercodes berechnen zu können, zu dem das Codewort gehört. Im allgemeinen wird eine solche Berechnung nicht mehr optimal im Sinne von maximaler Mindestdistanz in den Untercodes sein, aber diese Berechnungsmethoden sind notwendig, um lange Codes überhaupt partitionieren zu können.

9.2 GC-Codes mit Blockcodes

321

Methode 2: Gegeben seien zwei lineare Codes, für die gilt: B (2) (q; n, k (2) , d(2) ) ⊂ B (1) (q; n, k (1) , d(1) ).

Ferner sei k (1) = m + k (2) , m > 0 und d(2) > d(1) . Der Code B (2) kann nun folgendermaßen zur Partitionierung des Codes B (1) benutzt werden, damit gilt: B wobei

(1)

=

m ν=q [

i=1

(2)

Bi ,

 (2) Bi = vi + B (2) , vi ∈ GF (q)n , i = 1, . . . , ν.  (2) (2) Die Menge vi + B heißt Coset von B (vergleiche Abschnitt 1.3 und Aufgabe 7.1). Damit erhält man die Konstruktionsregel für die Partitionierung des Codes B (1) wie folgt: Wähle aus der Menge aller Cosets des Codes B (2) diejenigen ν Cosets aus, deren Vereinigung den Code B (1) ergibt.

Anmerkung: Die somit konstruierten Untercodes haben alle dieselbe Mächtigkeit, aber (2) die Codes Bi sind damit nichtlineare Codes mit Ausnahme desjenigen mit vi = 0. Sie sind nichtlinear, da das Nullwort nicht enthalten ist. Die Symbole a(1) , a(2) zur Nummerierung sind in diesem Falle: a(1) ∈ GF (q)m

und a(2) ∈ GF (q)k

(2)

.

Die Berechnungsvorschrift für eine Partitionierung lautet: (2)

Sei b ∈ B (1) ein Codewort, dann errechnet sich die Nummer des Untercodes Bi , in dem das Codewort b enthalten ist, dadurch, dass b gemäß B (2) decodiert wird. Der Fehler ist der Restklassenführer, und dieser ist mit der Nummer verknüpft. Im allgemeinen ist dies jedoch nur möglich, falls für B (2) ein ML-Decodierer existiert (siehe Abschnitt 1.3). Falls für B (2) nur BMD-Decodierung zur Verfügung steht, lässt sich diese Berechnung nicht immer durchführen, da ν nicht notwendigerweise kleiner ist als die Anzahl der korrigierbaren Fehlermuster. Diese Tatsache soll an dem folgenden Beispiel erläutert werden. Beispiel 9.5 (Partitionierung durch Decodierung) Seien B(2) (2; 15, 6, 6) ⊂ B(1) (2; 15, 14, 2) zwei BCH-Codes. Damit müssen wir 28 = 256 verschiedene Restklassen des Codes B(2) unterscheiden können, wenn wir b ∈ B(1) (2; 15, 14, 2) mit einem Decodierer für den Code B(2) decodieren. Für einen BMD-Decodierer gilt aber, dass nur Fehler vom Gewicht kleiner als die halbe Mindestdistanz decodiert werden können. Da die Mindestdistanz des Code B(2) (2; 15, 6, 6) gleich 6 ist, können nur Fehler vom Gewicht kleiner gleich zwei decodiert werden. Also: ! ! ! 15 15 15 + + = 1 + 15 + 15 · 7 = 16 + 105 = 121 < 256. 0 1 2

322

9 Verallgemeinerte Codeverkettung

Mit dem BMD-Decodierer können also Cosetleader für 121 Cosets bestimmt werden.



Methode 2 für zyklische Codes im transformierten Bereich: Die Beschreibung im transformierten Bereich (siehe Abschnitt 3.1.1) kann ausschließlich für zyklische Codes verwendet werden. Die Notation für Codewörter ist b(x) und für deren Transformation B(x). b(x)

B(x) |

0 {z

}

Syndrom

Das Syndrom ist gleich Null für alle Codeworte und ungleich Null, falls b(x) kein Codewort ist. Schreibt man das Codewort b(1) (x) als Codewort von beiden Codes in symbolischer Form, d. h. b(1) (x) ∈ B (1) und b(2) (x) ∈ B (2) , so erkennt man an der nachfolgenden Skizze, dass ein Codewort von B (1) ein Syndrom ergeben kann, das ungleich Null ist, wenn man es als Codewort von B (2) betrachtet. Syndrom }| {

z

∈ B(1)

0 0

∈ B(2)

0

Addiert man nun ein beliebiges Codewort von B (2) , so bleibt das Syndrom unverändert. Anders ausgedrückt: Es gibt eine Zuordnung der Restklassenführer vi der Restklassen {b(2) + vi | b(2) ∈ B (2) } und dem Syndrom. 0

|

{z

}

Syndrom

0

vi : {b(2) + vi | b(2) ∈ B(2) }

Im folgenden wird eine weitere Methode zur Partitionierung von linearen Codes angegeben. Methode 3: Gegeben sei B (2) (q; n, k (2) , d(2) ) ⊂ B (1) (q; n, k (1) , d(1) ) mit k (2) + m = k (1) , m > 0, d(2) > d(1) . Seien G(1) und G(2) die Generatormatrizen der Codes B (1) und B (2) in systematischer Form. Wir berechnen nun: b(2) = a(2) · G(2) ∈ B (2) und b(1) = (0|a(1) ) · G(1) ∈ B (1) Dabei sei (0|a(1) ) ∈ GF (q)k Vektor a(1) .

(1)

(2)

mit a(2) ∈ GF (q)k mit a(1) ∈ GF (q)m .

ein Vektor, zusammengesetzt aus k (2) Nullen und dem

9.2 GC-Codes mit Blockcodes

323

Wegen B (2) ⊂ B (1) gilt für die Summe: b = b(2) + b(1) ∈ B (1) , d. h. die Summe ist ein Codewort des Codes B (1) . Außerdem hat der Vektor (a(2) , a(1) ) dieselbe Länge wie der Informationsteil des Codes B (1) . Ist ein Codewort b ∈ B (1) gegeben, so kann der Informationsteil berechnet werden. Er hat die Form (a(2) |˜ a(1) ). Das heißt, wir kennen a(2) und außerdem ist b−a(2) ·G(2) wieder ein Codewort von B (1) mit dem Informationsteil (0|a(1) ). Im Falle einer systematischen Codierung (siehe Abschnitt 3.1.5) bleibt a(2) in b ∈ B (1) unverändert. Die Partitionierung mittels Methode 3 ist bei linearen Codes sicher zu bevorzugen, da die Partitionierung berechenbar ist und damit Codes beliebiger Länge verwendet werden können. Beispiel 9.6 (Partitionierung durch Codierung) Für zyklische Codes können wir das Generatorpolynom statt der Generatormatrix verwenden. Gegeben seien der Parity-Check-Code B(1) (2; 7, 26 , 2) mit dem Generatorpolynom g1 (x) und der Simplex-Code B(2) (2; 7, 23 , 4) mit g2 (x). Es gilt: B(2) ⊂ B(1) , und somit g2 (x) = ∆(x)·g1 (x). Wir können daher die Methode 3 benutzen, um den Parity-Check-Code B(1) zu partitionieren.

Die Vektoren a(1) ∈ GF (2)3 und a(2) ∈ GF (2)3 seien repräsentiert durch die beiden Polynome ai (x) = a0,i + a1,i · x + a2,i · x2 , i = 1, 2. Dann gilt: b(x) = a2 (x) · g2 (x) + x3 · a1 (x) · g1 (x) ∈ B(1) . Für ein gegebenes Codewort b(x) können wir damit a(1) und a(2) wie folgt berechnen: ` ´ b(x) : g1 (x) = a2 (x) · g1 (x) · ∆(x) + x3 · a1 (x) · g1 (x) : g1 (x) = a2 (x) · ∆(x) + x3 · a1 (x) = w(x). Die Koeffizienten w0 , w1 , w2 bestimmen rekursiv a2 (x) mittels drei Gleichungen aus der Beziehung x3 · a1 (x) = w(x) − a2 (x) · ∆(x). 

Bei der Konstruktion von GC-Codes ist es notwendig, flexibel in der Wahl der Parameter µ1 und µ2 zu sein (a(1) ∈ GF (q)µ1 und a(2) ∈ GF (q)µ2 ). Hierbei kann das Prinzip der Codeverkürzung benutzt werden. Bevor wir hierzu den Satz 9.3 beweisen, wollen wir drei Beispiele dazu untersuchen. Beispiel 9.7 (Partitionierung verkürzter Codes) Wir wollen eine Partitionierung mit der Nummerierung a(2) ∈ GF (2)3 und a(1) ∈ GF (2)6 konstruieren. Wir benutzen dazu den BCHCode C (1) (2; 31, 210 , 12). Der BCH-Code C (2) (2; 31, 25 , 16) ist ein Untercode des BCH-Codes C (1) . Für die Generatorpolynome g1 (x) und g2 (x) der beiden Codes gilt g2 (x) = ∆(x) · g1 (x). Zunächst verkürzen wir beide Codes indem wir 3 statt 5 bzw. 9 statt 10 Informationssymbole benutzen, d. h.: B(2) (2; 29, 23 , 16)

und

B(1) (2; 30, 29 , 12) .

Nun wenden wir Methode 3 an, damit gilt: b(x) = a2 (x) · g2 (x) + x3 · a1 (x) · g1 (x) ∈ B(1) . Dabei sind a1 (x) und a2 (x) die entsprechenden Polynome von a(1) und a(2) . Für ein Codewort b(x) können wir nun sowohl a(1) als auch a(2) entsprechend Beispiel 9.6 berechnen. 

324

9 Verallgemeinerte Codeverkettung

Beispiel 9.8 (Partitionierung in Codes unterschiedlicher Länge) In diesem Beispiel wollen wir eine Partitionierung mit der Nummerierung a(1) ∈ GF (2)8 und a(2) ∈ GF (2)8 berechnen. Hierzu wollen wir den BCH-Code C (1) (2; 31, 216 , 7) benutzen. Ein Untercode von C (1) ist der BCH-Code C (2) (2; 31, 210 , 12). Die entsprechenden Generatorpolynome sind g1 (x) und g2 (x), mit g2 (x) = ∆(x) · g1 (x). Durch Verkürzen erhalten wir B(2) (2; 29, 28 , 12)

B(1) (2; 31, 216 , 7).

und

Die Partitionierung kann nun entsprechend Beispiel 9.7 berechnet werden.



Beispiel 9.9 (5-fache Partitionierung) Wir wollen die Methode 3 verwenden, um den BCH-Code B(1) (2; 31, 225 , 4) 5-fach zu partitionieren. Die Nummerierung soll mit a(i) ∈ GF (2)5 durchgeführt werden. Dabei benutzen wir die folgenden BCH-Codes: B(5) (2; 31, 5, 16) ⊂ B(4) (2; 31, 10, 12) ⊂ B(3) (2; 31, 15, 8) ⊂ B(2) (2; 31, 20, 6) ⊂ B(1) (2; 31, 25, 4). Sei systematische Codierung vorausgesetzt, dann ergibt sich ein Codewort b(1) ∈ B(1) wie folgt: v5 :

a(5)

∈ B(5)

v4 :

0

a(4)

v3 :

0

0

a(3)

v2 :

0

0

0

a(2)

v1 :

0

0

0

0

∈ B(4) ∈ B(3) ∈ B(2) a(1)

∈ B(1)

b(1) = v1 + v2 + v3 + v4 + v5 ∈ B(1) . Das Wort a(5) ist unverändert im Codewort b(1) enthalten. Für jedes gegebene b(1) können alle a(i) , i = 1, 2, . . . , 5, berechnet werden. 

Die vorangegangenen Beispiele lassen sich durch den folgenden Satz verallgemeinern: Satz 9.3 (Konstruierbarkeit der Partitionierung) Gegeben sei B (2) (q; n, k (2) , d(2) ) ⊂ B (1) (q; n, k (1) , d(1) ), mit k (2) + m = k (1) , d(2) > d(1) . Mit Methode 3 kann eine Partitionierung für die Alphabete a(1) ∈ GF (q)µ1 und a(2) ∈ GF (q)µ2 konstruiert werden, wenn gilt: µ2 ≤ k (2)

und

µ1 ≤ m + (k (2) − µ2 ) .

Beweis: G(2) sei die Generatormatrix von B(2) . Sei a(2) ∈ GF (q)µ2 , a(1) ∈ GF (q)µ1 , dann gilt a(2) · G(2) = b(2) ∈ B(2) . Für µ2 < k(2) ist dies ein Codewort eines verkürzten Codes. Um nun (1) das Codewort b(1) ∈ B(1) zu konstruieren, bilden wir (0|a(1) ) ∈ GF (q)k mit 0 ∈ GF (q)µ2 . (1) Damit gilt: a(1) ∈ GF (q)k −µ2 und k(1) = k(2) + m. 2

9.2 GC-Codes mit Blockcodes

325

Anmerkung: Falls µ1 + µ2 < k (1) ist, können wir beide Codes B (1) und B (2) verkürzen. Außerdem können die Codes B (1) und B (2) bereits verkürzte Codes sein. Als nützlich für die später beschriebene Decodierung wird sich die folgende Eigenschaft von Methode 3 erweisen. Sie besagt, dass zwei unterschiedliche Codeworte eines Codes, die nicht in demselben Untercode sind, sich in ihrer Nummer a(1) unterscheiden müssen. Satz 9.4 (Eindeutigkeit der Partitionierung) Gegeben sei eine Partitionierung des Codes B (1) mittels Methode 3. Es gilt: B (2) (q; n, k (2) , d(2) ) ⊂ B (1) (q; n, k (1) , d(1) ).   ˆ durch a ˆ(1) , a ˆ(2) . Außerdem gelte Das Codewort b sei definiert durch a(1) , a(2) , und b ˆ Für jedes v = b − b ˆ ∈ B (1) , v 6= 0 und v 6∈ B (2) gilt: a ˆ(1) 6= a(1) . b 6= b. Beweis: G(1) und G(2) seien die Generatormatrizen der beiden Codes. Da beide Codes linear sind, können wir annehmen a(1) = a(2) = 0. Damit gilt: ˆ (2) · G(2) − (0|ˆ v =0−a a(1) ) · G(1) . ˆ (1) 6= 0 gelten muss. Da v 6∈ B(2) ist, folgern wir, dass a

9.2.3

2

Codekonstruktionen

Wir wollen zunächst Beispiele von Partitionierungen aus dem vorherigen Abschnitt benutzen, um einige Konstruktionen für GC-Codes zu beschreiben. Zum Vergleich soll zuvor herkömmliche Codeverkettung betrachtet werden, d. h. ohne Partitionierung des inneren Codes (siehe hierzu Beispiel 9.20 aus Abschnitt 9.2.4). Beispiel 9.10 (Verkettung von QR- und RS-Codes) Der QR-Code B(1) (2; 17, 8, 6) sei der innere und der RS-Code A(1) (28 ; 255, 223, 33) sei der äußere Code (Der RS-Code ist der Standardcode in der Satellitenkommunikation, siehe [WHPH87]). Die Zahlen a(1) ∈ GF (2)8 nummerieren die Codewörter des Codes B(1) (man kann sie als Informationsteil ansehen). Der verkettete Code hat die Länge na · nb = 255 · 17 = 4335, die Anzahl der Informationszeichen aus GF (2) ist 223 · 8 = 1784, und für die Mindestdistanz gilt: d ≥ 6 · 33 = 198. Wir konstruieren mit den gleichen Codes einen GC-Code, indem wir zusätzlich den inneren Code B(2) (2; 17, 16, 2), d. h. einen Parity-Check-Code, und als äußeren Code einen Wiederholungscode A(2) (28 ; 255, 1, 255) benutzen. Die Partitionierung sei wieder mittels Methode 3 durchgeführt. Das heißt, wir haben die Codes CC und CGC mit den Parametern CC (2; 4335, 1784, 198)

und

CGC (2; 4335, 1792, 198)

konstruiert. Der GC-Code hat bei gleicher Mindestdistanz 64 mal mehr Codeworte.



Im folgenden wollen wir einen GC-Code mit einer Partitionierung höherer Ordnung konstruieren. Beispiel 9.11 (Verkettung von BCH- und RS-Codes) In Beispiel 9.9 haben wir eine Partitionierung 5. Ordnung des BCH-Codes B(1) (2; 31, 225 , 4) angegeben. Wir hatten dort die Nummerierung a(i) ∈ GF (2)5 , i = 1, 2, . . . , 5, gewählt. Das bedeutet, dass wir 5 äußere Codes über dem Alphabet GF (2)5 brauchen.

326

9 Verallgemeinerte Codeverkettung

Entsprechend Abschnitt 9.2.2 haben die BCH-Codes die folgenden Mindestdistanzen: (i)

B(i) (2; 31, 25(6−i) , db ), (1)

db

= 4,

(2)

db

i = 1, 2, . . . , 5, (3)

= 6,

db

= 8,

(4)

db

= 12,

(5)

db

= 16.

Wollen wir einen GC-Code mit der Mindestdistanz d ≥ 96 konstruieren, so benötigen wir wegen d ≥ min

i=1,...,5

˘

(i)

db · d(i) a

¯

äußere Codes mit den folgenden Mindestdistanzen: d(1) a = 24,

d(2) a = 16,

d(3) a = 12,

d(4) a = 8,

d(5) a = 6.

Als äußere Codes können wir die folgenden RS-Codes wählen: (i) A(i) (25 ; 31, ka(i) = 31 − d(i) a + 1, da ),

i = 1, 2, . . . , 5.

Der GC-Code hat dann die Parameter Länge: Mächtigkeit:

n = na · nb = 312 = 961, 5 Y M= Ma(i) = 2470 , i=1

Mindestdistanz:

d ≥ 96.

CGC (2; 961, 2470 , 96).



Modifikationen von Rate, Länge und Mindestdistanz von GC-Codes Wie schon in Abschnitt 8.1.10 erwähnt, gibt es Anwendungen der Kanalcodierung, bei denen Codes verschiedener Raten verwendet werden, um die Codierung einem sich ändernden Kanal anzupassen. Im folgenden wollen wir mögliche Modifikationen von GC-Codes untersuchen, um Codes verschiedener Raten und Mindestdistanzen aus einem gegebenen GC-Code erzeugen zu können. Dazu werden wir nur die Erweiterung und die Verkürzung von Codes benutzen (siehe Abschnitt 4.3). (1)

(1)

Ist eine Partitionierung der Ordnung s eines Codes B (1) (q; nb , Mb , db ) gegeben, dann sind damit offensichtlich auch Partitionierungen kleinerer Ordnungen (s − j), j = 0, 1, . . . , s−1, definiert. Mit anderen Worten, jede zusammenhängende (s−j)-Teilmenge der Nummerierung der Partitionierung der Ordnung s ist wiederum eine mögliche Nummerierung. Die Teilmengen  a(j0 ) , a(j0 +1) , . . . , a(j0 +s−j−1) ,

j0 = 1, 2, . . . , j,

(9.4)

mit a(i) ∈ GF (q)µi sind gültige Nummerierungen von Partitionierungen der Ordnung s − j.

9.2 GC-Codes mit Blockcodes

327

Die Mindestdistanzen der inneren und äußeren Codes des GC-Codes mit der Partitionierung der Ordnung s sind bekannt, nämlich: (1)

(2)

(s)

d(1) a ,

d(2) a ,

d(s) a .

für die inneren Codes db , db , . . . , db für die äußeren Codes

...,

und

Für den GC-Code, der durch die Wahl einer Untermenge j0 , j0 + 1, . . . , j0 + s − j − 1, definiert wird, ist damit die Mindestdistanz und die Mächtigkeit, und somit auch die Coderate bestimmt. Eine weitere Modifikation besteht darin, den inneren Code B (1) um µs−j+1 + · · · + µs Stellen zu kürzen. Das bedeutet, wir haben j0 = 1 in der Gleichung (9.4) gewählt. Wir benutzen die Nummerierung a(1) , a(2) , . . . , a(s−j) , um eine Partitionierung gemäß Methode 3 aus Abschnitt 9.2.2 der Ordnung (s − j) zu nummerieren. Es ist ersichtlich, dass die Codewörter b(1) aus dem verkürzten Code B (1) stammen. Wählen wir jetzt die äußeren Codes A(1) , A(2) , . . . , A(s−j) , dann ergibt sich ein GC-Code C 0 mit derselben Mindestdistanz wie C, der Länge n0 = Qs−j (i) na · (nb − (µs−j+1 + · · · + µs )) und der Mächtigkeit M 0 = i=1 Ma .

Bemerkenswert bei dieser Möglichkeit ist, dass sich die benutzen Codes nicht geändert haben. Man kann also alle Codierer und Decodierer unverändert benutzen. Im folgenden wollen wir die Mindestdistanz modifizieren, wiederum ohne die benutzten Codes zu ändern. Hierzu nehmen wir an, dass alle a(i) , i = 1, 2, . . . , s, aus demselben Alphabet entstammen. Wir wählen j0 > 1 in Gleichung (9.4), benutzen aber die äußeren Codes A(1) , A(2) , . . . , A(s−j) , um die Nummerierung a(j0 ) , a(j0 +1) , . . . , a(j0 +s−j−1) ,

j0 > 1,

gegen Fehler zu schützen. Wir haben damit einen GC-Code C 0 konstruiert, der eine größere Mindestdistanz als C (i) hat, da db mit i größer wird. Deshalb gilt die Beziehung: d0 ≥

min

i=1,...,s−j

(i+j0 −1)

{db

· d(i) a } > d.

Die Länge bleibt bei dieser Modifikation unverändert (n0 = n), und die Mächtigkeit ist Qs−j (i) M 0 = i=1 Ma .

328

9 Verallgemeinerte Codeverkettung

Ein GC-Code kann auch dadurch modifiziert werden, indem man alle äußeren Codes um dieselbe Anzahl von Stellen verkürzt bzw. erweitert. Bei der Verkürzung der äußeren Codes ergibt sich ein GC-Code C 0 derselben Mindestdistanz, kleinerer Länge und kleinerer Mächtigkeit. Bei der Erweiterung (um eine Stelle) ergibt sich ein GC-Code C 0 mit gleicher Mächtigkeit, aber größerer Mindestdistanz und Länge. Derselbe Effekt ergibt sich, wenn der innere Code um eine Stelle erweitert wird. Es existieren viele weitere Varianten wenn wir zusätzlich andere äußere Codes zulassen, d. h. die Menge der Codes A(i) , i = 1, 2, . . . , s, vergrößern, um für die unterschiedlichen Modifikationen ≤ s davon auszuwählen. Dies ist bei RS-Codes als äußere Codes sehr naheliegend, da bei dieser Codeklasse wegen der MDS Eigenschaft nicht nur sehr einfach die Mächtigkeit verändert werden kann, sondern auch die Decodierer für Codes mit verschiedener Mindestdistanz sehr ähnlich sind. Verständlicherweise konnten wir nicht auf alle möglichen Modifikationen eingehen, deren Notwendigkeit maßgeblich durch die Randbedingungen bestimmt wird, unter denen ein GC-Code eingesetzt werden soll. Sie werden verwendet, um einen Code für eine schon vorgegebene Anzahl von Informations- und Codezeichen maßzuschneidern. Ein weiteres Beispiel soll das Gesagte vertiefen. Beispiel 9.12 (Modifikation eines GC-Codes) Aus Beispiel 9.9 kennen wir eine Partitionierung der Ordnung 5 des BCH-Codes B(1) (2; 31, 225 , 4). Damit haben wir in Beispiel 9.11 den GC-Code C(2; 961, 2470 , 96) konstruiert. Diesen Code wollen wir nun modifizieren. Zunächst, indem wir den inneren Code um 10 Stellen verkürzen. Außerdem benutzen wir die Nummerierung a(i) ∈ GF (2)5 , i = 1, 2, 3, mit den 3 äußeren Codes (i) A(i) (25 ; 31, ka(i) = 31 − d(i) a + 1, da ),

i = 1, 2, 3.

Diese haben die Mindestdistanzen: d(1) a = 24,

d(2) a = 16,

d(3) a = 12.

Jetzt benutzen wir Methode 3 von Abschnitt 9.2.2, um den inneren Code zu partitionieren. Damit erhalten wir den GC-Code C 0 C 0 (2; 651, 2220 , 96).

Nun wollen wir die Mindestdistanz verändern. Hierzu verwenden wir die inneren Codes B(i) und die Nummerierung a(i) ∈ GF (2)5 , i = 3, 4, 5, aber die gleichen 3 äußeren Codes (i) A(i) (25 ; 31, ka(i) = 31 − d(i) a + 1, da ),

i = 1, 2, 3,

und erhalten einen GC-Code C 0 (2; 961, 2220 , 192).

Die Länge und die Mächtigkeit von C 0 sind offensichtlich. Wir haben für die inneren Codes (3) (4) (5) die Mindestdistanzen db = 8, db = 12 und db = 16 benutzt. Damit können wir die 0 Mindestdistanz des GC-Codes C abschätzen durch: d0 ≥ min {8 · 24, 12 · 16, 16 · 12} = 192.



9.2 GC-Codes mit Blockcodes

329

Vergleich von Codeverkettungen Treten bei einem Nachrichtenübertragungssystem vornehmlich Bündelfehler auf, etwa im Mobilfunk, so wird Interleaving eingesetzt, um die Bündelfehler in Einzelfehler umzuwandeln (siehe Abschnitt 8.4.4). Für Faltungscodes ist Interleaving die einzige Möglichkeit, um die Korrektureigenschaften im Falle von Bündelfehlern zu verbessern. Bei Blockcodes müssen wir differenziertere Aussagen machen. Eigentlich ist nur wichtig, genügend gute Stellen zu haben, mit denen man die schlechten Stellen korrigieren kann. Das wird durch die Verwendung sehr langer Blockcodes erreicht. Andererseits wird bei der Codeverkettung der Effekt ausgenutzt, dass ein Bündelfehler einige Codewörter des inneren Codes vollständig verfälscht, andere innere Codewörter aber dafür fehlerfrei sind. Das bedeutet, im Falle von Codeverkettung sind Bündelfehler sogar von Vorteil (siehe auch Abschnitt 9.2.4). Eine sehr häufig vorgeschlagene Methode für Codes im Falle von Bündelfehlern ist die folgende, siehe z. B. [DC87, HEK87, KL87] und [KTL86]. Ein linearer innerer Code B(q; nb , kb , db ) wird mit einem linearen äußeren Code A(q µ ; na , ka , da ) verkettet. Für die Parameter muss gelten: ν · u = kb und na = 0 mod u. Die Codierung erfolgt in zwei Schritten. Zunächst werden die µ · ka Informationszeichen aus GF (q) mit dem äußeren Code A codiert und das Codewort in einer (u × kb )-Matrix dargestellt. Die Elemente der Matrix sind also aus GF (q). Nun wird im zweiten Schritt jede Zeile mit dem inneren Code B codiert. Ein Codewort ist damit eine (u × nb )-Matrix, wobei jede Zeile ein Codewort des inneren Codes B ist. Üblicherweise wird vorgeschlagen, Interleaving der Tiefe u zu verwenden (siehe [Bla, S. 116]). Damit erhalten wir u Codewörter des äußeren Codes A in einer Matrix mit (j) Elementen ai ∈ GF (q)µ : 

(1)

(2)

a a  1(1) 1(2)  a2 a2  . ..  .  . . (1) (2) ana ana

 (u) . . . a1 (u)  . . . a2  .  .. . . ..  (u) . . . ana

(9.5)

Eine solche Matrix kennen wir aber schon. Sie hat dieselbe Form wie diejenige, die wir in Gleichung (9.1) für GC-Codes konstruiert haben. Der Unterschied zu GC-Codes ist nun auch offensichtlich: Es wird hier keine Partitionierung des inneren Codes benutzt. Das hat die folgenden Konsequenzen: Wenn wir die Mindestdistanz konstant halten, hat ein GC-Code eine größere Coderate als der oben konstruierte Code. Wenn wir die Coderate konstant halten, hat der GC-Code eine größere Mindestdistanz. Wie groß ist der Gewinn, den wir mit einem GC-Code gegenüber einem gespreizten Code erzielen können? Wir bezeichnen einen gespreizten Code mit Cu . Er habe die Länge nu = na · nb , die Mächtigkeit Mu = (q µ )u·ka und die Mindestdistanz du ≥ da · db (entsprechend Satz 9.1 zu GC-Codes). Der folgende Satz gibt eine Abschätzung des Gewinns bei Benutzung

330

9 Verallgemeinerte Codeverkettung

von GC-Codes anstatt des Codes Cu an, wenn die Mindestdistanz konstant gehalten wird. Satz 9.5 (Verbesserung der Coderate) Seien Ra und Rb die Coderaten des inneren BCH-Codes B und der u äußeren RS-Codes A, mit denen der Code Cu konstruiert wurde. ∆R ist die Differenz der Coderate eines Codes Cu und eines GC-Codes gleicher Mindestdistanz und gleicher Länge n. Dann gilt die Beziehung:   da 1 u − 2 + u−1 ≤ ∆R < (1 − Ra )Rb . n 2 Beweis: Die linke Ungleichung ergibt sich durch die Annahme, dass sich die Mindestdistanz bei einer Partitionierung um mindestens 2 pro Untercode erhöht. Damit ergibt sich die Anzahl der zusätzlichen Informationszeichen des äußeren Codes A(i) zu da − da /2i−1 . Die Zunahme der Coderate ist also mindestens „ « u 1 X da da 1 · da − i−1 = u − 2 + u−1 . n i=2 2 n 2 Die rechte Ungleichung erhält man aus der trivialen Beziehung RGC < Rb durch Subtraktion von Ra · Rb . 2

Die Interpretation des Satzes 9.5 ist, dass der erzielbare Gewinn mit GC-Codes klein ist, wenn der gespreizte Code aus einem inneren Code mit kleiner und einem äußeren Code mit großer Coderate erzeugt wurde. Wir wollen diesen Sachverhalt noch an einem Beispiel erläutern. Beispiel 9.13 (Verbesserung der Coderate) Wir wählen ein Beispiel aus [HEK87]. Dort wurde die Verkettung von RS- und BCH-Codes für Satellitenkanäle mit Nebensprechen untersucht. In dieser Veröffentlichung wird ausdrücklich darauf hingewiesen, dass wegen den ausgeprägten Bündelstörungen nur verkettete Codes benutzt werden können. Es wurde unter anderem ein BCH-Code B(2; 31, 21, 5) als innerer Code verkettet mit einem äußeren RS-Code A(25 ; 31, 23, 9). Dadurch wurde ein Code Cu mit der Coderate Ra · Rb = 0.5 und der Mindestdistanz 45 erzeugt. Wir wollen nun diese Parameter mit denen von möglichen GC-Codes vergleichen. Zunächst halten wir die Mindestdistanz konstant. Die Partitionierung des BCH-Codes B(1) (2; 31, 20, 6) ergibt (siehe Beispiel 9.9): B(4) (2; 31, 5, 16) ⊂ B(3) (2; 31, 10, 12) ⊂ B(2) (2; 31, 15, 8) ⊂ B(1) (2; 31, 20, 6) mit der Nummerierung a(i) ∈ GF (2)5 , i = 1, 2, 3, 4. Dabei haben wir auf ein Informationsbit des inneren Codes verzichtet. Vergleiche hierzu die Methode 3 aus Abschnitt 9.2.2. Als äußere Codes wählen wir RS-Codes der Länge 31 mit den Mindestdistanzen d(1) a = 8,

d(2) a = 6,

d(3) a = 4,

d(4) a = 3.

9.2 GC-Codes mit Blockcodes

331

Wir haben einen GC-Code mit der Mindestdistanz 48 und der Coderate 0.56 konstruiert. Der Unterschied in der Coderate ist also ∆R = 0.06. Aus Satz 9.5 erhalten wir die Abschätzung 0.02 ≤ 0.06 < 0.17. Die Zahl 0.06 scheint klein, aber man beachte, dass die Anzahl der zusätzlichen Informationsbits pro Codewort 0.06 · 961 ≈ 57 ist, d. h. 257 mal so viele Codeworte. Einen weiteren möglichen GC-Code konstruieren wir wie folgt: Wir partitionieren den BCHCode B(1) (2; 31, 30, 2) in 5 Untercodes (Ordnung 6). Wir benutzen als äußere Codes erneut RS-Codes der Länge 31 und erhalten einen GC-Code mit der Mindestdistanz 48 und der Rate 0.666. Weiterhin haben wir in unserem Beispiel 9.9 einen GC-Code mit der Mindestdistanz 96 und der Rate 0.49 konstruiert. 

9.2.4

Decodierung von GC-Codes

Die Decodierung von verallgemeinert verketteten Codes erfolgt in mehreren Stufen, wobei die Anzahl dieser Stufen der Partitionierungsordnung des inneren Codes bzw. der Anzahl der äußeren Codes entspricht. In jeder Decodierstufe i wird das empfangene Wort zuerst zeilenweise bezüglich des Untercodes B (i) decodiert. Anschließend erfolgt eine Decodierung bezüglich des zugehörigen äußeren Codes A(i) , wodurch das Coset von B (i+1) für den folgenden Decodierschritt festgelegt wird. Dieses Prinzip soll zunächst an einem konkreten Beispiel plausibel gemacht werden. Beispiel 9.14 (Decodierung von verallgemeinert verketteten Codes) Ein Codewort des GC-Codes aus Beispiel 9.2 wird bei der Übertragung verfälscht. Es sind sieben Fehler aufgetreten (im Bild 9.10 nach der Übertragung grau markiert). 1

1

1

1

0

0

0

1

0

0

0

1

1

0

1

1

1

1

0

0

0

1

1

1

1

0

1

0

0

0

1

0

0

0

1

0

0

1

1

0 0

1

A

1

0

1

1

AH

|

{z

∈A

}

| {z }

∈ AH

Abbildung

|

}∈ Bi(2) 0 i1

0

0

1

1

1

0

0

1

1

0

0

0

0

¨ 0 Ubertragung 1

1

0

0

0

1

1

0

0

1

1

0

1

1

0

0

1

1

0

0

1

1

0

0

1

1

1

1

0

0

1

1

0

0

{z

}

∈ CGC

Abb. 9.10: Codierung und Übertragung des GC-Codes aus Beispiel 9.2. Die Decodierung erfolgt in zwei Stufen (entsprechend Bild 9.11): Zuerst wird das empfangene Wort bezüglich B(1) decodiert und eine Rückabbildung mit Hilfe des Partitionierungsschemas aus Bild 9.4 durchgeführt. Das Decodierergebnis des Codewortes aus A(1) legt dann den Untercode B(2) fest, der für eine erneute Decodierung des empfangenen Wortes zugrunde gelegt wird. Da B(2) eine größere Mindestdistanz als B(1) aufweist, kann in dieser Stufe der Fehler in der dritten Zeile des Codewortes korrigiert werden. Zum Abschluß wird noch das Codewort aus

332

9 Verallgemeinerte Codeverkettung

0

0

1

1

1

0

0

1

1

0

0

0

1

1

0

0

0

0

1

0

0

0 1

Decod. bzgl. B (1)

0

0

1

1

0

1

0

0

1

1

0

0

1

1

1

1

1

⊗ ⊗

0

1

0

1



Decod. 0 bzgl. A(1)

1

0

1 1

⊗ ⊗ ⊗ ⊗

R¨ uckabb.

1

1

0

0

1

0

0

1

1

0

1

0

0

1

1

0

0

1

1

0

1

0

0

1

0

1

1

0

0

1

1

0

1

0

0

1

1

0

0

1

1

0

0

0

1

1

0

1

bestimmt Code B (2)

0

Decod.

(2)

bzgl. B01

⊗ Ausl¨ oschung fehlerhaft

1

0

1

0

1

⊗ ⊗ ⊗ ⊗

0

1

0

1

0

1

1

0

0

0

1

⊗ 1

1

1

1

0

0

0

1

1

1

0

0

1

1

0

1

0

0

0

1

1

0

1

0

Decod. 0 bzgl. A(2)

0

0

1

1

0

1

0

0

1

1

0

0

0

1

1

1

R¨ uckabb.

0

0

1

Extraktion der Informationssymbole

1

0

1

1

Abb. 9.11: Decodierung mit dem GCD-Algorithmus.

A(2) decodiert. In diesem Beispiel konnten alle sieben aufgetretenen Fehler korrigiert werden, was der halben Mindestdistanz des verketteten Codes entspricht: —  16 − 1 = 7.  2

Wir wollen in diesem Abschnitt eine Modifikation des Decodieralgorithmus nach BlokhZyablov für GC-Codes angeben, die aus zwei verschiedenen Algorithmen besteht. Einen Algorithmus für den ersten Schritt der Decodierung, der GCD-1 genannt werden soll, und einen zweiten für alle weiteren Decodierschritte, der GCD-i heißen soll. Der Algorithmus GCD-1 ist eine Verallgemeinerung des Algorithmus aus [Zin81], der dort für alle s Schritte benutzt wird. Diese Modifikation ist notwendig, wenn man Decodierer für die inneren Codes einsetzen will, die auch Fehler vom Gewicht größer als die halbe Mindestdistanz decodieren können (etwa ML-Decodierer oder Decodierer, die Zuverlässigkeitsinformation benutzen können). Die getrennte Behandlung der Folgeschritte mittels GCD-i bietet die Möglichkeit, Informationen aus dem vorhergehenden Schritt bei der Decodierung zu berücksichtigen. Wir werden zeigen, dass die Einführung von GCD-i, im Vergleich zu den vorher beschriebenen Decodieralgorithmen, eine Erhöhung der Decodierkapazität bei gleichzeitiger Verringerung der Komplexität liefert. Wir wollen uns bei den Erläuterungen in diesem Kapitel auf lineare innere und äußere Codes über endlichen Körpern beschränken. Die Modifikationen, die im Falle von nichtlinearen Codes oder Codes über Räumen mit anderer als der Hamming-Metrik notwendig sind, ergeben sich unmittelbar.

9.2 GC-Codes mit Blockcodes

333

Zunächst soll die Notation, die wir im Folgenden benutzen, angegeben bzw. wiederholt werden. Der Code C(q; n, M, d) sei ein GC-Code basierend auf einer Partitionierung der Ordnung (1) (1) (i) (i) s eines inneren Codes B (1) (q; nb , kb , db ) und den äußeren Codes A(i) (q; na , ka , da ), i = 1, 2, . . . , s, wie in Abschnitt 9.2.1 beschrieben. Ein Codewort c ∈ C besteht aus na (1) Codewörtern der Länge nb des inneren Codes, d. h. bj ∈ B (1) , j = 1, 2, . . . , na . Ein Codewort c wird über einen q-nären symmetrischen Kanal (siehe Bild 7.2) über(1) tragen. Dabei wird jede Zeile bj der Matrix c durch den Kanalfehler ej ∈ GF (q)nb (1)

verfälscht. Die empfangenen Zeilen sind dann rj = bj + ej , j = 1, 2, . . . , na . Die Fehlervektoren ej werden im Folgenden Kanalfehler genannt. Das Symbol ⊗ kennzeichnet eine Auslöschung. Damit können wir nun den Decodieralgorithmus für den ersten Schritt beschreiben.



Xν+1 = J⊗



wt(f ) = ν

Xν = J⊗ ∪Jν

R¨ uckabbildung

wt(f ) = ν −1













⊗ ⊗ ⊗ ⊗

wt(f ) = ν Decodierung bzgl. B und



Xν−1 = J⊗ ∪Jν ∪Jν−1

wt(f ) = ν −1

⊗ ⊗ ⊗ ⊗ ⊗ ⊗ ⊗

wt(f ) = 0 wt(f ) = 0

Empfangswort

Abb. 9.12: Auslöschungskorrektur im ersten Decodierschritt beim GCD.

GCD-1: Decodierer für den ersten Schritt In jedem Decodierschritt wird nach der Decodierung des inneren Codes eine Auslöschungskorrektur (siehe Abschnitt 3.2.7) des äußeren Codes vorgenommen. Dies erfolgt ganz ähnlich wie bei dem in Abschnitt 7.4.1 beschriebenen GMD-Verfahren. Der äußere Code wird also wiederholt decodiert, wobei jedes Mal mehr unzuverlässige Symbole als Auslöschung gesetzt werden (siehe Bild 9.12). Der Abbruch erfolgt, wenn die Anzahl der geschätzten Fehler das Korrekturvermögen nicht mehr übersteigt. Wird ein HD-Decodierer für den inneren Code verwendet, so stellt die Anzahl der im inneren Codewort korrigierten Symbole die Zuverlässigkeit des zugehörigen Symbols des äußeren Codes dar. Deshalb werden die Decodierergebnisse des inneren Decoders im Folgenden in entsprechende Mengen eingeteilt. Selbstverständlich kann hier auch das Konzept des MAP-Decodierers (Abschnitt 7.2.2) eingesetzt werden, um entsprechende Zuverlässigkeitswerte zu erhalten.

334

9 Verallgemeinerte Codeverkettung (1)

(1)

Jede empfangene Zeile rj = bj + ej , j = 1, 2, . . . , na , muss im ersten Schritt mit einem Decodierer für den inneren Code B (1) decodiert werden. Das Ergebnis dieser Decodierung sei  (1) ˆ (1) = bj + ej − fj . b (9.6) j ⊗ Eine Auslöschung ergibt sich z. B. dann, wenn der Decodierer keine Lösung finden kann. (1) ˆ (1) 6= ⊗ kann nun eindeutig ein Zeichen a Aus jedem b ˆj aus dem Alphabet GF (q)µ1 j (1)

des ersten äußeren Codes A(1) bestimmt werden. Wird das Zeichen aj

übertragen,

(1)

können folgende Decodierergebnisse a ˆj auftreten:  (1)  falls fj = ej (korrekte Decodierung)  aj (1) a ˆj = 6= a(1) falls f = 6 e (Decodierfehler) j j j   ˆ ⊗ falls bj = ⊗ (Decodierversagen).

(9.7)

Wir wollen nun die Resultate der Decodierung, abhängig von der Anzahl der im inneren Decoder korrigierten Stellen, in verschiedene Mengen Jw enteilen.

Definition 9.6 (Korrigierte Stellen) Die na Zeilen des GC-Codes, die der innere Decodierer B (1) an w Stellen korrigiert hat, werden in Mengen Jw zusammengefasst. Die Menge J⊗ enthält alle Zeilen, bei denen ein Decodierversagen aufgetreten ist: Jw = {l | wt(fl ) = w, l = 1, 2, . . . , na } , ˆl = ⊗, l = 1, 2, . . . , na } . J⊗ = {l | a

w = 0, 1, 2, . . . , ν

Ein wesentlicher Unterschied zu der Definition in [Zin81] besteht darin, dass die Zahl ν nicht beschränkt ist. Die Zahl ν hängt nämlich vom Decodierer ab und ist im Falle eines ML-Decodierers größer als die halbe Mindestdistanz. Wir wollen nun noch die vom inneren Decodierer falsch decodierten Zeilen in der Menge E zusammenfassen:  (1) ˆl 6= ⊗, l = 1, 2, . . . , na . E = l | fl 6= el , a (9.8)

Die Menge Jw kann Zeilen beinhalten, deren korrigierte Stellen genau den Kanalfehlern entsprechen (korrekte Decodierung). Sie kann aber auch Zeilen beinhalten, die Decodierfehler sind. Wir wollen die Anzahl der falsch decodierten Zeilen, d. h. der Decodierfehler in der Menge Jw , mit tw bezeichnen und mit sw die Anzahl der korrekten Decodierungen. Formal ausgedrückt lautet dies: tw = |Jw ∩ E| sw = |Jw | − tw

w = 0, 1, . . . , ν.

(9.9)

Wir werden häufig Vereinigungsmengen der Mengen Ji benötigen. Wir wollen diese Vereinigungsmengen folgendermaßen definieren: ! ν [ Xj = J⊗ ∪ Ji , j = ν, ν − 1, . . . , 0. (9.10) i=j

9.2 GC-Codes mit Blockcodes

335

Schließlich definieren wir noch die Zahl v, die die Menge Xv festlegt, deren Mächtigkeit gerade noch kleiner als die Mindestdistanz des äußeren Codes ist: (1) v : |Xv | < d(1) a , |Xv−1 | ≥ da .

(9.11)

Wir können die Gewichte der Kanalfehler, die den Elementen einer Menge Jw entsprechen, angeben bzw. abschätzen. Das Gewicht ist genau gleich w, wenn das Element (1) nicht gleichzeitig der Menge E angehört, und sonst größer gleich db − w. Also:

∀ j∈J

  wt(ej ) ≥ 

(1)

db 2

, j ∈ J⊗ n (1) o db (1) wt(ej ) ≥ max db − w, 2 , j∈E    wt(ej ) = w , j 6∈ E .

:

w

(9.12)

Algorithmus 9.1 listet die notwendigen Schritte für GCD-1 auf. Es bleibt noch zu zeigen, dass dieser Algorithmus einen GC-Code bis zur halben Mindestdistanz korrigieren kann. Dazu benötigen wir einige Abschätzungen der Anzahl der Kanalfehler. Anmerkung: Prinzipiell können die Folgeschritte ebenfalls mit diesem Algorithmus durchgeführt werden. Das bedeutet für Leser, die nur am Verständnis der Decodierung interessiert sind, dass der folgende Beweis und die Modifikationen für die weiteren Schritte (Algorithmus GCD-i) überschlagen werden und auf Seite 342 fortgefahren werden kann. Wir wollen zwei Abschätzungen für die Anzahl der Kanalfehler aus den Mengen Jw aus Definition 9.6 herleiten. Die erste Abschätzung in Satz 9.7 ist eine untere Schranke, die die Anzahl der Kanalfehler von zwei Elementen aus derselben oder verschiedenen Mengen Ji abschätzt. Die zweite Abschätzung in Satz 9.8 stellt ebenfalls eine untere Schranke dar, die die Anzahl der Kanalfehler innerhalb einer Menge Ji abschätzt. Satz 9.7 (Kanalfehler in zwei Zeilen) Sei m ∈ Jw , j ∈ Jl und m ∈ E, j 6∈ E, dann gilt für die Gewichte der Kanalfehler:



l≥w

:

(1)

wt(em ) + wt(ej ) ≥ db . (1)

Beweis: Aus Gleichung (9.12) wissen wir, dass gilt: wt(em ) ≥ db − w, (1) (1) ergibt sich direkt: wt(em ) + wt(ej ) ≥ db − w + l ≥ db für l ≥ w.

wt(ej ) = l. Daraus 2

Satz 9.8 (Kanalfehler in der Menge Jw ) Die Anzahl der Kanalfehler in einer Menge Jw kann mittels der Parameter sw und tw abgeschätzt werden:

∀ : w∈{0,...,ν}

( (1) d |Jw | b2 wt(ej ) ≥ (1) tw db + (sw − tw )w j∈Jw X

für für

sw ≤ tw sw > tw .

336

9 Verallgemeinerte Codeverkettung

Algorithmus 9.1: Der Decodieralgorithmus GCD-1. Empfangen: rj , j = 1, 2, . . . , na  ˆj b Ergebnis des inneren Decodierers für rj = ⊗ Bestimme:

ˆ j 6= ⊗ −→ a ˆ j , j = 1, 2, . . . , na b v Jw , w = 0, 1, 2, . . . , ν und J⊗ Xj , j = ν, ν − 1, . . . , v

(Gl. (9.7)) (Gl. (9.11)) (Def. 9.6) (Gl. (9.10))

Initialisierung: j = ν + 1, X = ∞

Schritt 1: Falls j < v dann Schritt 5  (1) ˆ i , i 6∈ Xj a Schritt 2: zi = i = 1, 2, . . . , na ⊗, i ∈ Xj

˜2 , . . . , a ˜ na ) Schritt 3: decodiere (z1 , z2 , . . . , zna ) mit dem Decodierer für den Code A(1) zu (˜ a1 , a Schritt 4: Die Menge Tj der Zeilen, die der äußere Code korrigiert (verändert), ist ˆ l 6= a ˜l , a ˆ l 6= ⊗, l = 1, 2, . . . , na }. Tj = {l | a Bei Decodierversagen des äußeren Codes: j = j − 1, Schritt 1 na X Abschätzung der Anzahl der Fehler Γj : Γj = γi , mit: γl =

8 > >
> : max d(1) − w, b

(1)

db 2 ∗

o

, w = 0, 1, . . . , ν

, l ∈ J w ∩ Tj

˜ , L = Tj Falls Γj < X dann X = Γj , a = a ¨ ˝ Abbruch, falls die doppelte Anzahl der Fehler plus Auslöschungen kleiner als da2·db ist: (1) ` ´ d Falls X < b · d(1) a − |J⊗ | dann Schritt 5 2 j = j − 1, Schritt 1

Schritt 5: Die Decodierentscheidung ist a∗ (X und L werden für die weitere Decodierung benötigt). Es kann Decodierversagen auftreten.

Beweis: Zunächst schätzen wir den einem Element entsprechenden Kanalfehler ab. Dabei ist der Fall zu berücksichtigen, dass ein Decodierer verwendet wird, der auch Fehler vom Gewicht größer als die halbe Mindestdistanz decodieren kann. Wir erhalten: ( n (1) o db (1) , d − w für j ∈ E wt(e j ) ≥ max b 2 : j∈Jw wt(ej ) = w für j 6∈ E.



Aus Satz 9.7 folgt die Beziehung (1)

wt(ej ) + wt(el ) ≥ db

für

l, j ∈ Jw , l ∈ E, j 6∈ E.

(9.13)

Falls sw ≤ tw ist, gibt es sw Paare auf die Gleichung (9.13) angewendet werden kann. Die restlichen tw − sw Elemente entsprechen Decodierfehlern, und das Gewicht der Kanalfehler ist

9.2 GC-Codes mit Blockcodes

337

daher mindestens gleich der halben Mindestdistanz des inneren Codes. Falls aber sw > tw ist, gibt es tw Paare auf die Gleichung (9.13) angewendet werden kann. Hier entsprechen dann die restlichen tw − sw Elemente korrekten Decodierungen, und das Gewicht der Kanalfehler ist folglich gleich w. Also ergibt sich: X

sw ≤ tw :

j∈Jw

X

sw > tw :

j∈Jw

(1)

(1)

wt(ej ) ≥ sw db + (tw − sw ) (1)

(1)

db d = |Jw | b 2 2

wt(ej ) ≥ tw db + (sw − tw )w.

2

Um nun zu beweisen, dass der Algorithmus GCD-1 aus Bild 9.1 alle Fehler mit Gewicht kleiner als die halbe Mindestdistanz korrigieren kann, wollen wir im wesentlichen den Weg wählen, der in [Zin81] angegeben ist. Wir beweisen zuerst, dass jeder korrigierbare Fehler korrekt decodiert werden kann, und dann, dass es keine verschiedenen Γj (d. h. verschiedene Fehlergewichte bei einer Decodierung) geben kann, die beide kleiner (1) (1) als 12 · da · db sind. Satz 9.9 (Korrekturfähigkeit von GCD-1) Falls weniger als die halbe Mindestdistanz Fehler aufgetreten sind, dann kann der äußere Code in irgendeinem Schritt in GCD-1 den Fehler korrigieren. Wenn gilt na X

(1)

wt(ei )
10 (siehe [LBB96]). Ist z. B. die Bitfehlerwahrscheinlichkeit des Kanals p = 2 · 10−2 (entspricht AWGN-Kanal bei einem SignalRauschleistungsverhältnis von 1.86 dB), so ergibt sich: p = 4 · 10−2 p = 4 · 10−2

hard

=⇒ soft

=⇒

Psym ≈ 3.4 · 10−2 Psym < 2 · 10−3

¨ außerer

=⇒

¨ außerer

=⇒

PBlock ≈ 7 · 10−6

PBlock < 2 · 10−15 .



Beispiel 9.24 (Abschätzung bei Soft-Decision 2) Betrachten wir als inneren Code den BCH-Code B(i) (2; 63, 24, 15) und als äußeren Code den RS-Code A(i) (28 ; 255, 223, 33). Wenn der Algorithmus aus Abschnitt 7.3.3 zur Decodierung mit Zuverlässigkeitsinformation benutzt wird, verkleinert dies die Fehlerwahrscheinlichkeit des inneren Codes um den Faktor ≈ 100 (siehe [LBB96]). Wiederum sei die Bitfehlerwahrscheinlichkeit des Kanals p = 4 · 10−2 , so ergibt sich: p = 4 · 10−2 p = 4 · 10−2

9.2.5

hard

=⇒ soft

=⇒

Psym ≤ 4 · 10−3 Psym ≤ 5 · 10−5

¨ außerer

=⇒

¨ außerer

=⇒

PBlock < 1 · 10−15

PBlock ≈ 1 · 10−47 .



UEP-Codes mit mehrstufigem Fehlerschutz

Codes mit mehrstufigem Fehlerschutz (unequal error protection codes, UEP-Code) gewinnen zunehmend an Bedeutung, da es zahlreiche Anwendungen gibt mit unterschiedlicher Wichtigkeit der zu übertragenden Information. Quellencodierung und Kanalcodierung bilden eine Liaison, deren Ergebnis ein optimiertes Gesamtsystem ist, bei dem die Wichtigkeit von Information von der Quellencodierung mitgeliefert wird [Hag95]. Von

350

9 Verallgemeinerte Codeverkettung

der Kanalcodierung wird dann die Information durch Codes mit mehrstufigem Fehlerschutz entsprechend geschützt. Dies wurde z. B. durch Punktierung von Faltungscodes in Abschnitt 8.1.10 erreicht. Die Kanalcodierung berücksichtigt sowohl die Quellencodierung als auch die Modulation im Sinne der codierten Modulation, die im nächsten Kapitel behandelt wird. UEP-Codes zeichnen sich dadurch aus, dass verschiedene Informationsteile durch verschiedene Mindestdistanzen geschützt sind. Treten etwa t Fehler auf, so ist nur für die Informationsteile, die gegen t und mehr Fehler geschützt sind, garantiert, dass die Fehler korrigiert werden können, und zwar unabhängig davon, was in den anderen Informationsteilen passiert. Definition 9.17 (UEP-Codes) Ein GC-Code, der so konstruiert ist, dass das Produkt der Mindestdistanzen mit steigendem i kleiner wird, d. h. (i)

d(i) a · db wird kleiner, wenn i wächst, ist ein UEP-Code. Die Information, die mit dem äußeren Code A(i) codiert ist, ist dann (i) (i) mit der Mindestdistanz da · db geschützt. Auf die Decodierung von UEP-Codes brauchen wir nicht gesondert eingehen, da sie sich nicht von der Decodierung von GC-Codes unterscheidet, die in Abschnitt 9.2.4 beschrieben ist. Dort wird auch offensichtlich, warum das Produkt der Mindestdistanzen fallen muss. Bemerkenswert ist, dass die Decodierung eines normalen GC-Codes sich immer so verhält, als ob man einen UEP-Code korrigiert (vergleiche hierzu Abschnitt 9.2.4).

9.2.6

Zyklische Codes als GC-Codes

Es ist bekannt, dass jeder zyklische Code als GC-Code beschrieben werden kann. Diese interessante Eigenschaft wurde leider bisher noch nicht zur Decodierung von zyklischen Codes ausgenutzt. Einführende Beispiele Die beiden folgenden Beispiele zur Verkettung zyklischer Codes sind aus [Jen96] entnommen. Beispiel 9.25 (Verketteter zyklischer Code) Gegeben sei ein zweifach erweiterter zyklischer RS-Code A(23 ; 9, 6, 4) (siehe Abschnitt 3.1.7) als äußerer Code und ein zyklischer Simplex-Code B(2; 7, 3, 4) als innerer Code. Ein Code, dessen Prüfpolynom h(y) = (y n − 1) : g(y) irreduzibel ist, heißt minimal. Offensichtlich ist der Code B minimal. Wir wollen ihn wie folgt betrachten: Sei β ∈ GF (23 ) eine Nullstelle des irreduziblen Polynoms h(y) = (y 7 − 1) : g(y). Dann gilt bei einem minimalen zyklischen Code folgender Zusammenhang (Isomorphismus): γ = b(β), b(y) ∈ B ⇐⇒ ψ(γ) : b(y) =

6 X j=0

bj y j , bj = tr(β −j · γ),

9.2 GC-Codes mit Blockcodes

351

d. h. jedes der 23 Codewörter b aus B wird eineindeutig durch b(β) auf ein Element γ ∈ GF (2)3 abgebildet. Dabei ist tr(β −j · γ) die Trace-Funktion aus Definition 2.25. Mit dem primitiven Polynom y 3 + y + 1 errechnen wir: β 0 = 001, β 1 = 010, β 2 = 100, β 3 = 011, β 4 = 110, β 5 = 111, β 6 = 101. Das Generatorpolynom ergibt sich zu (mit K3 = {3, 6, 12 = 5 mod 7}): g(y) = (y − 1)(y − β 3 )(y − β 6 )(y − β 5 )

= (y − 1)(y 3 + y 2 + 1) = y 4 + y 2 + y + 1.

Ein mögliches Codewort mit dem Informationspolynom i(y) = y 2 + 1 ist b(y) = i(y) · g(y) = y 6 + y 3 + y + 1. Damit ist: γ = b(β) = β 6 + β 3 + β 1 + β 0 = 101 + 011 + 010 + 001 = 101 = β 6 . Mit der Trace-Funktion können wir die Codestellen wieder berechnen, z. B. die Stellen 2 und 3: b2 = tr(γ · β −2 ) = tr(β 6 · β −2 ) = tr(β 4 ) = β 4 + (β 4 )2 + (β 4 )4 = β 4 + β + β 2 = 0, b3 = tr(γ · β −3 ) = tr(β 6 · β −3 ) = tr(β 3 ) = β 3 + (β 3 )2 + (β 3 )4 = β 3 + β 6 + β 5 = 1. Eine wichtige Eigenschaft ist, dass eine zyklische Verschiebung v(y) = y · b(y) von b(y) einer Multiplikation von γ mit β entspricht, d. h. vi = tr(β −i · γ · β). Das Generatorpolynom des äußeren Codes A(23 ; 9, 6, 4) ist mit η ∈ GF (26 ) als primitives Element und α = η 7 als Element der Ordnung 9 aus den Kreisteilungsklassen K0 = {0} und K1 = {1, 8}: Y Y g(x) = (x − αi ) = (x − η 7·i ) = x3 + η 9 x2 + η 9 x + 1. i∈{0,1,8}

i∈{0,1,8}

Der verkettete Code CC mit der Länge 63 und der Dimension 18 ergibt sich als binäre (9 × 7)Matrix, wobei jede Zeile ein Codewort aus B ist. Da wir hier das Galois-Feld entsprechend gewählt haben, können wir ein Codewort aus CC auch anders ausdrücken. Sei a(x) = a0 + a1 x + a2 x2 + · · · + a8 x8 ∈ A und jede Stelle ai sei mit dem Code B codiert: bi (y) = ψ(ai ) =

6 X

bi,j y j ,

j=0

oder:

k

bi (y) = y g(y),

bi,j = tr(β −j · ai ) ,

ai = β k .

Damit lässt sich jedes Codewort von CC als Polynom der beiden Variablen x und y darstellen: c(x, y) =

8 X i=0

ψ(ai )xi = ψ(a0 ) + ψ(a1 )x + · · · + ψ(a8 )x8 =

8 X 6 X

bi,j y j xi .

i=0 j=0

Da die Längen von innerem und äußerem Code relativ prim sind, kann man nach dem Chinesischen Restesatz [McWSl, Ch. 10, Th. 5] für jedes Paar (i, j), 0 ≤ i ≤ 8, 0 ≤ j ≤ 6, ein ` finden, für das ` = i mod 9 und gleichzeitig ` = j mod 7 gilt (siehe Bild 9.13). Hiermit ist es

352

9 Verallgemeinerte Codeverkettung

i 0 1 2 3 4 5 6 7 8

j 0 1 2 3 4 5 6 c0 c36 c9 c45 c18 c54 c27 c28 c1 c37 c10 c46 c19 c55 c56 c29 c2 c38 c11 c47 c20 c21 c57 c30 c3 c39 c12 c48 c49 c22 c58 c31 c4 c40 c13 c14 c50 c23 c59 c32 c5 c41 c42 c15 c51 c24 c60 c33 c6 c7 c43 c16 c52 c25 c61 c34 c35 c8 c44 c17 c53 c26 c62

j 0

i 0 1 2 3 4 5 6 7 8

1 2 3 4 5 6 c62 c35 c8 c44 c17 c53 c26 c27 c0 c36 c9 c45 c18 c54 c55 c28 c1 c37 c10 c46 c19 c20 c56 c29 c2 c38 c11 c47 c48 c21 c57 c30 c3 c39 c12 c13 c49 c22 c58 c31 c4 c40 c41 c14 c50 c23 c59 c32 c5 c6 c42 c15 c51 c24 c60 c33 c34 c7 c43 c16 c52 c25 c61

Abb. 9.13: Matrixdarstellung eines Codewortes des verketteten Codes und dessen zyklische Verschiebung.

möglich, ein Codewort des verketteten Codes aus der Polynomdarstellung in zwei Variablen x und y in ein Polynom einer Variablen z = x · y zu transformieren: c(x, y)

⇐⇒

c(z) =

9·7−1 X

c` z ` = (c0 , c1 , . . . c62 ).

`=0

Die Koeffizienten c` sind in der Matrixdarstellung aus Bild 9.13 in aufsteigender Reihenfolge auf der sogenannten verlängerten Hauptdiagonalen zu finden. Ein um eine Stelle zyklisch verschobenes Codewort des verketteten Codes, wie in Bild 9.13 ebenfalls gezeigt, ist in der Darstellung als Polynom der Variablen x und y dann: ` ´ z · c(z) mod (z 63 − 1) = (x · y · c(x, y) mod (x9 − 1) mod (y 7 − 1) = ψ(βa8 ) + ψ(βa0 )x + · · · + ψ(βa7 )x8 .

Dies entspricht dem Polynom β(a8 + a0 x + · · · + a7 x8 ), und da der äußere Code linear und zyklisch ist, handelt es sich dabei wieder um ein Codewort von A. Damit ist plausibel, dass der verkettete Code CC ebenfalls ein zyklischer Code ist, und wir können den Code somit über ein Generatorpolynom beschreiben. Sei η ∈ GF (26 ) ein primitives Element, β = η 9 ein Element der Ordnung 7 und α = η 7 ein Element der Ordnung 9. Die Nullstellen des Prüfpolynoms des verketteten Codes ergeben sich aus dem Produkt der Nullstellen der Prüfpolynome von innerem und äußerem Code, wobei jeweils nur ein Element der Kreisteilungsklassen der Komponentencodes berücksichtigt werden muss, um die zugehörige Kreisteilungsklasse im verketteten Code festzulegen: β · α2 = η 9 · η 14 = η 23 , 3

9

21

4

9

28

β·α =η ·η β·α =η ·η

30

=η , 37

=η ,

23 ∈ K23 = {23, 29, 43, 46, 53, 58}, 30 ∈ K15 = {15, 30, 39, 51, 57, 60}, 37 ∈ K11 = {11, 22, 25, 37, 44, 50}.

Das Generatorpolynom des verketteten Codes CC kann anschließend über diese Kreisteilungsklassen von GF (26 ) bestimmt werden (primitives Polynom: z 6 + z + 1): h(z) =

Y

`∈K11 ∪K15 ∪K23

(z − η ` ),

g(z) =

z 63 − 1 , h(z)

9.2 GC-Codes mit Blockcodes

353

g(z) = z 45 + z 44 + z 42 + z 40 + z 38 + z 37 + z 35 + z 33 + z 31 + z 29 + z 28 + + z 26 + z 24 + z 22 + z 20 + z 19 + z 18 + z 9 + z 8 + z 6 + z 4 + z 2 + z + 1 . Dieser Code hat eine geplante Mindestdistanz (BCH-Bound) von d = 14. Eine Abschätzung der Mindestdistanz über die Komponentencodes der Verkettung ergibt jedoch d ≥ da · db = 4 · 4 = 16, und dies ist in diesem Fall auch die wahre Mindestdistanz. Der resultierende einfach verkettete Code hat die Parameter CC (63, 18, 16). Allerdings gibt es einen BCH-Code mit besserer Mindestdistanz: BCH(63, 18, 21). 

Im vorherigen Beispiel haben wir gezeigt, wie man aus zyklischen Codes einen zyklischen verketteten Code konstruieren kann. Durch entsprechende Verknüpfung von solchen Codes kann ein zyklischer GC-Code mit sehr guten Parametern konstruiert werden, wie das folgende Beispiel demonstriert. Beispiel 9.26 (Zyklischer GC-Code) Betrachten wir die beiden inneren Simplex-Codes B(1) (2; 7, 3, 4) und B(2) (2; 7, 3, 4), die sich durch ihr Generatorpolynom unterscheiden. Das Generatorpolynom von B(1) sei g1 (x) = (x − 1)(x − β 3 )(x − β 6 )(x − β 5 ) und das von B(2) g2 (x) = (x − 1)(x − β 1 )(x − β 2 )(x − β 4 ). B (1) B (2)

0 1 2 3 4 5 6

B (1) ⊕ B (2)

Abb. 9.14: Direkte Addition der Codes B formierten Bereich.

Element 6= 0 (1)

und B

(2)

und Darstellung im trans-

Die Addition eines Codewortes aus B(1) zu einem aus B(2) sei c (siehe hierzu Definition 6.18). Die Transformierte jedes möglichen c muss entsprechend Bild 9.14 eine Nullstelle bei β 0 = 1 besitzen. Die Menge aller Codeworte, deren Transformierte eine Nullstelle bei 1 haben, ist ein Parity-Check-Code. Damit kann der Parity-Check-Code als innerer Code aufgefasst werden, der in die Simplex-Codes partitioniert wird. Die äußeren Codes sind zwei RS-Codes, nämlich A(1) (23 ; 9, 2, 8) und A(2) (23 ; 9, 6, 4). Wir codieren nun 6 Informationsbits in A(1) und 18 in A(2) . Dann codieren wir die einzelnen Symbole des Codewortes von A(1) mit dem inneren Code B(1) (1) und erhalten den Code CC (2; 63, 6, 32). Entsprechend codieren wir die einzelnen Symbole des (2) (2) Codewortes von A mit dem inneren Code B(2) und erhalten den Code CC (2; 63, 18, 16). Jeder Code stellt einen zyklischen Code dar, und die Codeworte können als Matrizen repräsentiert werden, deren 9 Zeilen jeweils Codeworte der Simplex-Codes B(1) und B(2) sind. Die Addition beider Matrizen ergibt eine Matrix, deren 9 Zeilen Codeworte des PC-Codes (entsprechend Bild 9.14) sind. Der Code ist zyklisch, da die Addition zweier zyklischer Codes zyklisch ist. Der verallgemeinert verkettete Code hat die Parameter n = 63, k = 6 + 18 = 24 und d ≥ min{d(A(1) ) · d(B(1) ⊕ B(2) ), d(A(2) ) · d(B(2) )} = min{8 · 2, 4 · 4} = 16, was hier auch der wahren Mindestdistanz entspricht. Die BCH-Bound eines (63,24)-Codes ergibt dagegen lediglich eine Mindestdistanz von d = 15. Für die Decodierung überlegt man sich, dass man zunächst jede der 9 Zeilen bezüglich des (1) PC-Codes korrigiert. Danach wird der äußere Code A(1) decodiert und das Codewort CC berechnet. Nach Subtraktion dieses Codewortes können wir jede der 9 Zeilen erneut bezüglich des Simplex-Codes B(2) decodieren und danach den Code A(2) . 

354

9 Verallgemeinerte Codeverkettung

Dieses Beispiel aus [Jen96] ist Grundlage für viele Codes mit den besten bekannten Parametern (siehe [BJ74], [Jen85] und [Jen92]). Definition von zyklischen GC-Codes Entsprechend Beispiel 9.25 ergibt die Verkettung eines binären minimalen Codes und eines zyklischen Codes wiederum einen zyklischen Code. Dieses Ergebnis drückt der folgende Satz aus: Satz 9.18 (Zyklischer verketteter Code [BJ74]) Sei B(2; na , kb , db ), na ungerade, ein minimaler binärer zyklischer Code, und sei A(2kb ; na , ka , da ) ein zyklischer Code. Dann ist der verkettete Code CC (2; na · nb , ka · kb , ≥ da · db ) ein zyklischer Code, wenn ggT(na , nb ) = 1 ist. Die Nullstellen des Prüfpolynoms von i k−1 CC sind (β · αj )2 , wobei β, β 2 , . . . , β 2 die Nichtnullstellen des inneren Codes sind und α1 , α2 , . . . , αka die des äußeren Codes. Damit können wir entsprechend Beispiel 9.26 durch die direkte Summe einfach verketteter Codes GC-Codes konstruieren. Satz 9.19 (Zyklischer GC-Code [Jen96]) Sei ggT(na , nb ) = 1, dann ist jeder zyklische Code der Länge n = na ·nb die direkte Summe binärer zyklischer verketteter Codes, die aus einem inneren minimalen zyklischen binären Code und äußeren zyklischen Codes konstruiert sind. Zyklische GC-Codes entsprechen zyklischen Product-Codes, die erstmals von Weldon und Burton 1965 beschrieben wurden (siehe [BW65, LW70]). Beispiel 9.27 (Zyklischer GC-Code der Länge 255) Wir wollen einen binären zyklischen Code der Länge 255 konstruieren. Als innere Codes dienen binäre minimale BCH-Codes mit n = 15. Bild 9.15 zeigt die entsprechenden Kreisteilungsklassen des GF (24 ). Mit den Kreis0 1 2 3 4 5 6 7 8 9 1011121314

K0 K1 K3 K5 K7

Abb. 9.15: Die Kreisteilungsklassen zur Konstruktion aller minimalen binären Codes der Länge 15. teilungsklassen K7 , K5 und K3 , die die Nullstellen der jeweiligen Prüfpolynome bestimmen, ergeben sich die inneren minimalen Codes B(1) (15, 4, 8), B(2) (15, 2, 10) und B(3) (15, 4, 6). Die zugehörigen äußeren Codes werden wie folgt gewählt: A(1) (24 ; 17, 10, 8), A(2) (22 ; 17, 4, 12) und A(3) (24 ; 17, 2, 16). A(1) und A(3) sind, genauso wie in Beispiel 9.26, zweifach erweiterte RSCodes. A(2) dagegen ist ein nicht-binärer BCH-Code mit Symbolen aus dem GF (22 ) (vergleiche hierzu Abschnitt 4.4.1). Mit α ∈ GF (28 ) als Element der Ordnung 15 lässt sich ein Code der

9.2 GC-Codes mit Blockcodes

355

8

−1 Länge n = 2 15 = 17 konstruieren. Die weiteren Parameter dieses Codes können über die Kreisteilungsklassen ermittelt werden (q = 22 = 4, m = 8):

Ki = {i · q j mod n, j = 0, 1, . . . , m − 1} = {i · 4j mod 17, j = 0, 1, . . . , 7}. Wählen wir die Kreisteilungsklasse K6 = {6, 7, 10, 11} als Nullstellen des Prüfpolynoms, so folgt k = 4 und die geplante Mindestdistanz d = 12. Die Mindestdistanz der verallgemeinert verketteten Codes lässt sich zu d ≥ min{d(A(1) ) · d(B(1) ), d(A(2) ) · d(B(1) ⊕ B(2) ), d(A(3) ) · d(B(1) ⊕ B(2) ⊕ B(3) )} = min{8 · 8, 12 · 6, 16 · 4} = 64

abschätzen. Der verkettete Code CGC (255, 56, 64) hat damit bessere Parameter als ein vergleichbarer primitiver (255, 55, 63)-BCH-Code.  Beispiel 9.28 (Zyklischer GC-Code der Länge 1023) Als weiteres Beispiel soll ein zyklischer GC-Code mit den minimalen inneren Codes aus Bild 9.16 B(1) (31, 5, 16) (K15 ), 0 1 2 3 4 5 6 7 8 9 10

B (6) B (5) B (4) B (3) B (2) B (1)

12

14

16

18

20

22

24

26

28

30

K0 K1 K3 K5 K7 K11 K15

B (1) B (1) ⊕ B (2) B (1) ⊕ B (2) ⊕ B (3) B (1) ⊕ · · · ⊕ B (4) B (1) ⊕ · · · ⊕ B (5) B (1) ⊕ · · · ⊕ B (6)

db 30 16 10 16 10 16 16 16 12 8 6 4 2

Nicht-Nullstelle des transformierten Codeworts und Nullstelle des Pr¨ ufpolynoms

Abb. 9.16: Minimale binäre Codes der Länge 31 und mögliche Kombinationen durch direkte Addition abgeleitet aus den Kreisteilungsklassen für GF (25 ). B(2) (31, 5, 16) (K11 ) und B(3) (31, 5, 10) (K7 ) sowie den äußeren Codes A(1) (25 ; 33, 18, 16), A(2) (25 ; 33, 12, 22) und A(3) (25 ; 33, 2, 32) konstruiert werden. Im Vergleich zum primitiven (1023, 153, 251)-BCH-Code hat der GC-Code CGC (1023, 160, 256) bessere Parameter. Nimmt man jedoch zur Erhöhung der Rate einen weiteren minimalen inneren Code B(4) (31, 5, 16) (K5 ) hinzu, so ergibt sich mit den äußeren Codes A(1) (25 ; 33, 22, 12), A(2) (25 ; 33, 18, 16), A(3) (25 ; 33, 12, 24) und A(4) (25 ; 33, 2, 32) ein GC-Code CGC (1023, 270, 192), der im Vergleich zum (1023, 278, 205) -BCH-Code schlechtere Parameter aufweist. 

Am letzten Beispiel wurde deutlich, dass für niederratige Codes die Abschätzung der Mindestdistanz über die verallgemeinert verkettete Struktur eines zyklischen Codes im Vergleich zur BCH-Bound zu besseren Ergebnissen führt. Außerdem eröffnet die Interpretation von langen Codes als verallgemeinerte Verkettung wesentlich kürzerer Codes die Möglichkeit, Soft-Decodierverfahren für diesen Code anzuwenden.

356

9 Verallgemeinerte Codeverkettung

Jensen hat in [Jen92] gezeigt, dass jeder zyklische Code als GC-Code dargestellt werden kann. Somit können statt der zyklischen die nicht-zyklischen Codes betrachtet werden, die aus den gleichen inneren und äußeren Codes konstruiert sind, da sich die Decodereigenschaften nicht ändern.

9.3

Error Locating Codes

Das Prinzip der Error-Locating Codes (EL Codes) wurde von Wolf [WE63, Wolf65] eingeführt. Dieses Konzept ist in der Lage, Fehler in Teilbereichen eines Codewortes zu detektieren und zu korrigieren. Zyablov [Zya72] hat diese Klasse von Codes verallgemeinert und die Generalized Error-Locating Codes (GEL Codes) konstruiert. In [ZMB98, ZMB99, Gri02] wurde dann gezeigt, dass die GEL Codes systematisch codierte verallgemeinert verkettete Codes sind. Jeder GC Code kann durch einen GEL Code beschrieben werden und umgekehrt. Wir werden in diesem Abschnitt (G)EL Codes beschreiben und einige Beispiele angeben. Definition 9.20 (EL Code) Sei HB die Prüfmatrix des inneren Codes B(q; nb , kb , db ) und a ein Codewort des äußeren Codes A(q µ ; na , ka , da ). Jedes Codewort C des EL Codes ist eine nb × na Matrix, für die gilt: a = HB · C, a ∈ A.

(9.14)

Die Spalten cj der Codewortmatix C sind in der Regel keine Codewörter des inneren Codes B, denn HB · cj = aj ist ein Codesymbol des äußeren Codes. Der äußere Code hat die Redundanz ra = na − ka und der innere rb = nb − kb . Wir nehmen an, dass das Symbolalphabet des äußeren Codes der Redundanz des inneren Codes entspricht, also µ = rb . Der EL Code besitzt die Länge nc = na nb , die Dimension kc = nc − rc , wobei die Redundanz rc = ra rb ist. Die im Folgenden beschriebene Codierung verdeutlicht diese Definition. In Bild 9.17 ist die systematische Codierung veranschaulicht. Die Prüfmatrix des inneren Codes habe die Form HB = (Qb |Irb ), wobei Irb die rb × rb Einheitsmatrix ist. Nun schreiben wir die kc Informationssymbole in die Matrix C an die Stellen, die in Bild 9.17 durch Cl und X bezeichnet sind. Der mit P bezeichnete Teil bleibt zunächst frei. Damit enthalten die Spalten c1 , c2 , . . . , cka von C Information und entsprechen der Teilmatrix Cl . Im zweiten Schritt berechnen wir nun uj = HB · cj , j = 1, . . . , ka ,

also den Teil des Codewortes a, der mit u (Information) bezeichnet ist. Im dritten Schritt wird gemäß des äußeren Codes A die Redundanz r zur Information u berechnet und wir erhalten das Codewort a. Im letzten Schritt wird der Teil P der Matrix berechnet, also die Redundanz des Codewortes C. Für die Spalten j = ka + 1, . . . , na muss ja entsprechend Definition 9.20 gelten, dass sie die Symbole aj erzeugen, die durch Codierung mit dem äußeren Code berechnet wurden. Man kann die Unbekannten Teilspalten pj berechnen durch:     xj xj HB · = (Qb |Irb ) · = aj =⇒ pj = aj − Qb · xj . (9.15) pj pj

9.3 Error Locating Codes

357 na X

C

Cl (Informationssymbole)

ka a

u „Information“

kb nb

P

a = HB · C

r „Redundanz“

µa

Abb. 9.17: Systematische Codierung von EL Codes.

Damit ist die Redundanz P = pka +1 , . . . , pna berechnet und das Codewort C ist vollständig. Es sei angemerkt, dass a kein Teil des Codewortes C ist, weshalb a auch nicht übertragen wird. Gleichung (9.14) stellt eine Syndromberechnung dar und deshalb wird a auch als Syndromvektor des Codes B bezeichnet. Das Konzept des Syndromvektors kann gleichzeitig für Spalten und Zeilen der Codematrix angewendet werden. Damit können dann zweidimensionale rechteckige Fehler korrigiert werden (siehe [BBZS98, BBZS99]), was wir in Abschnitt 9.3.2 beschreiben werden. Wir wollen nun die Decodierung von EL Codes erläutern und dabei annehmen, dass die Anzahl der Fehler kleiner gleich der Anzahl der korrigierbaren Fehler ist. Die empfangene Matrix sei C0 = C + E, wobei E die Fehlermatrix ist. Zunächst wird der ˆ berechnet, indem mit der Prüfmatrix des inneren Codes multipliziert Syndromvektor a ˆ. Der Decoder für den Code A korrigiert a ˆ zu a, wenn weniger als wird: HB · C0 = a (da −1)/2 Spalten fehlerbehaftet sind. Man kann den Syndromfehlervektor b bestimmen ˆ − a. Die Symbole bj , j ∈ 1, . . . , na , die ungleich null sind identifizieren durch: b = a also die fehlerbehafteten Spalten in C0 (error locating). Mit dem Syndromfehlervektor b kann man den Spaltenfehler ej bestimmen, der dann zu der Spalte j der empfangenen Matrix C0 addiert wird. Die Decodierung pro Spalte j erfolgt also durch: Dec.A

ˆj = HB c0j , a ˆj =⇒ aj , bj = a ˆj − aj , ej = bTj · HTB , cj = c0j + ej . a Wegen der systematischen Codierung kann dann die Information direkt aus C ausgelesen werden. Beispiel 9.29 (EL Code) Ein EL Code kann mit dem inneren Code B(7, 4, 3) und dem äußeren Code A(23 ; 7, 5, 3) konstruiert werden. Er besitzt die Länge nc = 49 und die Dimension kc = nc − (na − ka )(nb − kb ) = 43. 

9.3.1

Verallgemeinerte Error Locating (GEL) Codes

Wir wollen in diesem Abschnitt die EL Codekonstruktion verallgemeinern.

358

9 Verallgemeinerte Codeverkettung

Definition 9.21 (GEL Code)Ein verallgemeinerter Error Locating Gode (GEL Code) (i) (i) der Ordnung s besteht aus s äußeren Codes A(i) (q µi ; na , ka , da ), i = 0, . . . , s − 1 und s (i) (i) inneren Codes B (i) (q; nb , kb , db ), i = 1, . . . , s. Die Prüfmatrix der inneren Codes B (s) sei   HB(i−1) /B(i)   ..   , . HB(1) , wobei HB(i) die Prüfmatrix von B (i) ist und a(i) ein Codewort des i-ten äußeren Codes A(i) . Für jedes Codewort C des GEL Codes gilt: a(i) = HB(i) /B(i+1) · C,

a(i) ∈ A(i) , i = 0, . . . , s − 1. (i)

(9.16)

(i)

(i)

Die Redundanzen der äußeren und inneren Codes sind ra = na − ka und rb = (i) (i) (i+1) (0) nb − kb . Wir wählen µi = kb − kb , kb = nb , für i = 0, . . . , s − 1. Der GEL Code Ps−1 (i) besitzt die Länge nc = na nb , die Redundanz rc = i=0 ra µi und damit die Dimension P (s) s−1 (i) kc = na kb + i=0 ka µi = nc − rc . Für s = 1 ist der GEL Code ein EL Code. Die systematische Codierung ist ähnlich der von EL Codes, nur dass mehrfach codiert werden muss. Die äußeren Codes werden ebenfalls systematisch codiert und wir nehmen an, dass für die Prüfmatrizen HB(i−1) /B(i) gilt:     (s−1) Qb Iµ(s−1) 0 0 ... 0 HB(s−1) /B(s)  (s−2) HB(s−2) /B(s−1)   Qb Iµ(s−2) 0 . . . 0          . .. . . . . ..  , HB(s) =   =  .. . . . .     (1)  HB(1) /B(2)    Q Iµ1 0  b (0) HB(1) Q I b

µ0

wobei Iµi die µi × µi Einheitsmatrizen sind. Die Prüfmatrizen HB(s) beschreiben eine Partitionierung in Untercodes, deren Nummerierung entsprechend Satz 9.4 eindeutig ist. Dabei sind Umformungen durch Zeilenoperationen in HB(i−1) /B(i) und Spaltenpermutationen von HB(s) erlaubt. Die Permutation von Spalten von HB(s) führt zu einem äquivalenten Code, ohne dass die Eigenschaften des verketteten Codes verändert werden. In Bild 9.18 wird die Codierung veranschaulicht. Zunächst wird wieder der weiße Teil der Matrix C mit den Informationssymbolen gefüllt. Dann wird der Informationsteil u(i) der äußeren Codes entsprechend Gleichung (9.16) berechnet. Dies kann prinzipiell ohne Kenntnis der Teile P(i) der Matrix C durchgeführt werden. Eine Alternative ist die iterative Berechnung entsprechend Beispiel 9.30. Die Redundanzteile r(i) der äußeren Codes i = 0, . . . , s − 1 werden durch systematische Codierung berechnet. Im letzten Schritt werden dann die Redundanzteile P(i) berechnet. Bezeichnen wir die Teilmatrizen

9.3 Error Locating Codes

359 na (s−1)

Cl

InformationsX(0) symbole

C

P(s−1) .. .

nb

a(0)

(s)

u(s−1)

r(s−1)

µ(s−1)

.. .

(1) ka

a(0)

(s−1)

kb

P(0)  (s−1)  a  ..  (s) S =  .  = HB · C

ka a(s−1)

X(s−1)

u(0)

r(0)

µ(0)

Abb. 9.18: Codierung von verallgemeinerten Error Locating Codes.

(oben rechts) mit X(i) , dann gelten die folgenden Beziehungen für i = 0, . . . , s − 1 (Bild 9.18):  (i)   X (i) (i) (i) r = Qb Iµ(i) · = Qb · X(i) + P(i) a P(i) (i)

⇒ P(i) = r(i) − Qb · X(i) .

Dabei wird die Matrix X(i) berechnet durch: (i+1)   (i+1) X X(i) = Cl P(i+1) (i)

(i+1)

(i+1)

(i)

(i+1)

wobei Cl eine (kb + µa ) × (ra − ra ) Informationsteilmatrix ist (unter der (i) (i) (s−1) (s−1) (s−1) Annahme µa = rb ). Ferner ist X die kb ×(na −ka ) Informationsteilmatrix eines EL Codewortes. Da die Teilmatrix P(i+1) von X(i) für die Berechnung von P(i) benötigt wird, werden die Matrizen P(i) rekursiv berechnet. Zuerst wird i = s − 1 berechnet und zum Schluss i = 0. Da ein GEL Code der Ordnung s ein systematisch codierter GC Code ist, kann die Decodierung bis zur Distanz dc2−1 mit dem Blokh–Zyablov Algorithmus [BZ74] garantiert werden. Es sei angemerkt, dass auch sehr viele Fehlermuster mit größerem Gewicht decodiert werden können.

360

9 Verallgemeinerte Codeverkettung S

=

·

H

0 1 0z H}|l2 { z H}|r2 { 1 000000 111111 1 0 1 1 0 0 0 C B B C 000000 111111 B B C C B B C 000000 111111 R2 1 1 1 0 1 0 0 C B B C C 000000 111111 = B B C C B B C C 000000 111111 1 1 0 0 0 1 0 B B C C 111111111111 000000 111111 @ @ 000000000000 A A 000000000000 111111111111 R1 1 1 1 1 1 1 1 000000000000 | 111111111111 {z } |{z}

Hl1

Hr1

·

W

0 1 B C B C B C X2 B C B C B C B C X1 B C 0000000 1111111 B C B C 0000000 1111111 B C 0000000 1111111 P2 B C B C 0000000 1111111 B C 0000000 1111111 B C 111111111111 000000000000 @ 111111111111 A 0000000 1111111 000000000000 P1 000000000000 111111111111

Abb. 9.19: Codierung des GEL Codes aus Beispiel 9.30.

Wir wollen die Konstruktion, die Codierung und die Decodierung noch an dem folgenden Beispiel veranschaulichen. Beispiel 9.30 (GEL Code) Wir werden einen GEL Code der Ordnung s = 2 konstruieren. Dazu verwenden wir die inneren Codes B(1) (7, 6, 2) und B(2) (7, 3, 4). Als äußere Codes wählen wir einen binären Wiederholungscode A(0) (2; 7, 1, 7) und einen RS Code A(1) (23 ; 7, 4, 4). Die Prüfmatrix HB(2) des Codes B(2) ist 0 1 1 0 1 1 0 0 0 „ « B1 1 1 0 1 0 0C HB(1) /B(2) C HB(2) = =B @1 1 0 0 0 1 0A . HB(1) 1 1 1 1 1 1 1 (2)

(0)

(1)

Der GEL Code besitzt die Länge nc = 49 und die Dimension kc = na kb +ka µ0 +ka µ1 = 34. Die systematische Codierung ist in Bild 9.19 veranschaulicht. Zunächst werden in den weißen Teil der Codematrix C die Informationssymbole eingetragen. Danach wird u(0) berechnet (besteht nur aus einem Bit), indem die erste Spalte mit der Prüfmatrix HB(1) multipliziert wird. (0) (1) Dann wird u(0) mit dem Code A(0) zu a(0) codiert. Nun können die Symbole ka + 1, . . . , ka von R1 entsprechend Gleichung (9.15) berechnet werden. Damit kann die Berechnung von u(1) (1) bis ka durch die Prüfmatrix HB(1) /B(2) durchgeführt werden. Der Vektor u(1) wird mit dem Code A(0) zu a(1) codiert. Die Redundanz des GEL Codes kann dann berechnet werden zu: P(1) = r(1) − Q(1) X(1) und P(0) = r(0) − Q(0) X(0) .

Sei die empfangene Matrix C0 , C0 = C + E. Zur Decodierung wird zunächst das Syndrom S0 = HB(2) · C0 berechnet. Jedes Symbol der letzten Zeile von S0 ist das Syndrom einer Spalte von C0 bezüglich B(1) , im Beispiel eine Parity Check Code mit Mindestdistanz d = 2. Diese letzte Zeile muss ein Codewort von A0 sein. Damit werden kleiner gleich 3 fehlerhafte Spalten sicher detektiert. Diese Spalten können nun für den Code A(1) als Auslöschungen betrachtet werden (siehe Abschnitt 3.2.7), die in a1 = HB1 /B2 · C0 wegen Mindestdistanz 4 korrigiert werden können. Im letzen Schritt können wir nun mit dem Code B(2) (7, 3, 4) einen Fehler pro Spalte korrigieren, da wir das korrekte Syndrom kennen. 

Äquivalenz von GC und GEL Codes In [ZMB98, ZMB99] wurde gezeigt, das die Codeklassen GC Codes und GEL Codes

9.3 Error Locating Codes

361

äquivalent sind. Wir wollen die wichtigsten Aussagen dieser Arbeiten nachfolgend beschreiben und an Beispielen veranschaulichen. Ein GC Code der Ordnung s ist ein Spezialfall eines GEL Codes der Ordnung s − 1, s oder s + 1, abhängig von der Wahl der inneren und äußeren Codes. Die Aussage gilt ebenfalls umgekehrt. Beide Verkettungen basieren auf der Partitionierung des inneren Codes in Untercodes. Der Unterschied liegt in der Nummerierung der Partitionierung. Bei GEL Codes ist die Prüfmatrix HB(s) klar definiert, während bei GC Codes die Nummerierung beliebig gewählt werden kann. Jedoch kann die Nummerierung mit einer linearen Abbildung GB(1) durchgeführt werden. Beide Konstruktionen sind identisch für GTB(1) · S = C ⇐⇒ S = HB(s) · C, vorausgesetzt, dass gilt: GTB(1) = H−1 . Da HB(s) vollen Rang besitzt, kann immer ein B(s) GB(1) gefunden werden. EL Code −→ GC Code der Ordnung 2 Ein EL Code mit äußerem Code A und innerem Code B kann als GC Code der Ordnung 2 interpretiert werden. Dazu wählt man A = A(1) und B = B (2) und die Partitionierung B (1) (q; nb , nb , 1) ⊃ B (2) (q; nb , kb , db ) ⊃ B (3) (q; nb , 0, ∞). Mit den äußeren Codes A(1) und A(2) (q kb ; na , na , 1) besitzt der GC Code die gleichen Parameter wie der EL Code. (1) (1) (2) (2) Durch diese Beschreibung erhält man dc ≥ min{da db , da db } = min{da , db }. Die Codiermatrix   GB(2) GB(1) = G B(1) /B(2)

für den GC Code ist die Inverse der Abbildung HB .

Beispiel 9.31 (EL Code und GC Code der Ordnung 2)Für die Interpretation des EL Codes aus Beispiel 9.29 mit B(7, 4, 3) und A(23 ; 7, 5, 3) als einen GC Code benötigen wir die Partitionierung B(1) (7, 7, 1) ⊃ B(2) (7, 4, 3) ⊃ B(3) (7, 0, ∞) und die äußeren Codes A(1) (23 ; 7, 5, 3) und A(2) (2; 7, 7, 1). Die Mindestdistanz ergibt sich zu dc ≥ min{da , db } = 3. 

CC −→ GEL Ein klassischer verketteter Code (CC) mit dem äußeren Code A und innerem Code B kann als GEL Code der Ordnung 2 mit den Codes A(0) (q rb ; na , 0, ∞), A(1) = A, B (1) = B und B (2) (nb , 0, ∞). Beispiel 9.32 (CC Code und GEL Code der Ordnung 2) Wir betrachten einen CC Code mit A(23 ; 7, 4, 4) und B(7, 3, 4). Der GEL Code der Ordnung 2 A(0) (24 ; 7, 0, ∞), A(1) = A(23 ; 7, 4, 4), B(1) = B(7, 3, 4) und B(2) (7, 0, ∞) ist dazu äquivalent. 

GEL Code der Ordnung s −→ GC Code der Ordnung (s + 1)

(i)

(i)

Ein GEL Code der Ordnung s mit den inneren Codes B (i) (q; nb , nb , db ), i = 1, . . . , s (i) (i) und den äußeren Codes A(i) (q µi ; na , na , da ), i = 0, . . . , s − 1 ist ein Spezialfall des GC (s) Codes der Ordnung (s + 1) mit B (0) (q; nb , nb , 1) und A(s) (q kb ; na , na , 1) als zusätzliche Codes. Man beachte, dass die Indizes um 1 verschoben sind im Vergleich zur originalen Definition von GC Codes.

362

9 Verallgemeinerte Codeverkettung (i) (i)

Diese Beschreibung liefert die Mindestdistanz des Codes zu: dc ≥ mini=0,...,s {da db } = (0) (i) (i) (s) (0) (s) mini=1,...,s−1 {da , da db , db }, wobei gilt db = da = 1. Beispiel 9.33 (GEL Code der Ordnung s und GC Code der Ordnung (s + 1)) Der GEL Code der Ordnung 2 von Beispiel 9.30 kann als GC Code der Ordnung 3 interpretiert werden. Die Codes für den GEL Code sind B(1) (7, 6, 2), B(2) (7, 3, 4), A(0) (2; 7, 1, 7) und A(1) (23 ; 7, 4, 4). Für die Interpretation als GC Code benötigen wir noch die Codes: B(0) (7, 7, 1) (0) (1) (1) (2) und A(2) (23 ; 7, 7, 1). Die Mindestdistanz ist dc ≥ min{da 1, da db , 1 db } = 4 was eine Korrektur von einem Fehler garantiert. Beispiel 9.30 hat jedoch gezeigt, das spezielle Fehler vom Gewicht 3 korrigiert werden können. 

GC Code der Ordnung s −→ GEL Code der Ordnung (s + 1) Ein Spezialfall eines GEL Codes der Ordnung (s + 1) mit den zusätzlichen Codes (1) B (s+1) (q; nb , 0, ∞) und A(0) (q rb ; na , 0, ∞) ist ein GC Code der Ordnung s mit den (l) (l) (l) (l) (l) Codes B (l) (q; nb , nb , db ) und A(l) (q ma ; na , na , da ) l = 1, . . . , s. Beispiel 9.34 (GC Code der Ordnung s und GEL Code der Ordnung (s + 1))Der GC Code der Ordnung 2 mit B(1) (7, 4, 3), B(2) (7, 3, 4), A(1) (2; 7, 1, 7) und A(2) (23 ; 7, 4, 4) kann als GEL Code der Ordnung 3 interpretiert werden. Dazu benötigt man zusätzlich die Codes B(3) (7, 0, ∞) und A(0) (23 ; 7, 0, ∞). 

Selbstverständlich ist die Fehlerkorrektureigenschaft von äquivalenten GEL und GC Codes die gleiche.

9.3.2

GEL Codes für zweidimensionale Fehler b2

Fehlerblock

b1 fehlerhafte Pr¨ ufsymbole

Informationsteil

Parity-CheckSymbole

Abb. 9.20: Parity-Check-Symbole auf der Empfängerseite.

Nehmen wir an, ein Fehler auf dem Kanal bewirkt, dass in einem Codewort, das hier einer Matrix entsprechen soll, Bitfehler nur in einem rechteckigen Gebiet der Größe b1 ×b2 Bits auftreten. Dies kann als zweidimensionaler Bündelfehler interpretiert werden. Gemäß Gilbert [Gil60] ist die Kapazität eines Bündelfehlerkanals größer als die eines Kanals der unabhängige Fehler erzeugt, d. h. es muss möglich sein, mit einem Code mit größerer Rate zu übertragen. Wir wollen annehmen, dass die Prüfsymbole, gemäß Bild 9.20, nicht übertragen worden sind, sondern nach der Übertragung im Empfänger berechnet wurden. Dabei stellen die unterschiedlichen Grautöne verschiedene interleavte

9.3 Error Locating Codes

363

binäre Parity-Check-Codes dar. Auffallend ist, dass die meisten Prüfsymbole korrekt berechnet worden sind, und es stellt sich die Frage: Warum sollte man diese Prüfbits überhaupt übertragen? Im folgenden wollen wir eine Codekonstruktion beschreiben, die diese Frage dadurch löst, dass nur ein geringer Teil der Prüfbits übertragen werden muss, was die Anzahl der notwendigen Redundanzbits zur Korrektur eines zweidimensionalen Bündelfehlers erheblich reduziert. Das Konzept der Codierung von Prüfbits: Wir beschreiben eine mögliche Codekonstruktion aus [BBZS98], die in der Lage ist einen zweidimensionalen Bündelfehler der Größe b1 × b2 zu korrigieren (ein Bündelfehler mit b1 = 1 entspricht dann dem eindimensionalen Fall). Wir schreiben die Informationsbits in eine binäre (n1 × n2 )-Matrix, wobei, wie in Bild 9.21 dargestellt, ein Gebiet in der oberen rechten und der unteren linken Ecke zunächst zu Null gesetzt wird, d. h. wir können dort keine Informationsbits eintragen. Die Gebiete, die zu Null gesetzt werden, sind jeweils rechts oben 2b1 Zeilen und b2 Spalten und links unten b1 Zeilen und 2b2 Spalten, d. h. wir können in die (n1 × n2 )-Matrix n1 · n2 − 2b1 · b2 − b1 · 2b2 = n1 n2 − 4b1 b2 Informationsbits eintragen. Wir berechnen ein Codewort in drei Schritten wie folgt: Schritt 1: Jede Zeile von i = 2b1 , . . . , n1 − 1 wird mit b2 interleavten Parity-CheckCodes codiert, d. h. X pim = cij , i = 2b1 , . . . , n1 − 1, (9.17) j=m,m+b2 ,... j >= >>; Redundanzteil 9> >> >= Informationsteil (Parity>> Check-Symbole >> von Schritt 1) ; RS-Codewort

Abb. 9.22: Zweiter Codierschritt, RS-Codewort.

Schritt 3: Jetzt werden die rechten oberen Stellen, die zuvor zu Null gesetzt waren derart ergänzt, dass sie gemeinsam mit den entsprechenden RS-Codesymbolen und den Informationsbits, wie in Schritt 1, genau b2 interleavten PC-Codewörtern entsprechen. Anders ausgedrückt entspricht jede der Zeilen 0 bis n1 − b2 (inklusive den RS-Codeteil) genau b2 interleavten PC-Codes. Ausgehend von der ursprünglichen Matrix in Bild 9.21 werden nun die Schritte 1–3 entsprechend für die Spalten durchgeführt, um die Nullen in der unteren linken Ecke der Matrix zu ersetzen. Hier gilt die Einschränkung: n2 ≤ 2b2 + 1.

Die Codierung ergibt eine (n1 × n2 )-Matrix, ein Zeilen-RS-Codewort (2b2 ; n1 , n1 − 2b1 , 2b1 +1) und ein Spalten-RS-Codewort (2b1 ; n2 , n2 −2b2 , 2b2 +1). Wir übertragen jedoch nur die (n1 × n2 )-Matrix als Codewort des Codes C(n1 · n2 , n1 n2 − 4b1 b2 , dT = 3). Die Mindestdistanz dT = 3 entspricht der Korrektur eines Bündelfehlers b1 × b2 in kombinatorischer Metrik (siehe Anhang B). Satz 9.22 (Korrekturfähigkeit des Codes C) Jeder zweidimensionale Bündelfehler der Größe b1 × b2 kann mit dem Code C korrigiert werden. Beweis: Wir nehmen an, dass ein Bündelfehler der Größe b1 × b2 bei der Übertragung der (n1 × n2 )-Matrix aufgetreten ist. Zunächst berechnen wir, wie in Bild 9.23 veranschaulicht, die Paritätsbits der b2 interleavten PC-Codes der Zeilen und der b1 interleavten PC-Codes der Spalten. Die Matrizen rechts und unterhalb der Codematrix müssen im fehlerfreien Fall gültige RS-Codewörter der Codes (2b1 ; n1 , n1 − 2b1 , 2b1 + 1) und (2b2 ; n2 , n2 − 2b2 , 2b2 + 1) sein. Wie aus Bild 9.23 ersichtlich, können durch den (b1 × b2 )-Fehlerblock höchstens b1 Symbole des Zeilen- und b2 Symbole des Spalten-RS-Codes fehlerhaft sein. Gemäß der Mindestdistanzen beider Codes können die Fehler korrigiert werden. Damit sind Fehlerorte und Fehlerwerte in Zeilen und Spalten bekannt und können in der (n1 × n2 )-Matrix korrigiert werden. Falls der Bündelfehler entsprechend Bild 9.21 in der rechten oberen bzw. linken unteren Ecke liegt, muss er nicht korrigiert werden. 2

Zur Veranschaulichung wollen wir im Folgenden ein konkretes Beispiel berechnen. Beispiel 9.35 (Code zur Korrektur eines (4 × 4)-Bündelfehlers) Wir wollen einen (2; 150, 96, dT = 3)-Code konstruieren, der einen (4 × 4)-Bündelfehler korrigieren kann. Dazu schreiben wir die Information entsprechend Bild 9.24 in eine (10 × 15)-Matrix. Die grau

9.3 Error Locating Codes

365

ˆ Codewort-Matrix C

Fehlerblock

1 0 0 1 0 1 0 1 0 1 0 1



0000000000 1111111111 0 1 0 1 0 1 0 1 0 1 0 1

b1

Parity-CheckSymbole (RS-Codeworte)

| {z } b2

Abb. 9.23: Fehlerhafte Parity-Check-Symbole durch einen zweidimensionalen Bündelfehler.

hinterlegten Bereiche in der unteren linken und oberen rechten Ecke enthalten keine Information, sondern werden zunächst mit Nullen aufgefüllt. Zuerst wird in Zeilenrichtung codiert. Man beginnt mit der Berechnung von jeweils b2 = 4 Prüfsymbolen für die Zeilen 2b1 = 8 bis n1 − 1 = 9 nach Gleichung (9.17) und notiert das Ergebnis rechts neben dem Codewort. Eine dieser Prüfgleichungen ist in Bild 9.24 mit eingerahmten Kästchen markiert. Die Prüfsymbole jeder Zeile können im nächsten Schritt mit Hilfe der Logarithmentafel in Tabelle 9.1 als binäre Repräsentation von Symbolen aus dem GF (24 ) betrachtet werden (die Komponentendarstellung ist hier im Vergleich zu Beispiel 2.11 gespiegelt). Die Symbole in den Zeilen 8 und 9, α2 Tabelle 9.1: Logarithmentafel des Galois-Feldes GF (24 ).

α−∞ α0 α1 α2

0000 1000 0100 0010

α3 α4 α5 α6

0001 1100 0110 0011

α7 α8 α9 α10

1101 1010 0101 1110

α11 α12 α13 α14

0111 1111 1011 1001

und α10 , sind Informationssymbole eines verkürzten RS-Codes. Systematische Codierung mit dem Generatorpolynom 1 + α6 x + αx2 + α10 x3 + x4 + α3 x5 + α2 x6 + x7 + α2 x8 liefert das Codewort α13 + α5 x + α−∞ x2 + α12 x3 + α8 x4 + α10 x5 + α12 x6 + α9 x7 + α2 x8 + α10 x9 . Die Redundanzsymbole des RS-Codewortes werden ebenfalls binär interpretiert. Nun können die Bits in der oberen rechten Ecke des Codewortes (graue Fläche) so gewählt werden, dass die Prüfgleichungen auch für die Zeilen 0–7 erfüllt sind (siehe Bild 9.25). Die Berechnung der Prüfsymbole für die Spalten erfolgt ganz analog. Es ist jedoch zu beachten, dass die neu berechneten Redundanzsymbole für die rechte obere Ecke des Codewortes hierbei noch nicht berücksichtigt werden. Die Symbole, die sich aus den Spalten 8–14 ergeben haben, dienen als Information für den gleichen RS-Code wie bei der Codierung der Zeilen. Das fertig codierte Codewort ist in Bild 9.25 dargestellt. Bei der Übertragung des Codewortes ist ein Bündelfehler aufgetreten. Die fehlerhaften Bits sind in Bild 9.26 grau markiert. Die Berechnung der Prüfsymbole auf der Empfängerseite führt damit ebenfalls zu Fehlern in den beiden binär interpretierten RS-Codeworten. Diese Fehler können jedoch alle bei der Decodierung von horizontalem bzw. vertikalem RS-Codewort er-

366

9 Verallgemeinerte Codeverkettung

0 1 2 3 4 5 6 7 8 9

0

1

2

3

4

5

6

7

8

9 10 11 12 13 14

0 0 1 1 1 0 0 0 0 0

1 1 0 0 0 0 0 0 0 0

1 0 1 0 1 1 0 0 0 0

0 1 1 1 0 0 0 0 0 0

0 1 1 0 0 1 0 0 0 0

0 0 1 1 0 1 0 0 0 0

0 0 0 1 0 1 0 0 0 0

0 1 0 1 1 1 0 0 0 0

1 1 1 1 1 0 0 0 1 1

1 0 1 0 0 1 0 0 0 0

0

1

2

3

0

1

2

3

1 1 0 1 0 1 1 1 1 1

0 0 0 0 0 0 0 0 0 0

0 0 0 0 0 0 0 0 1 0

0 0 0 0 0 0 0 0 0 1

0 0 0 0 0 0 0 0 0 0

0

1

2

3

0

1

2

1 0 1 1

1 1 1 0

0 1 1 0

0 0 0 0

1 0 0 0

0 1 0 0

0 0 0 0

0 1 2 3 0 1 2 3 0 1

0 0 1 0 1 1 1 0 0

1

2

= α2 = α10

3

0 1 2 3 ∞ −

α = 1 α = 0 α∞ = − α = 5 α = 10 α = 13 α =

Abb. 9.24: Berechnung der Prüfsymbole in den Zeilen und Spalten.

kannt werden. Mit diesem Wissen ist es möglich, sämtliche Fehler im übertragenen Codewort zu korrigieren. Beispielsweise wird für Zeile 5 statt α8 das Symbol α10 decodiert. Es ist also ein einzelner Bitfehler in dieser Zeile aufgetreten, und aus dem Interleaving-Schema der Prüfgleichungen folgt, dass dieser Fehler einer der Spalten 1, 5, 9 oder 13 zugeordnet werden kann. Da der vertikale Komponentencode lediglich in Spalte 5 einen Fehler detektiert hat, kann dieser Fehler eindeutig der Position (5, 5) zugeschrieben werden. Die Fehler an den Positionen (6, 8) und (8, 8) können auf die gleiche Weise korrigiert werden. Die noch verbleibenden Fehler an den Stellen (6, 5), (7, 6), und (8, 7) sind an Redundanzstellen des Codewortes aufgetreten und nicht durch einen horizontalen Parity-Check-Code erfasst. Da die Informationssymbole der Codematrix nun jedoch fehlerfrei sind, können die Fehler leicht durch eine erneute Bestimmung der Redundanzbits bestimmt werden, falls dies nötig sein sollte. 

Die beschriebene Konstruktion kann noch verbessert werden. Zur Korrektur von (b1 × b2 )-Bündelfehlern werden dann nur 3b1 b2 Redundanzstellen benötigt. Dieses Ergebnis und weitere Untersuchungen zu dieser Art der Codekonstruktion findet man in [Bre97]. In [BS96] wurde gezeigt, dass die Singleton-Schranke ≥ 2b1 b2 Redundanzstellen zur Korrektur von (b1 × b2 )-Bündelfehlern ergibt. Wir wollen nun das beschriebene Konzept erweitern und verallgemeinert verkettete Codes damit konstruieren, die wir lediglich an zwei Beispielen beschreiben wollen. Es lässt sich zeigen, dass diese Konstruktion über die Prüfmatrix des inneren Codes äquivalent ist zur geläufigeren Beschreibung über die Generatormatrix, wie sie in Abschnitt 9.2 zur Einführung der verallgemeinerten Verkettung verwendet wurde. Ein Vorteil der neuen Betrachtungsweise ist neben der systematischen Codierung die Möglichkeit, durch das Abgrenzen von Fehlerstrukturen Abschätzungen für die Restfehlerwahrscheinlichkeiten durchführen zu können. Beispiel 9.36 (Systematischer GC-Code 1) Es wird ein (49, 34)-Array-Code konstruiert, der in drei Spalten der Codematrix W jeweils maximal einen Fehler korrigieren kann.

9.3 Error Locating Codes

0 1 2 3 4 5 6 7 8 9

367

0

1

2

3

4

5

6

7

8

9 10 11 12 13 14

0 0 1 1 1 0 0 1 0 0

1 1 0 0 0 0 0 0 0 1

1 0 1 0 1 1 1 1 1 0

0 1 1 1 0 0 0 1 0 0

0 1 1 0 0 1 0 1 1 1

0 0 1 1 0 1 1 1 0 1

0 0 0 1 0 1 0 1 0 0

0 1 0 1 1 1 0 0 0 1

1 1 1 1 1 0 0 0 1 1

1 0 1 0 0 1 0 0 0 0

1 1 0 1 0 1 1 1 1 1

1 0 1 1 1 1 1 1 0 0

0 0 1 1 1 0 1 0 1 0

0 0 0 0 0 1 1 1 0 1

1 0 1 1 0 0 0 1 0 0

1 0 1 0

1 0 0 0

1 1 0 1

0 1 1 0

1 1 1 1

0 0 0 0

0 1 0 0

1 1 0 1

1 0 1 1

1 1 1 0

0 1 1 0

0 0 0 0

1 0 0 0

0 1 0 0

0 0 0 0

1 0 0 1 1 1 1 0 0 1

0 1 0 1 0 1 1 1 0 1

1 1 0 1 1 1 1 0 1 1

1 0 0 1 0 0 1 1 0 0

= α13 = α5 = α−∞ = α12 = α8 = α10 = α12 = α9 = α2 = α10

α = 1 α = 0 α∞ = − α = 5 α = 10 α = 13 α = 7 α = 1 α∞ = − α = 12 α = 5 α = 7 α = 0 α = 8 α

=

∞ −

Abb. 9.25: Codewort nach abgeschlossener Codierung.

Die Codewörter werden als (7 × 7)-Matrix beschrieben (siehe Bild 9.27). Die Darstellung von W ist systematisch: Informationssymbole (weiß im Bild) und Redundanzsymbole (grau) sind getrennt. Der Code B(1) (7, 6, 2) (Parity-Check-Code) wird mit B(2) (7, 3, 4) (Simplex-Code) partitioniert und bestimmt die Prüfmatrix H. H wird wie folgt errechnet:

• Die unterste Zeile von H ist der Prüfvektor des Parity-Check-Codes in systematischer Darstellung (die systematische Form ergibt sich hier zwangsläufig). • Die drei ersten Zeilen werden ebenfalls in systematischer Darstellung zur Prüfmatrix für den BCH(7, 3, 4)-Code ergänzt (siehe Bild 9.27).

Zur Codierung eines gültigen Codewortes wird zunächst der Informationsteil von W mit den Informationssymbolen gefüllt. Anschließend werden die Redundanzsymbole so bestimmt, dass die Syndrommatrix S = H · W aus gültigen Codeworten der Codes A(1) (2; 7, 1, 7) (Wiederholungscode) und A(2) (23 ; 7, 4, 4) (RS-Code) in systematischer Darstellung besteht. Die genaue Vorgehensweise wird nachfolgend beschrieben: Über das Gleichungssystem S = H · W (siehe Bild 9.28) werden als erstes diejenigen Symbole der Syndrommatrix S berechnet, die den Informationsteilen der Codes A(i) entsprechen. Aufgrund der besonderen Form der Prüfmatrix H kann dies ohne Kenntnis der Redundanzsymbole der Codematrix W erfolgen. Anschließend können mit Hilfe der Codiervorschriften (Generatormatrizen) der Codes A(1) und A(2) die Redundanzteile R1 und R2 bestimmt werden. Die Syndrommatrix S setzt sich nun aus Codeworten der Codes A(i) zusammen. Die gesuchten

368

9 Verallgemeinerte Codeverkettung

0 1 2 3 4 5 6 7 8 9

0

1

2

3

4

5

6

7

8

9 10 11 12 13 14

0 0 1 1 1 0 0 1 0 0

1 1 0 0 0 0 0 0 0 1

1 0 1 0 1 1 1 1 1 0

0 1 1 1 0 0 0 1 0 0

0 1 1 0 0 1 0 1 1 1

0 0 1 1 0 0 0 1 0 1

0 0 0 1 0 1 0 0 0 0

0 1 0 1 1 1 0 0 1 1

1 1 1 1 1 0 1 0 0 1

1 0 1 0 0 1 0 0 0 0

1 1 0 1 0 1 1 1 1 1

1 0 1 1 1 1 1 1 0 0

0 0 1 1 1 0 1 0 1 0

0 0 0 0 0 1 1 1 0 1

1 0 1 1 0 0 0 1 0 0

1 0 1 0

1 0 0 0

1 1 0 1

0 1 1 0

1 1 1 1

0 1 1 0

0 1 0 1

0 1 0 1

0 0 0 1

1 1 1 0

0 1 1 0

0 0 0 0

1 0 0 0

0 1 0 0

0 0 0 0

1 0 0 1 1 1 0 0 1 1

0 1 0 1 0 0 1 1 0 1

1 1 0 1 1 1 1 0 1 1

1 0 0 1 0 0 1 1 0 0

= α13 = α5 = α−∞ = α12 = α8 = α8 = α11 = α9 = α8 = α10

∞ −

α = 1 α = 0 α∞ = − α = 5 α = 10 α = 3 α = 9 α = 9 α = 5 α = 12 α = 5 α = 7 α = 0 α = 8 α

=

Abb. 9.26: Empfangene Matrix mit einem Bündelfehler und fehlerhaften Prüfsymbolen. S

0 B B B B B B B @

=

∈ A(2) (23 ; 7, 4, 4) ∈ A(1) (2; 7, 1, 7)

1 0 CC BB 1 CC BB 1 CC = BB 1 CA B@ 1

·

H

0

1

1

0

0

1

1

0

1

0

1

0

0

0

1

1

1

1

1

1

1 C C 0 C C C 0 C C A 1

0

·

0 B B B B B B B B B B B B B B B @

W

1 C C C C C C C C C C C C C C C A

Abb. 9.27: Syndromgleichung der verketteten Code-Konstruktion. S

=

·

H

0 1 0z H}|l2 { z H}|r2 { 1 000000 111111 BB CC BB 1 0 1 1 0 0 0 C 000000 111111 BB CC BB 1 1 1 0 1 0 0 C C 000000 111111 R2 C 000000 111111 = B BB C C B C 000000 111111 1 1 0 0 0 1 0 C B B@ 000000000000 C 111111111111 000000 111111 A @1 1 1 1 1 1 1C A 000000000000 111111111111 R1 000000000000 | 111111111111 {z } |{z}

Hl1

Hr1

·

W

0 1 B C B C B C X 2 B C B C B C B C X 1 B C 0000000 1111111 B C B C 0000000 1111111 B C 0000000 1111111 P B C 2 B C 0000000 1111111 B C 0000000 1111111 B C 111111111111 000000000000 @ 111111111111 A 0000000 1111111 000000000000 P1 000000000000 111111111111

Abb. 9.28: Systematische Codierung des verketteten Codes.

9.3 Error Locating Codes

369

Redundanzsymbole einer Codematrix W werden dann aus dem Gleichungssystem S = H · W (siehe Bild 9.28) berechnet: „ « X2 R2 = (Hl2 |Hr2 ) = Hl2 X2 + Hr2 P2 =⇒ P2 = R2 + Hl2 X2 , |{z} P2 R1 = (Hl1 |Hr1 )



X1 P1

«

=I

= Hl1 X1 + Hr1 P1 =⇒ P1 = R1 + Hl1 X1 . |{z} =I

f zunächst die Syndrommatrix Zur Decodierung wird aus der empfangenen Codematrix W e f e ist das Syndrom einer SpalS = H · W berechnet. Jedes Symbol der letzten Zeile von S (1) f te von W bezüglich B , in unserem Beispiel ein Parity-Check-Code. Der PC-Code hat die Mindestdistanz d = 2, deshalb kann damit lediglich eine ungerade Anzahl von Fehlern in der jeweiligen Spalte erkannt werden. Ist in einer Spalte der Codematrix genau ein Fehler aufgetreten, so wird dadurch die letzte Zeile der Syndrommatrix an dieser Stelle verfälscht. Da diese Zeile ein Codewort von A(1) (Wiederholungscode) ist, können bei einer Länge von sieben Bit bis zu drei Spalten, in denen je ein Fehler aufgetreten ist, entdeckt werden. Die Information über die fehlerhaften Spalten wird im nächsten Schritt genutzt, um mit den übrigen drei Zeilen der Syndrommatrix, die ein Codewort von A(2) repräsentieren, eine Auslöschungskorrektur (siehe Abschnitt 3.2.7) durchzuführen. Sind bei der Übertragung nicht mehr als drei Fehler in verschiedenen Spalten der Codematrix aufgetreten, so ist die korrigierte Syndrommatrix fehlerfrei. Jede Spalte der Syndrommatrix entspricht dem Syndrom der jeweiligen Spalte der Codematrix bezüglich des Codes B(2) (7, 3, 4). Bei einer Mindestdistanz von d = 4 kann damit genau ein Fehler korrigiert werden. Da die Spalten von W in der Regel keine Codeworte von B(2) sind und folglich das zugehörige Syndrom 6= 0 ist, muss die Decodierung in dem Coset erfolgen, das dieses Syndrom aufweist. Das Decodierproblem kann durch Addition eines beliebigen Vektors aus diesem Coset in die übliche Form transformiert werden: s = HxT

=⇒ 0 = H(x + a)T , ∀{a | s = HaT }.

Nach erfolgter Decodierung muss die Transformation wieder rückgängig gemacht werden, um den gesuchten Vektor zu erhalten. 

Das Konstruktionsprinzip soll nachfolgend an einem weiteren Beispiel illustriert werden, das [GJZ97] entnommen wurde. Beispiel 9.37 (Systematischer GC-Code 2) Der Code wurde entwickelt, um die Bitfehlerrate einer bestehenden optischen Übertragungsstrecke von 10−4 auf etwa 10−10 zu reduzieren. Die Größe der Codewörter war mit 19440 Bit festgelegt. Die Prüfmatrix wird über einen (80, 55, 8)-Code (verkürzter BCH(255, 230, 8)-Code) und die Partitionierung B(1) (80, 79, 2) ⊃ B(2) (80, 71, 4) ⊃ B(3) (80, 63, 6) ⊃ B(4) (80, 55, 8) gebildet. Die Syndrommatrix setzt sich aus Codeworten der Codes A(1) (2; 243, 139, 27), A(2) (28 ; 243, 230, 14), A(3) (28 ; 243, 240, 4) und A(4) (28 ; 243, 242, 2) zusammen. Bei der Decodierung wird nach dem gleichen Prinzip, wie in Beispiel 9.36 erklärt, vorgegangen. Code A(1) dient zur Lokalisierung der Spalten mit einer ungeraden Anzahl von Fehlern. Beim Decodieren von A(2) werden die Syndrome der Spalten mit Einzelfehlern korrigiert und Spalten mit zwei Fehlern aufgedeckt. Mit den untersten neun Spalten der Syndrommatrix und Code B(2) können die Einzelfehler in den Spalten der Codematrix korrigiert werden. Falls es sich um

370

9 Verallgemeinerte Codeverkettung S25×243

0 BB BB BB BB BB BB BB @

∈ A(4) (28 ; 243, 242, 2) ∈ A(3) (28 ; 243, 240, 4) ∈ A(2) (28 ; 243, 230, 14) ∈ A(1) (2; 243, 139, 27)

0 1 B B B C B C B B 0 C C B C B C B C B C 1 · B C B C B C B 1 C B C B 1 C B B A B ··· 1 1 B @

H25×80

=

1 0 1 C B C B C B C B C B C B C B C =B C B ∗ C B C B C B C B C A B @ 1 1 ···

1 1

·

W80×243

1 C C C C C C C C C C C C C C C C C C C C A

Abb. 9.29: Syndromgleichung der verketteten Code-Konstruktion (schematisch).

eine Spalte mit drei Fehlern handelt, was zu diesem Zeitpunkt noch nicht erkennbar ist, wird eine falsche Korrektur durchgeführt, die jedoch im letzten Schritt mit dem stärksten Code B(4) wieder berichtigt werden kann. Anschließend können acht weitere Zeilen der Syndrommatrix (Code A(3) ) berechnet werden. Die 17 letzten Zeilen von S enthalten nun keine Fehler mehr, die von Einzelfehlern stammen. A(3) dient zur Korrektur des Syndroms bei zwei Fehlern pro Spalte und um 3-er Fehler zu lokalisieren, die dann letztlich mit Hilfe der Codes A(4) und B(4) korrigiert werden können. Sei ti die Anzahl der Spalten einer Codematrix mit i Fehlern, dann kann bei der Wahl der Codeparameter wie oben angegeben die Codematrix richtig korrigiert werden, wenn gilt: t1 ≤ 13 − 2t2 − t3 ,

t2 ≤ 3 − 2t3 ,

t3 ≤ 1

und

ti = 0, i ≥ 4.

Mit diesen Korrekturfähigkeiten kann der Code die Fehlerwahrscheinlichkeit eines BSC von 1 · 10−4 auf unter 1.2 · 10−10 reduzieren. Die Rate des Codes ist 0.988. 

9.4

GC-Codes mit Faltungscodes

Um GC-Codes mit Faltungscodes zu konstruieren, muss zunächst deren Partitionierung beschrieben werden. Danach soll eine GC-Codekonstruktion, die auf einem einzigen Faltungscode als inneren und äußeren Code basiert, und deren Decodierung beschrieben werden. Die Möglichkeit Faltungscodes zu partitionieren, wird im Kapitel 10 ausgenutzt, um Modulationsarten mit Gedächtnis als Trellis zu beschreiben und damit codierte Modulation mit sehr guten Distanzeigenschaften zu konstruieren.

9.4.1

Partitionierung von (P)UM-Codes

Wir wollen zunächst die Partitionierung von Faltungscodes auf die Partitionierung von Blockcodes zurückführen, indem wir die (P)UM-Code-Beschreibung verwenden. Dies war im übrigen auch der erste Ansatz (siehe [ZySha]), um GC-Codes mit inneren Faltungscodes zu konstruieren. In Abschnitt 8.7 haben wir (P)UM-Codes eingeführt und in Abschnitt 8.7.4 mögliche Konstruktionsmethoden auf der Basis von BCH-, RS- und RM-Codes dafür beschrieben.

9.4 GC-Codes mit Faltungscodes

371

Jeder Faltungscode kann als (P)UM-Code dargestellt werden, und die Codierung erfolgt durch ct = it Ga + it−1 Gb ,

i−1 = 0.

(9.18)

Jedes ct ist ein Codewort des Blockcodes Cα (siehe Abschnitt 8.7.1). Für eine mögliche Partitionierung benötigt man einen Untercode von Cα . Dies ist gleichbedeutend mit Untercodes von C0 und/oder C1 . Dieser Sachverhalt soll an den folgenden vier Beispielen veranschaulicht werden. Beispiel 9.38 (Partitionierung durch Generatormatrizen von (P)UM-Codes)Dieses Beispiel stammt aus [ZySha]. Die Generatormatrizen Ga und Gb eines UM-Codes (n = 6, k = 4) seien 1 0 1 0 1 0 1 1 1 0 1 1 1 1 1 1 B0 1 1 1 0 1C B0 0 0 1 1 1C C B C Ga = B @ 1 0 1 0 1 1 A , Gb = @ 1 0 0 1 1 0 A . 0 1 1 1 1 0 0 1 1 1 1 0 Dieser UM-Code hat die freie Distanz df = 5. Ein PUM-Code (n = 6, k0 Generatormatrizen: 0 1 0 1 B0 1 1 B Ga = @ 1 0 1 0 1 1

= 4|k1 = 2) mit der freien Distanz df = 4 habe die folgenden 1 1 0 1

1 0 1 1

1 0 1C C, 1A 0

0

1 B0 B Gb = @ 0 0

1 0 0 0

1 0 0 0

1 1 0 0

1 1 0 0

1 1 1C C. 0A 0

Beide Codes, der UM- und der PUM-Code, haben als Untercodes den B(2) (n = 6, k = 2) UM-Code mit den Generatormatrizen „ « „ « 1 0 1 1 1 0 1 1 1 1 1 1 (2) G(2) = , G = . a b 0 1 1 1 0 1 0 0 0 1 1 1 (2)

Man überzeugt sich, dass der Untercode die freie Distanz df = 7 hat. Entsprechend der GC-Konstruktion haben wir damit eine Partitionierung des UM- und des PUM-Codes in jeweils 22 Untercodes mit größerer freier Distanz erreicht. Wir werden in Abschnitt 9.5.1 bei der Verkettung von inneren Faltungs- mit äußeren Blockcodes nochmals auf dieses Beispiel zurückkommen. 

Wenn die (P)UM-Codes aus RS- bzw. BCH-Codes konstruiert sind, kann eine Partitionierung errechnet werden, indem geeignete Untercodes der RS- bzw. BCH-Codes gewählt werden. Beispiel 9.39 (Partitionierung von (P)UM-Codes mit RS-Codes) Die folgenden Codes haben wir teilweise schon in Beispiel 8.48 behandelt. Wir benutzen RS-Codes der Länge 7 über GF (23 ) und die entsprechenden Generatorpolynome des PUM-Codes wie folgt: g00 (x) = (x − α2 ) · (x − α3 ) · (x − α4 ) · (x − α5 ) · (x − α6 ) g01 (x) = (x − α0 ) · (x − α1 ) · (x − α4 ) · (x − α5 ) · (x − α6 )

g10 (x) = (x − α0 ) · (x − α1 ) · (x − α2 ) · (x − α3 ) · (x − α6 ) .

372

9 Verallgemeinerte Codeverkettung (0)

(1)

Das Informationspolynom it (x) wird aufgespalten in it (x) und it (x), also it (x) = it,0 + (0) (1) (0) (0) (1) (1) it,1 x + it,2 x2 + it,3 x3 = it (x) + it (x) = it,0 + it,1 x + it,0 x2 + it,1 x3 . Damit lautet die Codiervorschrift: (0)

(1)

(0)

ct (x) = it (x) · g00 (x) + it (x) · g01 (x) + it−1 (x) · g10 (x)

(0)

(1)

= at (x) + at (x) + bt (x), (0)

(1)

wobei it (x) den Grad 2 hat und it (x) ebenfalls. Man beachte, dass aufgrund der Konstruk(0) (1) tion aus einem gegeben ct (x), alle Codeworte (at (x), at (x) und bt (x)) explizit berechnet werden können; siehe Bild 9.30 und gegebenenfalls Abschnitt 8.7.4. Der PUM-Code hat die Parameter k = 4 und k1 = 2 sowie die Distanzen df ≥ n − (k − k1 ) + 1 = 7 − (4 − 2) + 1 = 6

und

dα ≥ n − (k + k1 ) + 1 = 7 − (4 + 2) + 1 = 2 . Ein möglicher Untercode ergibt sich zu: sub g00 (x) = (x − α1 ) · (x − α2 ) · (x − α3 ) · (x − α4 ) · (x − α5 ) · (x − α6 ) sub g01 (x) = (x − α0 ) · (x − α3 ) · (x − α4 ) · (x − α5 ) · (x − α6 )

sub g10 (x) = (x − α0 ) · (x − α1 ) · (x − α2 ) · (x − α4 ) · (x − α5 ) · (x − α6 ) .

Dieser Untercode hat die Parameter k = 3 und k1 = 1 sowie die Distanzen df ≥ n − (k − k1 ) + 1 = 7 − (3 − 1) + 1 = 6

und

dα ≥ n − (k + k1 ) + 1 = 7 − (3 + 1) + 1 = 4 . (2)

Der PUM-Code B(1) (23 ; n = 7, k = 4|k1 = 2) wird damit in die 23 Untercodes Bi (23 ; n = (2) 7, k = 3|k1 = 1), i ∈ GF (23 ), partitioniert. Die Untercodes Bi haben die gleiche freie Distanz wie der Ausgangscode, d. h. man hat durch die Partitionierung keinen Distanzgewinn bezüglich sub der freien Distanz erreicht, obwohl der Code Cαsub mit dem Generatorpolynom gα entsprechend Bild 9.30 eine größere Mindestdistanz hat. Diese Partitionierung ist somit ungeeignet, um GCCodes zu konstruieren. Ein anderer möglicher Untercode ergibt sich zu: sub2 g00 (x) = (x − α2 ) · (x − α3 ) · (x − α4 ) · (x − α5 ) · (x − α6 )

sub2 g01 (x) = (x − α0 ) · (x − α1 ) · (x − α3 ) · (x − α4 ) · (x − α5 ) · (x − α6 ) sub2 g10 (x) = (x − α0 ) · (x − α1 ) · (x − α2 ) · (x − α5 ) · (x − α6 ) .

Dieser Untercode hat die Parameter k = 3 und k1 = 2 sowie die Distanzen df ≥ n − (k − k1 ) + 1 = 7 − (3 − 2) + 1 = 7

und

dα ≥ n − (k + k1 ) + 1 = 7 − (3 + 2) + 1 = 3 . In diesem Falle hat man hat einen Distanzgewinn bezüglich der freien Distanz erreicht, und die Partitionierung ist für eine GC-Codekonstruktion geeignet. 

9.4 GC-Codes mit Faltungscodes g00 (x)

373

0 0 0 0 0

sub g00 (x)

0 0 0

sub (x) g01

0

0

sub g10 (x)

0 0 0

0

sub gα (x)

0 0 0

sub2 g00 (x)

0 0 0 0 0

g01 (x)

0 0

g10 (x)

0 0 0 0

gα (x)

0 0 0 0 0 0 0 0 0 0

sub2 g01 (x)

0 0

sub2 (x) g10

0 0 0

sub2 gα (x)

0 0 0

0 0 0 0 0 0 0 0

Abb. 9.30: Transformierte der Generatorpolynome der RS-Codes.

Beispiel 9.40 (Partitionierung von (P)UM-Codes mit BCH-Codes) Der PUM-Code aus Beispiel 8.49 war B(1) (n = 15, k = 10|k1 = 4) mit der freien Distanz df = 6 und hatte die Generatorpolynome g00 (x) = m0 (x) · m1 (x) · m5 (x) · m7 (x) g01 (x) = m0 (x) · m3 (x) · m7 (x) g10 (x) = m0 (x) · m1 (x) · m3 (x) · m5 (x). Ein möglicher Untercode habe die Generatorpolynome g00 (x) = m0 (x) · m1 (x) · m5 (x) · m7 (x) g01 (x) = m0 (x) · m1 (x) · m3 (x) · m5 (x) g10 (x) = m0 (x) · m1 (x) · m3 (x) · m5 (x) (2)

und ist somit einer der 22 Untercodes Bi (n = 15, k = 8|k1 = 4) mit der freien Distanz df = 8. In Bild 9.31 sind die Transformierten der jeweiligen Generatorpolynome der konstruierten g00 (x)

0 0 0

g01 (x)

0

g10 (x)

0 0 0 0 0 0 0

gα (x)

0 0 0

0 0 0 0

0 0 0

0 0

0 0 0 0

0 0 0

0

0

sub g00 (x)

0 0 0

sub g01 (x)

0

sub g10 (x)

0 0 0 0 0 0 0

sub (x) gα

0

0 0 0

0 0

0 0 0

0

0 0

0 0

0 0 0 0 0 0 0 0 0

0

0

Abb. 9.31: Transformierte der Generatorpolynome der BCH-Codes. Codes dargestellt.



374

9 Verallgemeinerte Codeverkettung

Beispiel 9.41 (Partitionierung von (P)UM-Codes mit RM-Codes) Wir betrachten die Codes aus Beispiel 8.50 und bestimmen zunächst die Generatorpolynome von BCH-Codes der Länge 31 nach dem gleichen Prinzip wie in Beispiel 9.40: g00 (x) = m0 (x) · m1 (x) · m3 (x) · m5 (x) · m15 (x) g01 (x) = m1 (x) · m3 (x) · m5 (x) · m7 (x) · m11 (x) g10 (x) = m0 (x) · m1 (x) · m7 (x) · m11 (x) · m15 (x). Analog zu Beispiel 9.40 können wir nun einen möglichen Untercode konstruieren, indem wir in sub der obigen Konstruktion g01 (x) durch g01 (x) = m1 (x) · m3 (x) · m5 (x) · m7 (x) · m11 (x) · m15 (x) ersetzen. Die Parameter des Untercodes sind dann n = 32, k = 11, k1 = 10, dα = 4 und df = 16. Die freie Distanz df des Untercodes ist hier nicht größer als die des ursprünglichen Codes. Durch die Partitionierung hat die Distanz zwischen parallelen Zweigen im Trellis von d01 = 16 auf dsub 01 = 32 zugenommen. Jedoch existieren im Untercode Pfade der Länge 2 mit Gewicht dsub = 16.  f

An den Beispielen sollte das Prinzip klar geworden sein, so dass auf eine allgemeine theoretische Beschreibung verzichtet werden kann, zumal wir im folgenden Abschnitt eine allgemeinere Methode zur Partitionierung herleiten werden. Dennoch wird die hier beschriebene Methode nochmals in Abschnitt 9.5.1 benötigt, um GC-Codes mit inneren (P)UM- und äußeren RS-Codes zu konstruieren.

9.4.2

Einführende Beispiele zur Partitionierung durch das Trellis

Im ersten Abschnitt haben wir erörtert, dass (P)UM-Codes anhand der darin enthaltenen Blockcodes partitioniert werden können. Am Beispiel des bekannten Faltungscodes der Rate 1/2 aus [Vit71] (siehe Beispiel 8.1) mit den Generatorsequenzen (oktal) g (1) = 7 und g (2) = 5 wollen wir die möglichen Partitionierungen genauer untersuchen. Wir folgen dabei der Vorgehensweise in [BDS97]. Die Basis ist dabei das Trellis des Codes gemäß Bild 9.32. Codebits Knoten (00) = 0

(1)

Informationsbits

Zweige (in Oktaldarstellung)

ut

t = (ut−2 , ut−1 , ut )

(2)

(vt , vt ) (0,0)

0

(1,1)

(01) = 1 (10) = 2

(0,1)

(11) = 3

t−1

0 1

(1,1)

4

1

(0,0) (1,0) (0,1)

5 0

2

1 0

(1,0)

t

1

0

t−1

3 6

1

t

t−1

7

t

Tiefe

Abb. 9.32: Abbildung der Code-/Eingabe-Bits am Trellis.

Das Trellis kann durch die Eingabe-Bits beschrieben werden, d. h. ein Knoten durch σ t = (ut−1 , ut ) und ein Zweig durch γ t = (ut−2, , ut−1 , ut ), d. h. zwei Bits für den Knoten, in dem er beginnt und ein Bit für die entsprechende Eingabe 0 oder 1. In einer Tiefe existieren 2ν = 4 Knoten, und zwei Zweige enden in und verlassen jeden Knoten.

9.4 GC-Codes mit Faltungscodes

375

Beispiel 9.42 (Partitionierung 2. Ordnung ohne Scrambler) Unser Beispielcode kann als UM-Code2 B(1) (n = 4, k(1) = 2, d(1) = 5) betrachtet werden und hat die Generatormatrizen “ ” “ ” 1 1 1 0 1 1 0 0 G0 = 0 0 1 1 und G1 = 1 0 1 1 .

Um eine Partitionierung zu erreichen, macht es Sinn, entsprechend der UM-Darstellung die Eingabebits ut in Gruppen zu zwei Bit zusammenzufassen. Wir wollen zusätzlich noch die (1) (2) Nummerierungsbits (zτ , zτ ) der Partitionierung einführen, und es gelte hier: ut−1 = zτ(1) und ut = zτ(2) . Dies bedeutet, wir haben damit die Nummerierung der Tiefe geändert, denn, wird im herkömmlichen Trellis nach Bild 9.32 die Nummer t um k(1) erhöht, so entspricht dies einer Erhöhung der Nummer τ um 1. B(1) (4, 2, 5)

(1)

(2)

ut−1 = zτ ,

ut−1

ut = zτ

...

ut

(00) = 0 (01) = 1

Pfade vom Gewicht 5 p1

(10) = 2

p2

(11) = 3 t−2

t−1

B(2) (4, 1, 5)

t

t+1

ut−1 = 0,

ut−1

t+2

(2)

ut = zτ

...

ut

(00) = 0 (01) = 1

Pfad vom Gewicht 5 p2

(10) = 2 (11) = 3 t−2

t−1

t

t+1

t+2

Abb. 9.33: Trellisse der Partitionierung 2. Ordnung ohne Scrambler. (1)

Bild 9.33 zeigt die Partitionierung, die erreicht wird, wenn man alle Nummerierungsbits zτ , τ = 0, 1, . . ., zu 0 wählt. Gezeigt ist der jeweilige Untercode mit dem entsprechenden Bit gleich 0. Im linken Teil des Bildes sind alle möglichen Pfade eingezeichnet, während im rechten Teil neben dem Nullpfad nur die Pfade mit der freien Distanz angegeben sind. Die gestrichelt umrandeten Knoten entsprechen den Knoten des UM-Code-Trellis. Die Pfade p1 und p2 haben Gewicht 5. Offensichtlich ist die freie Distanz im Untercode B(2) (n = 4, k(2) = 1, d(2) = 5) gleich der des Codes B(1) , d. h. d(1) = d(2) = 5, da der Pfad p2 ein Codewort des Untercodes bleibt. Das bedeutet, dass durch die Partitionierung keine Distanzerhöhung erreicht wurde und diese somit ungeeignet zur GC-Codekonstruktion ist. 

Das Beispiel hat gezeigt, dass die direkte Partitionierung des Codes durch die Betrachtung als UM-Code nicht notwendigerweise geeignet ist. Deshalb wollen wir im Folgenden 2 Zur

Vereinfachung wird auf die Indizes der Untercodes verzichtet, sofern dies eindeutig ist.

376

9 Verallgemeinerte Codeverkettung

einen äquivalenten Faltungscodierer konstruieren, d. h. die Menge der Codefolgen ist identisch, unterschiedlich ist lediglich die Zuordnung von Informationsfolgen zu Codefolgen, also die Codiervorschrift (siehe Abschnitt 8.2.3 zu äquivalenten Codiermatrizen). Beispiel 9.43 (Partitionierung 2. Ordnung mit Blockscrambler) Betrachten wir in Bild 9.34 das oberen Trellis, so ist eine Partitionierung des Codes B(1) (n = 4, k(1) = 2, d(1) = 5) dann günstig, wenn im Untercode B(2) möglichst die Pfade mit kleinem Gewicht nicht enthalten sind. Das bedeutet, die Pfade im rechten Teil sollen punktiert (im Sinne von gelöscht) werden. Dies kann erreicht werden, indem wir in den Tiefen t = 2τ , τ = 1, 2, . . ., genau diejenigen Knoten nicht zulassen, die zu Pfaden mit kleinem Gewicht gehören. Diese sollten im Untercode nicht vorkommen. Wählen wir die Knoten σ t ∈ {1, 2}, so werden die Pfade p1 und p2 entsprechend Bild 9.34 punktiert. B(1) (4, 2, 5)

(1)

(2)

(ut−1 , ut ) = (zτ , zτ )M

ut−1

...

ut

(00) = 0 (01) = 1

Pfade vom Gewicht 5 p1

(10) = 2

p2

(11) = 3 t−2

| {z }

t−1

(1) σ t−2 7→zτ −1

B(2) (4, 1, 6)

t

t+1

t+2

| {z }

| {z }

(1) σ t 7→zτ

(1) σ t+2 7→zτ +1

Knoten mit zugeordneten (1) Nummerierungsbits zτ

(2)

(ut−1 , ut ) = (0, zτ )M

ut−1

...

ut

(00) = 0 (01) = 1

Pfad vom Gewicht 6

(10) = 2 (11) = 3 t−2

| {z }

t−1

(2) σ t−2 7→zτ −1

t

t+1

t+2

| {z }

| {z }

(2) σ t 7→zτ

(2) σ t+2 7→zτ +1

Knoten mit zugeordneten (2) Nummerierungsbits zτ

Abb. 9.34: Trellisse einer Partitionierung 2. Ordnung mit Blockscrambler. Formal können wir dies schreiben, indem wir die erlaubten Knoten der Tiefe t = 2τ , τ > 0, berechnen durch: ˘ ` ´ ` ´ ¯ Vt = σ t : σ t = ut−1 , ut = 0, zτ(2) M; zτ(2) ∈ {0, 1} = {0, 3}. mit dem Scrambler und dem inversen Scrambler „ « 1 0 M = M−1 = . 1 1

Man überzeugt sich, dass der Untercode B(2) (n = 4, k(2) = 1, d(2) = 6) die freie Distanz d(2) = (1) (2) 6 besitzt. Partitionieren wir wie in Beispiel 9.42 mit den Nummerierungsbits (zτ , zτ ), so

9.4 GC-Codes mit Faltungscodes

377 (1)

werden durch den Scrambler offensichtlich dem Bit zτ (1) und dem Bit zτ = 1 die Knoten σ t ∈ {1, 2}.

= 0 die Knoten σ t ∈ {0, 3} zugewiesen

Dies kann auch anders interpretiert werden, nämlich aus den Codiermatrizen “ ” “ ” 1 1 1 0 1 1 0 0 G0 = 0 0 1 1 und G1 = 1 0 1 1 werden mittels dem Scrambler die äquivalenten Codiermatrizen “ ” “ ” 1 1 1 0 1 1 0 0 G00 = MG0 = 1 1 0 1 und G01 = MG1 = 0 1 1 1 erzeugt.

Zur Wiederholung: (siehe auch Abschnitt 8.2.3) Für jede Codiermatrix Gj existiert eine Menge äquivalenter Codiermatrizen G0j , die den gleichen Code erzeugen und die mittels Scramblermatrizen M (|M| = 1) berechnet werden können: G0j = MGj ,

j = 0, 1.

Die (k × k)-Matrix M ist invertierbar und M−1 heißt inverse Scramblermatrix. Der durch die modifizierten Generatormatrizen erzeugte Code ist identisch, lediglich die Abbildung zwischen Informationsfolge und Codefolge ist unterschiedlich. Partitionieren wir also wie in Beispiel 9.42 (1) (2) mit den Nummerierungsbits (zτ , zτ ), erhalten wir Untercodes mit größerer freien Distanz (1) (2) (d = 5 und d = 6), die zur GC-Codekonstruktion geeignet sind. 

Die Konsequenz aus diesem Beispiel ist, dass wir die geeigneten Codiermatrizen eines Codes finden müssen, um eine optimale Partitionierung eines inneren Faltungscodes zu erhalten. Im folgenden Beispiel wollen wir die Partitionierung weiter verbessern, indem wir Scrambler mit Gedächtnis zulassen. Beispiel 9.44 (Partitionierung 3. Ordnung mit einem Faltungsscrambler) Die Grundidee ist hier wiederum, durch die Partitionierung diejenigen Pfade im Untercode auszuschließen, die geringes Gewicht haben, um die Mindestdistanz im Untercode möglichst groß zu machen. Im Gegensatz zum vorherigen Beispiel betrachten wir hier jedoch nicht die Knoten sondern die Zweige des Trellis, entsprechend Bild 9.35. Da wir eine Partitionierung der (1) (2) (3) Ordnung 3 erreichen wollen, benötigen wir drei Nummerierungsbits (zτ , zτ , zτ ) und entsprechend Bild 9.35 wird jeder Zweig genau durch drei Bits nummeriert. Wir betrachten die (1) Tiefen t = 3τ und entsprechend dem Bild ordnen wir den Bits zτ die Zweige γ t−2 , den Bits (2) (3) zτ die Zweige γ t−1 und zτ die Zweige γ t zu. Auch hier überlegen wir uns für eine günstige Partitionierung, welche Zweige wir punktieren, um eine möglichst große freie Distanz im Untercode zu erhalten. Durch genaues Hinsehen erkennen wir, dass die Zweige γ t−2 ∈ {1, 2, 4} des Codes B(1) punktiert werden sollten, um (1) die Pfade p1 , p2 und p3 zu entfernen. Also sollten die Nummerierungsbits zτ = 0 die Zweige (1) γ t−2 ∈ {0, 3, 5, 6} bezeichnen und zτ = 1 die Zweige γ t−2 ∈ {1, 2, 4, 7}. Um den Code B(2) zu partitionieren, sollten die Pfade p4 , p5 und p6 mit Gewicht 6 punktiert werden, was bedeutet, dass die Zweige γ t−1 ∈ {1, 6} gelöscht werden sollten. Dies kann erreicht (2) werden, wenn die Nummerierungsbits zτ = 0 den Zweigen γ t−1 ∈ {0, 3, 4, 7} entspricht und (2) konsequenterweise zτ = 1 den Zweigen γ t−1 ∈ {1, 2, 5, 6}.

378

9 Verallgemeinerte Codeverkettung B(1) (6, 3, 5)

...

ut−4

ut−3

...

ut−2

(00) = 0 (01) = 1 p1

(10) = 2

Pfade vom Gewicht 5

p3

p2

(11) = 3 t−6

t−5

| {z }

t−4

t−3

t−2

t−1

| {z }

(1) γ t−5 7→zτ −1

t

B(2) (6, 2, 6)

...

ut−3

ut−2

t+1

| {z }

(1) γ t−2 7→zτ

Zweige mit zugeordneten (1) Nummerierungsbits zτ

(1)

γ t+1 7→zτ +1

...

ut−1

(00) = 0 (01) = 1

p4

p5

(10) = 2

Pfade vom Gewicht 6 p6

(11) = 3 t−6

t−5

t−4

t−3

| {z }

t−2

(2)

γ t−4 7→zτ −1

B(3) (6, 1, 8)

t−1

| {z }

t

t+1

(2)

ut−2

Zweige mit zugeordneten (2) Nummerierungsbits zτ

(2)

γ t−1 7→zτ

...

t+2

| {z }

γ t+2 7→zτ +1

ut−1

...

ut

(00) = 0 (01) = 1 (10) = 2

Pfad vom Gewicht 8 p7

(11) = 3 t−6

t−5

t−4

t−3

| {z }

t−2

(3)

γ t−3 7→zτ −1

t−1

t

| {z }

(3)

γ t 7→zτ

t+1

t+2

t+3

| {z }

(3)

γ t+3 7→zτ +1

Zweige mit zugeordneten (3) Nummerierungsbits zτ

Abb. 9.35: Trellisse der Untercodes für die Partitionierung 3. Ordnung.

Damit hat der Code B(3) die freie Distanz d(3) = 8, da der Pfad p7 mit Gewicht 8 nicht gelöscht (3) wird. Die dritten Nummerierungsbits zτ müssen nun die entsprechende Codefolgen auswählen, (3) (3) respektive zτ = 0 die Zweige γ t ∈ {0, 3, 4, 7} und zτ = 1 die Zweige γ t ∈ {1, 2, 5, 6}. Auch hier können wir wieder formal einen Scrambler berechnen, der unsere überlegte Abbil(j) (j) (j) dung in Untercodes leistet. Seien x(j) = (x1 , x2 , x3 )T , j = 1, 2, 3 drei Spaltenvektoren, dann ergeben sich aus den obigen Überlegungen die folgenden drei Bedingungen für die Abbildung der Informationsbits (ut−2 , ut−1 , ut ) (entspricht einem Zweig im Trellis) auf die drei (1) (2) (3) Nummerierungsbits (zτ , zτ , zτ ): (zτ(1) , zτ(2) , zτ(3) ) · M = γ =⇒ (zτ(1) , zτ(2) , zτ(3) ) = γ · M−1 = γ · X. Für die inverse Scramblermatrix X können wir damit das folgende Gleichungssystem aufstellen: {x(1) | ∀γ t−2 ∈{1,2,4} γ t−2 x(1) = zτ(1) 6= 0} {x(2) | ∀γ t−1 ∈{1,6}

{x(3) | ∀γ t ∈{1,2,5,6}

γ t−1 x(2) = zτ(2) 6= 0} γ t x(3) = zτ(3) 6= 0}

⇒ ⇒ ⇒

x(1) = (111)T x(2) = (011)T x(3) = (011)T .

9.4 GC-Codes mit Faltungscodes

379

Man beachte, dass die Abbildung der Nummerierungsbits auf die Zweige bzw. Informationsbits durch die Beziehung zτ(j) = γ t−3+j · x(j) ,

t = 3τ, τ = 1, 2, . . . ,

gegeben ist. Ausgeschrieben ergibt sich also: zτ(1) =(ut−4 , ut−3 , ut−2 ) · (111)T zτ(2) =(ut−3 , ut−2 , ut−1 ) · (011)T zτ(3) =

(ut−2 , ut−1 , ut ) · (011)T .

Wir haben damit die inverse Scramblermatrix berechnet und können diese mit den Matrizen 1 0 0 1 (1) (2) (3) 0 0 0 x3 x2 x1 B (1) (3) C 0 0A, X0 = @ 0 x(2) x2 A und X1 = @ x1 3 (1) (2) (3) x2 x1 0 0 0 x3 bzw. in der Transformationsschreibweise aus Abschnitt 8.1.8 wie folgt angeben: 0 1 1 1 0 M−1 (D) = X0 + DX1 = @ D 1 1 A . D 0 1

Man beachte, dass dieser inverse Scrambler Gedächtnis besitzt und daher auch als Faltungsscrambler bezeichnet werden kann. Eine Matrixinversion liefert den Scrambler 0 1 1 1 1 1 A. M(D) = @ 0 1 D D 1+D Damit kann man nun einen äquivalenten Codierer berechnen, wenn man die Codiermatrix des Codes zunächst in Operatorschreibweise darstellt, ! 1 1 1 0 1 1 G(D) = G0 + D · G1 = D D 1 1 1 0 , D 0 D D 1 1 und dann mit dem Scrambler multipliziert: 0

G (D) = M(D) · G(D) =

1 0 0

1+D D 1+D2

D 1+D D+D2

1+D 1+D D2

1 0 1+D

0 1 1

!

.

Wir haben damit eine Partitionierung 3. Ordnung unseres Codes B(1) abgeleitet mit den freien Distanzen d(1) = 5, d(2) = 6 und d(3) = 8. 

Es stellt sich die Frage, ob wir durch Verwendung eines Faltungsscramblers auch die Partitionierung 2. Ordnung verbessern können? Das folgende Beispiel beantwortet diese Frage mit ja.

380

9 Verallgemeinerte Codeverkettung

Beispiel 9.45 (Partitionierung 2. Ordnung mit Faltungsscrambler) Betrachten wir den Scrambler „ « „ « 0 1 D 1 −1 M(D) = bzw. M (D) = . 1 D 1 0 Entsprechend dem vorherigen Beispiel können wir den inversen Scrambler mittels zweier Spaltenvektoren x(1) und x(2) schreiben: 0 1 1 0 „ « “ ” B X0 0 0C C. M−1 (D) = X0 + X1 · D mit = x(1) , x(2) = B @ X1 0 1A 1 0 Gemäß dem linken Trellis in Bild 9.36 benötigen wir Zweige, die 4 Eingabebits entsprechen: γ t = (ut−3 , ut−2 , ut−1 , ut ) und zτ(1) = γ t x(1) , zτ(2) = γ t x(2) , t = 2τ, τ > 0. Dies wird erreicht, da wir 8 statt 4 Knoten verwenden, und somit ein Knoten der Tiefe t − 1 durch σ t−1 = (ut−3 , ut−2 , ut−1 ) definiert wird. Konsequenterweise ergibt sich ein Zweig als γ t = (σ t−1 , ut ) = (ut−3 , ut−2 , ut−1 , ut ). Es existieren noch zwei weitere Möglichkeiten der Trellisdarstellung, um diese Abbildung zu erreichen, die jeweils in das mittlere und rechte Trellis in Bild 9.36 gezeichnet sind. Das mittlere Trellis stellt ein zeitvariantes Trellis dar, das in ungeraden Tiefen (t = 2τ −1) 8 (sonst 4) Knoten besitzt. Das rechte Trellis benutzt die UM-Darstellung und betrachtet zwei aufeinanderfolgende Zweige der Tiefe t−1 und t als einen verlängerten Zweig, der durch γ t,2 = (ut−3 , ut−2 , ut−1 , ut ) bezeichnet werden soll. Dieses Konzept der verlängerten Zweige wird im nächsten Beispiel nochmals verwendet. Unabhängig von der Interpretation im Trellis ergibt sich die folgende äquivalente Generatormatrix: „ « D 0 1+D 1+D 0 G (D) = M(D) · G(D) = . 1 + D + D2 1 + D 1 + D + D2 D + D2 Die freie Distanz des Untercodes B(2) ist d(2) = 8.



Im folgenden Beispiel wollen wir noch eine Partitionierung 4. Ordnung ableiten. Beispiel 9.46 (Partitionierung 4. Ordnung durch verlängerte Zweige) Betrachten wir zwei aufeinanderfolgende Zweige γ t−1 und γ t als einen einzigen verlängerten Zweig γ t,2 = (ut−3 , ut−2 , ut−1 , ut ), so können wir diesen 4 Bits entsprechend dem vorherigen Beispiel die Nummerierungsbits zuordnen. Bild 9.37 zeigt die verlängerten Zweige. Wir löschen auch hier wieder in den 4 Schritten der Partitionierung diejenigen verlängerten Zweige γ t,2 , γ t+4, 2 , γ t+8, 2 , . . ., die zu Pfaden mit kleinem Gewicht gehören. Damit erhalten wir eine Partitionierung 4. Ordnung: B(4) (8, 1, 10) ⊂ B(3) (8, 2, 6) ⊂ B(2) (8, 3, 6) ⊂ B(1) (8, 4, 5).

9.4 GC-Codes mit Faltungscodes

381

B (1) (4, 2, 5)

ut−1

ut

ut+1

...

0 1 2 3 t−2

4 5

t

| {z }

t+2

| {z }

(1)

t,27→zτ(1) t+2,2 7→zτ+1

6 7 t− 2 t−1

t

t+1

t−2 t−1

t+2

| {z }

| {z }

t 7→zτ(1)

(1)

t+2 7→zτ+1

t

t+1

t+2

| {z }

| {z }

t 7→zτ(1)

(1)

t+2 7→zτ+1

B (2) (4, 1, 8)

ut−1

ut

ut+1

...

0 1 2 3 t−2

4 5

t

| {z }

t+2

| {z }

(2)

t,27→zτ(2) t+2,2 7→zτ+1

6 7 t− 2 t−1

t

t+1

t−2 t−1

t+2

| {z }

| {z }

t 7→zτ(2)

(2)

t+2 7→zτ+1

t

t+1

t+2

| {z }

| {z }

t 7→zτ(2)

(2)

t+2 7→zτ+1

Abb. 9.36: Trellisse der Untercodes für die drei Darstellungen.

Die zugehörigen Scrambler errechnen sich zu: 0

0 1 @ M= 0 1

1 1 1 0

0 0 1 0

1 0 0A 0 1

bzw.

M−1

0

1 1 @ = 1 1

1 0 0 1

0 0 1 0

1 0 0A 0 . 1

Hierfür betrachten wir den Code B(1) als PUM-Code (n = 8, k(1) = 4, d(1) = 5) und erhalten die (4 × 8)-Codiermatrizen als: 0

1 0 G0 = @ 0 0

1 0 0 0

1 1 0 0

0 1 0 0

1 1 1 0

1 0 1 0

0 1 1 1

1 0 1A 0 1

und

0

0 0 G1 = @ 1 1

0 0 1 0

0 0 0 1

Daraus berechnen wir durch Multiplikation mit dem Scrambler lenten Codierers zu: 0 1 0 0 0 1 1 1 0 1 0 0 0 0 1 1 0 1 0 1 1 1 0 0 0 0 0 G0 = @ 0 0 1 1 0 1 0 1 A und G1 = @ 1 1 0 1 1 1 0 1 1 1 1 1 0 1

0 0 0 1

0 0 0 0

0 0 0 0

0 0 0 0

1 0 0A 0 . 0

die Codiermatrix des äquiva0 0 0 1

0 0 0 0

0 0 0 0

0 0 0 0

1 0 0A 0 . 0

382

9 Verallgemeinerte Codeverkettung

B(1) (8, 4, 5)

(1)

(2)

(3)

(4)

(ut−3 , ut−2 , ut−1 , ut ) = (zτ , zτ , zτ , zτ )M

ut−3

ut−2

ut−1

...

ut

(00) = 0 (01) = 1

Pfade vom Gewicht 5

(10) = 2 (11) = 3 t−4

t−3

t−2

t

|

{z

t+2

t+4

|

(1)

γ t,2 7→zτ

B(2) (8, 3, 6)

t+1

}

{z

}

(1)

γ t+4,2 7→zτ +1 (2)

(3)

Zweige mit zugeordneten (1) Nummerierungsbits zτ

(4)

(ut−3 , ut−2 , ut−1 , ut ) = (0, zτ , zτ , zτ )M

ut−3

ut−2

ut−1

...

ut

(00) = 0 (01) = 1 (10) = 2

Pfade vom Gewicht 6

(11) = 3 t−4

t−3

t−2

t

|

{z

t+2

t+4

|

(2)

γ t,2 7→zτ

B(3) (8, 2, 6)

t+1

}

{z

}

(2)

γ t+4,2 7→zτ +1 (3)

Zweige mit zugeordneten (2) Nummerierungsbits zτ

(4)

(ut−3 , ut−2 , ut−1 , ut ) = (0, 0, zτ , zτ )M

ut−3

ut−2

ut−1

...

ut

(00) = 0 (01) = 1 (10) = 2

Pfad vom Gewicht 6

(11) = 3 t−4

t−3

t−2

t

|

{z

t+1

t+2

}

B(4) (8, 1, 10)

t+4

|

(3) γ t,2 7→zτ

{z

}

(3) γ t+4,2 7→zτ +1

Zweige mit zugeordneten (3) Nummerierungsbits zτ

(4)

(ut−3 , ut−2 , ut−1 , ut ) = (0, 0, 0, zτ )M

ut−3

ut−2

ut−1

...

ut

(00) = 0 (01) = 1 (10) = 2

Pfad vom Gewicht 10

(11) = 3 t−4

t−3

t−2

t

|

{z

}

(4)

γ t,2 7→zτ

t+1

t+2

t+4

|

{z

}

(4)

γ t+4,2 7→zτ +1

Zweige mit zugeordneten (4) Nummerierungsbits zτ

Abb. 9.37: Trellisse der Untercodes für die Partitionierung 4. Ordnung.

Anmerkung: In [BDS97] wurde gezeigt, dass diese Konstruktion zu einer höheren Decodierkomplexität führt, allerdings wird dort auch eine Partitionierung 4. Ordnung ohne eine solche Erhöhung beschrieben. 

In Tabelle 9.2 sind die Ergebnisse aus den ersten vier Beispielen zusammengefaßt. Das Fehlergewicht cw ist dabei definiert als die Anzahl der Pfade mit Gewicht w, die zu einem

9.4 GC-Codes mit Faltungscodes

383

festen Zeitpunkt vom Nullpfad des äquivalenten Codierers ausgehen, multipliziert mit der gemittelten Anzahl an Informationsbits gleich 1. In unserem Fall entsprechen für (i) einen Untercode Bz(1) ,...,z(i−1) die Informationsbits der Nummerierung z(i) . Man erkennt, dass die Partitionierung ein und desselben Faltungscodes auf unterschiedlich gute Art durchgeführt werden kann. Als Maß für die Qualität dient hier die freie Distanz, aber es ist ein ungelöstes Problem, ob nicht eine der erweiterten Distanzen aus Abschnitt 8.3 geeigneter ist. Das Konzept der verlängerten Zweige kann selbstverständlich dazu benutzt werden, Partitionierungen noch höherer Ordnung abzuleiten. Tabelle 9.2: Fehlergewicht der Nummerierungen der Untercodes für Codeworte mit Gewicht w. Fehlergewicht cw für Distanz w Beispiel 9.42 Beispiel 9.43 Beispiel 9.45 Beispiel 9.44 Gewicht w B(1) B(2) B(1) B(2) B(1) B(2) B(1) B(2) B(3) 5 1 1 2 2 3 6 4 2 6 1 8 6 4 7 12 3 16 0 20 14 0 8 32 4 40 2 46 2 32 14 1 9 80 5 96 0 104 0 72 0 0 10 192 6 224 3 234 4 160 48 2 11 448 7 512 0 528 0 352 0 0 12 1024 8 1152 4 1184 8 768 156 3 .. .

9.4.3

Partitionierung von Faltungscodes

Wir haben im vorherigen Abschnitt gezeigt, dass die Qualität einer Partitionierung eines Codes von dem verwendeten Codierer abhängig ist. Die prinzipiellen Möglichkeiten der Partitionierung von Faltungscodes wurden an Beispielen demonstriert. Wir wollen dies für Faltungscodes der Rate 1/n verallgemeinern (eine Erweiterung auf Rate k/n ist möglich). Wir wollen im Folgenden die wichtigsten Punkte aus [BDS97] darstellen, insbesondere den Algorithmus mit dem die Scrambler bei gegebenem Faltungscode berechenbar sind, um eine Partitionierung der Ordnung s zu erreichen. Unser Ziel ist dabei, einen für die Partitionierung optimalen äquivalenten Codierer zu finden. Dies kann gemäß Abschnitt 9.4.3 durch Konstruktion eines geeigneten Scramblers erfolgen. Gegeben sei ein Faltungscode C der Rate 1/n mit Gesamteinflußlänge ν und der freien Distanz d. Die binäre Informationsfolge i = (i1 , i2 , . . . , it , . . .) wird auf s sogenannte Nummerie(j) (j) (j) rungsfolgen z(j) = (z1 , z2 , . . . , zτ , . . .), j = 1, 2, . . . , s, der Partitionierung abgebildet: zτ(j) = is(τ −1)+j ,

τ = 1, 2, . . . .

Die Partitionierung der Ordnung s wird dann mittels dieser Nummerierung gemäß Bild 9.38 durchgeführt.

384

9 Verallgemeinerte Codeverkettung

z (1) (D)

Scrambler

...

u(1) (D)

...

M(D)

z (s)(D)

Multiplexer u

Faltungscode

v

C

u(s) (D)

Abb. 9.38: Äquivalenter Codierer des Faltungscodes C für eine Partitionierung der Ordnung s.

Zur Codierung werden die Nummerierungsfolgen durch den Scrambler (s × s)-Matrix und den Multiplexer auf die Eingangsfolge u = (u1 , u2 , . . . , ut , . . .) abgebildet, die dann mit der Generatormatrix des Faltungscodes in das Codewort v codiert wird. Wir erhalten eine Partitionierung (s)

(2)

Bz(1) ,z(2) ,...,z(s−1) ⊂ · · · ⊂ Bz(1) ⊂ B (1) . (j)

Dabei ist ein Untercode Bz(1) ,z(2) ,...,z(j−1) definiert als die Menge der Codewörter von C, für die gilt: • z(1) , z(2) , . . . , z(j−1) sind durch die Nummerierung vorgegeben, und • z(j) , z(j+1) , . . . , z(s) sind beliebige Folgen. Der Code B (1) ist der Code C selbst. Für die freien Distanzen der Untercodes gilt: d = d(1) ≤ d(2) ≤ · · · ≤ d(j) ≤ · · · ≤ d(s) , wobei d die freie Distanz von C ist. In Transformationsschreibweise erhalten wir für die Nummerierungen z(D) = (z (1) (D), z (2) (D), . . . , z (s) (D)) , (j)

(j)

(j)

mit z (j) (D) = z1 + z2 D + z3 D2 + · · · , und entsprechend für den Ausgang des Scramblers u(D) = (u(1) (D), u(2) (D), . . . , u(s) (D)) , mit u(j) (D) = uj + us+j D + u2s+j D2 + · · · . Es gilt: u(D) = z(D) · M(D) und entsprechend z(D) = u(D) · M−1 (D).

(9.19)

Wir setzen voraus, dass eine rechtsinverse Matrix M−1 (D) existiert und dass M(D) realisierbar ist. Falls M(D) = M gilt, nennen wir diese Blockscrambler und sonst Faltungsscrambler . Die Codiermatrix des äquivalenten Faltungscodes berechnet sich wie folgt: G0 (D) = M(D) · G(D),

9.4 GC-Codes mit Faltungscodes

385

wobei G(D) die (s × sn)-Generatormatrix des Faltungscodes C ist, die ein kleineres Gedächtnis besitzt (siehe hierzu auch Abschnitt 8.7.4 über UM-Codedarstellung). In [BDS97] wurde bewiesen, dass für einen nicht-katastrophalen Codierer des Originalcodes auch der äquivalente Codierer und alle Codierer der Untercodes nicht-katastrophal sind, sofern der inverse Scrambler polynomiell ist. Wir haben in den vorangegangenen Beispielen gesehen, dass unter bestimmten Bedingungen die Untercodes durch das Trellis des zu partitionierenden Codes dargestellt werden können, indem entweder Knoten oder Zweige entfernt werden und wir haben dies als Knoten- bzw. Zweigpunktierung bezeichnet. Der Algorithmus 9.3 berechnet den inversen Scrambler M−1 (D). Bei Codes der Rate 1/n besitzt ein Trellis in jeder Tiefe 2ν Knoten und zwei Zweige enden in und verlassen jeden Knoten. Die Knoten der Tiefe t σ t = (ut−ν+1 , . . . , ut ) können durch ν Eingabe-Bits beschrieben werden; entsprechend Zweige durch γ t = (σ t−1 , ut ) = (ut−ν , . . . , ut ). Jedes Codewort ist ein möglicher Pfad p = (p1 , . . . , pt . . .) im Trellis des entsprechenden Codes und kann äquivalent als eine Folge von Knoten (σ 1 , . . . , σ t , . . .) bzw. Zweigen (γ 1 , . . . , γ t , . . .) beschrieben werden. Bei Knotenpunktierung beschreiben wir einen Pfad durch Knoten, bei Zweigpunktierung durch Zweige. Dazu benutzen wir folgende Notation des inversen Scramblers. Ein inverser Scrambler M−1 (D) besteht aus s Spalten m−1 j (D), j = 1, 2, . . . , s. Weiterhin sei M−1 (D) =

q X

Xl D l

l=0

mit binären (s × s)-Untermatrizen Xl , wobei q der maximale Grad der Polynome des inversen Scramblers ist. Damit schreiben wir die Matrix   Xq  ..   .  ˆ (1) , . . . , x ˆ (j) , . . . , x ˆ (s) X=  = x X1 X0 mit s Spalten der Länge s · q. Jede Spalte muss der folgenden Bedingung genügen: ∆(j) Nullen

ˆ x

(j)

= (0|x

(j)

|

z}|{ 0

)T ,

0 ≤ ∆(j) < s.

∆(j) wird als Verschiebung der j-ten Spalte bezeichnet. Der Teilvektor x(j) enthält alle Stellen der Spalte, die ungleich Null sind. Für Knotenpunktierung hat dieser Teilvektor die Länge ν bzw. bei Zweigpunktierung ν + 1. Daraus folgt q = dν/se. Dies definiert eine Zuordnung von (−1)

ˆ (j) ⇐⇒ mj (x(j) , ∆(j) ) =⇒ x

(D).

386

9 Verallgemeinerte Codeverkettung

Anmerkung: Die ersten und/oder letzten Stellen von x(j) können auch Nullen ent(j) halten. Eine Zuordnung zwischen dem Nummerierungsbit zτ und einem Knoten bzw. Zweig ergibt sich dann zu: ( σ sτ −∆(j) x(j) bei Knotenpunktierung (j) (j) zτ = psτ −∆(j) x = (9.20) (j) γ sτ −∆(j) x bei Zweigpunktierung. Satz 9.23 (Pfadpunktierung) Ein Codewort des Codes C ist bei gegebenen Spalten (j) (i) m−1 und ∆(i) , i < j, nicht in dem Untercode Bz(1) ,z(2) ,...,z(j−1) enthalten, i (D), d. h. x sofern für den dem Codewort entsprechenden Pfad p = (p1 , p2 , . . . , pt , . . .) gilt: ∃zτ(i) :

zτ(i) 6= psτ −∆(i) x(i)

i < j und τ > 0.

Beweis: Gemäß Gleichung (9.20) ergibt sich die Zuordnung zwischen dem Pfad p eines Codewortes und den entsprechenden Nummerierungsfolgen z(i) , i ∈ {1, 2, . . . , s}. Nach der Defi(i) nition eines Untercodes muss immer zτ = psτ −∆(i) x(i) für i < j und τ > 0 gelten. Daraus folgt unmittelbar der Satz. 2

Wenn man die Spalten des inversen Scramblers berechnet (siehe etwa Beispiel 9.44), so existieren unterschiedliche Strategien für die Spaltenwahl, was in der Regel zu unterschiedlichen Scramblern führt, d. h. es existiert keine eindeutige Wahl. Wir werden im folgenden Algorithmus zwei Kriterien anwenden: 1) Die freie Distanz im Untercode soll so groß wie möglich sein. 2) Die Anzahl der Bitfehler, bei falscher Decodierung mit dem Viterbi-Algorithmus soll minimal sein. Bei Pfaden mit gleichem Gewicht, punktieren wir diejenigen, die einen größeren Beitrag zur Bitfehlerrate liefern. Algorithmus 9.3 ist eine Möglichkeit, eine Scramblermatrix M(D) unter Beachtung dieser Kriterien zu berechnen. Anmerkung: Für |M−1 (D)| = 1 erhält man einen realisierbaren nicht-rekursiven Codierer, ansonsten einen realisierbaren rekursiven Codierer. Mit Algorithmus 9.3 kann nun ein beliebiger Faltungscode partitioniert werden und dann mit geeigneten äußeren Codes ein GC-Code konstruiert werden. Die Ergebnisse können auch auf Faltungscodes mit beliebigen Raten oder über nichtbinäre Alphabete verallgemeinert werden. Für Trellisse mit längeren Zweigen sei auf [BDS97] verwiesen.

9.4.4

Konstruktion und Decodierung eines GC-Codes

In diesem Abschnitt wollen wir einen GC-Code [BDS96a] auf der Basis eines einzigen Faltungscodes konstruieren, nämlich dem Faltungscode des ESA/NASA-SatellitenStandards, der von dem Consultative Committee for Space Data Systems (CCSDS) [WHPH87] vorgeschlagen wurde. Dieser Code C hat die Rate 1/2, Gesamteinflußlänge ν = 6 und die Generatorsequenzen (oktal) g (0) = 133 und g (1) = 171. Wir werden eine

9.4 GC-Codes mit Faltungscodes

387

Algorithmus 9.3: Algorithmus zur Berechnung einer Scramblermatrix M(D). Eingabe: Ordnung s der Partitionierung, Codetrellis von C. Initialisierung: j = 1.

Schritt 1: Sei EdH die Menge aller Pfade, die Codewörtern mit Hamming-Gewicht dH = d(j) des Untercodes B(j) entsprechen. Setze η = 1. Schritt 2: Gegeben sind alle Spalten m−1 i (D), i = 1, 2, . . . , j − 1. Bestimme alle Lösungen für η zusätzliche Spalten m−1 j+l (D), 0 ≤ l < η, gemäß Satz 9.23, so dass alle Pfade in EdH gelöscht sind. Wenn keine Lösung existiert, dann setze η = η + 1. ⇒ Schritt 2. Schritt 3: Falls mehrere Lösungen existieren, wähle diejenigen aus, für die die freie Distanz des Untercodes B(j+η) maximiert wird. Schritt 4: Falls wiederum mehrere Lösungen existieren, wähle diejenige aus, bei der die (j+l) Fehlergewichte cd(j+l) aufsteigend minimiert werden, d. h. (j)

(j+l)

(j+η−1)

cd(j) ≥ · · · ≥ cd(j+l) ≥ · · · ≥ cd(j+η−1) ,

Schritt 5: j = j + η. Wenn gilt (j ≤ s) ⇒ Schritt 1.

0 ≤ l < η.

Schritt 6: Wähle, wenn möglich, eine inverse Scramblermatrix mit Determinante der Form |M−1 (D)| = 1 + · · · . ` ´−1 Berechne M(D) = M−1 (D) . (j)

Ausgabe: M(D), M−1 (D), d(j) und cd(j) , j = 1, 2, . . . , s.

Partitionierung 6. Ordnung mit Blockscrambler für Knotenpunktierung dieses Codes ableiten und als äußere Codes punktierte Versionen desselben Codes benutzen (siehe Abschnitt 8.1.10). Damit kann ein Gewinn von ca. 1 dB gegenüber dem ESA/NASAStandard erreicht werden. Dieser stellt eine herkömmliche Verkettung dieses Faltungscodes als inneren Code mit einem äußeren RS-Code dar. Konstruktion des inneren Codes Zunächst leiten wir die Partitionierung des inneren Codes entsprechend den vorangehenden Abschnitten ab und schreiben dazu den Code als UM-Code B (1) (n = 12, k (1) = 6, d(1) = 10), wobei d(1) die freie Distanz darstellt. Die Codiermatrizen sind    110111110010 11 0 0 1 1 0 1 1 1 1 1 0 0 1 0 0 0 0 0 1 1 0 1 1 1 1 1 0 0 G0 =  0 0 0 0 0 0 1 1 0 1 1 1  und G1 =  1 1    000000001101 11 000000000011 01

0 1 1 0 1 1

0 1 0 0 1 1

0 0 1 1 0 1

0 0 1 0 0 1

0 0 0 1 1 0

0 0 0 1 0 0

0 0 0 0 1 1

0 0 0 0 1 0

0 0 0 0 0 1

 0 0 0 . 0  0 1

388

9 Verallgemeinerte Codeverkettung Tabelle 9.3: Freie Distanzen und Anzahl der minimalgewichtigen Pfade.

Freie Dist. d(i) Anzahl ad(i)

Untercodes basierend auf den originalen Codiermatrizen B(1) B(2) B(3) B(4) B(5) B(6) 10 10 10 10 10 10 34 17 9 3 2 1

Untercodes basierend auf den äquivalenten Codiermatrizen (1) (2) (3) (4) (5) (6) B0 B0 B0 B0 B0 B0 10 10 10 12 12 16 34 23 9 6 2 1

Entsprechend dem Algorithmus in Abschnitt 9.4.3 berechnen wir die Spalten des inversen Blockscramblers zu: T m−1 1 = (0 0 1 0 0 0) ,

m−1 = (1 0 0 0 1 0)T , 2

T m−1 3 = (0 1 0 1 0 1) ,

T m−1 4 = (0 0 0 1 0 1) ,

m−1 = (0 0 0 0 0 1)T , 5

T m−1 6 = (0 0 0 0 1 0) .

−1 Man beachte, dass die ersten drei Spalten m−1 und m−1 benötigt werden, um 1 , m2 3 alle Pfade mit Gewicht 10 zu punktieren. Des weiteren werden durch die Spalten m−1 4 und m−1 5 alle Pfade mit Gewicht 12 und 14 punktiert. Die Inversion liefert den Blockscrambler   001000 1 0 0 0 0 0 0 1 0 0 0 0 M = 0 1 0 1 0 0,   000101 100010

und damit erhält man die äquivalenten Codiermatrizen zu:    000011011111 0 1 1 0 1 1 1 1 1 0 0 1 0 1 0 0 1 1 0 1 1 1 1 1 0 0 1 G00 =  0 0 1 1 0 1 0 0 1 0 1 1  und G01 =  0    000000110100 1 110111111111 0

0 1 0 1 0 0

1 0 1 1 1 1

0 0 1 1 1 1

1 0 0 1 0 0

1 0 0 0 1 0

0 0 0 1 1 1

0 0 0 1 1 0

0 0 0 0 1 1

0 0 0 0 0 1

0 0 0 0 1 0

 0 0 0 . 0  1 0

(i)

Man erhält die Codiermatrizen der linearen Untercodes B 0 , indem man die ersten i − 1 Zeilen der äquivalenten Codiermatrizen G00 und G01 streicht. Explizit haben wir die folgende Partitionierung erreicht: B0

⊂ B

(6)

0 (3)

(12, 1, 16) ⊂ B 0 (12, 4, 10) ⊂ B

(5)

0 (2)

(12, 2, 12) ⊂ B0 (12, 5, 10) ⊂ B

(4)

0 (1)

(12, 3, 12) ⊂ (12, 6, 10).

Falls wir auf dieselbe Art den Originalcode (G0 und G1 ) partitionieren, erhalten wir keinen Distanzgewinn in den Untercodes. Dieser Sachverhalt ist in Tabelle 9.3 veranschaulicht. Dabei ist zusätzlich die Anzahl der Pfade mit der entsprechenden freien Distanz für jeden Untercode eingetragen. Die Bilder 9.39 und 9.40 zeigen deutlich den erreichten Gewinn in der Bitfehlerrate für die entsprechenden Untercodes bei einem Gaußkanal und BPSK-Modulation.

9.4 GC-Codes mit Faltungscodes

389

0

10

uncod. BPSK (1)

B (12,6,10) B(2)(12,5,10) B(3)(12,4,10) B(4)(12,3,10) B(5)(12,2,10) B(6)(12,1,10)

−1

10

−2

PBit

10

−3

10

−4

10

−5

10

−4

−3

−2

−1 ES/N0 [dB]

0

1

2

Abb. 9.39: Bitfehlerraten für die Viterbi-Decodierung des Originalcodierers. 0

10

uncod. BPSK (1) B‘ (12,6,10) (2) B‘ (12,5,10) B‘(3)(12,4,10) (4) B‘ (12,3,12) B‘(5)(12,2,12) B‘(6)(12,1,16)

−1

10

−2

PBit

10

−3

10

−4

10

−5

10

−4

−3

−2

−1 ES/N0 [dB]

0

1

2

Abb. 9.40: Bitfehlerraten für die Viterbi-Decodierung des äquivalenten Codierers.

Äußere Codes und Interleaving Als äußere Codes A(i) werden durch Punktierung des ESA/NASA-Standard-Faltungscodes erhaltene Codes verwendet. In [WHPH87] sind solche Codes mit den Raten zwischen 1/2 und 16/17 angegeben. In Tabelle 9.4 sind die verwendeten äußeren Codes aufgelistet. (6) Da der Code B 0 schon eine so geringe Bitfehlerrate aufweist, ist A(6) ein (n, n, 1) Code, d. h. uncodiert. Als äußerer Code A(5) wurde ein punktierter Code der Rate 19/20 per (1) Computersimulation aus dem Code B 0 errechnet. Anmerkung: U. a. in [Hole88] sind punktierte Faltungscodes mit 64 Zuständen aufgelistet, die bessere Parameter besitzen, als die hier gewählten. Aber die Idee hier ist,

390

9 Verallgemeinerte Codeverkettung außere Codes ¨ Eingangsbits

i(1)

Interleaver

A(1)

I (1)

A(2)

I (2)

A(3)

I (3)

A(4)

I (4)

A(5)

I (5)

R = 1/2

i(2)

R = 3/4

i(3)

R = 6/7

i(4)

R = 16/17

i(5)

R = 19/20

i(6)

innerer Code

z(1)

z(2) verbesserter partitionierter ESA/NASAStandardz(4) Faltungscode

z(3)

c

z(5)

z(6)

Abb. 9.41: Codierung des GC-Codes. Tabelle 9.4: Punktierte äußere Codes abgeleitet vom ESA/NASA-Faltungscode. Code

Rate R

A(1) A(2) A(3) A(4) A(5) A(6)

1/2 3/4 6/7 16/17 19/20 1/1 (uncodiert)

Spektrum Freie Distanz Fehlergewicht dA cdA 10 5 3 3 3 –

36 42 5 393 991 –

Punktierungsmatrix (oktal) 1 6 72 152205 1773425

/ / / / / –

1 5 45 125572 1004352

dass ein einziger Code die Basis für den gesamten GC-Code darstellt. Der auf der Basis des ESA/NASA-Standardcodes konstruierte GC-Code H hat die Rate RH ≈ 0.416. Um eine Fehlerfortpflanzung (siehe etwa [WH93a]) von einem Schritt zum nächsten zu vermeiden, verwenden wir Interleaver I (i) entsprechend Bild 9.41. Es handelt sich dabei um rechteckige Blockinterleaver mit unterschiedlicher Zeilen- und Spaltenzahl. Die äußeren Faltungscodes sind alle auf die Länge nA terminiert. Um die entsprechenden Werte anzupassen, definieren wir quasi-rechteckige Interleaver, wie in Bild 9.42 gezeigt. (i) (i) Der jeweilige Interleaver I (i) besteht aus Ir Zeilen, Ic Spalten und einer teilweise gefüllten letzten Spalte, derart, dass gilt: nA = Ic(i) · Ir(i) + ∆I (i) . Die Bits werden spaltenweise in den Interleaver geschrieben und zeilenweise ausgelesen. Um den inneren Code zu terminieren, werden 6 Tailbits benötigt, d. h. bei jedem Interleaver ein Bit. Die Parameter der verwendeten Interleaver sind in Tabelle 9.5 aufgelistet.

9.4 GC-Codes mit Faltungscodes

391 (i)

1

Ic

∆I (i)

(i)

Ir

Abb. 9.42: Quasi-rechteckiger Blockinterleaver I (i) .

Die Gesamtlänge des Codes ist damit nH = nB · (nA + 1) = 49164. Der GC-Code H hat Tabelle 9.5: Parameter der Interleaver. Ir Ic ∆I

I (1) 64 64 0

I (2) 65 63 1

I (3) 66 62 4

I (4) 67 61 9

I (5) 68 60 16

die freie Distanz dH ≥ 16, die durch die letzte Stufe, d. h. durch den Untercode B 0 mit der freien Distanz 16, bestimmt wird.

(6)

Decodierung und Simulationsergebnisse Die Decodierung eines GC-Codes wird entsprechend Abschnitt 9.2.4 durchgeführt (dieses Decodierprinzip wird oft auch als multistage decoding bezeichnet). Im ersten Schritt ˆ(1) durch einen Decodierer für den Code B 0 (1) bestimmt. wird die Nummerierungsfolge z Diese Folge wird dem Decodierer für den äußeren Code A(1) übergeben. Der Decodierer ˜(1) und die Informationsfolge ˜i(1) . Im zweiten Schritt wird die Folge bestimmt die Folge z (2) (1) ˜ dazu benutzt, um mit dem inneren Decodierer den Code B 0 z˜(1) zu decodieren. Das z (2) (2) ˆ wird dann mit dem zweiten äußeren Code A decodiert. Die weiteren Ergebnis z Schritte erfolgen entsprechend. Anmerkung: Die iterative Decodierung (Abschnitt 7.4.4) zwischen inneren und äußeren Codes könnte hier angewendet werden (siehe z. B. [WH93a]). Wie man einen GC-Code optimal decodiert ist ein noch ungelöstes Problem. Des wegen wollen wir uns hier auf den Fall beschränken, dass die Decodierer der inneren Codes Zuverlässigkeitswerte ausgeben (soft output decoding), die Decodierer der äußeren Codes allerdings nur binäre Werte (hard output decoding). (i)

Betrachten wir die Decodierung des inneren Codes B 0 z˜(1) ,...,˜z(i−1) im i-ten Schritt. Die (i)

(i)

ˆ(i) = (ˆ geschätzte Nummerierungsfolge z z1 , . . . , zˆτ , . . .) wird nach Gleichung (9.20) bestimmt durch ˆ t0 m−1 zˆτ(i) = σ i ,

(9.21)

392

9 Verallgemeinerte Codeverkettung

ˆ t0 dem geschätzten Knoten der Tiefe t0 = s · τ entspricht. Die Menge der zu wobei σ betrachtenden Knoten ist für i ∈ [1, s] durch die Beziehung n o (i) Ωt0 = σ : σM−1 = (˜ zτ(1) , . . . , z˜τ(i−1) , ξ (i) , . . . , ξ (s) ) gegeben, wobei ξ (i) , . . . , ξ (s) beliebige Werte {0, 1} annehmen kann.

Im Falle von Hard-Decision-Output-Decodierung des inneren Codes kann ein Viterbi(i) -Algorithmus verwendet werden, bei dem nur die Knoten Ωt0 der entsprechenden Tiefe betrachtet werden. Für die Soft-Decision-Output-Decodierung werden entsprechend Abschnitt 7.2.2 die L-Werte als Metrik verwendet: (i)

λ(i) τ = ln (i)

P (ˆ zτ = 0) (i)

P (ˆ zτ = 1)

,

(9.22)

(i)

wobei P (ˆ zτ = 1) und P (ˆ zτ = 0) die entsprechenden Wahrscheinlichkeiten dafür sind, (i) dass das Bit zˆτ gleich 0 bzw. 1 ist. Wie in Abschnitt 8.4.3 bzw. 8.5 beschrieben, existieren einige Algorithmen für diese Decodierung; u. a. der SOVA [HH89] und der s/s-MAP-Algorithmus aus [BCJR74]. Wir wollen hier einen modifizierten s/s-MAPAlgorithmus verwenden, den wir deshalb im Folgenden beschreiben wollen. Sei n o (i) Ωt0 (0) = σ : σM−1 = (˜ zτ(1) , . . . , z˜τ(i−1) , 0, ξ (i+1) , . . . , ξ (s) ) n o (i) Ωt0 (1) = σ : σM−1 = (˜ zτ(1) , . . . , z˜τ(i−1) , 1, ξ (i+1) , . . . , ξ (s) ) , 1 ≤ i ≤ s,

mit beliebigen ξ (i+1) , . . . , ξ (s) ∈ {0, 1}. Des weiteren sei pt (σ) die Wahrscheinlichkeit, dass der gesendete Pfad durch den Knoten σ in der Tiefe t geht, unter der Bedingung der empfangenen Folge. Dann können wir die L-Werte gemäß Gleichung (9.22) schreiben als P  p (σ) (i) t 0 σ∈Ωt (0) 0  mit t0 = sτ. P λ(i) (9.23) τ = ln p (σ) (i) σ∈Ω (1) t0 t0

Die Codeworte (Pfade) beginnen bei der Tiefe 0 und enden bei Tiefe te im Nullknoten. Entsprechend dem Algorithmus aus [BCJR74] kann die Berechnung der Wahrscheinlichkeit pt (σ) folgendermaßen durchgeführt werden: pt (σ) = αt (σ) · βt (σ).

(9.24)

Dabei bezeichnen αt (σ) und βt (σ) die Wahrscheinlichkeiten, dass der gesendete Pfad in der Tiefe t durch den Knoten σ verläuft, unter der Voraussetzung der empfangenen Folge von 0 bis t bzw. von t bis te . Nun benötigen wir noch die Übergangswahrscheinlichkeit γ t (σ 0 , σ) von Knoten σ 0t−1 nach σ t . Die Wahrscheinlichkeiten αt (σ) und βt (σ) können rekursiv berechnet werden durch: ( (i) 0 : t = sτ, σ 6∈ Ωt0 =sτ αt (σ) = P (9.25) 0 0 σ 0 αt−1 (σ ) · γ t (σ , σ) : sonst

9.4 GC-Codes mit Faltungscodes

393

mit den Werten α0 (0) = 1 und α0 (σ) = 0 für σ 6= 0. Entsprechend erhalten wir: ( (i) 0 : t = sτ, σ 6∈ Ωt0 =sτ βt (σ) = P (9.26) 0 0 σ 0 βt+1 (σ ) · γ t+1 (σ , σ) : sonst mit βte (0) = 1 und βte (σ) = 0 für σ 6= 0.

Bisher haben wir alle Berechnungen durch Summation von Wahrscheinlichkeiten durchgeführt. Ersetzen wir in den Gleichungen (9.23), (9.25) und (9.26) die Summation durch eine Maximierung, so wird die Komplexität geringer und die Gleichungen (9.25) und (9.26) gehen in die des Viterbi-Algorithmus über. Mit dieser Änderung können wir demnach die Metrikberechnungen mit dem Viterbi-Algorithmus durchführen, indem wir einmal bei der Tiefe 0 und dann erneut bei der Tiefe te beginnen. Man beachte, dass hier jedoch die Vergangenheit der Pfade nicht gespeichert werden muss. Dies entspricht dem Max-Log-MAP-Algorithmus aus [RVH95]. 0

10

Verkettung zweier (133,171)−Codes −1

10

uncod. BPSK −2

10 PBit

Hard−Decision s/s−MAP

−3

10

Max−Log−MAP

−4

10

−5

10

0

0.5

1

1.5

2 2.5 Eb/N0 [dB]

3

3.5

4

Abb. 9.43: Bitfehlerraten der (verallgemeinert) verketteten Codes.

Zur Decodierung des GC-Codes H wurden die inneren Codes auf zwei Arten decodiert. Zunächst mit dem s/s-MAP-Algorithmus aus [BCJR74] und dann mit dem Max-LogMAP-Algorithmus. Wie Bild 9.43 zeigt, waren bei der Bitfehlerrate 10−5 die entsprechenden Werte Eb /N0 = 1.55 dB bzw. Eb /N0 = 1.6 dB, d. h. es tritt eine Differenz von 0.05 dB auf. Zum Vergleich wurde auch noch eine Hard-Output-Decodierung des inneren Codes durchgeführt und eine herkömmliche Verkettung zweier Faltungscodes C mit einem (64 × 64)-Block-Interleaver. Gegenüber der herkömmlichen Verkettung bringt der GC-Code H einen Gewinn von 2.2 dB.

9.4.5

Turbo-Codes und ungelöste Probleme

Wie schon erwähnt, hat im Jahre 1993 eine herkömmliche Verkettung von Faltungscodes [BGT93] mit sehr großem Interleaver durch sehr kleine Restbitfehlerraten für

394

9 Verallgemeinerte Codeverkettung Informationsfolge i i i Systematischer nur Redundanz Codierer r1 CV1

i, r1, r2

i Interleaver

u Systematischer nur Redundanz Codierer CV2

r2

Abb. 9.44: Codierschema für Turbo-Codes.

Redundanz 2

Turbo-Code d = d1 + d2 − 1

Information

Redundanz 1

Information

Redundanz 1

Aufsehen gesorgt. Die Autoren gaben ihrem Schema den Namen Turbo-Codes, und seither sind zahllose Veröffentlichungen dazu erschienen [RS95, BM96, RW95, WH95] und viele andere. Hauptsächlich handelt es sich dabei um Arbeiten zur iterativen Decodierung mittels s/s-MAP-Algorithmen entsprechend Abschnitt 7.4.4. Bild 9.44 zeigt schematisch die Codierung eines Turbo-Codes. Veranschaulicht man sich diese Art der Verkettung an Blockcodes, so erkennt man, dass es sich dabei um „schlechte“ Codes handelt. Wie in Bild 9.45 dargestellt, ist die garantierte Mindestdistanz des verketteten Codes d nur bei kleinen Mindestdistanzen der Komponentencodes d1 und d2 annähernd so gut wie für Produktcodes.

Redundanz 2

Produktcode d = d1 · d2

Abb. 9.45: Resultierende Distanz bei serieller und paralleler Verkettung.

Die Arbeiten zu den Turbo-Codes haben dann auch dieses Phänomen der schlechten Mindestdistanz gezeigt, das sich durch ein „Abknicken“ der Bitfehlerratenkurve bei Werten zwischen 10−4 und 10−8 hin zu der asymptotisch erwarteten Bitfehlerrate zeigt. Es ist bekannt, dass die Bitfehlerrate bei sehr gutem SNR einzig von der Mindestdistanz des Codes bestimmt wird. Dieses Abknicken wurde inzwischen auch in [Svi95] bzw. [BM96] theoretisch abgeleitet. Es blieb und bleibt ein rätselhaftes Phänomen, warum diese schlechten Codes (aus Sicht der Mindestdistanz) bei kleinem SNR durch die iterative Decodierung so hervorragend decodiert werden können. Die Decodierung wird entsprechend Abschnitt 7.4.4 durch s/s-MAP-Algorithmen durchgeführt, die zunächst den einen Komponentencode decodieren und damit die empfangenen Werte der Informationssymbole entsprechend modifizieren. Danach wird der zweite Komponentencode decodiert und wieder die Werte der Information modifiziert, usw. Prinzipiell besteht jedoch kein Unterschied zu der iterativen Decodierung, die wir in Abschnitt 7.4.4 beschrieben haben. Es gibt jedoch zahlreiche Varianten, wie und wann

9.5 GC-Codes mit Block- und Faltungscodes

395

die empfangenen Werte der Informationsstellen modifiziert werden und ob die empfangenen Werte der Redundanzstellen ebenfalls modifiziert werden oder nicht. Des weiteren gibt es Varianten zu der Anzahl der Iterationen und zu den verwendeten Faltungscodes. Dies führt uns zu dem ersten ungelösten Problem, das sowohl für Turbo-Codes, Produktcodes, GC-Codes, ja für lange Codes generell existiert, nämlich die Decodierung bei kleinem SNR. Da es sich in der Regel bei verketteten Codes um sehr lange Codes handelt, kann keine ML-Decodierung durchgeführt werden. Darüber hinaus ist nicht einmal bekannt, ob eine ML-Decodierung in diesem Fall sinnvoll ist, oder ob nicht eine s/s-MAP-Decodierung bessere Ergebnisse liefert, geschweige denn wie weit entfernt man noch von einer ML-Decodierung ist. Speziell für eine iterative Decodierung ist für fast alle Fälle ungeklärt, ob und wohin die Iterationen konvergieren. Und für GC-Codes kommt zusätzlich das Problem hinzu, dass nicht nur zwischen innerem und äußerem Code, sondern auch noch zwischen den Stufen der Paare von inneren und äußeren Codes iteriert werden kann. Somit ist auch die Decodierung von GC-Codes, die auf Faltungscodes basieren, ein ungelöstes Problem. Für die Codekonstruktion ist eine ungelöste Frage welchen Code ein verwendeter Interleaver verkettet mit einem Code ergibt. Des weiteren eröffnet die Partitionierung von Faltungscodes so viele Möglichkeiten von Codekonstruktionen, unter denen sich noch „Juwelen“ befinden könnten.

9.5

GC-Codes mit Block- und Faltungscodes

Bisher haben wir GC-Codes erörtert, bei denen innere und äußere Codes jeweils nur Block- oder nur Faltungscodes waren. Selbstverständlich lassen sich auch GC-Codes konstruieren, bei denen der innere Code ein Block- oder Faltungscode ist, und die äußeren Codes aus der jeweils anderen Codeklasse sind, oder auch gemischt. Leider existieren recht wenige Veröffentlichungen zu diesem Fall, oder anders ausgedrückt, es sind recht wenige konkrete Konstruktionen untersucht worden und damit bekannt. Jedoch ist die Anzahl der Möglichkeiten solche GC-Codes zu konstruieren derart groß, dass wir sie sicher hier nicht alle darstellen können. Deshalb wollen wir uns auf wenige Spezialfälle beschränken, die jedoch das Prinzip verdeutlichen, mit dem sich dann jeder neuartige GC-Codes ausdenken kann.

9.5.1

Innere Faltungs- und äußere Blockcodes

Dieser Fall hat in Form einer herkömmlichen Verkettung einen prominenten Vertreter, nämlich den ESA/NASA-Standard zur Satellitenkommunikation [WHPH87]. Dabei wird als innerer Code der Faltungscode B (1) , den wir in Abschnitt 9.4.4 beschrieben haben, und als äußerer Code ein RS-Code (255, 223, 33) über GF (28 ) benutzt. Mit der im vorherigen Abschnitt beschriebenen Partitionierung des inneren Codes B (1) und entsprechenden äußeren RS-Codes könnte ein GC-Code konstruiert werden, der bei gleicher Mindestdistanz eine größere Coderate oder bei gleicher Coderate eine größere Mindestdistanz besitzt. Leider ist ein solcher GC-Code bisher noch nicht analysiert worden. In [ZySha] sind zahlreiche Codes mit inneren (P)UM-Codes (also Faltungscodes) und äußeren RS-Codes konstruiert worden, und einige von ihnen wollen wir im Folgenden

396

9 Verallgemeinerte Codeverkettung

beschreiben. Dabei werden wir immer eine herkömmliche Verkettung CC mit einer GCKonstruktion CGC gleicher Rate vergleichen, mit dem zu erwartenden Ergebnis, dass der GC-Code eine wesentlich größere Mindestdistanz besitzt. Herkömmlich verketteter Code CC : Eine binäre Informationsfolge i wird gemäß Bild 9.46 in eine Matrix Mi geschrieben, die aus IC · κ Zeilen und ka Spalten besteht. Jede der IC (κ × ka )-Teilmatrizen stellt die Informationssymbole des äußeren RS-Codes A(na = 2κ − 1, ka , da ) über dem Alphabet GF (2κ ) dar. Wir codieren diese IC Matrizen zu IC Codeworten (a1 , a2 , . . . , aIC ) des Codes A und erhalten die Matrix Ma .

Als inneren Code verwenden wir einen (P)UM-Code B(nb , kb |kb1 , db ) (db ist die freie Distanz), wobei gelten soll, dass µC = κ/kb ganzzahlig ist. Damit codieren wir die Matrix Ma , indem wir die erste Spalte der Matrix mit B codieren, danach die zweite Spalte bis zur na -ten Spalte.

nb kb

1

na κ

ka

2

3 .. .

IC Matrix Mi

Matrix Ma

Codewort CC

Abb. 9.46: Einfache Verkettung von RS-Codes und PUM-Codes.

Der so konstruierte Code CC hat die Eigenschaft, dass der Faltungscode ein Gedächtnis aufeinanderfolgender Blöcke bewirkt. In der Praxis kann man durch einfügen von 0-

9.5 GC-Codes mit Block- und Faltungscodes

397

Symbolen diese Abhängigkeit unterbrechen, was einer Terminierung des Faltungscodes entspricht, sich aber auf die Coderate auswirkt. Für die Coderate RC , die Länge nC und die Dimension kC des Codes CC erhalten wir nC = IC · µC · na · nb , kC = IC · µC · ka · kb , kC ka · kb RC = = = Ra · Rb . nC na · nb In [ZySha] bzw. [ZS87] wurde für die Mindestdistanz dC bewiesen, dass gilt: dC ≥ min{da · db , ω · µC · IC · da },

µC = κ/kb ,

IC Interleavertiefe.

Der Parameter ω ist der Mittelwert des Gewichts einer Schleife im Zustandsdiagramm des inneren (P)UM-Codes, wie er in Abschnitt 9.4.1 definiert ist (siehe auch [TJ83]). Der herkömmlich verkettete Code ist damit: CC (2; nC = IC µC na nb , kC = IC µC ka kb , dC ≥ min{da db , ωµC IC da }). Verallgemeinert verketteter Code CGC : Hier wird eine binäre Informationsfolge i gemäß Bild 9.47 in eine Matrix Mi geschrieben, (i) die aus s unterschiedlichen (κ × ka )-Matrizen, i = 1, 2, . . . , s, besteht. Insgesamt hat die Matrix IGC · κ binäre Zeilen, und die Anzahl der Spalten ist variabel mit dem Wert (i) ka entsprechend Bild 9.47. Konsequenterweise muss die Ordnung s die Interleavertiefe (i) IGC teilen. Jede der IGC (κ × ka )-Teilmatrizen, i = 1, 2, . . . , s, stellt die Informations(i) (i) symbole der äußeren RS-Codes A(i) (na = 2κ − 1, ka , da ) über dem Alphabet GF (2κ ) dar. Man beachte, dass es jeweils IGC /s äußere Codes A(i) gibt. Wir codieren diese (i) (i) (i) IGC Matrizen zu IGC /s Codeworten (a1 , a2 , . . . aIGC /s ), i = 1, 2, . . . , s, der Codes A(i) und erhalten die Matrix Ma . Diese ist eine binäre (κ · IGC × na )-Matrix, bei der entsprechend Bild 9.47 die Zeilen umsortiert werden. Als inneren Code verwenden wir (1) (1),1 (1) (1) einen (P)UM-Code B (1) (nb , kb |kb , db ), wobei gelten soll, dass µGC = κ/kb ganzzahlig ist. Des weiteren kann der Code B (1) derart in Untercodes partitioniert werden (vergleiche Abschnitt 9.4.3), dass gilt: (i)

(i),1

B (i) (nb , kb |kb (j)

mit kb

=

(1) kb

(i)

, db ),

· (s − j + 1) , s

i = 1, 2, . . . , s, j = 2, 3, . . . , s.

Damit codieren wir die Matrix M0a , indem wir die erste Spalte der Matrix mit gemäß der Abbildungsvorschrift der Partitionierung des inneren Codes B (1) codieren, danach die zweite Spalte bis zur na -ten Spalte. Der so konstruierte binäre GC-Code CGC hat

9 Verallgemeinerte Codeverkettung nb kb

398

κ

(3)

ka

1

(2)

2

ka

(1)

3

ka

.. .

IGC (1)

ka

Matrix Mi

(2)

ka

(3)

na

ka

Matrix Ma

Matrix M′a Codewort CGC

Abb. 9.47: Verallgemeinerte Verkettung von RS-Codes und PUM-Codes.

die folgenden Parameter:

Dimension:

nGC = IGC · µGC · na · nb , s X IGC (1) kGC = · µGC · kb · ka(i) , s i=1

Coderate:

RGC =

Länge:

Mindestdistanz:

s (1) k kGC 1 X (i) = b · · k , nGC nb na i=1 a (i)

(i) dGC ≥ min {d(i) · µGC · IGC · d(i) a · db , ω a }. i=1,...,s

Der Beweis für die Mindestdistanz folgt direkt aus dem Beweis für dC und der Betrachtung der einzelnen Paare A(i) und B (i) [ZS87]. Auch hier ist der Parameter ω (i) der Mittelwert des Gewichts einer Schleife im Zustandsdiagramm der inneren (P)UMCodes B (i) .

9.5 GC-Codes mit Block- und Faltungscodes

399

Anmerkung: Bei Verwendung von na identischen Codierern können mit dieser Konstruktion theoretisch auch unendlich lange (P)UM-Codes als innere Codes benutzt werden. Wir wollen nun vier konkrete Codes der obigen Konstruktion berechnen, wobei zwei davon herkömmlich verkettet und zwei GC-Codes sind. Grundlage bilden der UM(n = 6, k = 4, d = 5)- und der PUM(n = 6, k = 4|k (1) = 2, d = 4)-Code aus Beispiel 9.38 und deren dort hergeleitete Partitionierung. Die oberen Schranken der freien Distanzen für diese beiden Codes sind 6 für UM und 4 für PUM, und für den UM(n = 6, k = 2, d = 7)Untercode der beiden Codes hat die Schranke den Wert 8 (siehe [HS73]). Des weiteren (1) (1) (2) haben diese Codes die Parameter ωUM = 3/4, ωPUM = 1 und ω(P)UM = 2. Beispiel 9.47 ((GC)-Codes der Länge 360) Als äußere Codes wollen wir RS-Codes über GF (24 ) der Länge 15 verwenden. Betrachten wir eine herkömmliche Verkettung mit dem Code UM(n = 6, k = 4, d = 5) und mit einem RS-Code A(24 ; 15, 11, 5), indem wir IC = 4 und µC = κ/kb = 4/4 = 1 wählen, d. h. die Matrix Mi ist eine binäre (16 × 11)-Matrix. Je vier Zeilen bilden die 11 Informationssymbole des äußeren Codes A. Nach dieser Codierung erhalten wir eine binäre (16×15)-Matrix, die wir mit dem inneren UM-Codes spaltenweise codieren. Die damit errechnete binäre (24×15)-Matrix stellt ein Codewort des Codes CC mit den Parametern nC = IC · µC · na · nb = 4 · 1 · 15 · 6 = 360 , kC = IC · µC · ka · kb = 4 · 1 · 11 · 4 = 176 ,

dC ≥ min{da · db , ω · µC · IC · da }) = min{5 · 5, (3/4) · 1 · 4 · 5} = 15

dar. Tauschen wir den inneren Code gegen den PUM(n = 6, k = 4|k(1) = 2, d = 4)-Code aus, so erhalten wir 0 CC (2; nC = 360, kC = 176, dC ≥ min{da db , ωµC IC da } = min{5 · 4, 1 · 1 · 4 · 5}).

Jetzt konstruieren wir durch die Verwendung der möglichen Partitionierung des UM- bzw. PUM-Codes die entsprechenden GC-Codes. Zunächst sei der innere Code der UM(n = 6, k = 4, d = 5)-Code, der in 22 UM(n = 6, k = 2, d = 7)-Untercodes partitioniert wird. Wie in Bild 9.47 dargestellt, schreiben wir die 176 (2) (1) Informationsbits in eine (κ = 4 × ka = 13)-Matrix, dann in eine (κ = 4 × ka = 9)-Matrix, (2) (1) danach erneut in eine (κ = 4 × ka = 13)-Matrix und zum Schluss in eine (κ = 4 × ka = (1) 4 9)-Matrix. Danach werden diese Teilmatrizen mit den äußeren Codes A (2 ; 15, 9, 7) und A(2) (24 ; 15, 13, 3) codiert. Die (16 × 15)-Matrix wird umsortiert, indem wir die ersten zwei Zeilen kopieren, dann die 5. und 6. Zeile, dann die 3. und 4., usw. Zur Codierung mit dem inneren Code gehen wir entsprechend der Abbildung der Partitionierung wie folgt vor: Das 3. und 4. Bit der ersten Spalte der umsortierten Matrix bestimmen den Untercode und das 1. und 2. Bit das Codewort im Untercode, usw. Der konstruierte Code CGC hat die Parameter nGC = IGC · µGC · na · nb = 4 · 1 · 15 · 6 = 360 , s X (1) kGC = IGC /s · µGC · kb · ka(i) = 4/2 · 1 · 4 · (9 + 13) = 176 , i=1

(i)

(i) dGC ≥ min {d(i) · µGC · IGC · d(i) a · db , ω a } i=1,2

= min{7 · 5, 3 · 7, 3/4 · 1 · 4 · 7, 2 · 1 · 4 · 3} = 21 .

400

9 Verallgemeinerte Codeverkettung Tabelle 9.6: Parameter der Codes aus Beispiel 9.47 (herkömmliche Verkettung). nC

RC

dC

µC

IC

B

360 360 2016 2016 6120 6120

0.4889 0.4889 0.5 0.5 0.4994 0.4994

15 20 66 88 195 260

1 1 2 2 2 2

4 4 2 2 2 2

UM PUM UM PUM UM PUM

A(na , ka , da )

(24 ; 15, 11, 5) (24 ; 15, 11, 5) (28 ; 84, 63, 22) (28 ; 84, 63, 22) (28 ; 255, 191, 65) (28 ; 255, 191, 65)

Tabelle 9.7: Parameter der Codes aus Beispiel 9.47 (verallgemeinerte Verkettung). nGC

RGC

360 360 2016 2016 6120 6120

0.4889 0.4889 0.5 0.5 0.4994 0.4994

dGC µGC

s

IGC

B

21 24 91 112 273 329

2 2 2 2 2 2

4 4 2 2 2 2

UM PUM UM PUM UM PUM

1 1 2 2 2 2

(1)

(1)

(2)

(2)

A(1) (na , ka , da ) A(2) (na , ka , da ) (24 ; 15, 9, 7) (24 ; 15, 10, 6) (28 ; 84, 54, 31) (28 ; 84, 57, 28) (28 ; 255, 165, 91) (28 ; 255, 173, 83)

(24 ; 15, 13, 3) (24 ; 15, 12, 4) (28 ; 84, 72, 13) (28 ; 84, 69, 16) (28 ; 255, 217, 39) (28 ; 255, 209, 47)

Tauschen wir wieder den UM-Code gegen den PUM(n = 6, k = 4|k(1) = 2, d = 4)-Code aus, der ebenfalls den UM(n = 6, k = 2, d = 7)-Code als Untercode besitzt, und benutzen die 0 äußeren Codes A(1) (24 ; 15, 10, 6) und A(2) (24 ; 15, 12, 4), so erhalten wir den Code CGC mit nGC = 4 · 1 · 15 · 6 = 360 ,

kGC = 4/2 · 1 · 4 · (9 + 13) = 176, (i)

(i) dGC ≥ min {d(i) · µGC · IGC · d(i) a · db , ω a } i=1,2

= min{6 · 4, 4 · 7, 1 · 1 · 4 · 6, 2 · 1 · 4 · 4} = 24 .



Die Ergebnisse des Beispiels sind in den Tabellen 9.6 und 9.7 zusammengefasst; gemeinsam mit weiteren Codes der Längen 2016 und 6120 mit deren entsprechenden Parametern. Die Konstruktion erfolgt analog dem Beispiel mit denselben inneren Codes. Man beachte den erheblichen Gewinn in der Mindestdistanz bei gleicher Rate zwischen herkömmlicher und verallgemeinerter Verkettung. Zur Übung kann mit dem inneren PUM(n = 6, k = 4|k (1) = 2, d = 4)-Code mit der Partitionierung von Beispiel 9.38 ein (2; 600, 240, 44)-GC-Code konstruiert werden, indem zwei verkürzte RS-Code der Länge 255 verwendet werden.

9.5.2

Innere Block- und äußere Faltungscodes

Für diesen Fall sind wenig Ergebnisse bekannt, vor allem für GC-Codes. Wir wollen in diesem Abschnitt zwei Beispiele betrachten, wobei eines ein GC-Code darstellt. Ein bedeutendes Beispiel für herkömmliche Verkettung stellen einige Direct-Sequence Code-Division-Multiple-Access- (DS-CDMA) Systeme dar (siehe z. B. [Kam, Pro]). Wir

9.5 GC-Codes mit Block- und Faltungscodes

Faltungscode

Interleaver

R = 1/3, ν = 9

18 × 32

401

R(1, 6)

R = 6/64

Kanal

ViterbiDecodierer

Deinterleaver 18 × 32

Soft-OutputDecodierer

Abb. 9.48: Original IS-95-Schema.

können ein DS-CDMA-System als Verkettung eines inneren Blockcodes (in der Regel ein RM-Code erster Ordnung entsprechend Abschnitt 5.1) als Spreizsequenz und eines äußeren Faltungscodes betrachten. Allgemein werden durch einen Blockcode k Bits auf n Bits gespreizt. Eine Matched-Filter-Bank, mit der die Korrelation für die entsprechenden Sequenzen durchgeführt wird, können wir als eine ML-Decodierung interpretieren, bei der alle möglichen Codesequenzen mit der empfangen Sequenz verglichen werden. Wir wollen im Folgenden ein Beispiel betrachten, das die Codekonstruktion des USMobilfunkstandards IS-95 modifiziert und dadurch eine Verbesserung der Restbitfehlerrate erreicht. Das Beispiel stammt aus der Arbeit [FB96]. Beispiel 9.48 (Mobilfunkstandard IS-95) Wir wollen hier den Originalcode des IS-95Standards für die Übertragung von der Mobil- zur Basisstation (Bild 9.48) mit einem verketteten Code vergleichen, den wir leicht modifiziert haben, indem wir entsprechend Bild 9.49 die Rate des inneren Codes verkleinern und die des äußeren vergrößern. Die Gesamtrate bleibt dabei konstant. Als inneren Code wählen wir einen UM-Code, der auf dem RM-Code basiert (siehe Abschnitt 8.7.4). Während der IS-95-Code die Mindestdistanz dIS = 14·32 = 448 besitzt, Unit-Memory-Code Faltungscode

Interleaver

Faltungscode

R = 2/3, ν = 5

6 × 48

R = 1/2, ν = 2

R(1, 6)

Wort-IL 3 × 32

R = 6/64

Kanal

ViterbiDecodierer

Deinterleaver 6 × 48

Soft-OutputDecodierer

FHT

Wort-DIL 3 × 32

Abb. 9.49: Modifiziertes IS-95-Schema. ist dUM = 16·32 = 512. Bild 9.50 zeigt die Simulationsergebnisse, bei denen eine kohärente Detektion angenommen wurde. Man erkennt einen Gewinn von 1.4 dB bei einer Restbitfehlerrate von 10−3 . In [FB96] ist auch eine inkohärente Detektion angegeben, wobei der Gewinn dann auf ca. 1 dB zurückgeht. Beide Konstruktionen weisen etwa die gleiche Decodierkomplexität auf. 

402

9 Verallgemeinerte Codeverkettung 0

10

−1

10

−2

PBit

10

−3

10

−4

10

IS−95 innerer UM−Code −5

10

0

0.5

1

1.5

2 2.5 E /N [dB] b

3

3.5

4

0

Abb. 9.50: Bitfehlerrate bei kohärenter Detektion.

Das zweite Beispiel betrachtet die RM-Konstruktion (Abschnitt 9.6) mit Faltungscodes. Es handelt sich hier um einen GC-Code, der in der Vorveröffentlichung [Che97] beschrieben ist. Beispiel 9.49 (|u|u + v|-Konstruktion mit Faltungscodes) Betrachten wir den binären Blockcode B(1) (2, 2, 1) als inneren Code. Eine Partitionierung liefert die Untercodes (2) Bi (2, 1, 2), i = 0, 1, deren Mindestdistanz doppelt so groß ist wie die von B(1) . Damit können wir zwei äußere Faltungscodes verwenden, deren freie Distanz sich um den Faktor zwei unterscheidet. Nehmen wir an, der erste Faltungscode A(1) habe die freie Distanz df und der zweite df /2, so erhalten wir einen GC-Code mit der freien Distanz df . In [Che97] sind einige Konstruktionen angegeben. 

Der Fall innerer Blockcode und äußerer Faltungscode tritt häufiger bei codierter Modulation in Kapitel 10 auf.

9.6

Mehrfachverkettung und Reed-Muller-Codes

Wir werden Reed-Muller-Codes (RM-Codes), die wir in Abschnitt 5.1 eingeführt haben, hier als verallgemeinerte, mehrfach verkettete Codes beschreiben. Zur Wiederholung: Ein RM-Code R(r, m) ist ein binärer Code der Länge n = 2m , der  m m−r Dimension k = 1 + m + + · ·· + m . Der zu 1 2 r und der Mindestdistanz d = 2 R(r, m) duale Code ist der RM-Code R(m − r − 1, m).

Wir wollen im Folgenden die Konstruktion von RM-Codes als verallgemeinert verkettete Codes angeben. Der innere Code sei ein binärer Blockcode der Länge 2, der Dimension 2 und der Mindestdistanz 1, d. h., der Code besteht aus allen binären Vektoren der Länge 2: (1)

B (1) (nb = 2, kb

(1)

= 2, db = 1) = {(0, 0), (1, 1), (1, 0), (0, 1)}.

9.6 Mehrfachverkettung und Reed-Muller-Codes

403

(2)

Der Code B (1) kann in die Untercodes Ba(1) mit der Mindestdistanz 2 partitioniert werden: B (1) =

1 [

a(1) =0

(2)

(2)

Ba(1) (nb = 2, kb

(2)

(2)

= 1, db = 2).

(2)

Dabei ist: B0 = {(0, 0), (1, 1)} und B1 = {(1, 0), (0, 1)}. Die Codewörter ergeben sich zu: b00 = (0, 0), b01 = (1, 1), b10 = (1, 0), b11 = (0, 1).

(9.27)

Alle Nummerierungen der Partitionierung sind binär: (a(1) , a(2) ) ⇐⇒ b ∈ B (1) .

(9.28)

Wir bilden nun eine (na × 2)-Matrix: 

 (1) (2) a1 a1  (1) (2)   a2 a2   . ..   . .  . .  (1) (2) ana ana

(1)

(1)

Die erste Spalte ist ein Codewort des ersten äußeren Codes A(1) (na , ka , da ), und die (2) (2) zweite Spalte ist ein Codewort des zweiten äußeren Codes A(2) (na , ka , da ). Jede Zeile (1) (2) (aj , aj ) nummeriert ein Codewort des inneren Codes B (1) . Nach der entsprechenden Abbildung ergibt sich ein Codewort des GC-Codes C(2; nc , kc , dc ), d. h. eine Matrix aus na Codewörtern des inneren Codes:     b1 b11 b12      b2   b21 b22   . = . (9.29) ..   .   . . .   .   . bna bn a 1 bn a 2 (1)

Es gilt: Für die Länge nc = 2na , für die Dimension kc = ka (1) (1) (2) (2) Mindestdistanz dc ≥ min{da · db , da · db }.

(2)

+ ka

und für die

Satz 9.24 (RM-Code als GC-Code) Wählt man als inneren Code B (1) (2, 2, 1) und als äußere Codes die RM-Codes A(1) = R(r, m), A(2) = R(r+1, m) der Länge na = 2m , so ist der konstruierte GC-Code C(2; nc , kc , dc ) der RM-Code R(r + 1, m + 1). Beweis: Die Abbildung durch die Gleichungen (9.27) und (9.28) kann als ba(1) a(2) = (a(1) ⊕ a(2) , a(2) )

(9.30)

404

9 Verallgemeinerte Codeverkettung

geschrieben werden, wobei ⊕ die Addition modulo 2 bezeichnet. Nun ordnen wir die Elemente des Codewortes aus Gleichung (9.29) als Vektor der Länge 2na folgendermaßen an: c = (b12 , b22 , . . . , bna 2 , b11 , b21 , . . . , bna 1 ).

(9.31)

Die Beziehung (9.30) in Gleichung (9.31) eingesetzt ergibt: ` (2) (2) (1) (2) (1) (2) (1) (2) ´ c = a1 , a2 , . . . , a(2) na , a1 ⊕ a1 , a2 ⊕ a2 , . . . , ana ⊕ ana .

Diese Darstellung ist identisch zu Theorem 2, Kapitel 13, aus [McWSl], das die |u|u ⊕ v|Konstruktion von RM-Codes beschreibt und im Folgenden angegeben ist: R(r + 1, m + 1) = {|u|u ⊕ v| : u ∈ R(r + 1, m), v ∈ R(r, m)}. 2

Damit ist der GC-Code der RM-Code R(r + 1, m + 1).

Mit dieser Methode kann damit der RM-Code R(r + 1, m + 1) wie folgt konstruiert werden: c = (b1 , b2 , . . . , bna )

 (1) (2) (2) (1) (2) (2) (2) (2) = a1 ⊕ a1 , a1 , a2 ⊕ a2 , a2 , . . . , a(1) na ⊕ ana , ana .

Die äußeren Codes A(1) und A(2) können auch als GC-Codes betrachtet werden. Damit lässt sich die oben beschriebene Codekonstruktion sukzessive anwenden. Ausgehend von dem RM-Code R(0, m), ˜ 1 ≤ m ˜ < m, einem Wiederholungscode, und dem RM-Code R(m ˜ − 1, m), ˜ 1≤m ˜ < m, einem Parity-Check-Code, als mögliche äußere Codes sowie dem inneren Code B (1) (2; 2, 2, 1) kann somit jeder RM-Code R(r, m) auf diese Weise konstruiert werden. Diese Tatsache ist in Bild 9.51 veranschaulicht und zeigt, dass ein beliebiger RM-Code auf die Verkettung von Wiederholungscodes und Parity-CheckCodes zurückgeführt werden kann. Dies werden wir bei der Decodierung verwenden. R(1, 1)

R(0, 1)

(2, 2, 1)

(2, 1, 2) R(1, 2) (4, 3, 2)

R(0, 2) (4, 1, 4) R(0, 3)

R(0, 5)

R(1, 5)

R(0, 7)

R(1, 7)

R(2, 7)

(128, 29, 32)

R(3, 7)

(128, 64, 16)

R(4, 7)

(32, 32, 1) R(5, 6) (64, 63, 2)

R(4, 6) (64, 57, 4)

(128, 99, 8)

R(5, 5)

(32, 31, 2)

(32, 26, 4) R(3, 6) (64, 42, 8)

R(4, 4) (16, 16, 1) R(4, 5)

R(3, 5)

(32, 16, 8) R(2, 6) (64, 22, 16)

(64, 7, 32)

(128, 8, 64)

R(2, 5)

(8, 8, 1) R(3, 4) (16, 15, 2)

R(2, 4) (16, 11, 4)

(32, 6, 16) R(1, 6)

R(0, 6) (64, 1, 64)

(128, 1, 128)

R(1, 4) (16, 5, 8)

R(3, 3)

(8, 7, 2)

(8, 4, 4)

R(0, 4) (16, 1, 16)

(32, 1, 32)

R(2, 3)

R(1, 3)

(8, 1, 8)

R(2, 2) (4, 4, 1)

R(5, 7)

(128, 120, 4)

R(6, 6) (64, 64, 1) R(6, 7)

(128, 127, 2)

PC-Codes

Wiederholungscodes

Abb. 9.51: Struktur von RM-Codes.

R(7, 7)

(128, 128, 1)

GF (2)n

9.6 Mehrfachverkettung und Reed-Muller-Codes

9.6.1

405

GMC, Decodieralgorithmus für RM-Codes

Wir wollen im Folgenden ein Decodierverfahren [SB95] angeben, das die Tatsache ausnutzt, dass RM-Codes als GC-Codes beschrieben werden können. Des weiteren wollen wir dazu eine naheliegende Erweiterung als Listendecodierverfahren erörtern, mit dem die Decodierergebnisse wesentlich verbessert werden. Die Grundidee der Decodierung basiert auf dem Algorithmus für GC-Codes, der in Abschnitt 9.2.4 erläutert ist. Hier werden allerdings, sowohl für die inneren als auch für die äußeren Codes, Decodierverfahren verwendet, die entsprechend Abschnitt 7.2.2 Zuverlässigkeitsinformation benutzen. Die Decodierung von RM-Codes wird auf die Decodierung von Wiederholungs- und Parity-Check-Codes zurückgeführt, und diese können ML decodiert werden. Wir wollen entsprechend Abschnitt 7.2.2, unter Annahme von BPSK-Modulation und AWGN-Kanal, die folgende Notation benutzen (0 → +1 und 1 → −1): c = (c1 , . . . , cn ) ∈ R(r, m), n = 2m , sei das gesendete Codewort, y = (y1 , . . . , yn ) sei der empfangene Vektor . ML-Decodierer: Λcˆ =

n X j=1

ln



p{yj | cj = cˆj } p{yj | cj = cˆj }



.

Algorithmus 9.4: SDML-Decodierung für Wiederholungs- und PC-Codes. SDML-Decodierung eines Wiederholungscodes der Länge n: ! n X cˆi = sign yj , i = 1, . . . , n. j=1

SDML-Decodierung eines Parity-Check-Codes der Länge n: cˆj = sign(yj ) , Falls p =

n Y

j=1

j = 1, . . . , n.

cˆj = −1 bestimme i : |yi | = min{|yj |} und setze cˆi = −ˆ ci . j

Der Decodierer GMC ist in Algorithmus 9.5 beschrieben und besteht aus drei Schritten. Falls der RM-Code ein Wiederholungscode (R(0, m)) oder ein Parity-Check-Code (R(m − 1, m)) ist, so wird er im ersten Schritt decodiert. Ein anderer RM-Code wird durch rekursive Anwendung des Decodierverfahrens in den Schritten 2a und 2b decodiert. Im dritten Schritt wird das durch den Decodierer geschätzte Codewort ausgegeben. Dabei werden SDML-Decodierer für Wiederholungscodes und für Parity-CheckCodes benutzt, die in Algorithmus 9.4 definiert sind. Beispiel 9.50 (Decodierung des R(1, 3) mit GMC) Wir wollen im Folgenden ein Zahlenbeispiel für die einzelnen Schritte bei der Decodierung mit GMC angeben.

406

9 Verallgemeinerte Codeverkettung

Algorithmus 9.5: Decodieralgorithmus für Reed-Muller-Codes R(r, m). Eingabe: y = (y1 , . . . , yn ) Empfangsvektor Schritt 1: Decodierung Wiederholungscode oder Parity-Check-Code Falls r = 0 oder r = m − 1, dann SDML-Decodierung von y gemäß ˆ, dann Schritt 3. Wiederholungscode oder Parity-Check-Code zu c Schritt 2: Decodierung GC-Code ` (1) (1) ´ Schritt 2a: Bestimmung der Metrik y(1) = y1 , . . . , yn/2 des ersten äußeren Codewortes: (1)

yj = sign(y2j−1 · y2j ) · min{|y2j−1 |, |y2j |}, j = 1, . . . , n/2 . Erste äußere Decodierung: ˆ (1) mittels GMC. Decodiere y(1) gemäß R(r − 1, m − 1) zu a ` (2) (2) ´ Schritt 2b: Bestimmung der Metrik y(2) = y1 , . . . , yn/2 des zweiten äußeren Codewortes: ` (1) ´ (2) yj = 12 a ˆj · y2j−1 + y2j , j = 1, . . . , n/2 . Zweite äußere Decodierung: ˆ (2) mittels GMC. Decodiere y(2) gemäß R(r, m − 1) zu a ˆ aus a ˆ (1) und a ˆ (2) : Schritt 2c: Bestimmung des GC-Codewortes c ` (1) (2) (2) (1) (2) (2) ´ ˆ= a c ˆ1 · a ˆ1 , a ˆ1 , . . . , a ˆn/2 · a ˆn/2 , a ˆn/2 .

ˆ = (ˆ Schritt 3: Decodiere c c1 , . . . , cˆn ) .

ˆ = (ˆ Ausgabe: c c1 , . . . , cˆn ) decodiertes Codewort.

Gesendetes Codewort: c = (−1.0, +1.0, −1.0, +1.0, +1.0, −1.0, +1.0, −1.0). Empfangenes Wort: y = (−0.9, +1.2, −0.1, +0.6, −0.1, −1.3, +0.2, +0.3). Schritt 2a: y(1) = (−0.9, −0.1, +0.1, +0.2). SDML Decodierung von y(1) gemäß Wiederholungscode R(r = 0, m = 2) zu: ˆ (1) = (−1.0, −1.0, −1.0, −1.0). a Schritt 2b: y(2) = (+2.1, +0.7, −1.2, +0.1). SDML Decodierung von y(2) gemäß Parity-Check-Code R(r = 1, m = 2) zu: ˆ (2) = (+1.0, +1.0, −1.0, −1.0). a ˆ Schritt 2c: c = (−1.0, +1.0, −1.0, +1.0, +1.0, −1.0, +1.0, −1.0).



ˆ = c. Damit wurde das empfangene Wort y korrekt decodiert, d. h. c

Herleitung der Metrik (1)

In diesem Abschnitt wollen wir die in Schritt 2a und 2b benutzte Metrik yj (2) yj

und

herleiten. Dazu nehmen wir an, die Koordinaten des empfangenen Wortes seien statistisch unabhängig. Dies ist eine Näherung, da das empfangene Wort aus Codewort plus Fehler besteht. Bei einem gedächtnislosen Kanal sind zwar die Koordinaten des Fehlerwortes statistisch unabhängig, dagegen im allgemeinen nicht die Stellen eines Codewortes.

9.6 Mehrfachverkettung und Reed-Muller-Codes

407

Die Eingabe in den Decodieralgorithmus ist der Empfangsvektor y = (y1 , . . . , yn ). Zur Erinnerung: Entsprechend den Überlegungen in Abschnitt 7.2.2 kann yj als Zuverlässigkeit interpretiert werden und bei empfangenem Wert y˜ ergab sich:   p{˜ y | cj = +1} yj ∼ ln , j = 1, . . . , n. (9.32) p{˜ y | cj = −1} Für den ersten äußeren Decodierer benötigen wir die Metrik: ! (1) p{y | aj = +1} (1) yj ∼ ln , j = 1, . . . , n/2. (1) p{y | aj = −1} Unter Benutzung von Gleichung (9.30) erhalten wir die bedingten Wahrscheinlichkeiten zu: (1)

p{y | aj

= c2j−1 · c2j = +1}

= p{y | c2j−1 = +1}·p{y | c2j = +1}+p{y | c2j−1 = −1}·p{y | c2j = −1} , (1)

p{y | aj

= c2j−1 · c2j = −1}

= p{y | c2j−1 = +1}·p{y | c2j = −1}+p{y | c2j−1 = −1}·p{y | c2j = +1}.

Das Verhältnis der Wahrscheinlichkeiten ergibt: (1)

= +1}

(1)

= −1}

p{y | aj p{y | aj

=

p{y | c2j−1 =−1} p{y | c2j =−1} p{y | c2j−1 =+1} · p{y | c2j =+1} p{y | c2j−1 =−1} p{y | c2j =−1} p{y | c2j−1 =+1} + p{y | c2j =+1}

1+

.

Eine grobe Näherung des Logarithmus dafür ist:        (1) p{y | aj =+1} p{y | c2j−1 =+1} p{y | c2j =+1} ln ≈ sign ln p{y | c2j−1 · ln p{y | c2j (1) =−1} =−1} p{y | aj =−1} o n p{y | c2j−1 =+1} p{y | c2j =+1} · min ln p{y | c2j−1 , ln =−1} p{y | c2j =−1} . (1)

Damit haben wir für yj : (1)

yj

≈ sign(y2j−1 · y2j ) · min{|y2j−1 |, |y2j |} , j = 1, . . . , n/2.

(9.33)

Simulationen haben gezeigt, dass die Verbesserung bei Kenntnis des Proportionalitätsfaktors aus Gleichung (9.32) unwesentlich ist. Für den zweiten äußeren Decodierer benötigen wir die Metrik:

(2) yj

∼ ln

(1)

=a ˆj , aj

(1)

(2)

= +1}

(1)

=a ˆj , aj

(1)

(2)

= −1}

p{y | aj p{y | aj

!

, j = 1, . . . , n/2.

408

9 Verallgemeinerte Codeverkettung

Mit Gleichung (9.30) errechnen sich die bedingten Wahrscheinlichkeiten zu: (1)

=a ˆj , aj

(1)

=a ˆj , aj

p{y | aj p{y | aj

(1)

(2)

(1)

(2)

= +1} = p{y | c2j−1 = a ˆ(1) · (+1) , c2j = +1} = p{y | c2j−1 = a ˆ(1) } · p{y | c2j = +1} = −1} = p{y | c2j−1 = a ˆ(1) · (−1)} · p{y | c2j = −1}.

Das Verhältnis der Wahrscheinlichkeiten ergibt: (1)

p{y | aj

(1)

p{y | aj

(1)

(2)

=a ˆj , aj

= +1}

(1)

= −1}

(2)

=a ˆj , aj

=

p{y | c2j−1 = +ˆ a(1) } p{y | c2j = +1} · . p{y | c2j−1 = −ˆ a(1) } p{y | c2j = −1}

(2)

Damit erhalten wir für yj : (2)

yj

=

 1 (1) a ˆj · y2j−1 + y2j , j = 1, . . . , n/2, 2

(9.34)

wobei der Faktor 12 lediglich der Normierung dient. Zwei Tatsachen, die Näherungen in Gleichung (9.33) und die Annahme der statistischen Unabhängigkeit der Koordinaten des empfangenen Wortes, trennen den Algorithmus von einem ML-Decodierer. Da der Algorithmus GMC den Schritten der Algorithmen GCD-1 und GCD-i aus Abschnitt 9.2.4 folgt und die Decodierung der inneren und äußeren Codes verbessert, ist garantiert, dass GMC bis zur halben Mindestdistanz korrigiert. Sei c = (c1 , , . . . , cn ) ∈ R(r, m) mit ci ∈ {−1, 1} übertragen und y empfangen. Der Fehler eines AWGN-Kanals ist e = y −c. Die Hamming-Distanz des Codes ist d = 2m−r , und die quadratische euklidische Distanz δ ergibt sich zu δ = 4 · d = 4 · 2m−r = 2m−r+2 . Satz 9.25 (Korrekturfähigkeit von GMC) Der Algorithmus GMC korrigiert alle Fehler e = (e1 , . . . , en ), für die gilt: n X i=1

e2i

n X = (yi − ci )2 < i=1

√ !2 δ = d = 2m−r . 2

(9.35)

Beweis: Wir nehmen an, dass c = (1, 1, . . . , 1) gesendet wurde, und überprüfen die einzelnen Schritte des Algorithmus GMC. Schritt 1: Die SDML-Decodierung von y im Falle von r = 0 oder r = m − 1 korrigiert definitionsgemäß korrekt für n X i=1

(ei − 1)2 < d.

9.6 Mehrfachverkettung und Reed-Muller-Codes

409

Schritt 2a: Wir werden zeigen, dass wenn y unter der Annahme, dass der Fehler kleiner als die halbe euklidische Distanz ist (Gleichung (9.35)), korrekt gemäß R(r, m) decodiert wird, dann wird auch y(1) gemäß R(r − 1, m − 1) (d = 2m−r ) korrekt decodiert. Dabei ist: ` (1) (1) ´ y(1) = y1 , . . . , yn/2 mit (1)

yj

= sign ((1 + e2j−1 )(1 + e2j )) · min{|1 + e2j−1 |, |1 + e2j |},

j = 1, . . . , n/2 . (9.36)

Ohne Beschränkung der Allgemeinheit können wir annehmen: |1 + e2j−1 | ≤ |1 + e2j |. Damit geht Gleichung (9.36) über in: (1)

yj

= sign(1 + e2j ) · (1 + e2j−1 ).

Es existieren 4 Fälle: i)

Beide Stellen fehlerhaft: 1 + e2j−1 ≤ 0 und 1 + e2j ≤ 0 ` (1) ´2 =⇒ yj − 1 = (|1 + e2j−1 | − 1)2 ≤ (|1 + e2j−1 | + 1)2 = e22j−1

ii) Erste Stelle fehlerhaft: 1 + e2j−1 ≤ 0 und 1 + e2j ≥ 0 ` (1) ´2 =⇒ yj − 1 = ((1 + e2j−1 ) − 1)2 = e22j−1

iii) Zweite Stelle fehlerhaft: 1 + e2j−1 ≥ 0 und 1 + e2j ≤ 0 ` (1) ´2 =⇒ yj − 1 = (|1 + e2j−1 | + 1)2 ≤ (|1 + e2j | + 1)2 = e22j iv) Beide Stellen korrekt: 1 + e2j−1 ≥ 0 und 1 + e2j ≥ 0 ` (1) ´2 =⇒ yj − 1 = ((1 + e2j−1 ) − 1)2 = e22j−1 .

Mit Gleichung (9.35) erhalten wir entsprechend den Abschätzungen für die 4 Fälle: n/2 n/2 n/2 n X X ` (1) ´2 X ˘ ¯ X 2 yj − 1 ≤ max e22j−1 , e22j ≤ e2j−1 + e22j = e2i < d. j=1

Damit kann y

(1)

j=1

j=1

i=1

gemäß R(r − 1, m − 1) decodiert werden.

Schritt 2b: Hier müssen wir zeigen, dass y(2) korrekt decodiert wird, unter der Annahme, dass y(1) korrekt decodiert wurde und der Bedingung (9.35). Dabei ist ` (2) (2) ´ y(2) = y1 , . . . , yn/2 mit (2)

yj

=1+

1 (e2j−1 + e2j ) , 2

j = 1, . . . ,

n . 2

Damit erhalten wir die folgende Abschätzung: ´ ` (2) ´2 1 1` 2 e2j−1 + 2 |e2j−1 · e2j | + e22j yj − 1 = (e2j−1 + e2j )2 ≤ 4 4 ´ 1` 2 ≤ e2j−1 + e22j . 4

Dies ergibt als Abschätzung für die Summe:

n/2 n/2 n X ` (2) ´2 ´ 1 X` 2 1X 2 d yj − 1 ≤ e2j−1 + e22j = ei < . 2 2 2 j=1 j=1 i=1

410

9 Verallgemeinerte Codeverkettung

Die Distanz von R(r, m − 1) ist aber gerade

d 2

= 2m−r−1 und y(2) kann decodiert werden.

Durch rekursive Anwendung gelangt man zu Codes mit r = 0 oder r = m − 1, die korrekt decodiert werden können, und die Behauptung ist bewiesen. 2

Entsprechend den Betrachtungen zu ordered statistics in Abschnitt 7.4.2 kann man die Abschätzung der Decodierfähigkeit des GMC-Algorithmus noch verbessern: Sei Ω die Teilmenge der Mächtigkeit d = 2m−r der n Codestellen für die die Summe X (yi + ci ) i∈Ω

maximal wird, dann kann man mit GMC alle Fehler korrigieren, für die gilt [SB94]: X (yi + ci ) < d = 2m−r . i∈Ω

Entsprechendes gilt für:

P

i∈Ω

9.6.2

−ci (yi + ci ) < d = 2m−r .

L-GMC, Listendecodierung von RM-Codes

Wir werden zunächst den erweiterten GMC-Algorithmus angeben. Anschließend werden die damit erreichten Bit- und Blockfehlerraten sowie die Decodierkomplexität untersucht. Ein großer Nachteil des GMC-Algorithmus ist, dass immer wenn ein Code aus zwei kürzeren gebildet wird, eine endgültige Entscheidung (hard decision) für die kürzeren, d. h. die äußeren Codes getroffen wird. Die Idee ist nun, hier das Konzept der Listendecodierung aus Abschnitt 7.4 anzuwenden. Wir berechnen deshalb in jedem Rekursionsschritt eine Liste von L „besten“ Codeworten des verketteten Codes, aus den Ergebnissen einer Listendecodierung der beiden äußeren Codes. Die besten Codeworte sind dabei die Codeworte mit der kleinsten euklidischen Distanz zum entsprechenden Teil des empfangenen Vektors. Die Wahrscheinlichkeit, dass das ML-Codewort des verketteten Codes in dieser Liste enthalten ist, ist sicher größer als ohne Liste. Eine geeignete Modifikation des GMC-Algorithmus zur Soft-Decision-Listendecodierung eines RM-Codes R(r, m) zeigt Algorithmus 9.6 (siehe auch [LBD98]). Man beachte, dass sich für die Listentiefe L = 1 der GMC-Algorithmus ergibt. Der Algorithmus L-GMC gibt aus der in Schritt 2e erstellten Liste der Länge L1 · L die L Codeworte mit der kleinsten euklidischen Distanz zu y in aufsteigender Reihenfolge aus (Schritt 3). Man beachte, dass dies nicht notwendigerweise die L Codeworte des Codes mit kleinster Distanz zu dem empfangenen Vektor y sind, da es sich sonst um ein ML-Decodierverfahren handeln würde. Anstatt der Sortierung nach der kleinsten euklidischen Distanz kann in Schritt 3 auch gemäß des größten Skalarproduktes sortiert werden. Beispiel 9.51 (Vergleich von GMC und L-GMC am Beispiel des R(2, 4)-Codes) Das Nullcodewort des RM-Codes R(2, 4), d. h. (2; 16, 11, 4), werde über einen AWGN-Kanal übertragen und als y empfangen. Bild 9.52 zeigt die Schritte bei der Decodierung mit GMC.

9.6 Mehrfachverkettung und Reed-Muller-Codes

411

Algorithmus 9.6: Der L-GMC-Algorithmus. Eingabe:

Ausgabe: 1. 2.

Codelänge: Ordnung des Codes: Empfangener Vektor: Listenlänge: decodierte Codeworte:

m: n = 2m , m ≥ 2 r y = (y1 , y2 , . . . , yn ) 1 ≤ L ≤ 6 (1 ≤ L ≤ 2 für r = 0) ˆ[i], i = 1, . . . , L c

(a) Falls (r = 0): RC-Listendecodierung von y mit Listenlänge L. (b) Falls (r = m − 1): PC-Listendecodierung von y mit Listenlänge L. (a) Falls (r = 1): L1 = 2, sonst: L1 = L.

(b) Falls (L = 1 ∧ r = 1): L1 = 1.

(c) Berechne die Metrik für das 1. äußere Codewort: (1) yj ≈ sign(y2j−1 · y2j ) · min {|y2j−1 |, |y2j |} ,

j = 1, . . . , 2m−1 .

(d) Decodiere y(1) gemäß R(r − 1, m − 1) zu ˆ (1) [i], i = 1, . . . , L1 , mittels L-GMC (Listenlänge L1 ). a (e) Für i = 1 bis L1 i. Berechne die Metrik für das 2. äußere Codewort: (2) (1) yj = a ˆj [i] · y2j−1 + y2j , j = 1, . . . , 2m−1 .

ii. Decodiere y(2) gemäß R(r, m − 1) zu ˆ (2) [`], ` = 1, . . . , L, mittels L-GMC (Listenlänge L). a iii. Für ` = 1 bis L bestimme die GC-Codeworte ˆ[(i − 1) · L + `] = c (1) (2) (2) (1) (2) (2) (ˆ a1 [i] · a ˆ1 [`], a ˆ1 [`], . . . , a ˆ2m−1 [i] · a ˆ2m−1 [`], a ˆ2m−1 [`]). ˆ[i], i = 1, . . . , L1 · L, nach der euklidischen Distanz zu y in (f) Sortiere die Codeworte c aufsteigender Reihenfolge. ˆ[i], i = 1, . . . , L. 3. Ausgabe der (sortierten) Codeworte c

Dabei stellen die grau hinterlegten Werte die Fehler bei Hard-Decision dar. Man erkennt, dass der GMC-Algorithmus hier nicht korrekt decodieren kann. Nun wollen wir denselben empfangenen Vektor mit L-GMC (L = 2) decodieren, was in Bild 9.53 zu sehen ist. Auch hier stellen die grau hinterlegten Werte die Fehler bei der Hard-Decision dar. Am Ende des Algorithmus stehen die L1 · L = 4 Codeworte, an deren Beginn der Wert des Skalarproduktes mit y notiert ist. Man erkennt, dass bei der Decodierung mit L-GMC das gesendete Codewort Element der Liste ist und das größte Skalarprodukt (12.4) besitzt, d. h. decodiert wird. 

Generell kann man nicht zeigen, ob der L-GMC-Algorithmus ein ML-Decodierverfahren ist, bzw. wie viel schlechter die Decodierung im Vergleich ist. Dies bedeutet, man ist auf Simulationen angewiesen, und einige werden wir in Abschnitt 9.6.3 beschreiben. Für die Klasse der RM-Codes erster Ordnung können wir jedoch folgenden Satz beweisen. Satz 9.26 (L-GMC ist ein SDML-Decodierverfahren für R(1, m)) Der Algorithmus L-GMC mit L = 2 decodiert alle RM-Codes erster Ordnung R(1, m) bzw. (2; 2m , m + 1, 2m−1 ) Soft-Decision Maximum-Likelihood (SDML).

412

9 Verallgemeinerte Codeverkettung

1

c=

1

1

1

gesendetes Codewort R(2, 4)

1

1

1

1

1

1

1

1

1

1

1

1

empfangenes Codewort R(2, 4)

y = 1.0 1.2 1.4 1.0 0.7 -0.5 0.5 1.0 1.4 -0.1 1.6 -0.1 1.0 0.8 1.1 0.4 R(1, 3)

R(2, 3)

y(1) = 1.0 1.0 -0.5 0.5 -0.1 -0.1 0.8 0.4

y(1) (1) a ˆ1

R(0, 2)

R(1, 2)

= 1.0 -0.5 0.1 0.4

y(2)

= 2.0 0.0 -0.2 1.2

= 1

(2) a ˆ1

= 1

(1) a ˆ1

1

1

1

-1

-1

1

R(1, 3) = 1

1

-1

-1

-1

-1

1

y(2)

1

(2)

a ˆ1

R(2, 3) = 2.2 2.4 -1.2 0.5 -1.5 -1.7 1.8 1.5 = 1

1

-1

-1

-1

-1

-1

1

1

1

1

1

1

R(2, 4) cGMC = 1 ˆ

1

1

1

1

-1

1

-1

1

-1

1

Abb. 9.52: Zu Beispiel 9.51: Decodierung mit GMC.

Beweis: Wir werden zunächst beweisen, dass wenn L-GMC den Code R(1, m − 1) SDML decodiert, dass dann auch der Code R(1, m) SDML decodiert wird. Wir wollen hier zur Vereinfachung die folgende Darstellung wählen: R(1, m)

=

L

R(1, m − 1) R(1, m − 1) R(0, m − 1)

Ein Codewort des R(1, m) ergibt sich dann zu: ` (2) (2) (1) (2) (1) (2) ´ ˆ= a c ˆ1 , . . . , a ˆn/2 , a ˆ1 · a ˆ1 , . . . , a ˆn/2 · a ˆn/2 ,

(9.37)

ˆ (2) ∈ R(1, m − 1) und a ˆ (1) ∈ R(0, m − 1). Das zu maximierende Skalarprodukt können mit a wir wie folgt ausdrücken:

hˆ c, yi =

n X i=1

cˆi yi =

n/2 X i=1

cˆi yi +

n X

i=n/2+1

cˆi yi =

n/2 X i=1

(2)

a ˆi yi +

n/2 X i=1

(1)

(2)

a ˆi · a ˆi yi+n/2

n/2 n/2 X ` (2) ´ X (2) ` ´ (1) (2) (1) = a ˆ i yi + a ˆi · a ˆi yi+n/2 = a ˆ i · yi + a ˆi · yi+n/2 . | {z } i=1 i=1 (2) yi

(9.38)

9.6 Mehrfachverkettung und Reed-Muller-Codes

c=

1

1

1

413

gesendetes Codewort R(2, 4)

1

1

1

1

1

1

1

1

1

1

1

1

1

empfangenes Codewort R(2, 4)

y = 1.0 1.2 1.4 1.0 0.7 -0.5 0.5 1.0 1.4 -0.1 1.6 -0.1 1.0 0.8 1.1 0.4 R(1, 3)

R(2, 3)

y (1) = 1.0 1.0 -0.5 0.5 -0.1 -0.1 0.8 0.4 R(0, 2)

y (1) = 1.0 -0.5 0.1 0.4 (1)

a ˆ1

(1)

a ˆ2

R(1, 2)

y (2) = 2.0 0.0 -0.2 1.2 (2)

1

1

1

1

a1 ˆ

= -1

-1

-1

-1

a2 ˆ

=

(2)

=

1

-1

-1

1

=

1

1

1

1

y (2) = 0.0 1.0 0.0 -1.4 (2)

hy (1) , a ˆ(1) i

(1)

3.4

a ˆ1

3.0

a ˆ2

(1)

a1 ˆ

= -1

1

1

-1

(2) a2 ˆ

=

1

-1

-1

1

R(1, 3)

R(2, 3)

=

1

1

-1

-1

-1

-1

1

1

y (2) = 2.2 2.4 -1.2 0.5 -1.5 -1.7 1.8 1.5

=

1

1

1

1

1

1

1

1

a ˆ1

=

1

1

-1

-1

-1

-1

1

1

(2) a ˆ2

=

1

1

1

1

-1

-1

1

1

1.4

1

-1

-1

1

-1

1

1

-1

1.4

-1

1

-1

1

1

-1

1

-1

(2)

y (2) = 2.2 2.4 0.2 1.5 1.3 1.5 1.8 1.5 (2)

hy, ˆ ci 11.8

9.4

=

1

1

1

1

1

1

1

1

(2) a ˆ2

=

1

1

-1

1

-1

1

1

1

R(2, 4) cGMC = ˆ

10.4 12.4

a ˆ1

cL-GMC = ˆ

1

1

1

1

1

-1

1

-1

1

-1

1

-1

1

1

1

1

1

1

1

1

-1

1

-1

1

1

-1

1

-1

1

1

1

1

1

1

1

1

1

1

1

1

1

1

1

1

1

1

1

1

1

1

-1

-1

1

1

-1

-1

1

1

1

1

1

1

1

1

Abb. 9.53: Zu Beispiel 9.51: Decodierung mit L-GMC. ˆ (1) = +1 und a ˆ (1) = −1. Der Wiederholungscode R(0, m−1) besitzt nur die beiden Codeworte a Deshalb existieren für R(1, m) nur die beiden Möglichkeiten {(u|u) | u ∈ R(1, m − 1)}, für (ˆ a(1) = +1) (1)

{(u| − u) | u ∈ R(1, m − 1)}, für (ˆ a

und

= −1) .

Gemäß Voraussetzung decodiert L-GMC den Code R(1, m − 1) SDML. Betrachten wir das ˆ (1) = −1) Skalarprodukt hˆ c, yi, so liefert L-GMC für die beiden Teilmengen (ˆ a(1) = +1 und a jeweils das Codewort mit dem größten Skalarprodukt (ML-Codewort). Eines dieser beiden

414

9 Verallgemeinerte Codeverkettung

ML-Codeworte der Teilmengen muss das ML-Codewort des Gesamtcodes R(1, m) sein. Konsequenterweise wird R(1, m) SDML decodiert. Für eine vollständige Induktion brauchen wir nur noch zu zeigen, dass R(1, 2) durch L-GMC SDML decodiert wird, was erfüllt ist. 2

9.6.3

Simulationsergebnisse und Komplexität

Wir wollen einige Simulationsergebnisse der Bit- und Blockfehlerraten von verschiedenen RM-Codes erörtern. Dabei werden wir den GMC- als Spezialfall des L-GMCAlgorithmus mit L = 1 auffassen. Bei allen Beispielen wurde mit einem AWGN-Kanal und BPSK-Modulation simuliert. Um die Qualität der Decodierung zu beurteilen, gibt es die Möglichkeit des Vergleichs mit ML-Decodierung. Da die ML-Decodierung nur für relativ kurze Codes durchführbar ist, benötigt man eine obere Schranke, wie die Union-Bound (siehe hierzu beispielsweise [Pro]) bzw. eine untere Schranke. Als untere Schranke kann folgende Abschätzung dienen: Satz 9.27 (Schranke für Blockfehlerwahrscheinlichkeit) (ohne Beweis) Ein MLDecodierer kann keine kleinere Restblockfehlerwahrscheinlichkeit erreichen als ein Decodierer, der unter Kenntnis des gesendeten Codewortes c und des Ergebnisses eines ˆ die folgende Entscheidung a ˆ trifft (y empfangen): beliebigen Decodierers c ˆ = c =⇒ a ˆ=c=c ˆ • c ˆ 6= c • c

ˆ) =⇒ a ˆ=c dE (y, c) ≤ dE (y, c ˆ) =⇒ a ˆ=c ˆ dE (y, c) > dE (y, c

ˆ=c • Decodierversagen: a Das Verfahren kann benutzt werden, um eine untere Simulationsschranke für die SDMLBlockfehlerrate zu erhalten. Simulationen haben gezeigt, dass je näher ein Decodierer an SDML herankommt, desto dichter ist diese Schranke. Offensichtlich ist sie im Falle eines SDML-Decodierers identisch mit diesem. Des weiteren kann die Näherung d · PBlock n benutzt werden, um bei systematischer Codierung die Bitfehlerrate aus der Blockfehlerrate zu berechnen. PBit ≈

Beispiel 9.52 (Simulation des R(1, 5)-Codes) Zunächst soll der relativ kurze RM-Code R(1, 5), der ein (32, 6, 16)-Code ist, untersucht werden. Neben der Decodierung mit dem Algorithmus GMC wurden zum Vergleich eine BMD-, SDML- und HDML-Decodierung durchgeführt. Die Ergebnisse sind in Bild 9.54 dargestellt. Dabei ist die Blockfehlerwahrscheinlichkeit über dem Signal-Rauschverhältnis aufgetragen. Wir hatten in Satz 9.26 bewiesen, dass der Algorithmus L-GMC mit L = 2 eine ML-Decodierung darstellt. Aus dem Bild folgt, dass die Decodierung mit GMC bei Eb /N0 = 6 dB eine etwa um den Faktor 80 kleinere Restblockfehlerwahrscheinlichkeit ergibt als die BMD-Decodierung. Man beachte, dass die SDML-Decodierung identisch mit dem Decodierergebnis von L-GMC für L = 2 ist. 

9.6 Mehrfachverkettung und Reed-Muller-Codes

415

0

10

−1

10

−2

PBlock

10

−3

10

BMD HDML GMC SDML

−4

10

−5

10

2

2.5

3

3.5

4 4.5 E /N [dB] b

5

5.5

6

0

Abb. 9.54: Vergleich verschiedener Decodierprinzipien beim R(1, 5). Beispiel 9.53 (Simulation der R(r, 6)-Codes) In diesem Beispiel sollen die Codes R(2, 6) und R(4, 6) untersucht werden. Die Bilder 9.55 und 9.56 zeigen die Blockfehlerraten für die SoftDecision-Decodierung mit L-GMC. Dabei wurden Listenlängen von L = 1, 2, 3, 4 verwendet. Die Decodierung mit Listenlänge L = 1 entspricht dem GMC. Die RM-Codes sind systematisch codiert. Um die Decodierergebnisse gegenüber einer SDML-Decodierung einschätzen zu können, wurde jeweils die Simulationsschranke (Satz 9.27) für die Blockfehlerwahrscheinlichkeit in den Bildern mit eingetragen. Die Simulationsschranken wurden mit den entsprechenden Liste-4-Decodierern ermittelt. 0

10

−1

10

−2

PBlock

10

−3

10

GMC L−GMC Liste 2 L−GMC Liste 3 L−GMC Liste 4 unt. Schranke für SDML

−4

10

−5

10

0

1

2

3 Eb/N0 [dB]

4

5

6

Abb. 9.55: Blockfehlerraten für den R(2, 6)-Code mit L-GMC. Die Blockfehlerraten zeigen zusammen mit den unteren Schranken für SDML-Decodierung, dass wir mit L-GMC und einer Listenlänge L = 4 näherungsweise SDML-Decodierung errei-

416

9 Verallgemeinerte Codeverkettung 0

10

−1

PBlock

10

−2

10

GMC L−GMC Liste 2 L−GMC Liste 3 L−GMC Liste 4 unt. Schranke für SDML

−3

10

−4

10

0

1

2

3 4 E /N [dB] b

5

6

7

0

Abb. 9.56: Blockfehlerraten für den R(4, 6)-Code mit L-GMC. chen. Des weiteren ist zu erkennen, dass der Verlust einer Decodierung mit GMC gegenüber einer SDML-Decodierung mit steigender Ordnung der RM-Codes fällt. Dieses Verhalten lässt sich wie folgt erklären: Bei der rekursiven Decodierung von RM-Codes höherer Ordnung mittels GMC werden hauptsächlich hochratige Untercodes verwendet. Dagegen enthalten RM-Codes niedriger Ordnung größtenteils niederratige Untercodes. Bei der Berechnung der Metriken zur rekursiven Decodierung wurde als Näherung die statistische Unabhängigkeit der Codesymbole vorausgesetzt. Die Codesymbole von niederratigen Codes zeigen jedoch eine höhere statistische Abhängigkeit als die Codesymbole hochratiger Codes. Diese Näherung ist deshalb bei der Metrikberechnung für RM-Codes niedriger Ordnung ungenauer als bei der Berechnung der Metrik für RM-Codes mit höherer Ordnung. 

Da wir mit dem L-GMC Algorithmus ein effizientes Soft-Decision-Decodierverfahren mit geringer Komplexität zur Verfügung haben, wollen wir im folgenden Beispiel noch die beiden längeren RM-Codes R(4, 9) = (512, 256, 32) und R(5, 10) = (1024, 638, 32) untersuchen. Beispiel 9.54 (Simulation des R(4, 9) und des R(5, 10)-Codes) Für die Codes R(4, 9) = (512, 256, 32) und R(5, 10) = (1024, 638, 32) ist kein ML-Decodierverfahren bekannt. Die Bilder 9.57 bzw. 9.58 zeigen die Bitfehlerrate der Codes R(4, 9) und R(5, 10) für eine Decodierung mit L-GMC und Listenlängen von 1 bis 4. Der Gewinn zwischen GMC (d. h. L = 1) und L-GMC mit L = 4 beträgt bei einer Bitfehlerrate von 10−4 1.1 dB bzw. 0.8 dB. Eine untere Schranke für die Bitfehlerwahrscheinlichkeit konnte für diese Codes nicht ermittelt werden, da die Simulationsschranke (Satz 9.27) keine sinnvollen Werte liefert. Dies kann bedeuten, dass wir mit L-GMC für die betrachteten Listenlängen keine näherungsweise SDMLDecodierung erreichen. Der Verlust gegenüber einer SDML-Decodierung könnte durch die höhere Anzahl an Rekursionsschritten im Vergleich zu kürzeren RM-Codes erklärt werden. Denn die Gleichungen zur Metrikberechnung (9.33) und (9.34) müssen bei längeren Codes mehrmals (rekursiv) angewendet werden bis ein Wiederholungs- oder PC-Code zur Decodierung erreicht ist. Da bei jeder Berechnung dieser Metriken die Näherungsannahme der statistischen Unab-

9.6 Mehrfachverkettung und Reed-Muller-Codes

417

−1

10

−2

PBit

10

−3

10

−4

GMC L−GMC Liste 2 L−GMC Liste 3 L−GMC Liste 4

10

−5

10

0

1

2

3 E /N [dB] b

4

5

6

0

Abb. 9.57: Bitfehlerraten für den R(4, 9)-Code mit L-GMC.

−1

10

−2

PBit

10

−3

10

−4

GMC L−GMC Liste 2 L−GMC Liste 3 L−GMC Liste 4

10

−5

10

0

1

2

3 Eb/N0 [dB]

4

5

6

Abb. 9.58: Bitfehlerraten für den R(5, 10)-Code mit L-GMC. hängigkeit der Codesymbole getroffen wird, verschlechtert sich die Metrik und somit auch das Decodierergebnis mit zunehmender Anzahl an Rekursionsschritten. 

Komplexität des L-GMC-Algorithmus: Die Decodierung mit L-GMC hat eine geringere Komplexität als alle bisher für RMCodes bekannten Decodierverfahren mit Zuverlässigkeitsinformation. Z. B. benötigt die Viterbi-Decodierung des RM-Codes R(4, 9) = (512, 256, 32) über das Trellis mehr als 1030 mal so viele Rechenoperationen pro Codewort als die Decodierung mit dem GMCAlgorithmus. Als Maß für die Komplexität der Decodierung eines Codewortes werden wir die Anzahl der Fließkomma-Operationen angeben. Alle übrigen Operationen, wie z. B. Zuweisungen

418

9 Verallgemeinerte Codeverkettung

oder Integer-Operationen, werden nicht gezählt, da der Aufwand vergleichsweise gering ist. Tabelle 9.8 listet die Anzahl der zur Decodierung eines Codewortes benötigten Fließkomma-Operationen einiger oben behandelter Beispiele auf. Man erkennt, dass die Komplexität von L = 1 nach L = 2 nur um den Faktor 2 bis 7 zunimmt und damit schon eine große Verbesserung der Decodierung erreicht wird. Der Faktor für die Erhöhung der Komplexität wird bei einem Code mit länger werdender Liste L kleiner. Tabelle 9.8: Komplexität des Algorithmus L-GMC.

9.7

Code

GMC

R(2, 6) R(3, 6) R(4, 6) R(4, 9) R(5, 10)

1615 1687 1140 23531 53075

Liste 2

L-GMC Liste 3

Liste 4

6248 4929 2280 152928 366817

13048 9418 3494 544398 1393418

25134 16015 4896 1524372 4017037

Anmerkungen

Die Verkettung von Codes wurde bereits im Jahre 1954 von Elias in Form von Produktcodes eingeführt. Forney [For66a] hat dann im Jahre 1966 verkettete Codes untersucht, indem er den sogenannten Superkanal verwendet hat. Einige Jahre später, 1974, haben Blokh und Zyablov das Konzept der verallgemeinerten Codeverkettung veröffentlicht [BZ74] und die Hard-Decision-Decodierung von GC-Codes bis zur halben Mindestdistanz beschrieben (siehe auch [Zin81] und [Eri86]). Im Jahre 1976 hat Zinoviev in [Zin76] aus nahezu trivialen Codes bis zur Länge 16 längere Codes erzeugt, die zu den besten bekannten Codes zählen (vergleiche hierzu die Tabelle [McWSl, S. 675]). Das Grundkonzept der verallgemeinerten Verkettung bietet derart viele Möglichkeiten, dass wir die Beschreibung der weiteren Ergebnisse in unterschiedliche Gebiete aufteilen wollen. Die folgende Aufzählung der Arbeiten erhebt keinen Anspruch auf Vollständigkeit. GC-Codes mit Blockcodes: GC-Codes zur Korrektur von Bündelfehler und Einzelfehler sind durch Zinoviev und Zyablov in [ZZ79b] untersucht worden. T. Ahlin, T. Ericson und V. Zyablov analysierten in [AEZ85] die Verwendung von GC-Codes bei FadingKanälen. Codes mit mehrstufigem Fehlerschutz, sogenannte UEP-Codes (unequal error protection codes), wurden in [ZZ79a] analysiert (siehe auch [LL87]). Zyklische verkettete Codes wurden von Berlekamp und Justesen [BJ74] eingeführt, und Jensen hat in [Jen85], [Jen92] und [Jen96] bewiesen, dass jeder zyklische Code als GC-Code betrachtet werden kann. Damit lassen sich GC-Codes mit den gleichen inneren und äußeren Codes sowohl in zyklischer Form als auch nicht-zyklisch darstellen. Verkettete Codes, die auf die Fehlerstruktur des Kanals angepasst sind, lassen sich aus den Blot-Correcting-Codes [Bre97] ableiten und wurden erstmals in [GJZ97] vorgestellt. Dabei handelt es sich um das Konzept, die Redundanz erneut zu codieren und nur die Redundanz der Redundanz zu übertragen. Die Singleton-Schranke ist in [BS96] bewiesen

9.7 Anmerkungen

419

und ergibt, dass zur Korrektur eines zweidimensionalen Bündelfehlers der Größe b1 · b2 bit mindestens 2b1 b2 Redundanzbit notwendig sind. Interessant ist, dass dies für b1 = 1 der Reiger-Schranke aus Abschnitt 6.5 entspricht. Im Jahre 1980 wurde von Bos [Bos80] gezeigt, dass GC-Codes mit inneren Codes über beliebige Metriken konstruiert werden können. Diese Tatsache wird durch die codierte Modulation in Kapitel 10 ausgenutzt. Des weiteren wurden in [For88a] und [For88b] Spezialfälle von GC-Codes intensiv untersucht, die dort Coset-Codes genannt werden. Weitere zahlreiche Veröffentlichungen sind zu diesem Thema seit 1985 erschienen, und einige davon sind: [AEZ85, DC87, HEK87, KL87, KTL86, Eri86] und viele mehr (siehe auch die Zusammenfassung von Kapitel 10). Auch der Standard-Code für Satellitenübertragung ist ein verketteter Code (siehe [WHPH87]). Decodierung von GC-Codes: Die Decodierung von verketteten Codes war lange Zeit nicht zufriedenstellend gelöst. Decodiert man zunächst den inneren und dann den äußeren Code, so kann man zeigen, dass man damit nicht garantiert bis zur halben Mindestdistanz des GC-Codes korrigieren kann. Im Jahre 1974 haben Dumer, Zinoviev und Zyablov einen Decodieralgorithmus für GC-Codes [DZZ81] veröffentlicht und bewiesen, dass man damit verkettete Codes bis zur halben Mindestdistanz decodieren kann. Weitere Arbeiten zur Decodierung von GC-Codes sind [BS90, BKS92] und [SB90] (siehe auch Zusammenfassung von Kapitel 10). GC-Codes mit Faltungscodes: Die ersten Konstruktionen von GC-Codes mit inneren Faltungscodes basieren auf (P)UM-Codes und sind in [ZySha] bzw. [ZSJ95] beschrieben. Des weiteren wurden in [JTZ88, ZJTS96] und [ZS87] Schranken für GC-Codes mit inneren UM-Codes angegeben. Die Partitionierung kann jedoch für beliebige Faltungscodes (nicht nur für UM-Codes) durchgeführt werden, wie in der Arbeit [BDS96a] aus dem Jahre 1996 gezeigt wurde. Mit Block- ([BDS96a]) und Faltungs- ([BDS96b]) Scrambler-Matrizen wird ein Faltungscodierer in einen äquivalenten Codierer überführt, der dann partitioniert werden kann. Eine Übersicht und die Beschreibung aller Verfahren findet man in [BDS97]. Darin wird auch ein Algorithmus angegeben, um Blockund Faltungsscrambler für beliebige Faltungscodes zu berechnen, der dem aus Abschnitt 9.4.3 entspricht. Die beschriebenen Methoden können als Verallgemeinerung der Verfahren aus [ZySha] aufgefasst werden, die wir im wesentlichen in Abschnitt 9.4.1 erläutert haben. Grundlage für die Partitionierung stellt die algebraische Beschreibung von Faltungscodes in [For70] und [JW93] dar, wo gezeigt wurde, dass viele verschiedene Codiermatrizen für einen Code existieren. Die Betrachtungsweise eines Faltungscodes als (P)UM-Code geht auf Lee [Lee76] zurück. Die Arbeit [BGT93] zu den sogenannten Turbo Codes aus dem Jahre 1993 hat zur Decodierung von GC-Codes basierend auf Faltungscodes einen interessanten Beitrag geleistet. Die Grundidee dabei weist zahlreiche Gemeinsamkeiten mit den sogenannten Low-Density-Parity-Check-Codes auf, die von Gallager in [Gal62] eingeführt wurden. Jedoch ist das Problem der ML-Decodierung eines GC-Codes noch nicht gelöst und es fehlen theoretische Ergebnisse hierzu (vergleiche etwa [ZS92]). Zu Turbo-Codes sind zahlreiche Veröffentlichungen erschienen und einige davon sind: [BM96, BDMP95, RS95] und [WH95]. RM-Codes: Mit dem Prinzip der mehrfachen verallgemeinerten Codeverkettung konnten wir die Klasse der Reed-Muller-Codes (siehe auch Zusammenfassung von Kapitel 5)

420

9 Verallgemeinerte Codeverkettung

beschreiben und direkt einen Decodieralgorithmus angeben, der sehr einfach Zuverlässigkeitsinformation benutzen kann und gleichzeitig eine sehr geringe Komplexität aufweist. Die |u|u ⊕ v|-Konstruktion wird auch Plotkin-Konstruktion genannt [Plo60] und stammt aus dem Jahre 1960 (1951 auf russisch). Die rekursive Beschreibung von RMCodes ist auch in [Gore70] angegeben. Im Jahre 1988 veröffentlichte Forney in [For88b] eine rekursive Coset-Codes-Konstruktion, die ein Spezialfall der verallgemeinerten Codeverkettung ist. Für die Decodierung von RM-Codes ohne Zuverlässigkeitsinformation sind verschiedene Decodierverfahren bekannt. RM-Codes können durch das in Abschnitt 7.3.2 beschriebene Mehrheitsdecodierverfahren decodiert werden, z. B. mit dem Reed-Algorithmus (siehe [McWSl, Ch. 13]) oder dem Verfahren aus [TSKN82]. Weiterhin ist von Seroussi et al. in [SL83] ein ML-Decodierverfahren für punktierte R(m−3, m) RM-Codes beschrieben worden. Ein weiteres ML-Decodierverfahren für RM-Codes erster Ordnung R(1, m) ist in [McWSl, Ch. 14] oder auch Karyakin [Kar87] beschrieben. Für die Decodierung mit Zuverlässigkeitsinformation existieren ebenfalls verschiedene Verfahren. Be’ery et al. [BS86] beschreiben ein ML-Decodierverfahren, das auf der Hadamard-Transformation basiert. Litsyn et al. beschreiben in [LS83] und [LNSM85] einen suboptimalen Algorithmus für RM-Codes erster Ordnung. Weiterhin wurde von Forney in der Arbeit [For88b] ein ML-Decodierverfahren für RM-Codes veröffentlicht, das auf der Trellisdarstellung des Codes (Abschnitt 6.7) und der Viterbi-Decodierung (Abschnitt 7.4.3 bzw. 8.4.2) basiert. In diesem Kapitel wurden behandelt: Wir haben in diesem Kapitel das sehr mächtige Prinzip der verallgemeinerten Codeverkettung definiert und untersucht. Ausgehend von einem inneren Code in einem Raum mit einer bestimmten Metrik, und damit einer definierten Mindestdistanz, wird dieser Code in Untercodes mit größerer Mindestdistanz partitioniert. Die Untercodes können wiederum in Untercodes partitioniert werden, solange, bis die Partitionierung nur noch ein Codewort enthält. Die Partitionierungen werden nummeriert und die Nummerierung wird mit je einem äußeren Code geschützt. Wir haben Konstruktionsmethoden für die Partitionierung abgeleitet. Des weiteren haben wir ein Decodierverfahren angegeben, das GC-Codes bis zur halben Mindestdistanz decodieren kann. Nach der Definition von GC-Codes war die Konstruktion von UEP-Codes offensichtlich, zu denen wir einige Ergebnisse angegeben haben. Wir haben die Korrektur von Bündelfehlern bei GC-Codes erläutert und haben das Prinzip der verallgemeinerten Codeverkettung mit Interleaving und herkömmlicher Codeverkettung verglichen. Zyklische GC-Codes wurden definiert und erörtert und das Konzept der erneuten Codierung der Redundanz eingeführt. Die Partitionierung von Faltungscodes erlaubte GCCodes mit inneren Faltungscodes zu konstruieren. Damit wurden alle vier Möglichkeiten zur Konstruktion von GC-Codes mit Block- und Faltungscodes angesprochen und mehr oder weniger ausführlich behandelt. An vielen Stellen existieren noch ungelöste Probleme und offene Fragen. Das bedeutet, es sind noch viele Untersuchungen durchzuführen, die gegebenenfalls zu interessanten Ergebnissen führen können. Anmerkungen: Bei der Decodierung von GC-Codes existieren noch ungelöste Probleme. Es fehlen theoretische Ergebnisse, um durch ML-Decodierung der beteiligten Codes

9.7 Anmerkungen

421

eine näherungsweise ML-Decodierung des Gesamtcodes zu erreichen. In vielen Fällen ist unbekannt, wie weit man noch von einer ML-Decodierung entfernt ist. Eine prinzipiell andere Vorgehensweise ist, nicht einen allgemein gültigen Decodieralgorithmus für beliebige Codeklassen zu entwickeln, sondern zu einem guten und effizienten Decodieralgorithmus die passenden Codes zu konstruieren. Auf dieser Idee basieren die Low-Density-Parity-Check-Codes ebenso wie die Turbo-Codes. Eigentlich ist mit diesem Kapitel auch schon die codierte Modulation beschrieben. Um der Wichtigkeit dieses Gebietes Rechnung zu tragen, wollen wir den Spezialfall der codierten Modulation im nächsten Kapitel eingehender untersuchen.

10

Codierte Modulation

Ziel dieses Kapitels, in dem Kapitel 9 vorausgesetzt wird, ist es, die Grundkonzepte von codierter Modulation zu beschreiben. Da sich dieses Gebiet noch in der Forschung befindet, können nicht alle neuen Ergebnisse im Detail berücksichtigt werden. Vielmehr geht es um das Verständnis, warum das Konzept der verallgemeinerten Verkettung auch bei Modulation als innerem Code größere euklidische Distanzen bewirkt. Zunächst soll das Grundprinzip an zwei einführenden Beispielen veranschaulicht werden. Danach definieren wir Codes im euklidischen Raum (codierte Modulation) als Spezialfall der verallgemeinerten Codeverkettung. Als äußere Codes können dabei sowohl Block- als auch Faltungscodes benutzt werden. Entsprechend dem Kapitel zur verallgemeinerten Verkettung von Codes, wollen wir hier ebenfalls zwei Fälle unterscheiden, nämlich wenn der innere Code einem Blockcode entspricht, d. h. Modulation ohne Gedächtnis und wenn der innere Code einem Faltungscode entspricht, d. h. Modulation mit Gedächtnis. Zum ersten Fall gehören u. a. PSK- (phase shift keying) und QAM(quadrature amplitude modulation) Modulationsverfahren [Kam, Pro] und zum zweiten die CPM- (continuous phase modulation) Modulationsverfahren wie etwa CPFSK (continuous phase frequency shift keying) und MSK (minimum shift keying), die mittels eines Trellis beschrieben werden können. Obwohl die Decodierung identisch mit der von verketteten Codes des vorigen Kapitels ist, wird die Decodierung von codierter Modulation hier gesondert erläutert, unter anderem auch wegen der Metrik. Weiterhin werden mehrdimensionale Räume und Lattices erörtert, da diese für die Partitionierung vielfältigere Möglichkeiten eröffnen, als Signale im zweidimensionalen Raum. Dies ist eng verknüpft mit dem Konzept der mehrfachen verallgemeinerten Codeverkettung. Die Partitionierung von Modulationsverfahren mit Gedächtnis wird ebenfalls diverse zusätzliche Varianten erlauben.

10.1

Einführende Beispiele

Zunächst betrachten wir ein einfaches Beispiel eines Modulationsverfahrens, dessen Signale im eindimensionalen Signalraum der reellen Zahlen R repräsentiert werden und somit als Punkte auf einer Geraden dargestellt werden können. Dabei könnte es sich z. B. um die eindimensionale ASK- (amplitude shift keying) Modulation [Kam, S. 424] handeln. Wir verwenden als Metrik des inneren Codes die quadratische euklidische Distanz gemäß Abschnitt 7.1.4 und vergleichen in dem folgenden Beispiel, die herkömmliche Verkettung mit codierter Modulation. Beispiel 10.1 (Eindimensionale innere Modulation) Gegeben sei eine Gerade mit den vier Punkten {0, 1, 2, 3} entsprechend Bild 10.1. Jeder Punkt ist durch zwei Bits eindeutig

424

10 Codierte Modulation

nummeriert. Die minimale quadratische euklidische Distanz dieser Punkte ist δ = 1 und wir 0

1

2

3

x

Abb. 10.1: Modulationsalphabet von 4-ASK (eindimensional). benutzen für den inneren Code die Notation X (R, M = 4, δ = 1), wobei M die Mächtigkeit des Modulationsalphabets kennzeichnet. Zunächst betrachten wir die einfache Verkettung von Kanalcodierung und Modulation. Anschließend stellen wir diesem das Konzept der codierten Modulation gegenüber. Zur Codierung (gemäß Bild 10.2) werden zwei Informationsbits zunächst mit dem äußeren Wiederholungscode A(22 ; 4, 1, 4) codiert, und dann wählt jedes der vier Symbole einen Punkt aus X aus. Ein Codewort besteht daher aus vier Punkten aus R, i1 i2 A

i1 i2

x1

i1 i2

x1

i1 i2

x1

i1 i2

x1

x1 ∈ {0, 1, 2, 3}

Abb. 10.2: Herkömmliche Verkettung. d. h. das Codewort ist aus R4 , und der entsprechende verkettete Code ist C(R4 , M = 22 , δ = 4). Dabei ist die Mindestdistanz des verketteten Codes bezüglich der gleichen Metrik, wie die des inneren Codes, zu betrachten. Um nun codierte Modulation zu erhalten, partitionieren wir den Code X (1) = X entsprechend (2) (2) Bild 10.3 in 2 mal 2 Punkte, also in X0 und X1 . Als äußere Codes benutzen wir A(1) (2; 4, 1, 4) X (1)

δ (1) = 1 0

1

2

3

0

1

(2)

δ (2) = 4

Xl

0

1

2

3

0 0

1

2

0 1

3

0

1

1

2

3

0 2

3

0

1

2

1 3

0

1

2

3

Abb. 10.3: Partitionierung von 4-ASK. und A(2) (2; 4, 4, 1) und erhalten damit CGC (R4 , M = 25 , δ = min{1 · 4, 4 · 1}) Bei gleicher Mindestdistanz hat der GC-Code (die codierte Modulation) 8 mal so viele Codeworte. Die Codierung ist in Bild 10.4 dargestellt. Ein Codewort besteht hier ebenfalls aus 4 reellen Zahlen. 

Das Prinzip der codierten Modulation und von GC-Codes ist identisch. Es wird lediglich eine andere Metrik für den inneren Code benutzt. In einem zweiten Beispiel soll noch der gängige Fall einer zweidimensionalen Modulation betrachtet werden.

10.1 Einführende Beispiele

i1

425

A(1)

i1

i2

i1

i3

i1 i1 i1

i1 A(2) i4

i2 i3 i4 i5

i1

i1

i5

i2

(2) 1 (2) Xi 1 (2) Xi 1 (2) Xi 1

Xi

i3 i4 i5

x1 x2 x3 x4

xi ∈ {0, 1, 2, 3}

Abb. 10.4: Codierte Modulation, Codierung des GC-Codes. Beispiel 10.2 (Zweidimensionale innere Modulation) In Bild 10.5 ist die Partitionierung von 8-PSK dargestellt. Die Energie der Signalpunkte sei dabei zu 1 normiert. Dies kann ab der zweiten Stufe als Partitionierung von QPSK betrachtet werden. Jeder der 4 Punkte wird mit zwei Bits nummeriert. Benutzen wir zur Codierung zwei verkürzte BCH-Codes (2; 30, 14, 8), so erhalten wir den verketteten Code C. Verwenden wir die in Bild 10.5 dargestellte Partitionierung 010 011

001

100

000 111

101 110

1

1

1

0

0

0

1

1

0

1

0

0

1

0

Abb. 10.5: Partitionierung von 8-PSK. und die zwei äußeren BCH-Codes, A(1) (2; 30, 14, 8) und A(2) (2; 30, 24, 4), so ergibt sich der verallgemeinert verkettete Code CGC . Beide haben die Parameter C(R60 , M = 228 , δ = 8 · ρ = 16)

und

CGC (R60 , M = 238 , δ = min{2 · 8, 4 · 4}).

Der Code C besitzt die Rate 14/30 und CGC die größere Rate 19/30. Konstruieren wir einen GC-Code, bei dem die Rate gleich 14/30 ist, so ergibt sich mit den zwei äußeren BCH-Codes A(1) (2; 30, 9, 12) und A(2) (2; 30, 19, 6) der Code CGC (R60 , M = 228 , δ = min{2 · 12, 4 · 6}) mit größerer Mindestdistanz (24 > 16). 

426

10 Codierte Modulation

Die Beispiele sollten das Konzept veranschaulichen. Wir können nun den Fall von codierter Modulation beschreiben, wenn der innere Code (die Modulation) einem Blockcode entspricht, d. h. gedächtnislos ist.

10.2

GC mit Blockmodulation

Als Blockmodulation bezeichnen wir hier alle Modulationsarten ohne Gedächtnis (siehe z. B. [Kam], [Pro]) ASK (amplitude shift keying), FSK (frequency shift keying), PSK (phase shift keying), QAM (quadrature amplitude modulation), usw. Die bei digitaler Übertragung am häufigsten benutzten Modulationsarten sind PSK und QAM. Wir wollen zunächst die Partitionierung von diesen Modulationsarten beschreiben.

10.2.1

Partitionierung von Signalen

Zunächst wurden im Beispiel 10.1 Signale im eindimensionalen reellen Raum R partitioniert (ASK). Die Partitionierung von Codes über beliebige Räume mit euklidischer Metrik ist prinzipiell nichts anderes als bei Codes mit Hamming-Metrik. Wir müssen uns hier nur auf den euklidischen Raum R2 beschränken, da in der Signaltheorie die modulierten Signale in diesem Raum beschrieben werden (Betrag und Phase bzw. Inphaseund Quadraturkomponente, siehe z. B. [Kam], [Pro, S. 106]). Eine Menge von Signalen si ∈ R2 , i = 1, 2, . . . , M (1) , ist dabei eine Menge von M (1) Punkten, die einen Code X (1) (R2 , M (1) , δ (1) ) über dem euklidischen Raum definieren. Die Metrik, d. h. die Distanz δ zwischen zwei Punkten s1 = (x1 , y1 ) und s2 = (x2 , y2 ), definieren wir als die quadratische euklidische Distanz entsprechend Abschnitt 7.1.4: δ = distE (s1 , s2 ) = (x1 − x2 )2 + (y1 − y2 )2 .

(10.1)

Dann ist die Mindestdistanz δ (1) eines Codes gleich dem Minimum aller Distanzen zwischen beliebigen Punkten: δ (1) = min {distE (si , sj )} . si ,sj ∈X si 6=sj

Wir wollen nun den Code X (1) ⊂ R2 in s Untercodes partitionieren, so dass gilt: X (1) =

s [

i=1

(2)

Xi ,

Ps (2) (2) (2) (2) dabei ist Xi (2, Mi , δi ) und M (1) = i=1 Mi . Die Mindestdistanz des Untercodes (2) Xi ist definiert als das Minimum der Mindestdistanzen aller Untercodes: n o (2) δ (2) = min δi . i=1,...,s

(2)

Wie schon bei Codes über endlichen Körpern, kann nun jeder Untercode Xi (3) in Untercodes Xi,j partitioniert werden, und so weiter.

wiederum

10.2 GC mit Blockmodulation

427

Betrachten wir die bisherigen Beispiele, so ist die oben beschriebene Partitionierung äquivalent zu dem sogenannten set partitioning, das Ungerböck in seiner bekannten Arbeit [Ung82] für 8-PSK beschrieben hat. Für die Modulationsarten QAM und M -PSK wollen wir im Folgenden die Partitionierung für eine binäre Nummerierung angeben, d. h. a(i) ∈ GF (2). 2s -PSK: Die Signale si , i = 1, 2, . . . , M = 2s , sind die Punkte auf einem Einheitskreis in R2 mit den Phasen i · ∆φ,

i = 0, 1, . . . , 2s − 1,

wobei ∆φ =

2π 2s

ist.

Daher gilt für die Mindestdistanz von X (1) (R2 , 2s , δ (1) ): δ (1) = 4 sin2

∆φ = 2(1 − cos ∆φ). 2

Eine Partitionierung des Codes X (1) der Ordnung s mit binärer Nummerierung wird nun wie folgt konstruiert. Wir partitionieren zuerst den Code X (1) in zwei Untercodes (2) (2) X0 und X1 : (2)

Xi (R2 , 2s−1 , δ (2) ), i = 0, 1,

mit δ (2) = 2(1 − cos 2∆φ) .

Allgemein gilt: (l)

Xi1 ,i2 ,...,il−1 (R2 , 2s−(l−1) , δ (l) ),

für l = 1, 2, 3, . . . , s,

und für die Mindestdistanzen:  δ (l) = 2 1 − cos(2l−1 · ∆φ) ,

l = 1, 2, 3, . . . , s .

Die Nummern i1 , . . . , is werden durch die binären Vektoren (a(1) , a(2) , . . . , a(s) ), a(i) ∈ (s) GF (2) ausgedrückt. Wir erinnern uns, dass a(s) das Codewort im Untercode Xi1 ,i2 ,...,is−1 auswählt. Eine Partitionierung von 8-PSK ist in Bild 10.5 dargestellt. Die Erweiterung für höherwertige PSK-Verfahren ist selbsterklärend. M -QAM: Die Partitionierung von M -QAM-Signalen (siehe z. B. [Kam, S. 372], [Pro, S. 189]) ist ähnlich zu der von PSK. Für eine Partitionierung mit binärer Nummerierung beschränken wir uns auf den Spezialfall M = 2s . Damit stellt QAM einen Code X (1) (R2 , M (1) = 2s , δ (1) ) mit der Mindestdistanz δ (1) =

6 M −1

428

10 Codierte Modulation

¯s 1 ist zu Eins normiert. Für die Mindestdar, vorausgesetzt die mittlere Signalenergie E distanzen der Untercodes gilt die Beziehung: δ (j+1) = 2δ (j) ,

j = 1, 2, . . . , s − 1 .

In Bild 10.6 ist eine Partitionierung von 16-QAM dargestellt, wobei auf die Darstellung der letzten Partitionierungsstufe verzichtet wurde.

1

1

1

0

0

0

1

1

0

1

0

0

1

0

Abb. 10.6: Partitionierung von 16-QAM (ohne letzte Stufe).

Natürlich können auch andere Modulationsarten ohne Gedächtnis entsprechend partitioniert werden. Außerdem gibt es keine Restriktion nur binäre Nummerierungen zu verwenden. Anmerkung: Orthogonale und biorthogonale Signale entsprechen Simplex-Codes bzw. RM-Codes erster Ordnung (vergleiche Abschnitt 5.1). Beim Simplex-Code haben die Codeworte alle gleiches Gewicht, d. h. es kann durch Partitionierung kein Untercode mit größerer Distanz konstruiert werden.

10.2.2

Definition der Codierten Modulation

Modulierte Signale können als Code über dem euklidischen Raum R2 angesehen wer(1) den. Damit kann jede Modulationsart, die aus Mb Signalen besteht, als innerer Code (1) X (1) (R2 , Mb , δ (1) ) eines GC-Codes betrachtet werden, indem eine entsprechende Par1

Die mittlere Signalenergie ist die Summe der Einzelsignalenergien multipliziert mit deren Auftritts¯s = P |si |2 · P (si ) wahrscheinlichkeiten: E i

10.2 GC mit Blockmodulation

429

titionierung dieses Codes durchgeführt wird. Üblicherweise (nicht notwendigerweise) wird eine binäre Nummerierung verwendet. Für eine Partitionierung gilt: X (1)

=

(2)

=

Xi1

2 [

(2)

i1 =1 2 [ i2 =1

.. . (s)

Xi1 ,...,is−1 =

2 [

X i1 , (3)

Xi1 ,i2 ,

xi1 ,i2 ,...,is .

is =1

Die Binärzahlen i1 , i2 , . . . , is mit ij ∈ GF (2) nummerieren damit die Partitionierung und xi1 ,i2 ,...,is ist ein Codewort (Signal) des Codes X (1) . Mit dieser Partitionierung sind ebenfalls die Mindestdistanzen δ (i) , i = 1, 2, . . . , s, definiert. Die s äußeren Codes sind (i) (i) Binärcodes A(i) (2; na , Ma , da ). Der damit konstruierte GC-Code ist: ! s Y 2·na (i) (i) (i) CGC R ,M = Ma , δ ≥ min {da · δ } i=1

i=1,...,s

über dem euklidischen Raum R2·na . Die Mindestdistanz δ ist die minimale quadratische euklidische Distanz zwischen zwei beliebigen Punkten (Codeworten) der Konstruktion (des GC-Codes). Die beschriebene Konstruktion wird häufig auch als „multilevel coding“ bezeichnet.

Codierte Modulation mit äußeren Faltungscodes: Verwendet man äußere Faltungscodes, so erhält man codierte Modulationssysteme, die den GC-Codes aus Abschnitt 9.5 entsprechen. Es wird in der Regel die freie Distanz df (Abschnitt 8.1.6) benutzt, um die Eigenschaften der Konstruktion anzugeben, d. h. für die Abschätzung der Distanz gilt: (i)

δ ≥ min {df · δ (i) }. i=1,...,s

Asymptotischer Codiergewinn: Setzt man eine konstante Nettodatenrate voraus, so ist der asymptotische Codiergewinn bei codierter Modulation definiert als: ∆ = 10 log10 (δ/δmod ).

(10.2)

Dabei bedeutet asymptotisch, dass dieser Codiergewinn bei sehr gutem Kanal mit additivem weißen Rauschen erreicht werden kann. In unserer Schreibweise ist δ die Mindestdistanz des GC-Codes und δmod die Mindestdistanz der uncodierten Modulation. Damit ist die Modulation gemeint, die benötigt wird, um die gleiche Informationsdatenrate zu übertragen (entsprechend der Coderate). Wird beispielsweise ein GC-Code der Rate 1/2 mit der Mindestdistanz δ, basierend auf innerer QPSK-Modulation, verwendet, so besitzt BPSK-Modulation die gleiche Informationsdatenrate und δmod entspricht der Mindestdistanz von BPSK (vergleiche auch Abschnitt 7.2.4 zum Codiergewinn).

430

10.2.3

10 Codierte Modulation

Lattices und verallgemeinerte Mehrfachverkettung

Die Möglichkeiten zur Partitionierung eines Codes (Menge von Signalpunkten) im Raum R2 sind sehr beschränkt, gegenüber einer Partitionierung eines Codes in einem mehrdimensionalen Raum. Ein GC-Code mit Signalen aus dem Raum R2 als inneren Code und binäre äußere Codes Ai der Länge na , kann jedoch selbst als Code in einem mehrdimensionalen Raum R2na aufgefasst werden. Eine Partitionierung eines solchen GC-Codes und die Verwendung von äußeren Codes, um die Nummerierung zu schützen, ergibt einen mehrfach verallgemeinert verketteten Code. Weitere Möglichkeiten mehrdimensionale Räume zu konstruieren, sind Spherical-Codes [EZ95] und Lattices [CoSl], die beide in engem Zusammenhang stehen. Wir wollen im Folgenden einige bekannte Lattices aus [CoSl] als GC-Codes mit identischen Parametern beschreiben, wie in [BS92] gezeigt. Lattices: Seien x die Punkte des n-dimensionalen Raums Rn : x = (x1 , x2 , · · · , xn ),

xi ∈ R.

Eine n-dimensionale Kugel in Rn mit Radius ρ und dem Mittelpunkt u ist definiert durch:   n X 2 2 x: (xi − ui ) = ρ . i=1

Das Volumen einer Einheitskugel (z. B. [CoSl]) ist:  n 2   π für n gerade  n 2 ! n−1 Vn =  n  2 · n−1 !  2 2 · π für n ungerade n!

(10.3) .

Ein Lattice ist nun definiert als alle Mittelpunkte von sich berührenden n-dimensionalen Kugeln in Rn mit den Bedingungen: i) 0 ist ein Mittelpunkt. ii) Sind u und v Mittelpunkte, dann müssen auch u + v und u − v Mittelpunkte sein. Eine klassische Frage der Lattice-Theorie ist, die größtmögliche Dichte ∆, die definiert ist als Dichte: ∆ =

Volumen innerhalb der Kugeln , Volumen des Raumes

d. h. den Anteil des gesamten Raumes, der innerhalb der Kugeln liegt (vergleiche hierzu auch die Hamming-Schranke, Abschnitt 1.1.2, die dieselbe Frage für einen Code in

10.2 GC mit Blockmodulation

(2)

(s)

2

0

(3)

X0,0

X0,0,... ,0

0

4

6

4

2s − 2

8

8

1

3

5

7

2s − 1 (2) X1

2s − 4

2s−1

0

2s − 1

0 1 2 3 4 5 6 7 8

X (1) X0

431

2s−1 − 1

2s − 1 (s) X1,1,... ,1

Abb. 10.7: Partitionierung von 2s Punkten auf einer Geraden.

Hamming-Metrik beantwortet). Leider ist die Frage der größtmöglichen Dichte nur für n ≤ 8 und n = 24 gelöst [CoSl]. Die bekannte Lösung für n = 24 geht auf die Existenz des perfekten Golay-Codes (Abschnitt 4.2) zurück. Wir konstruieren einen GC-Code mit den s äußeren Codes A(i) (2; na , Ma(i) , d(i) a ),

i = 1, 2, . . . , s.

Hierzu benötigen wir eine binäre Partitionierung der Ordnung s des inneren Codes, der durch 2s Punkte auf einer Geraden definiert sein soll: X (1) (R, 2s , δ (1) = 1) = {0, 1, 2, 3, . . . , 2s − 1}. Die Partitionierung ist in Bild 10.7 dargestellt. Für die quadratischen euklidischen Mindestdistanzen der Untercodes X (i) , i = 1, . . . , s gilt: δ (i) = (2i−1 )2 ,

i = 1, 2, . . . , s.

Wir haben damit den GC-Code CGC

R ,M = na

s Y

i=1

Ma(i) , δ

! n o (i) i−1 2 ≥ min da · (2 ) i=1,...,s



konstruiert. Wir können um jedes Codewort eine Kugel mit Radius 2δ legen, die sich dann entsprechend der Definition von Lattices gerade berühren. Unter Berücksichtigung von Gleichung (10.3) ist das Volumen einer Kugel [CoSl] √ !n δ n Vn · (Radius) = Vn · , Vn : Volumen der Einheitskugel. 2 Das Volumen des ganzen Raumes, in dem alle M Codeworte (Kugeln) liegen, ist (2s )n . Damit ergibt sich die Dichte eines GC-Codes zu: √ !n M δ ∆GC ≥ s n · Vn · . (2 ) 2 Wir wollen einige Beispiele dieser Konstruktion betrachten.

432

10 Codierte Modulation

Beispiel 10.3 (Konstruktion A aus [CoSl]) Wählen wir als äußere Codes A(1) (2; n, M, d)

und

A(2) (2; n, 2n , 1)

und s = 2, so erhalten wir für die Mindestdistanz des GC-Codes δ ≥ min{1 · d, 4 · 1}. Die Dichte in Rn errechnet sich zu: !n ( √ !n ) p min{d · 1, 1 · 4} M · 2n M d ∆GC ≥ V = V min ,1 . n n (22 )n 2 2n 2 Diese Dichte ist identisch der von Konstruktion A [CoSl, S. 137]. Es ist offensichtlich, dass es keinen Sinn macht einen äußeren Code mit der Mindestdistanz d > 4 zu benutzen, da sich sonst die Dichte verschlechtert, da M mit zunehmender Distanz kleiner wird.  Beispiel 10.4 (Konstruktion B aus [CoSl]) Wählen wir wieder s = 2 und als äußere Codes A(1) (2; n, M, d)

und

A(2) (2; n, 2n−1 , 2),

so erhalten wir für die Mindestdistanz des GC-Codes δ ≥ min{1 · d, 4 · 2}. Die Dichte in Rn errechnet sich zu: !n ( √ !n ) p min{d · 1, 2 · 4} M · 2n−1 M d n/2 ∆GC ≥ Vn = n+1 Vn min ,2 . (22 )n 2 2 2 Für einen GC-Code, der gemäß Mindestdistanz optimiert ist, würden wir einen äußeren Code mit d = 8 wäh