Stimmen zu vorangegangenen Auflagen: „Beim Thema Codierung /. . ./ ist das Dankmeier-Buch immer noch eins der besten“ P...
112 downloads
2581 Views
3MB Size
Report
This content was uploaded by our users and we assume good faith they have the permission to share this book. If you own the copyright to this book and it is wrongfully on our website, we offer a simple DMCA procedure to remove your content from our site. Start by pressing the button below!
Report copyright / DMCA form
Stimmen zu vorangegangenen Auflagen: „Beim Thema Codierung /. . ./ ist das Dankmeier-Buch immer noch eins der besten“ Prof. Dr. K.-U. Witt, FH Bonn-Rhein-Sieg, Sankt Augustin
„Es ist dem Autor gelungen, die wichtigsten Fragen der Codierung umfassend darzustellen und an geschickt gewählten Beispielen anschaulich zu machen.“ Prof. Dr. Gerhardt Berendt, FU Berlin „Dieses Buch werde ich meinen Studenten empfehlen, weil es sehr umfassend ist, dabei motivierend geschrieben. Auch technische Details werden verständlich.“ Dieter Riebesehl, FH Lüneburg
„Umfassend /. . ./ übersichtliche Darstellung der Theorien zur Codierung; empfehlenswert.“ Dr. Bruno Lurz, FB efi, Nürnberg
Aus dem Bereich IT erfolgreich lernen
Lexikon für IT-Berufe von Peter Fetzer und Bettina Schneider Grundkurs IT-Berufe von Andreas M. Böhm und Bettina Jungkunz Java für IT-Berufe von Wolf-Gert Matthäus Prüfungsvorbereitung für IT-Berufe von Manfred Wünsche Grundlegende Algorithmen von Volker Heun Algorithmen für Ingenieure – realisiert mit Visual Basic von Harald Nahrstedt Grundkurs Programmieren mit Delphi von Wolf-Gert Matthäus Grundkurs Visual Basic von Sabine Kämper Visual Basic für technische Anwendungen von Jürgen Radel Grundkurs Smalltalk – Objektorientierung von Anfang an von Johannes Brauer Grundkurs Software-Entwicklung mit C++ von Dietrich May Programmieren lernen mit Java von Erwin Merker und Roman Merker Grundkurs JAVA von Dietmar Abts Aufbaukurs JAVA von Dietmar Abts Grundkurs Java-Technologien von Erwin Merker Java ist eine Sprache von Ulrich Grude Middleware in Java von Steffen Heinzl und Markus Mathes Grundkurs Computergrafik mit Java von Frank Klawonn Masterkurs Computergrafik und Bildverarbeitung von Alfred Nischwitz und Peter Haberäcker Das Linux-Tutorial – Ihr Weg zum LPI-Zertifikat von Helmut Pils Rechnerarchitektur von Paul Herrmann Grundkurs Relationale Datenbanken von René Steiner Grundkurs Datenbankentwurf von Helmut Jarosch Datenbank-Engineering von Alfred Moos Grundkurs Datenbankentwicklung von Stephan Kleuker Grundlagen der Rechnerkommunikation von Bernd Schürmann Netze – Protokolle – Spezifikationen von Alfred Olbrich
www.vieweg.de
Grundkurs Computernetze von Jürgen Scherff Grundkurs Verteilte Systeme von Günther Bengel Grundkurs Mobile Kommunikationssysteme von Martin Sauter Grid Computing von Thomas Barth und Anke Schüll Grundkurs Wirtschaftsinformatik von Dietmar Abts und Wilhelm Mülder Grundkurs Theoretische Informatik von Gottfried Vossen und Kurt-Ulrich Witt Anwendungsorientierte Wirtschaftsinformatik von Paul Alpar, Heinz Lothar Grob, Peter Weimann und Robert Winter Business Intelligence – Grundlagen und praktische Anwendungen von Hans-Georg Kemper, Walid Mehanna und Carsten Unger IT-Projekte strukturiert realisieren von Ralph Brugger Grundkurs Geschäftsprozess-Management von Andreas Gadatsch Prozessmodellierung mit ARIS ® von Heinrich Seidlmeier Logistikprozesse mit SAP R/3® von Jochen Benz und Markus Höflinger ITIL kompakt und verständlich von Alfred Olbrich BWL kompakt und verständlich von Notger Carl, Rudolf Fiedler, William Jórasz und Manfred Kiesel Grundkurs Mediengestaltung von David Starmann Grundkurs Web-Programmierung von Günter Pomaska Web-Programmierung von Oral Avcı, Ralph Trittmann und Werner Mellis Grundkurs MySQL und PHP von Martin Pollakowski Grundkurs SAP R/3® von André Maassen und Markus Schoenen Controlling mit SAP ® von Gunther Friedl, Christian Hilz und Burkhard Pedell SAP ®-gestütztes Rechnungswesen von Andreas Gadatsch und Detlev Frick Kostenträgerrechnung mit SAP R/3® von Franz Klenger und Ellen Falk-Kalms Masterkurs Kostenstellenrechnung mit SAP® von Franz Klenger und Ellen Falk-Kalms Masterkurs IT-Controlling von Andreas Gadatsch und Elmar Mayer Grundkurs Codierung von Wilfried Dankmeier
Wilfried Dankmeier
Grundkurs Codierung Verschlüsselung, Kompression, Fehlerbeseitigung Mit 92 Abbildungen 3., überarbeitete und erweiterte Auflage
Bibliografische Information Der Deutschen Nationalbibliothek Die Deutsche Nationalbibliothek verzeichnet diese Publikation in der Deutschen Nationalbibliografie; detaillierte bibliografische Daten sind im Internet über abrufbar.
Das in diesem Werk enthaltene Programm-Material ist mit keiner Verpflichtung oder Garantie irgendeiner Art verbunden. Der Autor übernimmt infolgedessen keine Verantwortung und wird keine daraus folgende oder sonstige Haftung übernehmen, die auf irgendeine Art aus der Benutzung dieses ProgrammMaterials oder Teilen davon entsteht. Die Wiedergabe von Gebrauchsnamen, Handelsnamen, Warenbezeichnungen usw. in diesem Werk berechtigt auch ohne besondere Kennzeichnung nicht zu der Annahme, dass solche Namen im Sinne von Warenzeichen- und Markenschutz-Gesetzgebung als frei zu betrachten wären und daher von jedermann benutzt werden dürfen. Höchste inhaltliche und technische Qualität unserer Produkte ist unser Ziel. Bei der Produktion und Auslieferung unserer Bücher wollen wir die Umwelt schonen: Dieses Buch ist auf säurefreiem und chlorfrei gebleichtem Papier gedruckt. Die Einschweißfolie besteht aus Polyäthylen und damit aus organischen Grundstoffen, die weder bei der Herstellung noch bei der Verbrennung Schadstoffe freisetzen.
1. Auflage 1994 2. Auflage 2001 Diese Auflagen erschienen unter dem Titel „Codierung“ 3., überarbeitete und erweiterte Auflage August 2006 Alle Rechte vorbehalten © Friedr. Vieweg & Sohn Verlag | GWV Fachverlage GmbH, Wiesbaden 2006 Lektorat: Günter Schulz / Andrea Broßler Der Vieweg Verlag ist ein Unternehmen von Springer Science+Business Media. www.vieweg.de
Das Werk einschließlich aller seiner Teile ist urheberrechtlich geschützt. Jede Verwertung außerhalb der engen Grenzen des Urheberrechtsgesetzes ist ohne Zustimmung des Verlags unzulässig und strafbar. Das gilt insbesondere für Vervielfältigungen, Übersetzungen, Mikroverfilmungen und die Einspeicherung und Verarbeitung in elektronischen Systemen.
Konzeption und Layout des Umschlags: Ulrike Weigel, www.CorporateDesignGroup.de Umschlagbild: Nina Faber de.sign, Wiesbaden Druck- und buchbinderische Verarbeitung: MercedesDruck, Berlin Printed in Germany ISBN-10 3-528-25399-1 ISBN-13 978-3-528-25399-8
Vorwort Unsere besten Freunde
Das PasswortElend
Vertrauen ist gut….
Kompressor
Ganzzahlen – ganz stark
Jawohl, sie haben es nicht leicht! Unsere HighTech-Partner Handy, CD/MP3-Player, PC, LANs, WANs und alle die anderen. Klar, dass sie die ihnen anvertrauten Daten und Informationen mit größter Sorgfalt behandeln müssen und nicht die kleinste Verfälschung daran zulassen dürfen. Und das, obwohl ihnen fortwährend üble Störungen das Leben vergällen und schlimme Fehler erzeugen! Wenn dem tatsächlich so ist – wie – werden Sie sich vielleicht fragen, gelingt es dann doch, unsere hohen Ansprüche zu erfüllen? Zum Beispiel: Ist Ihnen manchmal nicht unwohl, dass Sie die vielen verschiedenen Passwörter und PINs für Ihre Euroscheckkarte, Ihren Internet-Provider, fürs Homebanking, für den Zugang zum PC-Netz Ihrer Firma, zu Ihrem Notebook, für Ihr Autoradio usw. immer im Gedächtnis behalten müssen, weil Sie diese Passwörter natürlich nirgendwo aufschreiben – sicherheitsbewusst wie Sie sind? Oder: Hätten Sie nicht gern gewusst, ob Sie Ihrer Bestellung im Internet – vielleicht nicht von vorn herein – aber doch wenigstens prinzipiell trauen können? Überhaupt: Wer gibt uns eigentlich die Sicherheit, dass ein digitales Bild oder eine elektronisch veröffentlichte Einnahmevorschrift für ein Medikament nicht unerkannt und absichtlich verfälscht wurden? Und schließlich: Eine Freundin übergibt Ihnen auf einer der guten alten Disketten (sie ist doch sonst nicht so vergruftet ….?) die neueste Version ihres Buchmanuskriptes zur kritischen Durchsicht vor Übergabe an den Verlag. Es hat mittlerweile einen Umfang von mehr als 4 Millionen Zeichen. Auf Ihren Einwand, dass so eine Diskette doch nur etwa 1,4 Millionen Zeichen fasst, lächelt sie überlegen, murmelt etwas von „Zippen auf weniger als die Hälfte“ und „Sie sollten sich lieber auf das Lesen konzentrieren“. Sind Sie jetzt nicht voller Zweifel, ob das mit rechten Dingen zugeht? Auf den folgenden Seiten werden Sie Antworten auf solche und ähnliche Fragen finden. Das Fachgebiet, mit dem wir uns dabei auseinander setzen, ist das der Codierungsverfahren und umfasst die Aufgaben der Datenfehlerbeseitigung, der Verschlüsselung und der Verdichtung (oder Kompression). Manches, was wir dabei entdecken, wird Sie vielleicht verblüffen, vor allem schon deshalb, weil wir oft nur mit ganzen Zahlen arbeiten. Vermutlich
V
Vorwort
Freie Wahlen
Checkpoint
Power satt
VI
haben Sie bisher kaum geahnt, was für erstaunliche Leistungen man aus diesen simplen „Dingern“ herausholen kann. Sie müssen dabei nicht unbedingt von vorn anfangen. Steigen Sie ruhig dort ein, wo es Ihnen vernünftig erscheint, und gehen Sie zurück, wenn Sie noch grundlegende Informationen benötigen. Einige Hilfen finden Sie besonders in den Kapiteln 1.3 (Einige Begriffe aus der Informations- und Nachrichtentechnik) und 2 (Mathematische Grundlagen). Für einen schnellen Überblick ist der Schnupperkurs in Kapitel 1.2 gedacht. Jedes Codierungsverfahren wird im Text anhand eines ausführlichen Beispiels erläutert. Dort, wo sich lästige Rechnerei (oder auch Nach-Rechnerei) nicht vermeiden lässt, ist es sehr zu empfehlen, sich das Leben durch Benutzung kleiner, selbst entwickelter Hilfsprogramme zu erleichtern. Der angenehme Nebeneffekt liegt darin, dass man bei Programmerstellung und Austesten sein Verfahrensverständnis oft gewaltig verbessert. Der eingesetzte Rechnertyp (Taschenrechner, PC usw.) und die Programmiersprache ist dabei ziemlich egal, denn es geht hier nicht um ausgefeilte, optimierte Abläufe für den praktischen Einsatz. Sehr gut eignen sich übrigens Programme in der Sprache C oder C++. Gute Compiler mit Entwicklungsumgebungen für Windows gibt es dafür kostenfrei z. B. unter www.bloodshed.com. Wenn Sie wollen, beantworten Sie doch die jeweils nach der Behandlung eines in sich geschlossenen Teilgebietes gestellten Fragen („Was blieb?“). Vielleicht helfen sie Ihnen, eventuelle „Verständnishänger“ aufzuspüren – falls diese überhaupt noch vorhanden sind. Die drei behandelten Teilgebiete der Codierung werden in aller Welt ständig und intensiv weiterentwickelt. Eine der Gründe liegt in der starken Nachfrage nach besseren und neuen Leistungen der Informations- und Kommunikationstechnik (was hierbei „besser“ bedeuten soll, geht weit über den technischen Aspekt hinaus und ist zu Recht Gegenstand kontroverser Diskussionen). Hier spielt u. a. das Internet eine wesentliche Rolle. Die Folge: Dauernd gibt es veränderte, verbesserte oder sogar prinzipiell neue Lösungswege für vorhandene Aufgabenstellungen, an denen sich die unterschiedlichsten Marktdisziplinen beteiligen: Mathematiker, Physiker, Ingenieure, Informatiker, Biologen, Mediziner, Wirtschaftswissenschaftler, Medienspezialisten usw. Dementsprechend groß und vielfältig ist die Zahl der Veröffentlichungen. Das vorliegende Buch kann – hoffentlich – einen Eindruck der heute (Juni 2006) aktuellen Verfahren und Begriffe vermitteln und liefert damit eine Grundlage, auf der bei Bedarf mit zusätzlichen Studien aufgebaut werden kann oder auch muss. Als Ergänzung und zur Aktualisierung lohnt es sich auf jeden Fall,
Hand anlegen
im Internet nach weiterem „Material“ zu suchen. Sehr zu empfehlen ist eine Anfrage an eine der zahlreichen Suchmaschinen, z. B. mit den Begriffen „Error Correction Code“, „Turbo Produktcode“, „public key“, „fiat shamir“, „zero knowledge protocol“, „Data Kompression“, „LZW“, „Fourier-Transformation“, „jpeg“, „wavelet“, um nur einige ganz wenige Beispiele zu nennen. Versuchen Sie's mal! Es macht Spaß und man findet manches Nützliche dabei. Die Lektüre der in diesem Buch behandelten Themen – auch einzelner – wird Ihnen helfen, die oft überwältigend umfangreichen, bunt gemischten Ergebnislisten auf Ihre Suchanfragen besser bewerten und gebrauchen zu können. Und wenn Sie doch einmal verzweifeln, steuern Sie die unten genannte Adresse an. Der Stein der Weisen ist dort zwar nicht versteckt, aber vielleicht greifen Sie einen der berühmten Strohhalme, um dem Sumpf zu entrinnen.
Und nun viel Vergnügen! Eppstein im Taunus, Juni 2006
www.vkfco.de
*)
Wilfried Dankmeier
*)
... auch eine Codierung, ... aber welche?
VII
Inhaltsverzeichnis 1 Aufgabenstellung und Ziel.......................................................................................... 1 1.1 Beispiele für Codes......................................................................................................... 1 1.2 Ein Schnupperkurs.......................................................................................................... 4 1.2.1 Verschlüsselung........................................................................................................ 6 1.2.2 Fehlerbeseitigung...................................................................................................... 7 1.2.3 Kompression........................................................................................................... 11 1.3 Begriffe aus der Informations- und Nachrichtentechnik............................................. 12 1.4 Aufgabenstellung........................................................................................................... 21 1.5 Ziel.................................................................................................................................. 28 1.6 Was blieb?...................................................................................................................... 29 2 Mathematische Hilfsmittel........................................................................................ 31 2.1 Grundlagen aus der allgemeinen Ingenieurmathematik............................................. 31 2.2 Weitere mathematische Hilfsmittel............................................................................... 34 2.3 Was blieb?...................................................................................................................... 48 3 Fehlerbeseitigung...................................................................................................... 49 3.1 Der Prozess der Fehlerentstehung................................................................................ 49 3.2 Die Prüfstellen: Notwendige und hinreichende Bedingungen................................... 52 3.3 Direkte Nutzung des Hammingabstandes ................................................................... 55 3.4 Hamming-Code.............................................................................................................. 56 3.4.1 Aufbau, Codierung und Hard Decision-Decodierung.......................................... 56 3.4.2 Generatormatrix G.................................................................................................. 60 3.4.3 Paritätsprüfmatrix H................................................................................................ 61 3.4.4 Syndrom und Fehlerposition bei HD-Decodierung.............................................. 62 3.4.5 Soft Decision-Decodierung.....................................................................................64 3.4.6 Technischer Gebrauch des Hamming-Codes........................................................ 65 3.4.7 Was blieb?............................................................................................................... 66 3.5 Leistungsbeurteilung von Codes................................................................................... 67 3.5.1 Beschreibung fehlerbehafteter Übertragungssysteme........................................... 67 3.5.2 Verteilung der Fehler auf die Codeworte.............................................................. 70 3.5.3 Einfluss der Informationsrate auf die Übertragungsrate....................................... 73 3.5.4 Kriterien: asymptotisches Verhalten bei langen Codes........................................ 76 3.5.5 Ein Beispiel............................................................................................................. 78
IX
Inhaltsverzeichnis 3.5.6 Grenzen: Das Theorem von Shannon................................................................... 82 3.5.7 Was blieb?............................................................................................................... 93 3.6 Erweiterungen des Hamming-Verfahrens.................................................................... 93 3.6.1 Verallgemeinerung auf andere Ganzzahlbasen.................................................... 93 3.6.2 Erweiterung um zusätzliche Fehlererkennung...................................................... 97 3.6.3 Was blieb?.............................................................................................................. 101 3.7 Zyklische Codes........................................................................................................... 101 3.7.1 Der Weg und die Mittel: Generatorpolynome und Reste...................................101 3.7.2 Bildung der Codewörter....................................................................................... 103 3.7.3 Generatorpolynom, irreduzible Polynome und Dekodierung........................... 111 3.7.4 Generatorpolynome für Mehrbitfehler-Korrektur............................................... 115 3.7.5 Eignungstest für g(x) zur t-Bitfehlerkorrektur..................................................... 117 3.7.6 Irreduzible Polynome über Z2 und Galoisfelder GF(2m).................................. 120 3.7.7 BCH-Code.............................................................................................................. 125 3.7.8 Reed-Solomon-Code für Mehrfach-Bündelfehler-Korrektur............................... 142 3.7.9 Vergleich zwischen BCH- und Reed-Solomon-Codes........................................ 153 3.7.10 Erkennung von Fehlerbündeln........................................................................... 155 3.7.11 Was blieb?............................................................................................................. 160 3.8 Goppa-Code................................................................................................................. 161 3.8.1 Erzeugung der Codewörter .................................................................................. 161 3.8.2 Zwei Lösungswege für die Decodierung.............................................................. 170 3.8.3 Der BCH-Code als Sonderfall des Goppa-Codes ................................................ 182 3.9 Reed-Muller-Code......................................................................................................... 192 3.10 Interleaving................................................................................................................ 203 3.11 Produkt-Codes........................................................................................................... 205 3.12 Maximum a Posteriori-Prinzip und Turboprodukt-Codes....................................... 212 3.13 Faltungs-Codes (Convolutional Codes).................................................................... 225 3.14 Was blieb?.................................................................................................................. 234 4 Rückgekoppelte Schieberegister............................................................................ 235 4.1 4.2 4.3 4.4
Eigenschaften............................................................................................................... 235 Fehlerbeseitigung durch Kreuzkorrelation................................................................. 249 Zufallserzeugung von Schlüsselwörtern..................................................................... 251 Was blieb?.................................................................................................................... 261
5 Datenverschlüsselung............................................................................................. 263 5.1 5.2 5.3 5.4 5.5 5.6 5.7
X
Datenverschlüsselung zur Informationssicherung..................................................... 264 Verschlüsselung nach dem Data-Encryption-Standard (DES)................................... 266 Verschlüsselung mit dem RSA-Algorithmus............................................................... 278 Das Rechnen mit großen Ganzzahlen........................................................................ 286 Erzeugung großer Pseudoprimzahlen........................................................................ 289 Was blieb?.................................................................................................................... 294 Verschlüsselung mit Hilfe des Goppa-Codes ............................................................295
5.8 5.9 5.10 5.11 5.12 5.13 5.14 5.15
Ansätze zur Suche nach Schwachstellen................................................................... 299 Verfahren zum Austausch von Schlüsseln (Diffie-Hellmann).................................. 301 Nachweis der Berechtigung (Benutzer-Authentikation).......................................... 303 Nachweis der Unversehrtheit einer Nachricht......................................................... 308 Nachweis der Absenderidentität (digitale Unterschrift, DSA)................................. 314 Hinweise zu PGP und GnuPG.................................................................................. 317 Weitere Entwicklungen, Quantenkryptographie..................................................... 318 Was blieb?.................................................................................................................. 322
6 Datenkompression.................................................................................................. 323 6.1 Verlustfreie Kompression............................................................................................ 323 6.1.1 Lauflängen-Codierung (Run Length Encoding = RLE)........................................323 6.1.2 Huffman- und Fano-Codierung............................................................................ 325 6.1.3 Lempel-Ziv-Welch-Codierung (= LZW-Codierung)............................................. 329 6.1.4 Arithmetische Codierung...................................................................................... 333 6.1.5 Was blieb?.............................................................................................................. 336 6.2 Verlustbehaftete Kompression.................................................................................... 337 6.2.1 Wesentliche Einspar-Potenziale........................................................................... 337 6.2.2 Fourier-Transformationen..................................................................................... 339 6.2.3 JPEG....................................................................................................................... 357 6.2.4 MPEG..................................................................................................................... 362 6.2.5 Konkurrenz: Fraktale und Wavelets ................................................................... 372 6.2.6 Was blieb?.............................................................................................................. 378 7 Literaturauswahl....................................................................................................... 379 8 Sachwortverzeichnis.................................................................................................381
XI
1
Aufgabenstellung und Ziel Zwei Fragen gleich zu Anfang: Welche „Objekte“ werden wir ins Visier nehmen? Was soll am Ende erreicht sein? Die Antwort lässt sich leichter finden, wenn wir uns im ersten Kapitel zunächst ein paar Beispiele ansehen. Der darauf folgende Schnupperkurs wird die drei Objekte „Fehlerbeseitigung“, „Verschlüsselung“ und „Kompression“ grob eingrenzen. Und schließlich verschaffen wir uns – aufbauend auf einigen Begriffen der Nachrichtentechnik – Klarheit über das Ziel dieses Grundkurses.
1.1
Morsecode
Beispiele für Codes Wenn wir unsere Mitmenschen auffordern, Beispiele für Codes und deren Verwendungszwecke zu nennen, so werden wir vermutlich eine ganze Reihe richtiger Antworten bekommen, da der Gebrauch von Codes für viele zum Alltag gehört. Das Ergebnis könnte sein: Funker ordnen mit Hilfe des Morsecodes den Zeichen des natürlichen Alphabets Codewörter aus kurzen und langen Signalen zu. Damit lassen sich Textzeichen per Morsetaste in elektrische Signale umwandeln, die über Funk an den Empfänger übermittelt und dort in akustische Tonfolgen umgesetzt werden. Der abhörende Mensch kann diese Tonfolgen, falls er ihre Bedeutung gelernt (und geübt) hat, in den Ausgangstext zurück wandeln. Der Morsecode weist sogar schon zwei bemerkenswerte Leistungsmerkmale auf: Einmal gestattet er auch unter schwierigen Funkempfangsbedingungen (Rauschen wegen geringer Empfangsfeldstärken oder starker Störungen) noch eine ausreichende Erkennbarkeit, zum anderen ist er Aufwands- oder Entropie-optimiert, d. h., den häufiger vorkommenden Buchstaben sind die kürzeren Codewörter zugeordnet. Der Buchstabe "e" besteht nur aus einem einzigen kurzen, der Buchstabe "t" aus einem einzigen langen Signal, "q" aber aus zwei langen, einem kurzen und einem langen Signal. Nimmt man Punkte und Striche zur Darstellung zu Hilfe, so ergeben sich die bekannten Abbildungen, z. B.: e wird zu "." t wird zu "-" q wird zu " --.- "
1
1 Aufgabenstellung und Ziel
ISBN-Code
Strichcode
ASCII-Code
2
Daneben gibt es im Funkverkehr noch weitere Codes, die ihrerseits mit Morsezeichen übertragen werden, z. B. die Q-Gruppen. Vom Wetterbericht der Nachrichten etwa kennt man die akustische Zeichenfolgen "QAM", welche im internationalen Funkverkehr "der Wetterbericht vom ... um ... lautet ...“ bedeutet. Tatsächlich spielt neben den beiden Darstellungsformen "kurzes" und "langes" Signal auch die Pause als Trennzeichen eine wesentliche Rolle, im allgemeinen ist ein solches Sonderzeichen bei Codes mit variabler Wortlänge aber nicht erforderlich, wie wir z. B. beim Huffman-Code in Unterkapitel 6.1.2 sehen werden. Genetische Codes sorgen für die Speicherung und Übertragung von Erbanlagen. Farbcodes auf einem Urin-Teststreifen helfen beim Nachweis bestimmter chemischer Stoffanteile, z. B. für Diabetiker. Der ISBN-Code dient der eindeutigen Identifizierung von Büchern und Schriften. Er besteht aus 10 Stellen (ist also ein Blockcode), in deren Folge zur besseren Lesbarkeit Bindestriche eingefügt sind, wie etwa beim ISBN-Code zum vorliegenden Buch. Jede Stelle wird aus 11 Symbolen gewählt, welche aus den Ziffern 0,1,2,...,9 und X (entspricht "10", siehe auch Kapitel 7 bei der Literaturangabe zu Heider, Kraus, Welschenbach) bestehen. Die erste Stelle gibt den Landescode des Verlags an, die zweite bis vierte (oder zweite bis dritte) den Verlagscode selbst, die fünfte bis neunte (oder vierte bis neunte) die verwaltungsinterne Nummerierung des Buches, die zehnte schließlich ist eine Stelle, mit der die ersten neun Ziffern geprüft werden. Dazu multipliziert man die erste Stelle mit 10, die zweite mit 9, die dritte mit 8 usw., addiert alles und ergänzt die Prüfstelle (die zehnte) so, dass die Gesamtsumme durch 11 teilbar ist. Dieses Vorgehen stellt übrigens einen Grundtyp dar, wie man ihn bei sehr vielen anderen Codes wieder findet. Strichcodes kennzeichnen Artikel in einem Supermarkt. Hier gibt es eine Fülle von standardisierten Varianten. Eine davon ist z. B. der EAN-Code ( EAN = Europäische Artikel-Nummerierung) in wiederum verschiedenen Ausführungen. Der EAN-13-Code etwa ist ganz ähnlich aufgebaut wie der ISBN-Code, besteht also aus einer Kennziffer, einer Betriebs- und Herstellernummer, einer Warenkennzeichnungsnummer und einer Prüfziffer. Der ASCII-Code stellt Schriftzeichen in binärer, dezimaler oder hexadezimaler Form dar (ASCII = American Standard Code for Information). Er ist ein Blockcode, d. h., alle Codewörter haben die gleiche Länge, in diesem Fall sind es 8 Binärstellen. Damit lassen sich 28 = 256 verschiedene Codewörter bilden, die den Buchstaben des Alphabets, den Ziffern, den Satz- und Steuerzeichen und diversen Sonderzeichen zugeordnet werden.
1.1 Beispiele für Codes Geheimcode
IEC-Farbcode
Geheimcodes verschlüsseln in vielen privaten, öffentlichen, wirtschaftlichen und militärischen Bereichen vertrauliche Informationen, die dann nur für Berechtigte lesbar sein sollen. CRC-Codes ermöglichen in der Kommunikationstechnik eine Fehlererkennung an übertragenen Daten (CRC = Cyclic Redundancy Check). Sie sind oft Bestandteil des so genannten Trailers eines Datenpakets und stellen – etwa als CRC-16-Standard – sicher, dass die durch Kanalstörungen entstandenen zusammenhängenden Fehlerbündel bis zur Länge von 16 Bit erkannt werden. Das Verfahren wird in Unterkapitel 3.7.10 erläutert. IEC-Farbcodes dienen Elektronikern zur Kennzeichnung elektrischer Widerstandswerte. Sie bestehen meistens aus vier Farbringen, wobei die ersten drei den Ohm-Wert selbst, der vierte Ring die Toleranz angeben. So verbirgt sich z. B. hinter der Kennzeichnung "Rot-Rot-Orange-Gold" die Aussage, dass ein Widerstand mit dem Wert 22 (=Rot-Rot) multipliziert mit 103 (= Orange) = 22 KOhm und einer Fertigungstoleranz von 5% (= Gold) vorliegt. Kompressionscodes helfen Internet-Surfern beim Einsparen von Übertragungs- und Speicherkosten mit Hilfe von z. B. " .zip"-Dateien für Texte und Grafiken oder MP3-Files für Musik. Mit solchen Codes wird die "Platz fressende" so genannte Redundanz von Informationsmengen verkleinert. Redundanz ist übrigens eine ganz grundlegende Eigenschaft von Informationen. Redundanz bedeutet, dass eine Informationsmenge (z. B. ein Text in einer natürlichen Sprache) mehr Platz (mehr Wörter) beansprucht, als zur Darstellung der Kerninformation eigentlich notwendig wäre. Das erscheint zunächst als überflüssig, kann aber sehr nützlich sein, wenn Redundanz gezielt eingesetzt wird. Überhaupt ist die Beseitigung von Datenfehlern nur möglich, wenn die Redundanz in einer Informationsmenge systematisch erhöht wird. Wenn man nun versucht, anhand dieser Beispiele einige Eigenschaften von Codes zu finden, so ergeben sich vielleicht folgende Beobachtungen: ¡
Jeder Code bildet eine endliche Informationsmenge (z. B. das natürliche Alphabet) von einer ursprünglichen Darstellungsform in eine neue Form ab.
¡
Jeder Code dient einem ganz bestimmten Zweck (oder auch mehreren zugleich), o der preiswerten Übertragung von Informationen, um diese mit möglichst wenig "Brutto-Bits" senden zu können (die TELEKOM verdient vermutlich eher an den übertragenen Info-Bits als an den Prüfstellen),
3
1 Aufgabenstellung und Ziel der störungsunempfindlichen Übertragung von Informationen, damit eine möglichst fehlerfreie Übermittlung garantiert ist (dies erwartet der Kunde eines Übertragungsdienstes als selbstverständliche Leistung), o der sowohl kompakten als auch sicheren Speicherfähigkeit von Informationen, wobei ersteres geringere Speicherkosten, letzteres größere Zuverlässigkeit mit sich bringt, o der einfachen Verständlichkeit für einen großen Personenkreis auch über Sprachgrenzen hinweg, wie beim Morsecode oder Barcode, o der möglichst großen – genauer gesagt vollkommenen – Unverständlichkeit für nicht befugte Personen, wie beim Geheimcode. Von den theoretisch denkbaren Codes werden daher nur diejenigen einer genaueren Betrachtung wert sein, bei denen der Aufwand für Codierung und Decodierung in einem vertretbaren Verhältnis zum erwarteten Nutzen steht. Der jeweilige Zweck bestimmt also ganz wesentlich die Auswahl eines Codes. Man kann nun bereits versuchen, eine allgemeine – und damit leider auch abstrakte – Definition für Codes zu finden: Ein Code entsteht durch die Abbildung eines Quellenalphabets in ein Codealphabet, wobei das Codealphabet ganz bestimmte gewünschte Eigenschaften aufweist, die das Quellenalphabet nicht hat. Die Abbildung selbst muss umkehrbar eindeutig sein, damit die durch die Codierung veränderte Form der Informationsdarstellung wieder die ursprüngliche Gestalt annehmen kann. Die Abbildungsvorschriften sind die Codierungsverfahren. o
Code-Definition
Das Quellenalphabet kann dabei ein wirkliches Sprachalphabet, aber genauso gut eine völlig abstrakte Informationsmenge sein. Wenn man zum Beispiel die elektronische Post zum Übertragen von Textdokumenten nutzen will, so wandelt (codiert) ein Anwendungsprogramm auf dem PC den Text in abstrakte Pakete von Bitfolgen, ergänzt diese durch Steuerinformationen, führt die Übertragung durch, entfernt die Steuerinformationen und decodiert schließlich die Kerninformation wieder in den Ausgangstext.
1.2
Ein Schnupperkurs Damit erkennbar wird, was uns bei den drei genannten Gebieten der Codierung erwartet, sehen wir uns ein Beispiel an. Es handelt sich um das Grundmotiv des berühmten Erzherzog-Jo-
4
1.2 Ein Schnupperkurs hann-Jodlers, also jenes literarische Kleinod alpenländischer Volkskunst, das Loriot so feinsinnig in seiner "Jodelschule" verwendet: holleri, di dudl jö, diridi di dudl dö, hollera di dadl do, holleri du dödl di, diri diri dudl dö Man kann sich vorstellen, dass – je nach Aufgabe und Interessenlage 3 Grundaufgaben ¡
dieser wertvolle Text auf jeden Fall unverfälscht übertragen und gespeichert werden muss
¡
das Original zunächst als Geheimnis gehütet und daher verschlüsselt aufbewahrt wurde
der Jodler möglichst kompakt aufgeschrieben werden, also mit einem Minimum an "Speicherplatz" auskommen sollte – natürlich ohne dabei den Inhalt zu verändern. Schließlich können auch Kombinationen dieser drei Aufgaben erwünscht sein. Damit der Text für unsere Zwecke einfach – und dennoch ohne Beschränkung der Allgemeinheit – behandelt werden kann, wird er so codiert, wie es auch im PC geschieht, nämlich als Folge von ASCII-Zeichen. Diese Zeichen sind international genormt und als eindeutige Kombination von 8 Nullen und Einsen, den Bits, dargestellt. Eine Tabelle enthält also genau 28 = 256 verschiedene Zeichen. Man bezeichnet diese auch als Codewörter. Ein Auszug ist in Tabelle 1.1 zu sehen Die Zeichen unterscheiden sich in wenigstens einer Stelle, maximal in 8 Stellen. Die Anzahl der unterschiedlichen Stellen heißt Hammingabstand d, der kleinste Wert, der im gesamten Code vorkommt, ist der Mindestabstand dmin. Ein brauchbarer Code muss einen Mindestabstand von 1 für jedes Zeichen gegen jedes andere aufweisen, sonst könnte man einzelne Zeichen (= Codewörter) nicht unterscheiden. Die Darstellung mit Null- und Eins-Elementen hat sich als besonders brauchbar erwiesen, weil die Zuordnung dieser beiden Werte zu technischen Zuständen wie „0 entspricht einer niedrigen elektrischen Spannung“ ¡
Abstand halten
Wertvolle Nullen und Einsen
„1 entspricht einer hohen elektrischen Spannung“ oder auch „0 entspricht einem niedrigen Ton“ „1 entspricht einem hohen Ton“ einfach ist.
5
1 Aufgabenstellung und Ziel Nr. 1 2 3 4 5 6 7 8 9 10 11 12
Zeichen a b c d e f g h i j k l
Bitfolge 0110 0001 0110 0010 0110 0011 0110 0100 0110 0101 0110 0110 0110 0111 0110 1000 0110 1001 0110 0010 0110 1011 0110 1100
Nr.
Zeichen m n o p q r s t u v w x
13 14 15 16 17 18 19 20 21 22 23 24
Bitfolge
Nr.
0110 1101 0110 1110 0110 1111 0111 0000 0111 0001 0111 0010 0111 0011 0111 0100 0111 0101 0111 0110 0111 0111 0111 1000
25 26 27 28 29 30 31 32 33 34 35 36
Zeichen y z ä ö ü ZWR ! ? , . : ;
Bitfolge 0111 1001 0111 0010 1110 0100 1111 0110 1111 1100 0101 1111 0010 0001 0011 1111 0010 1100 0010 0111 0011 1011 0011 1011
Tabelle 1-1: Einige ASCII-Zeichen Die ersten 8 der insgesamt 100 Zeichen des Erzherzog-JohannJodlers bilden als ASCII-Codewörter die 0/1-Folge h
o
l
l
e
r
i
ZWR
01101000
01101111
01101100
01101100
01100101
01100101
01101001
01011111
Trennzeichen zwischen den Codewörtern sind nicht erforderlich, da nach 8 Bits jeweils das erste Bit des nächsten Wortes beginnt.
1.2.1
Verschlüsselung Die erste Aufgabe ist die Verschlüsselung. Hier soll die Nachricht holleri di dudl dö.... nur einem bestimmten Personenkreis bekannt gegeben werden. Ein einfaches Verfahren, das viele als Kinderspiel verwendet haben, besteht in der zyklischen Verschiebung jedes Klartextzeichens um eine feste Positionszahl, dem Schlüssel, in der ASCII-Tabelle. Wählt man dazu etwa die Anzahl 7, so entsteht der Geheimtext ovsslyppakösaq;daakpypkpakpaköksak;daaovsslyhakpakhksakvdaaovsslypaköak;ksakpdaakpypakpypaköksak;
... bis zur Unkenntlichkeit
6
wobei hier zur Übersichtlichkeit die „kurze“ ASCII-Tabelle 1-1 von zuvor verwendet wurde. Wenn der Klartext aus der natürlichen Sprache stammt, ist diese Verschlüsselung so gut wie unbrauchbar, da die bekannte Häufigkeitsverteilung der Zeichen nicht verändert wird. Dies ist schon optisch an den sich wiederholenden Zeichenmustern zu erkennen. Man benötigt also den Schlüssel gar nicht, um aus dem Geheimtext wieder den Klartext zu machen. Eine wesentliche Verbesserung lässt sich erreichen, wenn jedes Zeichen um einen anderen, zufällig gewählten Positionswert (eine Zufallszahl) verschoben wird. Der Schlüssel ist dann zwar genauso lang wie der Klartext, aber man hat die charakteristische
1.2 Ein Schnupperkurs Häufigkeitsverteilung der Zeichen beseitigt. Ein solcher Schlüssel wäre z. B.: 14,8,31,10,6,23,15,30,4,11,33,25,15,21,16,22,3,20,13,20,31,6,32,21 ,12,30,22,1,26,13,26,30,2,5,32,9,33,7,25,2,0,36,27,12,18,1119,29,1, 11,25,29,15,30,2,10,36,36,6,19,7,... usw. Der Geheimtext sieht damit so aus: vwgvkexxhtäü:yöpmljnyjecu.!! vt.wihca;vn ;ä wxkbeübi.cnl mq!!y..fs,nu,übaxl?jf.kfbapecgm!ür,cjs
Perfekte Verschlüsselung
1.2.2
j.dk
Die zusammenhanglos erscheinende Zeichenfolge ist hier nicht entscheidend, dieser Eindruck kann bei konstanter Verschiebung auch entstehen. Der "Knackpunkt" liegt vielmehr in der nun flachen, und vor allem nicht mehr eindeutig umkehrbaren Häufigkeitsverteilung, die kaum noch Rückschlüsse auf statistische Charakteristiken des Klartextes erlaubt. So wird das dritte Klartextzeichen von links, das „l“, als „g“ verschlüsselt, das vierte, auch ein „l“, aber als „v“, das sechzehnte, wieder ein „l“, nun als „p“ und so weiter. So einfach es aussieht, ist dieses Verfahren doch ein Referenzmodell für so genannte perfekte Verschlüsselungen. Es wurde von dem Amerikaner Gilbert S. Vernam als one time pad eingeführt, weil die einzelnen Schlüssel so erscheinen, als ob sie hintereinander auf einem Zettelblock stehen. Dieser wird dann einmal kopiert und an den Partner übergeben, der die Zahlen vom Geheimtext wieder abzieht und damit den Klartext erhält. Hierin liegt allerdings auch ein großer Nachteil für den praktischen Einsatz. Der Schlüssel ist genauso lang, wie der Klartext selbst, das Verfahren wird damit sehr aufwändig. Im übrigen ist die Verschlüsselung als Codierung eines Klartextes in einen Geheimtext heute nur eine von weiteren wichtigen Aufgaben, ohne deren Ergebnisse keine durchgängige Informationssicherheit erreicht werden kann. Hierzu gehören z. B. der sichere Schlüsselaustausch, die Unveränderbarkeit von Dokumenten, die elektronische Unterschrift usw. Gerade die letzteren beiden haben wegen der Abwicklung von Geschäftsprozessen über das Internet einen erheblichen Stellenwert erhalten.
Fehlerbeseitigung Nun zur zweiten Aufgabe, der unverfälschten Übertragung und Speicherung dieser 800 Bits. Es kann vorkommen, dass einzelne Bits in den jeweils anderen Wert ”kippen”, etwa deswegen, weil für einen kurzen Moment eine Störspannung auf die Leitung einwirkt oder die Magnetisierung an dieser Stelle der Speicherplatten-Oberfläche nicht funktioniert. Wenn dies das Bit 29 trifft (fett kursiv), wird aus "holleri" ... die Folge "holderi"..., was in
7
1 Aufgabenstellung und Ziel unserem Fall natürlich zu einem unverzeihlichen Stilbruch führt. Aber ein ”Ungläubiger” würde das nicht merken. Eine sehr einfache Maßnahme, um das Auftreten eines solchen Fehlers wenigstens erkennbar zu machen, ist es, nach einer jeweils festen Anzahl von Textbits ein Prüfbit hinzuzufügen. Den Wert dieses Bits kann man z. B. so wählen, dass als Summe mit den vorangehenden 8 Bits immer eine gerade Zahl entsteht. Hier sieht das so aus: h 011010001
o 011011110
l 011011000
l 011011000
e 011001010
r 011001010
i 011010010
Wenn das 29. Bit (fett kursiv) durch eine Störung gekippt wird, h 011010001
o 011011110
l 011011000
l 001011000
e 011001010
r 011001010
i 011010010
ergibt die Quersumme eine ungerade Zahl. Man weiß dann zwar noch nicht, wo das gekippte Bit ist, aber immerhin kann man die Übertragung ein weiteres Mal anfordern, in der Hoffnung, dass diese nun vielleicht fehlerfrei ist. Hieraus lassen sich 5 nützliche Erkenntnisse ableiten:
8
¡
Um Fehler beseitigen zu können, muss man zusätzliche Prüfinformationen zur eigentlichen Nutzinformation hinzufügen, wobei das Gesamtvolumen wächst.
¡
Diese zusätzlichen Informationen erhöhen den Mindestabstand aller Codewörter untereinander, hier genau um den Betrag 1 auf dmin = 2.
¡
Wenn höchstens 1 Fehler pro 9 Bit auftritt, lässt sich dieser zwar nicht lokalisieren, aber wenigstens erkennen.
¡
Wenn 2 Fehler pro 9 Bit auftreten, hebt sich der Effekt auf, 3 Fehler würden aber wiederum erkannt. Da man nicht weiß, welche Fehlerkonstellation aktuell eintritt, kann man ein Fehlererkennungs- und Korrekturverfahren am ehesten danach beurteilen, wie viele Fehler im Mittel unerkannt bleiben (oder wie groß die Fehlerrate ist), wenn die Fehler statistisch eine bestimmte Verteilungsdichte aufweisen. C. E. Shannon hat hierzu übrigens ein fundamentales Gesetz formuliert.
¡
Soll ein 1-Bit-Fehler nicht nur erkannt, sondern auch korrigiert werden können, ist zusätzlich die Fehlerposition zu bestimmen. Das gelingt, wenn man weitere Prüfbits hinzufügt und mit jedem eine bestimmte Gruppierung von Informations- und Prüfbits absichert. In Kapitel 3 werden solche Verfahren beschrieben. Zur Übersichtlichkeit, aber ohne Beschränkung der Allgemeinheit, werden die einzelnen In-
1.2 Ein Schnupperkurs formationsbytes im folgenden Beispiel jeweils in eine linke und eine rechte Hälfte zu je 4 Bit geteilt. Das vorweg genommene Ergebnis dieses Hamming-Code-Verfahrens zeigt, dass hier insgesamt 3 Prüfbits nötig sind und das codierte Wort aus den 4 Infostellen und den 3 Prüfbits besteht. Die gesendete Bitfolge ist h
h
o
o
l
l
l
l
(links) 0110 011
(rechts) 1000 011
(links) 0110 011
(rechts) 1111 111
(links) 0110 011
(rechts) 1100 110
(links) 0110 011
(rechts) 1100 110
Ein (einziges!) gekipptes Bit innerhalb von 7 Bit lässt sich jetzt sicher korrigieren, da mit den 3 Prüfbits genügend Zusatzinformationen zur Verfügung stehen. Stellt man das Codewort mit seinen einzelnen Stellen als v = [x1 x2 x3 x4 y1 y2 y3] dar, so errechnen sich die Prüfbits aus den 3 Gleichungen x1 + x3 + y1 + y3 = gerade Zahl x2 + x3 + y2 + y3 = gerade Zahl x4 + y1 + y2 + y3 = gerade Zahl Ist ein Bit gekippt, dann ergeben sich eindeutig zu jeder der 7 möglichen Fehlerpositionen je eine, zwei oder alle drei Gleichungen als ungerade Zahl, und man kann die Fehlerposition hieraus bestimmen. Versuchen Sie's mal für ein gekipptes Bit an der zweiten Position von links. Die Prüfbits lassen sich im übrigen direkt aus dem aufgelösten Gleichungssystem errechnen: y1 = x2 + x3 + x4 y2 = x1 + x3 + x4 y3 = x1 + x2 + x4 Es gilt dabei die Vorschrift: yi = 0, wenn die rechte Seite eine gerade Zahl ist yi = 1, wenn die rechte Seite eine ungerade Zahl ist
Schlüsseleigenschaft: Mindestabstand
Die Erklärung finden wir in Unterkapitel 3.2. Eine besondere Bedeutung hat der Hammingabstand deshalb, weil sich die Grundaufgabe jeglicher Fehlererkennung und Fehlerkorrektur mit seiner Hilfe besonders einfach beschreiben lässt: Der Code der eigentlichen Nutzinformation, z. B. der ASCIICode, hat einen Mindestabstand von 1. Soll ein 1-Bit-Fehler erkannt werden können, muss man den Abstand auf 2 erhöhen.
9
1 Aufgabenstellung und Ziel
„Ohm'sches“ Gesetzt der Fehlerkorrektur
Jedes Codewort ist jetzt um 1 Bit länger, aber die Zahl aller Codewörter bleibt gleich. Tritt ein 1-Bit-Fehler innerhalb der 9 Bits auf, so ist dieses verfälschte Wort nicht in der Menge der zulässigen Codewörter enthalten und weist auf einen Fehler hin. Allerdings lässt sich daraus nicht eindeutig ableiten, an welcher Stelle der Fehler aufgetreten ist, da das empfangene Wort sowohl von seinem Codewort als auch von mindestens einem weiteren Wort den Abstand 1 hat. Erhöht man den Mindestabstand auf 3, wofür im allgemeinen leider mehr als ein zusätzliches Prüfbit nötig ist, so lässt sich hiermit ein 1-Bit-Fehler korrigieren. Warum? Das fehlerhafte Empfangswort hat nur zu seinem richtigen Codewort den Abstand 1, zu allen anderen aber den Abstand 2 und kann damit eindeutig zugeordnet werden. Wenn 2 Fehler auftreten würden, lässt sich dieser Fall zwar erkennen, der Korrekturversuch unter der Annahme, es sei nur ein 1-Bit-Fehler aufgetreten, würde aber zum falschen Codewort führen, nämlich zu demjenigen mit dem Abstand 1. Die Anzahl der pro Bitfolge auftretenden maximalen Fehler bestimmt also die Ausnutzung für die Erkennungs- oder Korrekturfähigkeit. Anders ausgedrückt: Wenn ein Code einen Mindestabstand dmin = 3 aufweist und pro Codewort höchstens ein 1-Bit-Fehler passieren kann, dann ist dieser korrigierbar. Würden dagegen zwei 1-BitFehler passieren, lassen sich diese nur erkennen, da man ja gerade nicht weiß, ob nur ein oder gar zwei Fehler aufgetreten sind. Diese Überlegungen kann man auf weitere Fehler ausdehnen. Mit einem Mindestabstand von 4 sind pro Codewort 3 Fehler erkennbar, oder besser ausgedrückt: Mit einem solchen Code kann man erkennen, wenn bis zu 3 Fehler auftraten. Wenn sicher ist, dass höchstens 2 Fehler passieren, lässt sich das aber auch anders nutzen. Wenn dann ein 1-Bit-Fehler auftritt, ist dieser korrigierbar, 2 Fehler werden sicher erkannt. Mit einem Code vom Mindestabstand 5 ist entweder die Erkennung von bis zu vier 1-Bit-Fehlern im Codewort oder die Korrektur von zwei 1-Bit-Fehlern möglich. In jedem Fall muss man sich vorher festlegen, ob Fehler erkennbar oder auch korrigierbar oder beides sein sollen, da das gewünschte Verfahren hierfür eine Anpassung erfordert. Wenn dies alles so einfach ist, warum, werden Sie sich fragen, muss man sich überhaupt so intensiv mit Fehlerbeseitigungsverfahren beschäftigen. Antwort: Das einzige Verfahren, mit dem sich die oben genannte Methode über den Mindestabstand unmittelbar umsetzen lässt, ist der Wiederholungscode. Für die Erkennung von t-„Stück“ 1-Bit-Fehlern benötigt man für das Code-
10
1.2 Ein Schnupperkurs wort dann zusätzlich zu jedem Informationsbit t Prüfbits, für die Korrektur sogar 2Yt Prüfbits. Dies ist im Vergleich zu anderen Verfahren, die den gleichen Abstand erzeugen, unwirtschaftlich viel. Allerdings erweist sich der Aufbau solcher effektiveren Codes als weitaus aufwändiger. Derartige Verfahren sind zum Beispiel der BCH-Code, der ReedSolomon-Code, Faltungscodes und Turbo-Produkt-Codes. Diese lernen wir in Kapitel 3 näher kennen.
1.2.3
Kompression Kommen wir zur dritten Teilaufgabe. Man kann sich denken, dass insbesondere bei großen Informationsmengen der Wunsch besteht, diese zu verkleinern, um Kosten für die Speicherung zu sparen oder um die Übertragungsleistung etwa für Videofilme zu steigern. Unser Beispieltext ist zwar zu klein, um nennenswerte Verdichtungsergebnisse zu erzielen, aber das Prinzip lässt sich hieran verdeutlichen. Ein Weg besteht in der Nutzung der Häufigkeitsverteilung der Zeichen oder gleichartiger Zeichenfolgen. Bei der Verschlüsselung stört diese Verteilung, da sie unerwünschte Rückschlüsse erlaubt, hier dagegen ist sie willkommen. Zum Beispiel kann man die immer gleiche Zuordnung von 8 Bits zu einem Zeichen der ASCII-Tabelle aufgeben und den häufigeren Zeichen ein kürzeres Codewort verpassen als den längeren. D. A. Huffman und R. M. Fano haben hierfür geeignete systematische Verfahren entwickelt. Die 13 Zeichen unseres Textes lassen sich danach so codieren:
Zeichen
Code
Zeichen
Code
Zeichen
Code
Zeichen
Code
d
11
e
00111
ö
00010
a
001010
ZWR
10
h
00110
u
00001
l
011
,
00100
r
00000
i
010
o
00011
j
001011
Wie das gemacht wird, sehen wir in Unterkapitel 6.1. Das ”d” und der Zwischenraum ZWR treten sehr häufig auf und sind deshalb mit nur 2 Bits dargestellt, alle anderen mit mehr. Der komprimierte Text hat nun statt 800 Bits nur einen Umfang von 320 Bits, ist also um 60 % verdichtet, ohne etwas vom Inhalt zu verlieren. Ein Trennzeichen wird nicht benötigt, da die Dekodierung eindeutig erfolgt. Es gibt nur ein einziges Zeichen, das genau die Folge 11 aufweist, nämlich das ”d”. Diese Folge
11
1 Aufgabenstellung und Ziel kommt nirgends woanders vor, auch die Folge 10 für „h“ nicht usw. Weitere Verfahren zu einer solchen verlustfreien Kompression sind die Lauflängen-Codierung, das LZW-Verfahren oder die arithmetische Codierung. Auch diese lernen wir in Unterkapitel 6.1 kennen. Während bei der Verdichtung von Text- und Programmdaten grundsätzlich nur verlustfrei gearbeitet werden darf, kann bei Bilddaten oder Audiosignalen oft ein Verlust des Darstellungsinhalts in Kauf genommen werden, ohne dass unser Gesichtsoder Gehörsinn dies als störend empfinden muss. Nachdem die Daten zunächst mit Transformationen wie der Fourier-, der Wavelets- oder der Fraktal-Transformation in eine geeignete Form gebracht wurden, lassen sie sich anschließend so weiter bearbeiten, dass Datenreduktionen von 1:20 bis 1:100 machbar sind. Mehr erfahren wir in den Unterkapiteln 6.2.1 bis 6.2.5.
1.3
Code
Begriffe aus der Informations- und Nachrichtentechnik Für den weiteren Verlauf ist es nützlich, dass wir uns über einige häufig gebrauchte Begriffe verständigen. Sie werden zum Großteil in der Nachrichtentheorie behandelt. Ein Code ist eine endliche Menge von Codewörtern, zum Beispiel die 256 Zeichen des ASCII-Codes. Ein Codewort ist das Element eines Codes, zum Beispiel ein ASCII-Zeichen. Im weiteren Verlauf betrachten wir nur Codes, deren Codewörter sich aus den Zahlen endlicher Ganzzahlmengen aufbauen, bei Binärcodes nur aus "0" und "1", bei Ternärcodes nur aus "0", "1" oder "2" und so weiter. Für den formalen Aufbau eines Codewortes gibt es dann im p-Zahlensystem (im Binärsystem ist p=2) 4 völlig gleichwertige Darstellungen: ¡
Als n-Tupel, zum Beispiel für einen 7-stelligen Code im Binärsystem: (1, 0, 1, 0, 1, 1, 1).
¡
Als n-stelliger Vektor, für das genannte Beispiel: [1 0 1 0 1 1 1].
¡
als n-stellige Zahl im p-System, für unser Beispiel also: 10101112 = 1·26 + 0·25 + 1·24 + 0·23 +1·22 + 1·21 + 1·20 .
¡
Als Polynom (n-1)-ten Grades in der unbestimmten Variablen x und mit Koeffizienten aus den endlich vielen Elementen des p-Zahlensystems, hier für das obige Beispiel: 1·x6 + 0·x5 + 1·x4 + 0·x3 + 1·x2 + 1·x1 + 1·x0 = x6 + x4 +x2 + x1 + x0
12
1.3 Begriffe aus der Informations- und Nachrichtentechnik Von diesen 4 Formen werden jeweils immer die benutzt, die gerade am günstigsten sind (oder von denen man dies annimmt), was auch immer damit gemeint ist. Als allgemeine Bezeichnung für ein fehlerfreies Codewort ist der Buchstabe v vorgesehen. Sind im empfangenen Wort w auch Fehler e enthalten, so entsteht es – theoretisch – als Summe aus Codewort v und Fehler e gemäß w
=v+e
„Theoretisch“ deshalb, weil es sich hier um ein stark vereinfachtes Modell für das mathematische Endergebnis handelt. Technisch gesehen durchläuft das Codewort einige Zwischenstufen, die genau zu betrachten sind. Eine Darstellung findet man in Unterkapitel 3.1. Codewortlänge n Die Codewortlänge n ist die Anzahl der Elemente eines Codewortes, im obigen Beispiel wäre n=7. Blockcodes sind Codes, bei denen alle Codewörter die gleiche Länge n haben. Im weiteren Verlauf werden überwiegend nur solche betrachtet. Der ASCII-Code gehört zum Beispiel dazu. Hingegen sind beim Huffman-Code zur Datenkompression Codewörter unterschiedlicher Länge geradezu ein grundsätzliches Ergebnis der Codierung. Die Anzahl aller aufstellbaren n-Tupel mit Elementen aus dem pAnzahl z aller beträgt z = pn. Für das obige Beispiel lassen sich möglichen Wörter Zahlensystem 7 demnach 2 = 128 Wörter bilden. Aber Vorsicht: Für den Zweck der Länge n der Datenfehlerbeseitigung werden als Codewörter nur geeignete Teilmengen hieraus genutzt (Redundanzerhöhung)! Systematische Codes enthalten in jedem Codewort die eigentliSystematischer chen Informationsstellen direkt. Diese sind also unmittelbar abCode lesbar und stehen zum Beispiel immer in den ersten k Stellen des Codewortes (oder wenigstens immer an denselben Stellen). Für die Datenfehlerbeseitigung ist dieser Aufbau zwar keineswegs zwingend, kann aber die Codierung und die Decodierung etwas erleichtern. Die Anzahl k der Informationsstellen gibt an, wie viele von den insgesamt n Stellen eines Codewortes die Nutzinformationen tragen. Diejenige Stellenzahl, die zur Überprüfung auf Fehler im empAnzahl m der fangenen Wort w benötigt wird, trägt die Bezeichnung m. Solche Prüfstellen Überprüfungen können zur Korrektur von Fehlern oder auch nur zur Fehlererkennung führen. Es gilt n = k + m. Die Entropie ist ein Maß für den Informationsgehalt eines ZeiEntropie H chens, eines Codewortes oder einer Nachricht und damit eines Zeichens elementar für die gesamte Informationstechnik. Der Begriff tritt in der Thermodynamik zur statistischen Beschreibung von Teil-
13
1 Aufgabenstellung und Ziel chenbewegungen auf. Er wurde im vorliegenden Zusammenhang von C. E. Shannon übernommen. Die Entropie errechnet sich aus dem Logarithmus des Kehrwertes der Auftrittswahrscheinlichkeit pi (Seite 47) eines Codewortes oder Zeichens im Gesamtverband aller Zeichen eines Textes gemäß H = log2
Entropie H(x) einer Quelle
1 1 = ld pi p
Dabei bedeutet log2 den Logarithmus zur Basis 2, log2 2 = 1. Die Entropie eines wenig wahrscheinlichen Zeichens ist hoch, die eines sehr wahrscheinlichen Zeichens gering. Ein Martinshorn zum Beispiel ertönt im Vergleich zu anderen akustischen Ereignissen über den Tag betrachtet – Gott sei Dank – sehr wenig. Wenn man es aber hört, signalisiert es einen Notfall, sicher eine wichtige Information. Sendet eine diskrete Quelle n verschiedene Symbole oder Zeichen mit den Wahrscheinlichkeiten p1, p2, … , pn aus, so ist ihre Entropie die Summe der Einzel-Entropien: n
n
H x = pi log2 pi = 1
z. B. für n=2:
pi log2 1p 1
i
H x = p1 log2 p1 p2 log2 p2
Eine binäre Quelle mit den beiden gleich wahrscheinlichen Symbolen 0 und 1 hat also die Entropie H(x) = 1. Bedingte Entropie Kommen beim Empfänger einer Nachricht einzelne von der Quelle ausgesendete Symbole xi als Signale yi mit einer WahrHy(x) scheinlichkeit qi fehlerhaft an, so ist die bedingte Entropie das Maß für die Ungewissheit dieser fehlerhaften Symbole. Bei n = 2: Hy x = qilog 2 q i 1q i log2 1q i
Kanal
Rauschquelle
14
Ist z. B. die Fehlerwahrscheinlichkeit für die Verfälschung einer binären, gleich verteilten Quelle 0.01 (1 Prozent aller Bits werden falsch empfangen), dann beträgt die Ungewissheit Hy(x) = 0.081 (Warum? Siehe Frage 1.4). Der Kanal ist die Summe aller technischen Komponenten (Modulatoren, Modems, Draht-, Lichtleiter- und Funk-Strecken, Demodulatoren, Verstärker, Regeneratoren, Frequenzumsetzer u. a.) mit der Aufgabe, eine Information von einem Sende- zu einem Empfangsort zu transportieren. Sie ist ein diskretes Modell für die Summe rs(t) aller auf einen Kanal einwirkenden verteilten Störsignale wie thermisches Widerstandsrauschen, temporäre Störimpulse durch Entladungen u. a. Über einen großen Zeitraum lässt sich das Rauschen meist angenähert als mittelwertfreie Normalverteilung p(x) mit dem
1.3 Begriffe aus der Informations- und Nachrichtentechnik Effektivwert V und einem konstantem Frequenzspektrum („weißes“ Rauschen) beschreiben.
Bild 1.1: Normalverteilungen und Rauschsignale rs für zwei verschiedene Effektivwerte , bzw. Signal/Störverhältnisse SNR SignalDefinitionen
Zur Signaldefinition einigen wir uns auf Folgendes: •
u: Informationsbit oder Informationswort (algebraischer Ausdruck aus 0 und/oder 1)
•
v: Codewortbit oder Codewort (algebraischer Ausdruck aus 0 und/oder 1)
15
1 Aufgabenstellung und Ziel •
us: Sendesignal-Wert oder -Wertefolge als physikalische Größen, (z. B. elektrische Spannungen) der uncodierten Information
•
vs: Sendesignal-Wert oder -Wertefolge als physikalische Größen (z. B. elektrische Spannungen) der codierten Information mit den Paritätsbits
•
rs: Rauschsignal-Wert oder -Wertefolge (physikalische Größen, z. B. elektrische Spannungen)
•
ws: Empfangssignal-Wert oder -Wertefolge, ws = vs + rs
•
w: HD (=Hard Decision)-demoduliertes Empfangssignalbit oder Empfangssignalwort, aus dem durch Decodierung die Schätzwerte û für die Informationsbits oder Informationsworte u ermittelt werden.
û: Schätzwert für die Informationsbits oder Informationsworte u • e: Fehlerbit oder Fehlerwort als Differenz w – v oder û - u. Die Differenz e = û - u steht mehr im Blickpunkt, da letztlich nur die Fehler in der Information und weniger die in den Prüfbits interessant sind. Das Signal/Stör-Verhältnis (Signal to Noise Ratio), oder kurz Störabstand, kennzeichnet als Verhältnis von mittleren Nutz- und Rauschsignalleistungen Sm und Nm einen wesentlichen Parameter für die Merkmale eines Kanals: •
SNR
SNR =
Sm Nm
Hat man als Sendesignal einen rechteckförmigen Spannungsverlauf mit den Maximalwerten +1/-1-Volt und der Zeitdauer T , so beträgt die Sendeleistung Sm =Es /T. Dabei ist Es die elektrische Energie, die man zum Aussenden eines Signalelementes der Zeitdauer T aufbringen muss. Die Leistung eines weißen Rauschsignals kann man als Produkt der Bandbreite B des Übertragungskanals und der – bei weißem Rauschen konstanten – spektralen Rauschleistungsdichte N0 beschreiben. Über einen Kanal mit der Bandbreite B lassen sich maximal B = 1/2YT Signalelemente der Zeitdauer T übertragen (Abtasttheorem!). Damit ist SNR =
E s /T 2E s Sm E /T = = = s Nm N0B N0 /2T N0
Die Signalelemente führen aber wegen der darin enthaltenen Prüfelemente nur Informationselemente Eb im Verhältnis der Rate
16
1.3 Begriffe aus der Informations- und Nachrichtentechnik R mit. Die Energie der Informationselemente lässt sich also auf die Energie der Signalelemente beziehen Eb =
Es R
oder Es = RE b
Daraus wird für rechteckförmige, codierte Informationssignale SNR =
dB = deziBel
2REb N0
Das logarithmische, dimensionslose Verhältnis zweier physikalischer Größen wie Spannungen, Leistungen und andere gibt man oft in der Einheit deziBel an. Für Leistungen ist definiert: SNR[dB] = 10log10
Übertragungsrate
S N
Ein Verhältnis Sm/Nm = 1 hat also SNR = 0 dB, eines von 100 ein solches von SNR = 20 dB, eines von 0.1 das von SNR = -10 dB. Die Übertragungsrate RC gibt an, welche Entropie bei gegebener Entropie H(vs) der Quelle zum Empfänger übertragen werden kann. Bei fehlerfreiem Kanal, der technisch H(vs) Bits überträgt, ist RC = H(vs). Bei fehlerhaftem Kanal verringert sich die Rate auf Rc = H vsHws vs = HwsH vs ws
Im oben genannten Beispiel kommen auf 1000 gesendete Bits im Mittel 10 fehlerhafte. Theoretisch kann dieser Kanal 919 fehlerfreie Bits bei 1000 gesendeten Bits übertragen, wenn die besten Fehlerkorrekturverfahren angewendet werden (es gibt aber keine Vorschrift darüber, wie diese aussehen müssen). Nimmt man der Einfachheit halber an, dass ein Codewort gerade 1000 Bits enthält und im Mittel 10 Fehlerbits pro Codewort entstehen, so können 81 Bits als Prüfbits verwendet werden. Mit den 81 Paritätsgleichungen lassen sich theoretisch alle 10 Fehlerbits korrigieren. Das ist die Aussage des berühmten Kapazitätstheorems von C. E. Shannon für diesen Fall, siehe auch Unterkapitel 3.5.5. Es hat weitreichende Bedeutung für die Informatik. C gibt an, wie viele Bits ein technischer Übertragungskanal maximal in Bezug auf alle möglichen Quellen und Störungen pro Zeiteinheit fehlerfrei übertragen kann (s bezeichnet die Einheit „Sekunden“) C =
MaximumRc s
= MaximumR*c =
MaximumH xH y x s
17
1 Aufgabenstellung und Ziel Shannon hat gezeigt, dass C maximal wird, wenn sowohl Quelle wie auch Störungen normal verteilte Wahrscheinlichkeiten aufweisen. Informationsrate Die Informationsrate – oder einfach Rate – R gibt das Verhältnis R von Infostellen zur Codewortlänge an und ist ein Maß dafür, wie gut der Code zur Informationsdarstellung ausgenutzt wird. R =
nm m k = = 1 n n n
Gibt es nur Informationsstellen, so ist k = n und damit R = 1. Fehler lassen sich in diesem Fall überhaupt nicht behandeln. Bei sehr großer Anzahl von Prüfstellen wird R sehr klein. Das Codewort enthält dann nur wenige Informationsstellen, allerdings ist die Möglichkeit zur Fehlerbeseitigung besser. Kompressionsrate Die Kompressionsrate Rk gibt das Verhältnis der Bit-Anzahl eines komprimierten Codes zur Bit-Anzahl des Originalcodes an. Bei verlustfreier Verdichtung sind Kompressionsraten von 0.5 bis 0.25 zu erreichen, bei verlustbehafteter können es 0.1 bis unter 0.01 sein (JPEG, MP3 .... ). Hamminggewicht Das Hamminggewicht g eines binären Codewortes ist die Anzahl der enthaltenen Einsen. So hat das Wort v
=
(1, 0, 1, 0, 1, 1, 1)
ein Gewicht g = 5. Hammingabstand Der Hammingabstand d ist die Anzahl derjenigen Stellen, in denen sich zwei Codewörter unterscheiden. Die beiden Wörter
Mindestabstand
(n,k,dmin)-Code
v1
=
(1, 0, 1, 0, 1, 1, 1)
v2
=
(1, 1, 0, 0, 0, 1, 1)
haben also den Abstand d=3. Der Mindestabstand dmin als kleinster auftretender Hammingabstand d in der Menge aller Wörter eines Codes gehört zu den wichtigsten Eigenschaften von Codes überhaupt, da sich hieraus ableitet, wie viele Fehlstellen pro Codewort erkannt oder korrigiert werden können. Dies ist die Kurzbezeichnung für einen Code der Länge n mit k Informationsstellen und Mindestabstand dmin . Die Anzahl tkor korrigierbarer Fehler gibt an, wie viele Fehler mit einem bestimmten Verfahren mindestens korrigiert werden können. Es besteht ein einfacher Zusammenhang zwischen dem Mindestabstand dmin und tkor: dmin 2tkor 1
18
1.3 Begriffe aus der Informations- und Nachrichtentechnik Die Anzahl terk erkennbarer Fehler gibt an, wie viele Fehler mit einem Verfahren lediglich erkannt, aber nicht korrigiert werden können. Auch hier besteht ein einfacher Zusammenhang mit dem Hammingabstand: dmin terk 1
Die Anzahl tkor + terk korrigierbarer und erkennbarer Fehlerstellen (nur sinnvoll für tkor < terk , warum?) gibt an, wie viele Fehlerstellen korrigiert und wie viele zugleich noch erkannt werden können. Z. B. nutzen sehr viele Halbleiter-Arbeitsspeichereinheiten (RAMs) in Rechnersystemen Verfahren zur Datenfehlerbeseitigung, mit denen sich ein Einzelfehler korrigieren und ein Doppelfehler wenigstens noch erkennen lässt. Es gilt dann für den Hammingabstand: dmin tkor t erk 1
Fehlerrate EBR
Fourier-Transformation
Die Fehlerrate EBR (Error Bit Rate) ist bei der Datenübertragung das mittlere Verhältnis der fehlerhaften Info-Bits ohne oder nach der Fehlerkorrektur zu allen Info-Bits. Sie stellt daher ein grundlegendes Kriterium zur Beurteilung der Korrekturverfahren dar. Es lassen sich 3 Fälle unterscheiden: • Ohne Störsignal rs ist EBR = 0. • Bei mittelwertfreiem Gauß-verteilten Störsignal ohne Fehlerkorrektur kann die Fehlerrate nicht kleiner als EBR = 0.5 werden. Ein solches Ergebnis ist aber bereits vollkommen unbrauchbar, da die empfangenen Info-Bits auch durch Würfeln ermittelt werden könnten. • Bei mittelwertfreiem Gauß-verteilten Störsignal mit Fehlerkorrektur lässt sich die Fehlerrate wesentlich senken. Das ist ja gerade auch das Ziel. Werte im Bereich ab EBR = 10-6 und kleiner sind unbedingt erwünscht. Bei unzweckmäßiger Ausführung der Fehlerkorrektur kann EBR allerdings sogar größer als ohne Fehlerkorrektur werden. Sorgfalt und Überprüfung sind also unbedingt notwendig. Ein mathematisches Verfahren, um einen Zeit- oder Ortsabhängigen Verlauf, zum Beispiel die Ausgangsspannung s(t) eines Mikrofons oder die Folge der Bildpunkte s(x) auf einer Fotografie in sinusförmige Teilsignale zu zerlegen und – umgekehrt – aus diesen Teilsignalen wieder den ursprünglichen Verlauf herzustellen. Das Verfahren wird zum Beispiel bei der Datenkompression benutzt, um weniger wichtige Anteile in einem Originalsignal erkennen zu können. Diese Anteile müssen dann bei der Übertragung und Speicherung nicht berücksichtigt werden, was eine Einsparung gegenüber dem Volumen des Originalsignals ergibt.
19
1 Aufgabenstellung und Ziel Eine vollständige Wiederherstellung des Verlaufs ist in diesem Fall zwar nicht mehr möglich, man hat aber durch eine gezielte Auswahl der wegzulassenden Anteile eine gute Möglichkeit, den wesentlichen Informationsgehalt zu erhalten. Es gibt einige Varianten dieses Verfahrens, die den besonderen Anforderungen der Datenkompression angepasst sind, zum Beispiel : ¡
FFT = Fast Fourier-Transformation, ein Algorithmus, der besonders effektiv und damit schnell arbeitet und sich für Echtzeitbearbeitung eignet.
¡
DFT = Diskrete Fourier-Transformation, die eingesetzt wird, wenn nicht der kontinuierliche Signalverlauf s(t), sondern nur diskrete „Abtastwerte“ von kurz hintereinander folgenden Zeitpunkten im Abstand T als Zahlenwertreihe s(0), s(T), s(2T), s(3T), .... vorliegen. Dies ist der Fall, wenn die Zahlenreihe als Ausgangsdatenstrom eines Analog-Digital-Wandlers entsteht.
DCT = Diskrete Cosinus-Transformation, ein Sonderfall der DFT. Fraktale sind Funktionen, die Randzonen von Flächen beschreiben, und bei Erhöhung der Darstellungsgenauigkeit (Zoomen) immer neue, ähnliche Strukturen zeigen. Dieser Prozess ist – sehr entfernt – vergleichbar mit der Darstellung einer Kontur auf einer Landkarte, zum Beispiel einer Küstenlinie. Ein sehr kleiner Maßstab wie etwa 1:1 000 000 zeigt diese Linie beinahe als Gerade, je größer der Maßstab wird, desto feinere Details werden sichtbar. Die bekannten „Apfelmännchen“ entstehen auf dieser Grundlage. Fraktale Transformationen beruhen auf der Nutzung eines einfachen Grundelements, etwa eines Quadrats. Durch Kopieren, Verkleinern und Verschieben der Kopien (= Transformieren) und Kombinieren so erzeugter Zusatz-Elemente kann eine gegebene Kurve (Funktion) sehr gut angenähert werden. Die Technik der fraktalen Transformationen eignet sich grundsätzlich als Vorbereitungsschritt für die Datenkompression, bringt mit Kompressionsraten von 1:100 bei akzeptabler Darstellung sehr gute Ergebnisse, befindet sich aber zur Zeit noch in der Entwicklung für den praktischen Einsatz. Die Wavelet-Transformation (wavelet = kleine Welle) ist eine zur Fourier-Transformation alternative Technik für die angenäherte Darstellung von Funktionen. Während die Fourier-Transformation als Basisfunktionen Sinus- und Cosinusschwingungen verwendet, benutzt die Wavelet-Transformation spezielle „scharfe“ Funktionen, um vor allem kontrastreiche Signale in Bildern und Klängen mit „steilen“ Übergängen zu beschreiben. Dies gelingt damit besser als bei der Fourier-Transformation, weil die ¡
Fraktale
Wavelet-Transformation
20
1.3 Begriffe aus der Informations- und Nachrichtentechnik
Bandbreite B
Modulation
Abtasttheorem
1.4
Zuordnung zu hohen Frequenzanteilen und ihrem zeitlichen Auftreten lokalisierbar wird. Die Bandbreite B gibt als Differenz B = fmax – fmin an, welche Spektralanteile f mit fmin f fmax eines gesendeten Signals ws auf einem Kanal ungedämpft übertragen werden. B beeinflusst über das Signal/Stör-Verhältnis zusammen mit dem gewählten Modulationsverfahren unmittelbar die Kanalkapazität. Modulation ist ein technisches Verfahren, um eine gegebene physikalische Form einer Information so umzuwandeln, dass sie auf technischen Kanälen möglichst effektiv übertragen werden kann. Einige Verfahren sind Amplitudenmodulation (Rundfunk), Frequenzmodulation (Rundfunk, Modem), Pulscodemodulation (A/D-Wandlung), Basisband-Modulation (Abbildung eines zweiwertigen Zustands in einen Spannungs- oder Stromwechsel). Diese von Shannon und Nyquist gefundene elementare Beziehung besagt, dass ein auf das Spektrum B begrenztes Signal ws über einen Kanal der Bandbreite B vollständig übertragen wird, wenn man zur Signaldarstellung Abtastwerte im zeitlichen Abstand T kleiner oder mindestens gleich T 1/(2YB) verwendet. Zum Beispiel kann man eine „0/1“-Folge in eine symmetrische Rechteckspannung mit dem Mittelwert 0 abbilden. Hat der Kanal die Bandbreite B = 1/T und ordnet man je zwei Bit die Größe +1 oder -1 Volt über die Zeitspanne T zu, so überträgt der Kanal gerade die sinusförmige Grundschwingung sin(ZYt/T). Wird diese zweimal pro Periode abgetastet (= analog gemessen und als Digitalzahl dargestellt, so kann sie der Empfänger – bei rauschfreiem Kanal – vollständig rekonstruieren.
Aufgabenstellung Codierungsverfahren zur Fehlerbeseitigung, Verschlüsselung und Kompression gehören zu den Standardhilfsmitteln in Informatiksystemen. Obwohl Fehlerbeseitigung und Verschlüsselung in keinem Zusammenhang zu stehen scheinen, beruhen sie doch zum Teil auf gleichen mathematischen Grundlagen. Machen wir uns zunächst klar, welche Aufgaben gestellt sind, wenn Datenfehler beseitigt werden müssen. Datenfehler treten entweder bei der Übertragung von Daten aus einem Datenspeicher in einen anderen oder bei der Speicherung selbst auf. Im ersten Fall wird die Nachricht durch Störungen des Übertragungskanals in zufälliger Weise verändert, im zweiten Fall ist aufgrund von technischen Fehlern (zum Beispiel durch zerstörte Zellen eines Halbleiterspeichers, Fehlstellen in der magnetisierbaren Beschichtung von Platten, ...) die einwandfreie Speicherung unmöglich. In jedem Fall muss die richtige Nachricht aus dem teilweise zerstörten Rest wiederhergestellt werden.
21
1 Aufgabenstellung und Ziel Dies gelingt nur, wenn man zusätzlich zur Nachricht weitere Informationen überträgt, die wesentliche Inhalte dieser Nachricht enthalten. Die gesamten übertragenen Informationen sind dann redundant, die Informationsrate R wird kleiner als 1. Eine Teilaufgabe ist es, gerade soviel zusätzliche Informationen zu übertragen, dass bis zu einem bestimmten Zerstörungsgrad der Nachricht deren sichere Rückbildung möglich ist. Mit Hilfe des Hammingabstandes d, siehe Seite 18, kann man diese Aufgabe leichter fassbar machen. Dazu zunächst eine fast selbstverständlich klingende Aussage: ¡
Die Codewörter eines Codes müssen wenigsten paarweise den Hammingabstand 1 aufweisen, damit sie überhaupt unterschieden werden können. Das dürfte ziemlich klar sein, da zwei Wörter mit dem Abstand 0 sich nicht unterscheiden lassen und damit wertlos sind.
¡
Liegt nun ein vollständiger Code vor, so heißt "Mindestabstand 1“ aber auch, dass in diesem Code ein oder mehrere Fehler nicht erkannt, geschweige korrigiert werden können, da durch Fehler in jedem Fall wieder ein zulässiges Codewort entstünde. (Hinweis: Es geht hierbei ausschließlich um den rein technischen Standpunkt, bei dem nur die abstrakten Codewörter ohne jeglichen Bezug zu ihrem Bedeutungsgehalt betrachtet werden. In der natürlichen Sprache dagegen kann man Fehler oft auch aus dem Sinnzusammenhang korrigieren).
¡
Hat man andererseits einen Code, bei dem alle Codewörter paarweise wenigstens den Abstand 2 aufweisen, so erzeugt ein Fehler ein Empfangswort w, welches zu einem oder mehreren anderen Codewörtern v einen Abstand von nur d=1 hat und damit nicht zu den zulässigen Wörtern gehört. Dann gestattet die systematische Prüfung jedes empfangenen Codewortes das sichere Erkennen eines Fehlers, allerdings nur eines einzigen. Alle geradzahligen Fehler würden wieder zulässige Codewörter ergeben.
Vergrößert man den Mindestabstand weiter, so lassen sich auch mehr Fehler erkennen und sogar korrigieren. Mit diesen Überlegungen ist der Lösungsweg schon skizziert: Die Aufgabe besteht darin, solche Codes zu finden, in denen die Codewörter einen vorgegebenen Mindestabstand dmin haben. An zwei Beispielen soll dies etwas genauer erläutert werden. Ein vollständiger Binärcode der Länge n=3 hat 8 Codewörter. Schreibt man diese als Zeilen und Spalten in eine Tabelle und bildet paarweise die Hammingabstände, so erhält man die folgende symmetrische "Matrix", welche in der Hauptdiagonalen (natürlich) mit dem Wert "0" besetzt ist, wie Tabelle 1-2 zeigt. ¡
22
1.4 Aufgabenstellung Bei vollständiger Ausnutzung der Codelänge n=3 stehen 8 Codewörter zur Verfügung. Wegen des Mindestabstandes von nur d=1 ist dann allerdings keine Fehlerbeseitigung möglich. Um die Erkennbarkeit eines Einzelfehlers sicherzustellen, sucht man unter diesen 8 Wörtern die größte Anzahl, die paarweise (also jedes mit jedem) den Abstand 2 haben. Im allgemeinen lassen sich mehrere unterschiedliche, aber gleichwertige solcher Teilmengen finden. 000 001 010 011 100 101 110 111
000 0
001 1 0
010 1 2 0
011 2 2 1 0
100 1 2 2 3 0
101 2 1 3 3 1 0
110 2 3 1 3 1 2 0
111 3 2 1 3 2 1 1 0
Tabelle 1-2: Hammingabstände der 8 Wörter des Binärcodes der Länge n=3 Wie sieht die Suche nach solchen Kandidaten aus? Anhand der Tabelle 1-2 lässt sich ganz systematisch vorgehen: Schritt 1: Zunächst schaut man in der ersten Zeile nach, welche Wörter paarweise den Abstand d>1 aufweisen. Das sind die 4 Paare (000, 011), (000, 101), (000, 110) und (000, 111). Wegen des symmetrischen Aufbaus kann man sich bei der Suche auf den Bereich rechts oberhalb der Diagonalen beschränken. Damit ist aber nur die paarweise Eignung mit 000 sichergestellt, nicht jedoch die Eignung der übrigen Wörter untereinander. Schritt 2: Man geht in die Zeile mit dem Wort 011 als nächstem Kandidaten und überprüft die Abstände mit dem Rest aus dem ersten Schritt. Man braucht also nur noch in den Spalten nachzusehen, in denen 101, 110 und 111 stehen. Das ergibt die zwei Paare (011, 101) und (011, 110). Damit ist 111 ausgeschieden. Schritt 3: Das im zweiten Schritt begonnene Verfahren wiederholt sich solange, bis nur noch ein Paar übrig bleibt. Im vorliegenden Beispiel ist dieser Zustand erreicht, wenn das Paar (101, 110) überprüft wurde. Es erfüllt unsere Bedingung und als Teilmenge liegen damit die Wörter 000, 011, 101 und 110 vor. Schritt 4: Allerdings ist man damit noch nicht fertig, da nur diejenige Teilmenge interessiert, welche die größte Elementzahl hat. Das lässt sich durch systematisches Weiterprüfen erreichen. Man nimmt sich als nächstes die Paare vor, die in der zweiten Zeile stehen und somit das gemeinsame Codewort 001 besitzen. Ansonsten läuft alles wie zuvor ab. Als Ergebnis erhält man die 4 Wörter 001, 100, 010, und 111.
23
1 Aufgabenstellung und Ziel
Vielseitig, aber mühsam
rohe Gewalt
24
Auf diese Weise kommen nacheinander alle Zeilen dran und man kann aufhören, wenn die Anzahl der Zeilenelemente rechts der Diagonal-"0" gleich oder kleiner wird als die Anzahl der Elemente der bisher gefundenen größten Teilmenge. Im vorliegenden Beispiel sind mit den beiden Teilmengen auch schon alle möglichen gefunden. Wählt man diese Menge als Code, so lässt sich mit diesem ein Einzelfehler erkennen. Anhand des Würfels in Bild 1.2 kann man sich das klarmachen. Den 8 Eckpunkten des Würfels sind die 8 Wörter zugeordnet. Die erste Teilmenge besteht aus denjenigen vier Wörtern, die zu allen drei anderen durch mindestens einen weiteren Eckpunkt getrennt sind. Das entspricht einem Hammingabstand von d>1. Die zweite Teilmenge besteht aus den vier anderen Eckpunkten, unterscheidet sich aber sonst nicht. Man sieht daran auch unmittelbar die Wirkung eines Einzelfehlers: Dieser verändert ein Codewort so, dass ein nicht in der Teilmenge enthaltenes Wort entsteht, man also auf einem "verbotenen" Eckpunkt landet. Das Verfahren ist ebenfalls für die Suche nach Codes mit anderen Mindestabständen geeignet. Bei d>2 findet man allerdings in unserem Einfachstbeispiel nur noch Einzelpaare, zum Beispiel (000, 111) oder (100, 011) usw., also Codewörter mit Punkten auf Raumdiagonal gegenüberliegenden Ecken. Das sind Codes, bei denen man 2 Fehler erkennen oder einen Fehler korrigieren kann (leider hat man auch nur zwei Codewörter, so dass die Erstellung eines literarischen Textes mit einem solchen Zweizeichen-Alphabet ziemlich mühsam wäre). Wenn man ganz sicher ist, dass nur ein Einzelfehler auftreten kann, so lässt sich ein solches fehlerbehaftetes Wort leicht zum richtigen hin korrigieren, da in diesem Fall nur dasjenige in Frage kommt, welches einen Hammingabstand d=1 aufweist. Wenn z. B. der Code aus den beiden Wörtern 100 und 011 besteht und wir 101 oder 000 oder 110 empfangen, so kann nur das Wort 100 gesendet worden sein. Erwarten wir dagegen auch das Auftreten von zwei Fehlern, so ist die Fehlerkorrektur unmöglich, da aus 011 bei zwei Fehlern ja 110 entstanden sein könnte. Hier lässt sich das Auftreten von Fehlern lediglich erkennen. Das oben beschriebene Verfahren zur Bestimmung von Codes mit gegebenem Mindestabstand dmin ist mathematisch gesehen zwar ziemlich primitiv (in der angelsächsichen Literatur treffend als „Brute Force“-Methode bezeichnet), bei systematischem Arbeiten aber immerhin sicher. Leider stößt man damit schnell an die Grenzen des Machbaren, wenn die Codes länger werden. Dies ist eine Folge des exponentiellen Wachstums bei der Anzahl aller Wörter aufgrund des im Unterkapitel 1.3 genannten
1.4 Aufgabenstellung Zusammenhangs von Wörteranzahl z, Zahlenbasis p und Länge n, nämlich z = p2. Zwar kann man sich ein wenig durch den Einsatz von Rechnern entlasten, welche die Bildung der Abstandstabellen und die systematische Teilmengensuche durchführen, aber auch dann kommt man nicht besonders weit.
(0,0,1)
(1,0,1)
(0,1,1)
(1,1,1)
(0,0,0)
(0,1,0)
(1,0,0)
(1,1,0)
Bild 1.2: Darstellung der 8 Codewörter des Binärcodes der Länge n=3 als Würfeleckpunkte Wahre Freunde
Trotz dieser ernüchternden Ausgangslage ist der Gebrauch eines Rechners nicht nutzlos. Man kann damit Beispiele untersuchen und Ergebnisse der eigenen Überlegung nachprüfen. Oft bietet sich hier eine unerwartet gute Hilfestellung. Die Art und Leistungsfähigkeit des Systems ist für diese Art der Aufgaben meistens nicht wesentlich. Selbst programmierbare Taschenrechner sind geeignet. Zur Aufstellung solcher Beispiele wurde ein kleines Programmsystem zum Bestimmen der Hammingabstands-Tabellen und der Codes für vorgegebenen Mindestabstand entwickelt. Tabelle 1-3 enthält die damit berechneten Abstände für einen Binärcode der Länge n=5. Zur kompakteren Übersicht wurden die 32 Wörter nicht in Binär-, sondern in Dezimalform dargestellt. Für einen Code, der es gestattet, einen Einzelfehler zu korrigieren, ist tkor = 1. Der Mindestabstand dmin ergibt sich nach Unterkapitel 1.3, Seite 18 als d = 2·tkor + 1 oder d = 3. Das Programm ermittelt mehrere Teilmengen. Uns interessieren nur die
25
1 Aufgabenstellung und Ziel mit der größten Elementzahl, also die mit den meisten Codewörtern. 1 1 1 1 1 1 1 1 1 1 2 2 2 2 2 2 2 2 2 2 3 3 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
0 1 1 2 0 2 1 0 1 0
1 2 2 3 0
2 1 3 2 1 0
2 3 1 2 1 2 0
3 2 2 1 2 1 1 0
1 2 2 3 2 3 3 4 0
2 1 3 2 3 2 4 3 1 0
2 3 1 2 3 4 2 3 1 2 0
3 2 2 1 4 3 3 2 2 1 1 0
2 3 3 4 1 2 2 3 1 2 2 3 0
3 2 4 3 2 1 3 2 2 1 3 2 1 0
3 4 2 3 2 3 1 2 2 3 1 2 1 2 0
4 3 3 2 3 2 2 1 3 2 2 1 2 1 1 0
1 2 2 3 2 3 3 4 2 3 3 4 3 4 4 5 0
2 1 3 2 3 2 4 3 3 2 4 3 4 3 5 4 1 0
2 3 1 2 3 4 2 3 3 4 2 3 4 5 3 4 1 2 0
3 2 2 1 4 3 3 2 4 3 3 2 5 4 4 3 2 1 1 0
2 3 3 4 1 2 2 3 3 4 4 5 2 3 3 4 1 2 2 3 0
3 2 4 3 2 1 3 2 4 3 5 4 3 2 4 3 2 1 3 2 1 0
3 4 2 3 2 3 1 2 4 5 3 4 3 4 2 3 2 3 1 2 1 2 0
4 3 3 2 3 2 2 1 5 4 4 3 4 3 3 2 3 2 2 1 2 1 1 0
2 3 3 4 3 4 4 5 1 2 2 3 2 3 3 4 1 2 2 3 2 3 3 4 0
3 2 4 3 4 3 5 4 2 1 3 2 3 2 4 3 2 1 3 2 3 2 4 3 1 0
3 4 2 3 4 5 3 4 2 3 1 2 3 4 2 3 2 3 1 2 3 4 2 3 1 2 0
4 3 3 2 5 4 4 3 3 2 2 1 4 3 3 2 3 2 2 1 4 3 3 2 2 1 1 0
3 4 4 5 2 3 3 4 2 3 3 4 1 2 2 3 2 3 3 4 1 2 2 3 1 2 2 3 0
4 3 5 4 3 2 4 3 3 2 4 3 2 1 3 2 3 2 4 3 2 1 3 2 2 1 3 2 1 0
4 5 3 4 3 4 2 3 3 4 2 3 2 3 1 2 3 4 2 3 2 3 1 2 2 3 1 2 1 2 0
5 4 4 3 4 3 3 2 4 3 3 2 3 2 2 1 4 3 3 2 3 2 2 1 3 2 2 1 2 1 1 0
Tabelle 1-3: Hammingabstände aller binären Codewörter der Länge n=5 Für d>2 ergibt das immerhin bereits 120 Teilmengen mit 4 Elementen. Einige daraus sind: ( 0, 7,27,28)
( 0, 7,26,29)
( 0,11,21,30)
( 0,11,22,29)
( 1, 6,24,31)
( 1, 6,26,29)
( 2, 5,24,31)
( 2,15,21,24)
(11,12,18,21)
(11,12,17,22)
usw. Man kann sich anhand der Tabelle überzeugen, dass dies richtig ist, einfacher wird der Test mit einem kleinen Programm.
26
1.4 Aufgabenstellung Natürlich sind auch andere Vorgaben für den Mindestabstand möglich. Will man nicht nur einen Fehler korrigieren, sondern zusätzlich zwei Fehler erkennen, so ist tkor=1 und terk=2. Nach Kapitel 2.3 muss d > 2tkor+ terk + 1 sein, also d > 5. Es gibt dann allerdings nur noch 24 Teilmengen mit 2 Elementen, eine davon ist z. B.: (0,31)
(1,31)
(2,31)
(10,29).
Bei einer Codelänge von n=7 mit 128 Wörtern kann die Tabelle hier nicht mehr übersichtlich abgedruckt werden. Außerdem wäre es reichlich mühsam, mit diesem „Zahlenhaufen“ von Hand zu arbeiten. Für d>2 bringt das Programm unter anderem die Teilmengen (0,7,25,30,42,45,51,52,75,76,82,85,97,102,120,127) (0,7,25,30,43,44,50,53,74,77,83,84,97,102,120,127), denen wir im Kapitel 3 in ähnlicher Form wieder begegnen werden. Stellt man die Codewörter der ersten dieser beiden Teilmengen in binärer Form als Vektoren dar, so erhält man die Tabelle 1-4. Dieser Code ist wegen dmin=3 zur Korrektur eines 1Bit-Fehlers geeignet. 0
[0 0 0 0 0 0 0]
7
[0 0 0 0 1 1 1]
25
[0 0 1 1 0 0 1]
30
[0 0 1 1 1 1 0]
42
[0 1 0 1 0 1 0]
45
[0 1 0 1 1 0 1]
51
[0 1 1 0 0 1 1]
52
[0 1 1 0 1 0 0]
75
[1 0 0 1 0 1 1]
76
[1 0 0 1 1 0 0]
82
[1 0 1 0 0 1 0]
85
[1 0 1 0 1 0 1]
97
[1 1 0 0 0 0 1]
102
[1 1 0 0 1 1 0]
120
[1 1 1 1 0 0 0]
127
[1 1 1 1 1 1 1]
Tabelle 1-4: Durch systematische Suche über ein Programm gefundener Code mit dmin=3, „Brute Force“-Methode Aufgabenzettel
Aus den Ergebnissen der bisherigen Beobachtungen kann man nun versuchen, die Aufgabenstellung bei der Datenfehlerbeseitigung abzuleiten. Es geht darum,
27
1 Aufgabenstellung und Ziel ¡
Codes mit Codewörtern eines vorgegebenen Mindestabstandes zu finden,
¡
Codes zu ermitteln, die eine solche Eigenschaft bei einer möglichst kleinen Codewortlänge besitzen, also besonders platzsparend sind (denn irgendeinen Code zu finden, der einen Mindestabstand hat, ist ziemlich leicht),
solche Codes auszuwählen, die einfach (d. h. mit geringem technischen Aufwand) zu erzeugen und rück zu verwandeln (= decodieren) sind. Während die zuvor genannten beiden Aufgaben ausschließlich von den Eigenschaften der Zahlen bestimmt werden, ist diese dritte Eigenschaft in hohem Maße vom Stand der Technik abhängig. Denn auch ein aufwändig erscheinendes Codier- oder Decodierverfahren kann bei technischer Verwirklichung in hoch integrierten Halbleiterbausteinen und entsprechend guter Marktnachfrage durchaus bezahlbar sein, siehe zum Beispiel die Produkte von comtech aha corporation oder weitere Hersteller. Wenden wir uns nun noch kurz der Aufgabenstellung bei der Datenverschlüsselung zu. Hier ist die zu übertragende Nachricht in einer solchen Weise zu verändern (oder gezielt zu "stören"), dass sie von der Allgemeinheit nicht mehr erkannt, sondern nur noch von einem gewollten Adressatenkreis verstanden werden kann. Daher lassen sich zwei Teilaufgaben als Schwerpunkte erkennen: ¡
Bitte stören!
¡
der Code muss "sicher" sein, d. h. er darf von Unberechtigten nicht "geknackt" werden können,
das Codierungsverfahren soll dennoch einfach sein, damit es auch für große Nachrichtenmengen noch wirtschaftlich ist. Es stehen eine Vielzahl von Soft- und Hardwarelösungen zur Verfügung Bei der Datenkompression schließlich geht es, ähnlich wie bei der Fehlerbeseitigung, darum, Codes zu finden, die einerseits hohe Kompressionsraten erlauben, andererseits aber auch schnell erzeugt werden können. „Schnell“ ist hier relativ und orientiert sich am jeweils gültigen Stand der umgebenden Technik. Bei den heute (Juni 2006) üblichen PCs mit ca. 4 GHz Taktfrequenz, erwartet man von einem verlustfreien Kompressionsverfahren, dass es eine Datei von 10 MByte Größe in wenigen ( <2) Sekunden bearbeitet. Auch hierfür gibt es hoch integrierte Chips verschiedener Hersteller. ¡
1.5
Ziel Ziel beim Studium dieses Buches ist es, die zur Zeit aktuellen Codierungsverfahren zur Datenfehlerbeseitigung, Verschlüsse-
28
1.5 Ziel lung und Kompression verstehen zu lernen und daraus abzuleiten, welche Stärken und Schwächen diese haben, welcher Aufwand zur Realisierung notwendig ist, welche technischen Hilfsmittel es gibt. Das Durcharbeiten einzelner Beispiele kann dabei sehr hilfreich sein, insbesondere wenn man sich durch kleine, möglichst selbst geschriebene Programme unterstützen lässt. Dies bietet einen hervorragenden Weg, um sich mit den Arbeitsweisen der verschiedenen Verfahren besonders gut vertraut zu machen. Kein Ziel bei diesem ersten Kennenlernen der Codierungsverfahren ist es dagegen, möglichst das ganze Gebiet abzudecken oder mathematische Beweise durchzuführen (hier vertraut man einmal den Ergebnissen der Mathematiker). Allerdings muss man zugeben, dass die in einem Beweis steckenden Gedankengänge oft sehr hilfreich für den Prozess des eigenen Verstehenlernens sind, weshalb diese Hilfen an einigen Stellen genutzt werden sollen.
1.6
Was blieb? 1.
2.
3. 4.
5.
6.
In welchen Kombinationen für erkennbare und korrigierbare Fehlerbits kann ein Code mit Mindestabstand dmin = 4 verwendet werden? Wie verändert sich die Redundanz eines gegebenen Wortes, wenn man es fehlerkorrigierbar macht? verschlüsselt? komprimiert? Wie groß ist die Entropie eines Zeichens mit der Eintrittswahrscheinlichkeit p = 0.125? Schreiben Sie ein Programm, mit dem man durch systematisches Absuchen aller 26 Bitkombinationen der 6stelligen Binärworte die größten Untermengen mit dem Mindestabstand dmin = 3 und dmin = 4 findet. Berechnen Sie die Entropie einer kontinuierlichen Informationsquelle mit der Wahrscheinlichkeitsdichte p(x), p(x) normal verteilt mit Mittelwert xm =0 und Standardabweichung V. Welche besondere informationstheoretische Eigenschaft weist der Morsecode auf?
29
1 Aufgabenstellung und Ziel 7. 8.
9. 10. 11.
12.
13.
30
Ist ein um ein Prüfbit erweitertes ASCII-Byte ein systematisches Codewort? Welchen Störabstand hat ein Kanal, auf dem ein Rechtecksignal mit den Spannungswerten ±2.5 Volt übertragen wird und auf den eine mittlere Rauschspannung von 1.3 Volt einwirkt? Durch welche Eigenschaften ist ein perfekter Verschlüsselungscode gekennzeichnet Warum sind beim Huffman-Code zwischen den Codewörtern keine Trennzeichen erforderlich? Müssen beim Morsen zwischen den Zeichen Kennungen eingefügt werden, damit man die Zeichen unterscheiden kann? Wörter von Blockcodes weisen gegeneinander einen Hammingabstand auf. Ist ein solcher auch für Wörter eines Codes variabler Länge angebbar? Ist der Code nach Tabelle 1.4 systematisch?
2
Mathematische Hilfsmittel Die für das Verständnis der Codierungsverfahren notwendigen mathematischen Hilfsmittel teilen sich in zwei Gruppen auf. Die erste enthält Begriffe und Gebiete, die bereits aus der allgemeinen Ingenieurmathematik bekannt sind. Das folgende Unterkapitel 2.1 dient daher nur der Erinnerung. Es wird auffallen, dass die bereits in der Einleitung angedeutete Beschränkung auf das Rechnen mit ganzen Zahlen überwiegend zutrifft. Die zweite Gruppe geht auf ergänzende Hilfsmittel ein, die wahrscheinlich weniger geläufig sind. Sie werden im weiteren Verlauf an den Stellen angesprochen, wo sie erforderlich sind. Das Unterkapitel 2.2 kann daher zunächst übergangen und gleich das Kapitel 3 angesteuert werden.
2.1
Grundlagen aus der allgemeinen Ingenieurmathematik Das Gebiet der Codierungsverfahren hat sich aus der klassischen Nachrichtentechnik entwickelt und wurde sowohl von Ingenieuren als auch besonders von Mathematikern und Informatikern weiter untersucht. Es benutzt zur Beschreibung einige Hilfsmittel der Mathematik. Diese sind unerlässlich, stellen für den Ingenieur aber nicht unbedingt den einzigen Schwerpunkt dar. Für ihn kann es zunächst wichtiger sein, zur gegebenen Aufgabenstellung unter dem Blickwinkel der funktionssicheren, kostengünstigen Realisierung ein geeignetes Codierungsverfahren auszuwählen oder anzupassen. Dabei muss er sich – wenigstens fürs erste – auf die Beweisergebnisse der Mathematiker verlassen. Kann man sich dieser Auffassung anschließen, so verkleinert sich das vielleicht beunruhigende Gewicht des mathematischen Unterbaus erheblich. Was danach als Voraussetzung für das erste Verständnis erforderlich ist, beschränkt sich auf die folgenden Begriffe und Gebiete:
Ganzzahlrechnung
In der Codierungstheorie hat man es überwiegend mit ganzen Zahlen Z = ... -3, -2, -1, 0, 1, 2, 3 ... zu tun. Daher spielen Fragen der numerischen Genauigkeit, welche in anderen Bereichen der Ingenieurmathematik von sehr großer Bedeutung sind (z. B. bei der Lösung von Gleichungs- oder Differentialgleichungs-Systemen, bei der Eigenwertbestimmung usw.), im Allgemeinen keine Rolle. Das heißt aber, dass dann auch alle Ergebnisse „genau“ sind. Ausnahmen findet man allerdings bei den Verfahren mit
31
2 Mathematische Hilfsmittel
Endliche Ganzzahlkörper Zn
Endliche Ganzzahlmengen
Modulo-Funktion
32
„Soft Decision“, siehe Unterkapitel 3.4.5 und 3.12, sowie bei den Techniken zur verlustbehafteten Kompression, Unterkapitel 6.2. Die Elemente, aus denen sich die hier betrachteten Codewörter aufbauen, sind immer Teile eines endlichen Ganzzahlkörpers Zn (genau genommen brauchen wir sogar nur den nicht negativen Teil). Dieser Begriff wird noch etwas näher im Unterkapitel 2.2 erläutert, doch ist sicher schon jetzt einzusehen, dass dem binären Code die beiden Elemente "0", "1" aus dem Ganzzahlkörper Z2 zugrunde liegen. Ein ternärer Code baut sich aus den drei Elementen "0", "1", "2" des Körpers Z3 auf usw. Alle Rechnungen bewegen sich in endlichen Ganzzahlmengen. So besitzt der bekannte ASCII-Code mit 8 binären Informationsstellen (den Bits) genau 256 Codewörter, weil sich auf den beiden Zahlenelementen 0 und 1 des Binärsystems bei 8 Stellen 28=256 verschiedene Darstellungen bilden lassen. Das bedeutet, dass vollständige Lösungen prinzipiell immer durch systematisches Probieren gefunden werden können (wenn sich den Mathematikern hier wahrscheinlich auch die Haare sträuben). Tatsächlich hat diese Aussage aber nur einen sehr begrenzten Wert, da die betrachteten Zahlenräume, von harmlos aussehenden Beispielen angefangen (siehe der erwähnte ASCII-Code), derart groß werden können, dass die Probiermethode auch bei Einsatz von Superrechnern in einer vernünftigen Zeit kein Ergebnis mehr erbringt, eine Folge der Komplexität. Man kann dies erahnen, wenn man statt der 8 Binärstellen des ASCII-Codes auf die immer noch "normal" erscheinenden 128·8 = 1024 Binärstellen eines TCP/IP-Pakets geht. Hier sind 21024 = ca. 10340 Codewörter darstellbar, eine Menge, für deren Bildung ein Rechner selbst bei einer Erzeugungszeit von nur 10-9 Sekunden (1 Nanosekunde) 10331 Sekunden (= 10324 Jahre) benötigt. Dies zeigt überdeutlich, dass das Verfahrensverständnis und die durch mathematische Beweise abgesicherte allgemeine Gültigkeit der zugehörigen Lösungen unverzichtbar sind. Die Modulo-Funktion bestimmt mit z = x MOD y für die beiden reellen Zahlen x und y den Rest z, der sich (für positive x, y) nach fortlaufender Subtraktion x:= x - y ergibt, bis das Ergebnis kleiner als y ist (viele Taschenrechner, Interpreter und Compiler bieten diese Funktion). Bei anderen Vorzeichen von x und y gelten ähnliche Regeln. Für die vorliegenden Aufgaben kann man sich auf ganze Zahlen x, y beschränken. Im übrigen ist die Modulo-Funktion nicht nur für Zahlen, sondern auch für Polynome definiert. Da diese Eigenschaft bei den Codierungsverfahren oft verwendet werden muss, wird hierauf später noch eingegangen. Beispiele für die Modulo-Bildung mit ganzen Zahlen:
2.1 Grundlagen aus der allgemeinen Ingenieurmathematik Fall x0, y0:
Fall x0, y0:
Fall x0, y0:
Fall x0, y0:
13 MOD 7 = 6, 14 MOD 5 = 4,
da 6 = 13 - 1·7 da 4 = 14 - 2·5.
-31 MOD 9 = 5,
da 5 = -31 + 4·9
-1 MOD 2 = 1,
da 1 = -1 + 1·2.
230 MOD -3 = -1,
da -1 = 230 + 77·(-3)
86 MOD -18= -4,
da -4 = 86 + 5·(-18).
-12 MOD -9 = -3,
da -3 = -12 - 1·(-9)
-23 MOD -4 = -3, da -3 = -23 - 5·(-4). Man sieht hieraus, dass der Rest z nicht negativ ist, wenn negative Zahlen x und positive Zahlen y bei der Modulobildung vorliegen. Rechnet man immer nur mit anschließender Modulobildung bei positivem y, so sind unabhängig von allen möglichen negativen Zwischenergebnissen bei Subtraktionen die Endergebnisse immer nicht negativ. Die Rechenregeln für Addition, Subtraktion und Multiplikation gelten auch bei Modulobildung; außerdem bleiben das Assoziativgesetz (Vertauschung der Reihenfolge von Operationen) und das Kommutativgesetz (Vertauschung der Operanden) in Kraft. Beispiele: (7·13) MOD 5
= 91 MOD 5
=1
= ((7 MOD 5) · (13 MOD 5)) MOD 5 = (2·3) MOD 5
(7·(13-4)) MOD 5
= 6 MOD 5
=1
= 63 MOD 5
=3
= ((7·13) MOD 5 - (7·4) MOD 5) MOD 5 = (1 - 3) MOD 5 = (-2) MOD 5 Vektor- und Matrizenrechnung
=3
Das Rechnen mit Vektoren und Matrizen ist aus verschiedenen anderen Fachgebieten her bekannt. Als Besonderheit kommt hier lediglich hinzu, dass alle Rechenoperationen im Ganzzahlbereich und im allgemeinen auch mit der MOD-Funktion (siehe oben) durchgeführt werden. Beispiele: Addition zweier Vektoren der Dimension 5 mit Elementen im Ganzzahlkörper Z3:
33
2 Mathematische Hilfsmittel [1 0 2 1 2] + [1 1 2 2 0]
= [2 1 1 0 2],
((2+2) MOD 3 = 1 usw.)
Subtraktion dieser Vektoren: [1 0 2 1 2] - [1 1 2 2 0]
= [0 2 0 2 0],
((1-2) MOD 3
= 2 usw.)
Inneres Produkt dieser zwei Vektoren: [1 0 2 1 2] · [1 1 2 2 0]
= (1·1 + 0·1 + 2·2 + 1·2 + 2·0) MOD 3 = 7 MOD 3 = 1.
Polynome
Bei Matrizenoperationen läuft alles genauso ab, da diese in Zeilen- und Spaltenoperationen aufgeteilt werden, was wiederum den Vektoroperationen entspricht. Diese sind ebenfalls aus der Ingenieurmathematik bekannt. Eine Besonderheit im Rahmen der Codierungsverfahren liegt allerdings darin, dass die Koeffizienten Elemente eines endlichen Ganzzahlkörpers Zn sind. Ein Polynom 5-ten Grades mit Koeffizienten aus Z2 sieht demnach z. B. so aus: f(x)
= 1·x5 + 1·x4 + 0·x3 + 0·x2 + 1·x1 + 1 = x5 + x4 + x + 1.
Ein Polynom 4-ten Grades mit Koeffizienten aus Z5: f(x)
= 4·x4 - 2·x3 + 3·x2 - 4·x1 - 3 = 4·x4 + 3·x3 + 3·x2 + x + 2 (da z. B. (-2) MOD 5 = 3 ist).
Für alle Polynome gelten auch hier die aus dem Bereich der reellen Koeffizienten bekannten Regeln bezüglich Addition, Subtraktion, Multiplikation und Division, nur eben stets mit Ausführung der Modulobildung. Will man den Funktionswert eines solchen Polynoms berechnen, so dürfen für die unbestimmte Variable x nur Zahlen aus dem endlichen Körper Z5 eingesetzt werden. Es ist also im obigen Beispiel f(3)
= (4·34 + 3·33 + 3·32 + 3 + 2) MOD 5 = (324 + 81 + 27 + 3 + 2) MOD 5
2.2
= 2.
Weitere mathematische Hilfsmittel Wie schon erwähnt, beruhen die Verfahren zur Datenfehlerbeseitigung und Datenverschlüsselung auf mathematischen Grundlagen, die für den Ingenieur etwas außerhalb des gewohnten Rahmens von Algebra, Differential- und Integralrechnung liegen und daher manchem weniger geläufig sind. So ist bei "normalen" Ingenieuraufgaben das Rechnen im Bereich der reellen oder komplexen Zahlen erforderlich, während reine Ganzzahl-Operationen oder die Verwendung von Polynomen
34
2.2 Weitere mathematische Hilfsmittel
Mengen
mit ausschließlich ganzzahligen Koeffizienten praktisch nicht vorkommen. Aber gerade Codierungsverfahren bauen auf eben solchen Besonderheiten auf. Das wird vielleicht etwas verständlicher, wenn man berücksichtigt, dass Codes meistens nur aus Zahlen oder Symbolen in endlichen Wertebereichen definiert sind. Im einfachsten Fall können (bei einem binären Code) nur die beiden Werte 0 und 1 unterschieden werden. Weist man diesen beiden Werten physikalische Größen wie zum Beispiel die Spannungen -5 Volt und +5 Volt zu, so können durch Störungen auch abweichende Spannungen auftreten, aber man ist – zumindest bei Hard Decision-Verfahren (siehe Unterkapitel 3.1) – gezwungen, diese immer einer der beiden Zahlen 0 oder 1 zuzuordnen (Schmidt-Trigger). Die mathematischen Hilfsmittel für alle Rechnungen in solchen endlichen Wertebereichen liefert die Algebra, in der Mengen und ihre inneren Strukturen betrachtet werden. Mengen bestehen aus Elementen {a, b, c, d....}, etwa die Menge der natürlichen Zahlen N
= {0, 1, 2, 3, 4,...}
oder die der ganzen Zahlen Z
Halbgruppe
= {... -3, -2, -1, 0, 1, 2, 3 ...}.
Zwischen den Elementen sind Rechenoperationen, so genannte Verknüpfungen, möglich, die sich aber – abhängig von der jeweiligen Menge – nicht beliebig durchführen lassen. So kann man natürliche Zahlen innerhalb ihres Definitionsbereiches zwar ohne Einschränkung addieren und multiplizieren, nicht jedoch subtrahieren und dividieren. Bei der Arbeit mit mehr als einem Element ist darüber hinaus noch die Reihenfolge der Verknüpfungsoperationen zu beachten. Halbgruppe ¡
aEs ist eine innere Verknüpfung a+b = c oder a·b = d definiert, z. B. 1+2 = 3 oder 2·]3 = 6.
aEs gilt das Assoziativgesetz (a+b)+c = a+(b+c) oder (a·]b)·c=a]·(b·c). Mit diesen Festlegungen können einige bekannte Mengen bereits auf ihre Halbgruppeneigenschaft überprüft werden. So ist die Menge der natürlichen Zahlen N = {0, 1, 2, 3, 4,..} bezüglich Addition und Multiplikation eine Halbgruppe, nicht aber bezüglich der Subtraktion und Division. Die ganzen Zahlen Z = {..., -3, -2, -1, 0, 1, 2, 3 , 4,..} hingegen bilden auch für die Subtraktion eine Halbgruppe. Viele Verknüpfungen führen auf Elemente mit besonderen Eigenschaften, es sind dies die inversen und die neutralen Elemente. Bei den ganzen Zahlen Z gibt es bezüglich der Additi¡
35
2 Mathematische Hilfsmittel
Gruppen
on zu jedem positiven Element auch ein negatives, wobei die Verknüpfung selbst das Element 0 ergibt, also z. B. 2+(-2) = 0. "0" ist also ein neutrales Element, darüber hinaus sogar das einzige. Nun kann eine weitere algebraische Struktur definiert werden: Gruppen spielen eine Rolle bei Codes zur Datenfehlerbeseitigung (Codewörter bilden eine Gruppe). Die Menge, welche eine Gruppe darstellt, hat die Eigenschaft einer Halbgruppe, zusätzlich existieren aber noch: ¡
Ringe
ein neutrales Element und
¡ zu jedem Element a ein inverses Element ainv. Auch hier lassen sich wieder bekannte oder weniger bekannte Mengen auf die Gruppeneigenschaften prüfen. So ist z. B. (Z;+), d. h. die Menge der ganzen Zahlen bezüglich der Addition, eine Gruppe. Für die Multiplikation gilt dies nicht, da es in Z hierfür keine inversen Elemente gibt. Dies ist jedoch etwa für die Menge Q der rationalen Zahlen der Fall, da zu jedem Element a auch das inverse Element ainv = 1/a besteht und die Multiplikation a·(1/a) = 1 das neutrale Element "1" erbringt, wenn man die Zahl "0" ausnimmt. Demnach ist (Q\{0};]), d. h. die Menge der rationalen Zahlen ohne das Element "0" bezüglich der Multiplikation eine Gruppe. Gilt für die Verknüpfung auch das kommutative Gesetz a·]b = b·]]a, so nennt man diese Gruppe eine kommutative oder Abelsche Gruppe. Wenn in einer Menge nicht nur eine Verknüpfung, sondern deren zwei definiert sind, kommen weitere algebraische Strukturen hinzu. Ringe treten im Zusammenhang mit Codes zur Datenfehlerbeseitigung auf (Polynomringe über Erweiterungskörpern) und besitzen folgende Eigenschaften: ¡
Die Menge ist bezüglich der Addition eine kommutative Gruppe.
¡
Die Menge ist bezüglich der Multiplikation eine Halbgruppe.
¡
Es gelten für alle Elemente die distributiven Gesetze a·(b + c)=a·b + a·c
und (a + b)·c=a·c + b·c.
Die Menge der ganzen Zahlen bildet demnach nicht nur eine Gruppe, sondern einen Ring. Gilt in einem Ring, dass das Ergebnis einer Multiplikation nur dann Null ist, wenn wenigstens einer der beiden Faktoren selbst den Wert Null hat, dann bezeichnet man ihn als "nullteilerfrei". Gilt für die Verknüpfungen weiterhin noch das Kommutativgesetz und ist das neutrale Element der Multiplikation die "1", so liegt ein Integritätsring vor. Für die ganzen Zahlen trifft dies zu,
36
2.2 Weitere mathematische Hilfsmittel
Restklassenmengen
da unter anderem keine gleichzeitig von 0 verschiedenen Elemente existieren, für die aY]b = 0 wäre. Es gibt aber im Rahmen der weiteren Betrachtungen Mengen, die keine Nullteilerfreiheit aufweisen. Restklassenmengen sind von zentraler Bedeutung. Sie entstehen, wenn man in der Menge der ganzen Zahlen bei jedem Element und/oder bei jeder Verknüpfung die Modulo n-Operation durchführt (Abkürzung: MOD n). Dabei zieht man von jeder Zahl oder jedem Ergebnis einer Addition bzw. Multiplikation solange die Zahl n ab, siehe Seite 32 (oder addiert die inverse Zahl (-n) ), bis ein Rest kleiner als n übrig bleibt. Die Menge der so gebildeten Zahlen ist endlich (mit der so genannten Ordnung n) und erfüllt die genannten Ringeigenschaften. Eine Restklassenmenge z. B. Z5 = {0, 1, 2, 3, 4} wird aus allen ganzen Zahlen MOD 5 gebildet. Anhand einer Tabelle lassen sich hier alle möglichen Multiplikationsergebnisse aufstellen, da es sich um eine endliche Menge mit 5 Elementen handelt, die in 5·]5 = 25 verschiedenen Kombinationen multipliziert werden können. Bei geschachtelten Verknüpfungen entstehen dabei zwar auch Zwischenergebnisse, welche größer als 5 sind. Die Modulo 5-Operation kann man dann aber entweder bei jedem Teilergebnis oder zum Schluss anwenden. Beispiele: (2·4)·3 MOD 5
= 8·3 MOD 5 = 24 MOD 5
oder
=4
= (8 MOD 5) · (3 MOD 5) MOD 5 = 3·3 MOD 5 = 9 MOD 5
oder
=4
= (2 MOD 5 · 4 MOD 5) · 3 MOD 5 = (2·4) · 3 MOD 5 = 8·3 MOD 5
=4
und so weiter. Die Tabelle 2-1 für die Multiplikation aller Elemente paarweise untereinander sieht dann so aus: * 0 1 2 3 4
0 0 0 0 0 0
1 0 1 2 3 4
2 0 2 4 1 3
3 0 3 1 4 2
4 0 4 3 2 1
Tabelle 2-1: Paarweise Multiplikation aller Elemente im Z5
37
2 Mathematische Hilfsmittel Man erkennt, dass die Restklassenmenge Z5 nullteilerfrei ist. Bei Z6 trifft dies hingegen nicht zu, wie Tabelle 2-2 zeigt. Z 6 bildet also keinen Integritätsring. * 0 1 2 3 4 5
0 0 0 0 0 0 0
1 0 1 2 3 4 5
2 0 2 4 0 2 4
3 0 3 0 3 0 3
4 0 4 2 0 4 2
5 0 5 4 3 2 1
Tabelle 2-2: Paarweise Multiplikation aller Elemente im Z6 Generell sind Restklassenmengen aus ganzen Zahlen immer nur dann nullteilerfrei, wenn man die Restklassenbildung über MOD n mit Primzahlen n durchführt. Verständlich wird das aus der Definition der Primzahlen: Primzahlen sind alle natürlichen Zahlen, die sich ohne Rest nur durch 1 und sich selbst teilen lassen, also 2, 3, 5, 7, 11, 13, ... usw. Sie können demnach nicht in ganzzahlige Faktoren zerlegt werden. Körper
Ideal
38
Körper ist ein zentraler Begriff für alle Codierungsverfahren, z. B. Erweiterungskörper, Körpererweiterungen: Wenn eine Menge einen Ring bildet und zusätzlich bezüglich der Multiplikation eine Gruppe darstellt, also zu jedem Element a (außer a=0) ein inverses Element ainv existiert, so dass a](ainv)=1 gilt, so stellt diese Menge einen Körper dar. Für die Menge der ganzen Zahlen trifft dies nicht zu (Warum?), wohl aber für die Menge Q der rationalen Zahlen. Aber auch spezielle Restklassenringe sind Körper, nämlich alle, die aus der Modulo-Bildung bezüglich einer Primzahl hervorgegangen sind, wie z. B. Z3, Z5 usw. Dies erscheint vielleicht erstaunlich, da man bei Betrachtung der Tabelle 2-1 zunächst gar keine inversen Elemente erkennt. Aus dem Alltag ist man nur mit Bruchzahlen als inversen Elementen vertraut, die Definition des inversen Elements bezüglich der Multiplikation lässt aber auch ganzzahlige Inverse zu. Es muss nur gelten a·ainv = 1. Das trifft im Beispiel gemäß Tabelle 2-1 etwa für 2] ·3 MOD 5 = 1 zu. Also ist 3 das inverse Element zu 2. Da jedes Element außer 0 ein Inverses besitzt, ist die Restklassenmenge Z5 demnach nicht nur ein Ring, sondern ein Körper. Bildet eine Menge einen kommutativen Ring und gibt es darin eine Untergruppe zur Additionsgruppe, dann ist diese Untergruppe ein Ideal, wenn alle paarweisen Produkte zwischen
2.2 Weitere mathematische Hilfsmittel den Elementen des Ringes und der Untergruppe wiederum Elemente der Untergruppe sind. Ein Beispiel: Die Menge der ganzen Zahlen ist ein kommutativer Ring. Die Additionsgruppe hierin ist in diesem Fall die Menge selbst, mit "0" als neutralem Element. Es gilt ja, dass jedes Element mit jedem beliebigen anderen (oder mit sich selbst) addiert werden kann und dabei wieder ein Element der Menge entsteht. Inverse Elemente (-a), zu ihren Partnerelementen a addiert, bringen als Ergebnis das neutrale Element "0". Bei den natürlichen Zahlen trifft dies z. B. aber nicht zu. Eine Untermenge wären etwa alle geraden Zahlen {... -6, -4, -2, 0, 2, 4, 6...}. Jede paarweise Addition ergibt wieder ein Element der Untermenge selbst, also ist die Untermenge auch eine Gruppe mit "0" als neutralem Element. Aber auch dann, wenn diese Untermenge mit einem beliebigen Element aus der Menge der ganzen Zahlen multipliziert wird, entstehen nur Elemente, die ebenfalls ausschließlich in der Untermenge enthalten sind: 2· {...-6, -4, -2, 0, 2, 4, 6...}
= {... -12, -8, -4, 0, 4, 8, 12, ...}.
Für die ungeraden Zahlen stimmt dies nicht, da die Addition zweier ungerader Zahlen immer eine gerade Zahl ergibt und die Ergebnismenge nicht in der Untermenge enthalten wäre. Allgemein sind Ideale aus dem Ring der ganzen Zahlen die Teilmengen, die durch Multiplikation einer natürlichen Zahl n mit der Menge der ganzen Zahlen entstehen. Für n = 7 etwa ist 7 · {..., -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, ...} = {..., -35, -28, -21, -14, -7, 0 ,7, 14, 21, 28, 35, ...}, da die Gruppeneigenschaft vorliegt und die Multiplikation des Ideals mit einer beliebigen ganzen Zahl wieder auf eine Teilmenge des Ideals führt. Verwendet man bei dem oben angegebenen Beispiel als Element der ganzen Zahlen etwa -8, so erhält man -8 · { ...,-35, -28, -21, -14, -7, 0, 7, 14, 21, 28, ...} = {..., -280, -208, -168, -112, -56, 0, 56, 112, 168, 280,...} Primideale
Polynome
und damit eine Teilmenge der Untergruppe. Primideale sind z. B. beim Ring der ganzen Zahlen solche Ideale, zu deren Erzeugung als Multiplikator n eine Primzahl gewählt wurde. Eine ganze Reihe von Codes zur Datenfehlerbeseitigung (zyklische Codes) werden in der Form von Polynomen dargestellt. Bisher wurden nur Zahlen – genau genommen nur ganze Zahlen – betrachtet. Der Elementbegriff bei Mengen ist aber ganz abstrakt, weshalb auch ganz andere Elementtypen einbezogen
39
2 Mathematische Hilfsmittel werden können. Allerdings scheinen nur wenige für einen praktischen Gebrauch interessant zu sein. Solche Elemente können auch Polynome sein. Es ist aus technischen Gründen sinnvoll, die Werte der Koeffizienten und der Polynom-Variablen auf ganze Zahlen zu beschränken. Genau genommen sind sogar nur ganze Zahlen MOD n interessant. Z. B. gibt es einen Ring von Polynomen über einem endlichen Körper, etwa Z2. Die Koeffizienten (und gegebenenfalls x) haben dann nur die Werte 0 oder 1. Wählt man ein irreduzibles, d. h. ein nicht weiter in Polynome kleineren Grades zerlegbares Polynom, z. B. f(x) = x2 + x1 + 1 (es entspricht in dieser Eigenschaft der Primzahl aus den Zahlenmengen), so bilden alle Polynome MOD f(x) eine endliche Menge von "Restpolynomen", die wieder die Ringeigenschaften aufweisen. Algebraische Kör- Algebraische Körpererweiterungen sind ein zentraler Begriff für pererweiterungen Codes zur Datenfehlerbeseitigung (Nullstellen von irreduziblen Polynomen über endlichen Körpern). Wenn der Begriff "Körpererweiterung" im Augenblick vielleicht noch wenig sagt, so ist er unter anderen Bezeichnungen doch schon vertraut. Ingenieure arbeiten häufig mit komplexen Zahlen, und genau diese bilden einen Erweiterungskörper zu den reellen Zahlen. Um das verstehen zu können, betrachten wir das Polynom f(x)
= x2 + x + 1.
Es hat die beiden konjugiert komplexen Nullstellen x1,2 = 0.5 ±
0.5 1 2
= 0.5 ± 0.5 3i, mit i =
1
welche nicht zum Körper der reellen Zahlen gehören. Da diese komplexen Zahlen den Bereich der reellen Zahlen erweitern, soll geklärt werden, wie das funktioniert. Die Antwort erhält man über die Frage nach den Nullstellen eines irreduziblen Polynoms. Das klingt zunächst widersprüchlich, denn ein irreduzibles Polynom zeichnet sich gerade durch die Tatsache aus, dass es keine Nullstellen hat. Diese Feststellung trifft aber nur für Nullstellen im Körper der reellen Zahlen zu, nicht für solche aus den komplexen Zahlen, wie man am obigen Beispiel sieht. Eine Schlüsselstellung hat dabei die imaginäre Zahl i = c-1. Sie ergibt sich, wenn man sie als eine der Nullstellen des Polynoms g x = x 2 1
definiert: gi = i2 1 = 0, mit i = 1
Erweitert man den Körper der reellen Zahlen um dieses Element
40
2.2 Weitere mathematische Hilfsmittel i, so entsteht der Erweiterungskörper der komplexen Zahlen, in dem jedes Polynom n-ten Grades nach dem berühmten Fundamentalsatz der Algebra wenigstens eine Nullstelle hat. Diese Erklärung ist mathematisch gesehen zwar noch nicht einwandfrei, mag aber für das erste Verständnis genügen. Wie sieht es bei Erweiterungen eines endlichen Körpers aus? Ähnlich wie im Fall der reellen Zahlen entsteht hier eine solche Erweiterung, wenn ein irreduzibles Polynom über diesem endlichen Körper vorliegt und man wieder Nullstellen hierzu definiert. Als Beispiel betrachten wir das Polynom f(x)
= x3 + x + 1
über Z2. Die Nullstelle a muss die Beziehung f(a)
= a3 + a + 1 = 0
erfüllen, der Wert von a kann aber nicht in Z2 liegen, da sonst ein Linearfaktor (x – a) vorhanden und damit f(x) reduzibel wäre. Dabei ist die Frage unerheblich, wie a tatsächlich „aussieht", bei der imaginären Zahl i macht man sich vermutlich auch keine Gedanken, welche Bedeutung diese für unsere reale Welt hat. Es reicht, wenn man mit ihr rechnen kann und dabei Ergebnisse erhält, die am Ende nützlich für die reale Welt sind. Für a gelten die Beziehungen a a
=a 2
= a2
a3
= a + 1 *)
a4
= a2 + a
a5 = a3 + a2
= a2 + a + 1
a6 = a3 + a2 + a = a2 + a + a + 1
= a2 + 1.
*)
(aus der o. a. Nullstellenbeziehung)
Der erweiterte Körper enthält damit zusätzlich zu 0 und 1 noch die angegebenen 6 Elemente als Potenzen von a. Mehr gibt es nicht, da sich ab a7 alles wiederholt: a7 = a3 + a
=a+1+a
=1
= a0 .
Primitives Element Das primitive Element hat eine zentrale Funktion bei Codes zur Datenfehlerbeseitigung (Nullstellen eines irreduziblen Polynoms, Minimalpolynome). Das oben verwendete Nullstelle a weist die Eigenheit auf, dass sich daraus mit Ausnahme des Elementes 0 alle anderen Körperelemente durch Potenzierung ergeben. Daher nennt man es auch primitives Element.
41
2 Mathematische Hilfsmittel Ordnung eines Körperelements
Galoiskörper
Die Ordnung eines Körperelements ist ein wichtiger Begriff für einige Codes zur Datenfehlerbeseitigung (Codewortlänge). Wie zu sehen war, wird die Potenz ae des primitiven Elements a des Erweiterungskörpers bei einem bestimmten Exponenten e wieder gleich 1, im Beispiel zuvor war e=7, da a7 = 1. Dieser Exponent e heißt Ordnung des Elements a. Die Elemente eines Körpers müssen allerdings nicht alle dieselbe Ordnung haben. Außerdem ist die Ordnung nicht nur in Erweiterungskörpern definiert. So hat die Zahl 3 im Körper Z5 die Ordnung 4, die Zahl 4 aber nur die Ordnung 2 (weil 42 MOD 5 = 1 ist!). Man erkennt daraus, dass ein primitives Element die maximale Ordnung in diesem Körper haben muss, da sich sonst die anderen Elemente nicht durch Potenzierung hieraus darstellen lassen. Galoiskörper sind wesentliche Hilfsmittel bei der Konstruktion von Codes zur Datenfehlerbeseitigung und Verschlüsselung (Erweiterungskörper). Ein Galoiskörper ist die algebraische Erweiterung eines endlichen Körpers Zp bezüglich der Nullstelle a eines irreduziblen Polynoms über Zp vom Grad m, wobei p eine Primzahl sein muss. Dieser Körper wird dann auch mit GF(pm) – als Abkürzung für Galoisfeld – bezeichnet. Zum Beispiel definiert die Nullstelle des über Z2 irreduziblen Polynoms f(x) = x4 + x + 1
Charakteristik
Minimalpolynom
42
ein primitives Element des Galoisfeldes GF(24). Dieser Körper enthält also 16 Elemente. Die Charakteristik spielt eine Rolle bei Berechnungen innerhalb aller Codierungsverfahren. Die Charakteristik p eines endlichen Körpers ist diejenige Anzahl von "1"-Elementen, deren Summe MOD p gerade 0 ergibt. Für Z2 ist wegen (1 + 1) MOD 2 = 0 demnach ist p = 2, für Z5 wird wegen (1 + 1 + 1 + 1 + 1) MOD 5 = 0 die Charakteristik p=5. Aber auch alle Erweiterungskörper GF(2m) haben die Charakteristik p=2, bzw. alle GF(5m) die Charakteristik p=5. Daraus folgt: ¡
Die Summe von p gleichen, aber sonst beliebigen Körperelementen ist immer 0. Z. B. gilt im GF(23): a5 + a5 = 0.
¡
Die binomische Formel (a + b)p enthält keine gemischten Glieder: (a + b)p
= ap + bp
oder (a + b + ... + x)p
= ap + bp + .... + xp.
Begriff für Codes zur Datenfehlerbeseitigung und für Schieberegisterfolgen. Ein Minimalpolynom ist das über Zp irreduzible Polynom kleinsten Grades mit dem primitiven Element als eine der Nullstellen. Eulerfunktion: Begriff für Codes zur Verschlüsselung. Die Eulerfunktion, auch Eulersche -Funktion genannt, gibt die Anzahl
2.2 Weitere mathematische Hilfsmittel Eulerfunktion
der zu einer natürlichen Zahl n teilerfremden natürlichen Zahlen an, die kleiner sind als die Zahl n selbst. Beispiele: da die Zahlen 1, 2, 3 und 4 keinen gemeinsamen Teiler mit 5 haben, da 1, 5, 7, 11, 13 und 17 keinen gemeinsamen Teiler mit 18 haben.
(5) = 4 (18) = 6
Für Primzahlen p gilt immer (p)
= p - 1.
Für das Produkt p·q zweier Primzahlen p und q ist die Eulerfunktion (p·q) Satz von Euler
= (p-1)·(q-1).
Der Eulersche Satz ist für einige Verschlüsselungsverfahren (RSAAlgorithmus) nützlich. Er besagt, dass für zwei teilerfremde Zahlen a und b die Beziehung a(b) MOD b
=1
gilt. Eine Spielart ergibt sich, wenn b das Produkt zweier Primzahlen b=p]]q ist (siehe oben): = a(p-1)·(q-1) MOD p·q.
a(p·q) MOD pq
Euklidischer Algo- Der Euklidische Algorithmus ist ein wesentliches Hilfsmittel bei vielen Codierungsverfahren. Er dient zum Bestimmen des größrithmus ten gemeinsamen Teilers zweier Zahlen oder zweier Polynome. Für zwei Zahlen r0 und r1 gilt: r0 = q1·r1 + r2 (q1 drückt aus, wie oft r1 in r0 passt, r2 ist der ganzzahlige Rest) r1
=
q2·r2
+ r3
...
=
...
+…
rn-3
=
qn-2·rn-2
+ rn-1
rn-2
=
qn-1·rn-1
+ rn
rn-1
=
qn·rn
+0.
Der Algorithmus endet also, wenn der Rest rn+1 Null geworden ist. Die Zahl rn stellt den gesuchten größten gemeinsamen Teiler dar. Beispiel mit r0=48, r1=18: 48
= 2·18
+ 12
18
= 1·12
+6
12
= 2·6
+ 0.
Die Zahl 6 ist der größte gemeinsame Teiler, ggT(48,18) = 6.
43
2 Mathematische Hilfsmittel Euklidischer Algo- Für Polynome funktioniert der Euklidische Algorithmus ganz rithmus für Poly- ähnlich. Beispiel für zwei Polynome über Z2: nome r0(x) = x6 + x4 + x + 1 und r1(x) = x5 + x + 1, x6 + x4 + x + 1
= x·(x5 + x + 1)
+ (x4 + x2 + 1)
x5 + x + 1
= x·(x4 + x2 + 1)
+ (x3 + 1)
x4 + x2 + 1
= x·(x3 + 1)
+ (x2 + x + 1)
x3 + 1
= (x + 1)·(x2 + x + 1)
+ 0.
Hier ist das Polynom x2 + x + 1 der größte gemeinsame Teiler von r0(x) und r1(x). Bei teilerfremden Polynomen stellt das Restglied rn(x) ein Polynom nullten Grades dar, also eine Zahl. Diese ist für Polynome über andere endliche Körper als über den Z2 im allgemeinen von 1 verschieden, siehe Seite 167. Noch ein Hinweis: Die in jedem Teilschritt des Euklidischen Algorithmus notwendigerweise durchzuführenden Polynomdivisionen werden im Z2 bezüglich der Koeffizienten immer MOD 2 berechnet, also ergibt sich im ersten Teilschritt (x6 + 0·x5 + x4 + 0·x3 + 0·x2 + x + 1) x6
: (x5 + x + 1) = x + h(x)
+ x2 + x
________________________________________ mit Modulare inverse Zahlen und Polynome
x4
+ x2
h(x) =
5
+1
Rest = r(x)
r(x)/(x + x + 1).
Modulare inverse Zahlen und Polynome werden in einigen Decodier- und Verschlüsselungsverfahren (RSA-Algorithmus) benötigt. Für Zahlen gilt: Sind a und b teilerfremd, also ggT(a,b) = 1, so gibt es immer eine Zahl c, die Modulo a invers zu b ist, also die Eigenschaft b·c MOD a
=1
aufweist. Solche Zahlen hatten wir im Zusammenhang mit der Betrachtung von endlichen Körpern bereits kennen gelernt, siehe Tabelle 2-1. Der Begriff leitet sich aus den von unendlichen Körpern bekannten Verhältnissen her, nachdem es zu jedem Element b (außer für b=0) ein inverses Element binv gibt, für das b·binv=1 gilt. Beispiel: 7 ist ein Modulo 6 inverses Element zu 13, da 13·7 MOD 6 =1 ist.
44
2.2 Weitere mathematische Hilfsmittel Modulare inverse Elemente lassen sich über eine Umkehrung des oben beschriebenen Euklidischen Algorithmus berechnen. Man setzt r0 = a und r1 = b und durchläuft den Euklidischen Algorithmus, bis sich das Restglied rn = 1 ergibt, Voraussetzung ist ggT(a,b) = 1. Eine Fortführung der Rechnung bis rn+1 = 0 ist in diesem Sonderfall unnötig. Dabei merkt man sich die Faktoren q1, q2, ...., qn-1. Die Gleichung des letzten Schrittes wird nach rn aufgelöst und es entsteht: =1 = 1·rn-2 - qn-1·rn-1 , rn oder mit den Abkürzungen z0 = 1 und z1 = - qn-1 = z0·rn-2
+ z1·rn-1
= z0·rn-2
+ z1·[rn-3 - qn-2·rn-2]
= z1·rn-3
+
[z0 - qn-2·z1]·rn-2 ,
oder mit der Abkürzung z2 = z0 - qn-2·z1 = z1·rn-3
+ z2·rn-2
= z1·rn-3
+ z2·[rn-4 - qn-3rn-3]
= z2·rn-4
+
[z1 - qn-3·z2]·rn-3 ,
oder mit der Abkürzung z3 = z1 - qn-3·z2 = z2·rn-4
+ z3·rn-3
............................. = zn-2·r0 + zn-1·r1 . Die abkürzenden Ausdrücke zi stehen zueinander in der rekursiven Beziehung zi
= - qn-i·zi-1 + zi-2
mit
i = 2, 3, 4, ...., n-1
und z0 = 1, z1 = -qn-1 , die man leicht auswerten kann. Wird auf den letzten Schritt dieser Rückwärtsrechnung die MOD-Funktion mit r0 angewendet, so erhält man 1 MOD r0
=1
= zn-2·r0 MOD r0
+ zn-1·r1 MOD r0
=0 + zn-1·r1 MOD r0 , und zn-1 ist das modulare Inverse zu r1 bezüglich r0. Damit steht ein einfaches Verfahren zur Berechnung modularer inverser Zahlen zur Verfügung. Sonderfall: Wenn der Euklidische Algorithmus bereits in der ersten Zeile den Rest r2 = 1 ergibt, braucht die oben beschriebene Rekursion nicht durchlaufen zu werden. Hier ist n = 2, z1 = -q1 ist bereits die gesuchte modulare inverse Zahl. Beispiel: Für a = r0 = 43 und b = r1 = 20 erhält man mit dem Euklidischen Algorithmus die 3 Faktoren q1 = 2, q2 = 6 und q3 = 1.
45
2 Mathematische Hilfsmittel Da das Restglied rn = r4 = 1 ist, steht fest, dass es sich bei a und b um zwei teilerfremde Zahlen handelt und der Algorithmus im Schritt 3 beendet werden kann, n = 4. Mit z0 = 1 und z1 = -1 liefert die Rückwärtsrechnung: z2
= z0 - q2·z1
= 1+6
= 7
z3
= z1 - q1·z2
= -1 - 2·7
= -15 ,
und z3 = -15 (oder z3 = 28, warum?) ist die gesuchte modulare inverse Zahl zu 20 bezüglich 43. Probe: - 15·20 MOD 43
Fermat'sches Theorem
= -300 MOD 43
= 28·20 MOD 43 = 1.
Das Verfahren zur Berechnung modularer inverser Polynome läuft ganz entsprechend ab, r0(x) und r1(x) müssen als größten gemeinsamen Teiler dann ein Polynom nullten Grades haben. Dieses, eine Zahl, kann für Polynome über anderen endlichen Körpern als über den Z2 von 1 verschieden sein. Ein Beispiel hierzu findet man auf Seite 167 Das Fermat'sche Theorem ist hilfreich für das Verständnis der zyklischen Eigenschaften eines zyklischen Codes. Für endliche Körper mit n Elementen gilt, dass die n Linearfaktoren eines Polynoms mit den Körperelementen als Nullstellen das Polynom xn - x
= (x - a1)·(x - a2)·(x - a3)· .....
·(x - an)
bilden. Für GF(2 ) gilt z. B. mit einem primitiven Element und 3
1 = 0, 2 = 0 = 1 usw. x8 - x
= x·(x - 1)·(x - )· (x - 2)·...... ·(x - 6).
Wenn man die Nullstelle x = 0 nicht berücksichtigt, erhält man die Darstellung x7 – 1
Häufigkeit
Wahrscheinlichkeit P(x)
46
= (x - 1)·(x - )·(x - 2)· ......
·(x - 6).
Diese steht in engem Zusammenhang mit den so genannten Kreisteilungspolynomen, siehe Seite 106. Hat man eine Menge von n diskreten Zahlenwerten, so kann man ermitteln, wie oft - oder mit welchem prozentualen Anteil jeder Wert vorkommt. Im einfachen Fall eines binären ElementStromes treten nur Nullen und Einsen auf. Werden auf 1000 Bits 467 Nullen und 533 Einsen festgestellt, so betragen die Häufigkeiten „0“
46,7%
„1“
53,3%
Würde sich daran bei der Auswertung der nächsten 1000 Bits, der übernächsten usw. nichts Wesentliches ändern, so kann das Vertrauen in die Annahme steigen, dass auch der folgende Tausenderblock oder eine Teilmenge und überhaupt alle wei-
2.2 Weitere mathematische Hilfsmittel teren Mengen die gleichen Häufigkeiten aufweisen. Man wagt dann die Vorhersage, dass die zukünftigen Nullen und Einsen mit der Wahrscheinlichkeit 46,7% bzw. 53,3% erscheinen werden. P(x=0) = 0.467 P(x=1) = 0,533
Wahrscheinlichkeitsdichte p(x)
Aber Vorsicht: Das kann sich abhängig von sich ändernden Umgebungsbedingungen ebenfalls ändern. Häufigkeits- und Wahrscheinlichkeitsbetrachtungen stellen bei den zufällig einwirkenden Fehlereinflüssen in Übertragungskanälen ein wirksames Hilfsmittel zur Optimierung von Fehlerkorrekturverfahren dar, insbesondere bei der so genannten Soft Decision-Decodierung. Wenn die im Blickfeld stehenden Zahlenmengen sehr groß und fein gestuft sind, empfiehlt sich der Übergang zu Verteilungsdichte- bzw. WahrscheinlichkeitsdichteFunktionen p(x). Sie stellen dar, welchen Anteil an der sehr großen Gesamtmenge – oo x + oo ein sehr schmaler „Streifen“ dx an der Stelle x bis x + dx hat. Ein Beispiel bildet die Gauß'sche Normalverteilung mit der Dichte 2
p x=
Zentraler Grenzwertsatz
AWGN
1
2
2
e
xxm 2
2
Das ist die berühmte Funktion der Glockenkurve. Viele Vorgänge in Natur und Technik zeigen angenähert das dadurch beschriebene Verhalten: Von einem mittleren Wert xm (= Mittelwert) aus betrachtet, nehmen negative und positive Zahlen bei wachsendem Betrag anteilig ab. Wie „rasch“ dies geht, wird durch die Standardabweichung V charakterisiert. Dieser besagt, dass sich die Summe irgendwelcher zufällig verteilter Ereignisse den Eigenschaften einer Normalverteilungsdichte nähert. Daher erscheint es bei manchen realen Umgebungsbedingungen – mit entsprechender Vorsicht – gerechtfertigt, für Fehlereinflüsse Normalverteilungen anzunehmen. AWGN (= Additive White Gaussian Noise) ist ein Rausch- oder Störsignaltyp, den man zur Vereinfachung und stellvertretend für die unterschiedlichen, in Übertragungskanälen einwirkenden Störungen annimmt, um Fehlerbetrachtungen durchzuführen. Die Bezeichnung „weiß“ ist die Kennzeichnung für das zeitlichdynamische Verhalten der Störsignale: Man nimmt an, dass deren Frequenzspektrum in Abhängigkeit zur Bandbreite B des Kanals so gut wie konstant ist (so, wie weißes Licht auch alle Frequenzanteile mit etwa gleicher Intensität enthält)
47
2 Mathematische Hilfsmittel Verbundwahrscheinlichkeit P(vs,ws)
Bedingte Wahrscheinlichkeit P(vs|ws)
Bayes-Formel
Treten zwei Ereignisse vs und ws zugleich ein, so kann man zählen, wie häufig eine bestimmte Paarung aus einer Gesamtanzahl von Paarungen auftritt. Das darauf bezogene Ergebnis ist die Verbundwahrscheinlichkeit P(vs,ws). Bei der Übertragung von Informationen kann es zum Beispiel nützlich sein zu wissen, welche Verbundwahrscheinlichkeit P(vs,ws) gesendete und empfangene Signale vs und ws aufweisen. Bei voneinander unabhängigen Ereignissen gilt P(x,y) = P(x)·P(y), gesendete und empfangene Signale sind aber natürlich abhängig. Wegen der sehr vielen möglichen diskreten Werte der Empfangssignale ist hier die Verwendung der Verbundwahrscheinlichkeitsdichte p(x,y) zweckmäßig. Um das gesendete Signal vs festzustellen, wird das Empfangssignal ws gemessen. Wegen der Störungen ist die Frage zu beantworten, „wie gut“ ws das gesendete Signal wiedergibt. Die Antwort ist die Verbundwahrscheinlichkeit. Bei geringem Störpegel wird sie groß, bei starken Störsignalen klein sein. Ähnlich wie bei der Verbundwahrscheinlichkeitsdichte kann hier die alternative Verwendung der bedingten Wahrscheinlichkeitsdichte p(vs|ws) zweckmäßig sein. Manchmal lässt sich die bedingte Wahrscheinlichkeit P(ws|vs) leichter angeben als der Ausdruck P(vs|ws), d. h. die Antwort auf die Frage, wie groß die Wahrscheinlichkeit ist, ein bestimmtes Signal ws zu empfangen, wenn man das Sendesignal bereits kennt. Dann gestattet die Bayes-Formel eine Umrechnung: P v sw s =
2.3
P v s , ws
Was blieb? 1. 2. 3.
4.
5. 6.
48
P w sv s P vs
Was ist die inverse Zahl zu 35 Mod 74? Ist die Restklassenmenge aller ganzen Zahlen MOD 57 ein Körper? Wie lauten die Elemente des Erweiterungskörpers für die Nullstelle des über Z2 irreduziblen Polynoms x4 + x3 + x2 + x + 1 ? Welche Verteilungsdichtefunktion p(x) hat ein AWGNRauschen mit dem Effektivwert 0.5 Volt und dem Mittelwert -1.2 Volt? Restpolynom (x7 + 1) MOD (x3 + x2 + 1) über Z2 ? Wie wird in erster Näherung die Häufigkeitsverteilung der Geburtstage der Menschen bezogen auf die Kalendertage des Jahres sein?
3
Fehlerbeseitigung In diesem Kapitel werden einige der heute aktuellen Codierungsverfahren zur Datenfehlerbeseitigung beschrieben. Nachdem in Unterkapitel 3.1 der technische Prozess der Fehlerentstehung betrachtet wird, machen in 3.3 der Wiederholungscode und das Verfahren zur systematischen Suche nach Codewörter-Mehrfachpaaren den Anfang. Beide Spielarten nutzen die Vorgabe des gewünschten Mindestabstandes unmittelbar. Obwohl es nahe liegt, diesen Weg überhaupt bei der Erzeugung von Codes zu beschreiten, ist er – wenigstens zu Zeit – noch von geringem praktischen Nutzen. Wegen seiner Einfachheit und zur Abrundung der sehr unterschiedlichen Gestaltungsmöglichkeiten für die Erzeugung von Codes lohnt es sich dennoch, einen kurzen Blick darauf zu werfen, zumal der Einsatz leistungsstarker Rechner bei den systematischen Suchverfahren eine Wende bringen könnte. Von großer Bedeutung sind der Hamming-Code, Unterkapitel 3.4, und die zyklischen Codes mit ihren vielseitigen Varianten, Unterkapitel 3.7. Sie nutzen pfiffige Verfahren sowohl bei der Bildung der Codewörter als auch zur Decodierung und stellen den heutigen Standard für Fehlerkorrektur und Fehlererkennung dar. Der Goppa-Code im Unterkapitel 3.8 steht in einem interessanten Zusammenhang zu den zyklischen Codes. Wenn er sich gegenüber diesen auch weniger für den praktischen Einsatz zur Fehlerkorrektur eignet, so hat er aber Eigenschaften, die sich mit Vorteil sowohl bei der Decodierung zyklischer Codes (3.7) als auch bei der Datenverschlüsselung verwerten lassen (5.7). Einen noch anderen, sehr effektiven Weg geht das Verfahren von Reed-Muller zur Fehlerkorrektur, Unterkapitel 3.7. Ein Blick auf die Technik des Interleavings in 3.10, sowie zu den modernen Produkt- und Faltungscodes in 3.11, 3.12 und 3.13 schließt die Betrachtungen zur Datenfehlerbeseitigung ab.
3.1
Der Prozess der Fehlerentstehung Was sind Fehler und wie entstehen sie? Diese trivial erscheinende Frage soll dennoch etwas genauer betrachtet und beantwortet werden, da sich hieraus unmittelbare Folgen für die Arten ihrer Beseitigung ergeben. Dabei hilft ein Blick auf den Prozess, den ein Informationsstrom mathematisch und technisch
49
3 Fehlerbeseitigung vom Sender zum Empfänger durchläuft. Bild 3.1 zeigt den prinzipiellen Ablauf.
Codierung der Info-Bits u = u1, u2, ...., uk
Sendesignal vs = vs1, vs2, ...., vsn
Rauschen rs = rs1, rs2, ...., rsn
Decodierung zu Schätzwerten für die InfoBits û = û1, û2, ...., ûk
+
Empfangssignal ws = ws1, ws2, ...., wsn
Bild 3.1: Prozess der Informationsübertragung und Fehlerbeseitigung Das Informationswort u wird durch Prüfbits yi zum Codewort v erweitert: v = u1, u2, ......, uk , y1, y2, ym = v1, v 2, ........, vn
Die symbolischen 0/1-Folgen von v erhalten durch Modulation eine zur weiteren Übertragung geeignete technische Form als Spannungs- , Strom- oder Frequenzwerte und können nun als Sendesignal vs über den Kanal (Drahtleitungen, Glasfasern, Funkstrecken) zum Empfänger geschickt werden. Auf dem Kanal überlagern sich verschiedene Formen von Störungen rs ( thermisches Rauschen, diskrete Störimpulse durch Abschaltvorgänge), so dass beim Empfänger ein entstelltes Signal ws eintrifft, welches durch geeignete Maßnahmen in einen Schätzwert û für die gesendete Information u abgebildet werden muss. Die Güte dieser Abbildung, d. h. die „Trefferquote“, hängt vom
50
3.1 Der Prozess der Fehlerentstehung Mindestabstand dmin des Codes, dem Signal/Rausch-Verhältnis SNR und weiteren Einflüssen ab.
Bild 3.2: Darstellung der Signale u, us (hier us = vs), rs, ws, whd (= w ) und e für die zu übertragende Zeichenkette „Geiz“ Für das Beispiel der Zeichenkette „Geiz“ aus dem genialen Slogan „Geiz ist geil“ sind die einzelnen Signale im Zeitdiagramm Bild 3.2. dargestellt. Die Definitionen finden wir auf Seite 15. Die Infobits sind gemäß Tabelle 1-1 auf Seite 6 als Folge 0100 0111 0110 0101 0110 1001 0111 1010 gegeben. Die Sendefolge us ist hier uncodiert, vs = us, es wurden also keine Prüfbits hinzugefügt, was aber für diese Darstellung unerheblich bleibt.
51
3 Fehlerbeseitigung Codieren = Maximieren des Abstandes
Zwei Wege des Decodierens
3.2
Wie zu sehen, ist das Verfahren zur Erzeugung der Codewörter beim Sender (oberer Prozessteil) einheitlich. Hier geht es unabhängig vom gewählten Weg immer darum, durch die Prüfbits die paarweisen Hammingabstände aller Codewörter untereinander möglichst groß zu machen, damit sie sich aus dem „Pulverdampf“ des überlagerten Rauschens noch rekonstruieren lassen. Dagegen kann die Decodierung beim Empfänger auf zwei grundsätzlich verschiedene und auch verschieden leistungsfähige Arten durchgeführt werden. Der einfachere Weg ist der der Hard-Decision-Decodierung, der algebraisch geschieht. Er ist mit weniger Aufwand verbunden, läuft deshalb verhältnismäßig schnell ab, führt aber nicht ganz zu den guten Ergebnissen, die mit der Soft-Decision-Decodierung theoretisch erreichbar sind. Der Grund liegt darin, dass man wegen der zweiwertigen Entscheidungsfindung nicht die vollen Informationen nutzt, die in den analogen Werten des Empfangssignals ws stecken. Ziel ist letztlich, die Häufigkeit oder Rate unerkannter Fehler im Schätzwert û statistisch klein zu halten. Hierbei sind Werte kleiner als 10-6 (1 unerkanntes Fehlerbit auf 1 Million Infobits) unbedingt erwünscht.
Die Prüfstellen: Notwendige und hinreichende Bedingungen Zur Fehlerkorrektur bei p-nären Symbolen benötigt man zwei Informationen: Fehlerort ( = Stelle, an der der Fehler im Empfangswort auftrat) und Fehlerwert (der dann vom Wert des fehlerhaften Symbols im Empfangswort abgezogen werden muss). Im Sonderfall binärer Symbole ist nur die Kenntnis des Fehlerortes notwendig, weil der einzig mögliche Fehlerwert hier die binäre „1“ ist. Hat man m Prüfstellen pro Codewort bereitgestellt, so benötigt man m Gleichungen, aus denen sich über m geeignete Kombinationen der Informationsstellen ui die m Werte der yj bestimmen lassen. y1 = f1(u1, u2, ….., uk) y2 = f2(u1, u2, ….., uk) .................................. ym = fm(u1, u2, ….., uk) Der Wert jeder Prüfstelle liegt im Bereich 0, 1, ...., p – 1. Der Empfänger erhält das Empfangswort w = (w1, w2, … wk, wn-m+1……, wn) und berechnet
52
3.2 Die Prüfstellen: Notwendige und hinreichende Bedingungen wn-m+1 = f1(w1, w2, ….., wk) wn-m+2 = f2(w1, w2, ….., wk) ....................................... = fk(w1, w2, ….., wk)
wm
Falls alle Gleichungen y1 = wn-m+1 y2 = wn-m+2 ………….. yk = wn fehlerfrei – aber ohne Garantie
erfüllt (= wahr) sind, wird Fehlerfreiheit angenommen. Aber Vorsicht: Das Ergebnis muss nicht wirklich fehlerfrei sein, man hat nur keine weiteren Informationen, um hierüber sicher sein zu können, leider eine grundlegende Eigenheit aller Fehlerbeseitigungsverfahren. Falls einzelne oder alle Gleichungen nicht erfüllt sind, gibt es dafür bestenfalls pm – 1 unabhängige Kombinationen. Diese lassen sich prinzipiell für die Berechnung der Fehlerpositions- und Fehlerwert-Kombinationen nutzen. Soll der Code Fehler an maximal t Positionen im Codewort der Länge n korrigieren können, so treten folgende solcher Kombinationen auf: •
Bei einer einzigen Fehlerposition: np1
•
Bei 2 Fehlerpositionen:
•
Bei 3 Fehlerpositionen:
•
........
•
Bei t Fehlerpositionen:
n p12 2 n p13 3
n p1t t
Die Summe hierüber muss also folgender Bedingung genügen: t
1
n p1i pm1 i
Diese notwendige Bedingung ist in solch allgemeiner Form für p > 2 z. B. für den Reed-Solomon-Code oder den Goppa-Code erfüllt. Bei binären Quellen, also bei p = 2, vereinfacht sie sich zu
53
3 Fehlerbeseitigung t
1
n 2m1 i
Das trifft zum Beispiel für den BCH-Code und den Reed-MullerCode zu. Für p = 2 und t = 1 vereinfacht sich diese Beziehung nochmals in die für den Hamming-Code, Unterkapitel 3.4, zutreffende: n d 2m – 1 „notwendig“ reicht nicht hin
Allerdings sind diese Bedingungen nur notwendig, d. h., sie müssen auf jeden Fall erfüllt sein. Das reicht aber nicht aus, da sie zugleich alle unabhängig zu sein haben. Ist dies gegeben, so wird dies als hinreichend betrachtet. Es gibt zwar fast beliebig viele konstruierbare Anordnungen von Codes, welche die notwendige Bedingung erfüllen, aber weitaus weniger für die hinreichende. Diese ist in den meisten Fällen nur in speziellen Zahlenkörpern zu realisieren. Genügt ein Code zur Korrektur von t Fehlern den hinreichenden Bedingungen, so haben seine Codewörter automatisch den Mindestabstand dmin=2t +1.
Perfekte Codes
54
Hierin liegt ein gewaltiger Vorteil gegenüber der Codesuche mit der „Brute Force“-Methode. Auch Codewörter der Länge von einigen 1000 Bit können so in einfacher Weise bestimmt werden und man darf sicher sein, dass sie den Mindestabstand aufweisen. Wenn für einen Code die genannten Bedingungen hinreichend sind und zusätzlich das Gleichheitszeichen gilt, bezeichnet man ihn als perfekt. Der Hamming-Code etwa ist ein solcher. Er korrigiert einen einstelligen Fehler, t=1. Zu jedem vorgegebenen m>1 gibt es nach obiger Beziehung dann genau die passende Codewortlänge n. Beispiele für p=2: • m=1: unzulässig, da n=1 wäre • m=2: n = 3 • m=3: n = 7 • m=4: n = 15 Für t=2 ergibt sich außer der trivialen Lösung m=4, n=5 nur noch m=12, n=90. (Warum, siehe Aufgabe in Unterkapitel 3.4.7). Auch für t=3 ist eine perfekte Lösung bekannt, der Golay-Code. Welche Parameter gehören dazu?
3.3 Direkte Nutzung des Hammingabstandes
3.3
Super einfach, richtig und schlecht
Direkte Nutzung des Hammingabstandes Zu Anfang werden zwei Verfahren zur Bildung von Codes betrachtet, die den Hammingabstand unmittelbar nutzen. Die Bezeichnung "unmittelbar" mag in diesem Zusammenhang verwundern, da wir im Kapitel 2 doch die große Bedeutung des Hammingabstands festgestellt hatten und daraus vermutlich schließen, dass alle Verfahren darauf aufbauen. Tatsächlich werden die heute bedeutenden Codes aber mit Techniken gebildet, welche die erforderlichen Mindestabstände indirekt erzeugen. Für ein erstes Verständnis auf dem Gebiet der Datenfehlerbeseitigung mag es dennoch eine kleine Hilfe sein, die besagten beiden Codierungsverfahren ein wenig zu beleuchten. Das eine davon arbeitet zwar äußerst einfach und ist sehr vielseitig, hat aber leider eine schlechte Informationsrate. Es trägt die Bezeichnung "Wiederholungscode“ und beruht auf der Vervielfachung des zu übertragenden Symbols. Ein Beispiel verdeutlicht das Ist eine Bitfolge zu übertragen, etwa die 8 Bit des ASCII-Zeichens für den Buchstaben b, so besteht die Nachricht aus 1 0 0 0 0 1 0 0. Soll ein einziger Übertragungsfehler lediglich erkannt werden, so muss man für einen Hammingabstand von d 2 sorgen, d.h. man sendet jedes Bit doppelt: 11 00 00 00 00 11 00 00. Ist durch einen Fehler ein einziges Bit in einem der Zweierblöcke gekippt worden, so bemerkt man das durch verschiedene Binärwerte innerhalb des betroffenen Blocks und weiß, dass ein Fehler aufgetreten sein muss. Man weiß aber nicht, an welcher Stelle, da man das Original nicht kennt! Das wäre etwa der Fall, wenn im dritten Block das erste Bit "umfällt": 11 00 10 00 00 11 00 00. Soll ein Einzelfehler korrigierbar sein, so verdreifacht man jedes Bit: 111 000 000 000 000 111 000 000. Wird hier innerhalb eines Dreierblocks ein Bit verfälscht, so erkennt man das erstens sofort und ist darüber hinaus sogar in der Lage, diesen Fehler zu korrigieren, da man anhand einer "Mehrheitsbetrachtung" zusammen mit den übrigen Symbolen in diesem Block sofort die Fehlerposition sieht. Ein Einzelfehler im sechsten Dreierblock an der dritten Stelle ergibt: 111 000 000 000 000 110 000 000.
55
3 Fehlerbeseitigung Unter der Voraussetzung, dass höchstens ein einziger Fehler aufgetreten sein kann, muss der sechste Block also auf 111 korrigiert werden. Für die Korrigierbarkeit von 5 Einzelfehlern überträgt man das 11-fache jeder Stelle: 11111111111
00000000000
00000000000
00000000000
00000000000
11111111111
00000000000
00000000000
usw. An diesem letzten Beispiel sieht man, dass dieses einfache und durchsichtige Verfahren leider sehr viel Platz beansprucht. Es hat damit eine schlechte Informationsrate R (man bestimme diese einmal) und wird praktisch nicht verwendet. Das zweite Codierungsverfahren ist die bereits im Unterkapitel 1.4 auf der Seite 22 beschriebene systematische Suche von Codewörter-Mehrfachpaaren, die gegen einander einen gewünschten Mindestabstand aufweisen. Da man diese – an sich mühsame – Suche von Rechnern durchführen lassen kann, besteht damit ein gangbarer Weg, auch Codes zu finden, die von den anderen, anschließend beschriebenen Verfahren nicht erfasst werden. Allerdings ist die Bedeutung solcher Codes heute noch gering.
3.4
Hamming-Code Auf Richard Wesley Hamming, der wesentliche Beiträge zu Fragen der Codierung lieferte, geht ein Binärcode zurück, der sich durch eine einfache "Bauvorschrift" auszeichnet und außerdem noch besonders effektiv ist. Er gestattet die Korrektur eines Einzelfehlers pro Codewort, hat also den Mindestabstand d=3. Es empfiehlt sich, den Hamming-Code etwas gründlicher zu betrachten, da die Grundgedanken auch für andere Codierungsverfahren Bedeutung haben.
3.4.1
Aufbau, Codierung und Hard Decision-Decodierung Stellt man für ein Codewort m Prüfstellen zur Verfügung, so müssen diese aus geeigneten, unabhängigen Kombinationen der Informationsstellen ui berechnet werden, siehe Unterkapitel 3.2: y1 = f1(u1, u2, ….., uk) y2 = f2(u1, u2, ….., uk) ................................. ym = fm(u1, u2, ….., uk) Ein Codewort v mit n = k + m Stellen hat den Aufbau
56
3.4 Hamming-Code v = (u1, u2, ……, uk, y1, y2, …. , ym) Der Empfänger erhält w = (w1, w2, … wk, wn-m+1……, wn) und berechnet wn-m+1 = f1(w1, w2, ….., wk) wn-m+2 = f2(w1, w2, ….., wk) ....................................... wm
= fk(w1, w2, ….., wk)
Falls alle Gleichungen y1 = wn-m+1 y2 = wn-m+2 ………….. ym = wn erfüllt sind, nimmt er Fehlerfreiheit an (Einschränkung beachten, siehe Unterkapitel 3.2). Andernfalls hat er noch 2m – 1 verschiedene Kombinationen, um ein fehlerhaftes Bit an genau 2m – 1 möglichen Fehlerpositionen im Codewort zu identifizieren. Damit liegt die Länge n des Codewortes fest: n = 2m – 1 Da zu diesen 2m-1 Stellen auch die m Prüfstellen selbst gehören, bleiben für die Informationsstellen k = 2m - m -1 k darf auch übrig. Genau genommen stellt die so festgelegte Zahl der Inkleiner sein = an- formationsstellen bei vorgegebener Anzahl m der Prüfstellen die passungsfähig Obergrenze für k dar, so dass k auch kleiner sein könnte, was je nach Zweckmäßigkeit sogar genutzt wird, obwohl man im allgemeinen an möglichst vielen Informationsstellen interessiert ist um eine gute Informationsrate R zu erzielen. Zum Codieren muss nun die Konstruktion der Prüfstellen bei gegebenen Informationsstellen festgelegt werden. Den Schlüssel bilden die 2m möglichen Kombinationen erfüllter und nicht erfüllter Gleichungen am Empfangsort. Zieht man davon die einzige Kombination aller m erfüllter Gleichungen ab, so müssen die verbleibenden 2m – 1 Kombinationen nur noch eindeutig je einem Fehler in einer der n Positionen im Codewort zugeordnet werden. Ein systematischer Weg wurde von Hamming vorgeschlagen. Man nummeriert die 2m – 1 Fälle in binärer Darstellung durch.
57
3 Fehlerbeseitigung Die Binärzahlen haben genau m Stellen. Man baut daher eine Tabelle mit m+1 Spalten auf, die in der linken Spalte die 2 m – 1 Binärzahlen von 1 bis 2m - 1 enthält. Die rechts davon stehenden m Spalten werden den m Positionen der Binärzahlen zugeordnet. Man geht nun nacheinander durch die n Bitpositionen. Die Prüfstellen werden in die Spalten eingetragen, die nur eine einzige 1 enthalten. Bei mehr als einer 1 wird jeweils die nächste Infostelle berücksichtigt. Sie erscheint in jeder der m rechten Spalten, in der in der linken Spalte eine 1 zu sehen ist. einfaches Schema Am Ende werden die in jeder Spalte stehenden Bitpositionen aufsummiert, die Summe wird MOD 2 auf 0 gesetzt. Damit liegen auch die Werte für die Prüfstellen fest. Alternative: Jede Prüfstelle erhält einen solchen Wert 0 oder 1, dass die Summe der Gleichung einen geraden Wert annimmt. Ein Beispiel lässt dieses allgemein gültige Schema vielleicht klarer erkennen. Dazu wählt man m=3, die Codelänge ist dann n=7. Wir betrachten also einen Hamming-Code der Länge 7 mit 4 Informations- und 3 Prüfstellen. s1 000 001 010 011 100 101 110 111
s2 kein Fehler
s3 y1
y2 u1 y3 u2 u3 u4
u1 u2
u3 u4
u4
Tabelle 3-1: Bildung der Prüfstellen Codewortaufbau:
v = (u1 u2 u3 u4 y1 y3 y3)
Prüfstellen:
y1 = (u1 + u2 + u4) MOD2 y2 = (u1 + u3 + u4) MOD 2 y3 = (u2 + u3 + u4) MOD 2
Damit wird
v = [ (u1) (u2) (u3) (u4) (u1 + u2 + u4) ....
...(u1 + u3 + u4) (u2 + u3 + u4) ] MOD 2 Die zusätzliche Klammerung (u1) usw. dient hier nur der Kennzeichnung der Elemente des 7-er Tupels. Man sieht, dass das Codewort nach wie vor nur die Infostellen enthält, allerdings mit geringerer Informationsrate bzw. hinzugefügter Redundanz. Mit diesem systematischen Vorgehen ist sichergestellt, dass jede Stelle des Codewortes auf eine eindeutige Kombination der Paritätsgleichungen abgebildet wird. Der Empfänger setzt nun die
58
3.4 Hamming-Code ihm bekannten Werte der Empfangswortelemente wi in die Syndromgleichungen – dem Abbild der Prüfgleichungen – ein: s1
= (w1 + w2 +
w4 + w5) MOD2
s2
= (w1 + w3 +
w4 + w6) MOD2
s3
= (w2 + w3 +
w4 + w7) MOD2
verlässliche Fahn- Unter der anfangs getroffenen Voraussetzung, dass höchstens der: Syndrome eine Stelle verfälscht ist (t=1), haben die Syndromgleichungen die gewünschte eindeutige 0/1-Kombination. Der Name Syndrom entstammt den lateinischen Heilkundebegriffen und bedeutet so viel wie Krankheitsbild. Wenn einzelne Syndromgleichungen den Wert 1 haben, deutet das auf ein „krankes“ Empfangswort. Zum Decodieren betrachten wir in Tabelle 3-1 die Spalten, für die si den Wert 1 hat, lesen die zugehörige Position des Codewortes ab und korrigieren den Bitwert. Das ist bereits alles. Für die 24 = 16 Kombinationen von Infostellen ui können nun gemäß Tabelle 3-2 alle 16 Codewörter v berechnet werden: u1 u2 u3 u4 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1
0 0 0 0 1 1 1 1 0 0 0 0 1 1 1 1
0 0 1 1 0 0 1 1 0 0 1 1 0 0 1 1
0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
Codewort v
* * *
*
[0 0 0 0 0 0 0] [0 0 0 1 1 1 1] [0 0 1 0 0 1 1] [0 0 1 1 1 0 0] [0 1 0 0 1 0 1] [0 1 0 1 0 1 0] [0 1 1 0 1 1 0] [0 1 1 1 0 0 1] [1 0 0 0 1 1 0] [1 0 0 1 0 0 1] [1 0 1 0 1 0 1] [1 0 1 1 0 1 0] [1 1 0 0 0 1 1] [1 1 0 1 1 0 0] [1 1 1 0 0 0 0] [1 1 1 1 1 1 1]
Tabelle 3-2: Wörter eines 1-Bit-Fehler korrigierbaren (7,4,3)Hamming-Codes Man überzeuge sich, dass der Mindestabstand tatsächlich größer als 2 ist! Ein Vergleich mit dem auf Seite 27 genannten Beispiel, bei dem ein Code mit der Stellenzahl n=7 und dem Hammingab-
59
3 Fehlerbeseitigung stand d 3 auf ganz anderem Wege ermittelt wurde, zeigt deutliche Ähnlichkeiten (eine vollkommene Übereinstimmung ist in diesem Fall nicht zu erwarten, da die Rechnersuche theoretisch zwar alle möglichen Codemengen mit n=7 ergibt, praktisch wegen zu langer Suchzeiten aber vorzeitig abgebrochen wurde). Übrigens kann man die Positionen der Codewortstellen beliebig umtauschen, ohne dass sich an der Paritätsbeziehung zwischen den Prüf- und den Informationsstellen irgend etwas ändert. Man muss dies nur bei allen Codewörtern in der gleichen Weise tun. In der Anordnung oben bedeutet dies einen Spaltentausch. Da auch ein Zeilentausch keine Änderung der Code-Eigenschaften bewirkt, gibt es immer mehrere Ausführungen von Hamming-Codes mit gleichen Merkmalen. Mit dem oben beschriebenen Aufbau haben wir ohne Einschränkung der Allgemeinheit einen sehr übersichtlichen gewählt.
3.4.2
Generatormatrix G Das beschriebene Konstruktionsverfahren für den HammingCode ist zwar gegenüber dem primitiven Suchen per Rechnerprogramm wesentlich eleganter, lässt sich aber noch vereinfachen. Dazu stellt man die Infobits ui, die Codewortbits vi die Empfangswortbits wi und die Syndrombits si als Elemente von Vektoren dar und behandeln alles mit den Mitteln der Vektorenund Matrizenrechnung:
Ein starkes Fundament: Mathematik
60
u
= [u1 u2 …… uk]
v
= [v1 v2 ……………vn]
w
= [w1 w2 …………..wn]
s
= [s1 ss ....... sm]
Die Beschreibung wird damit sehr kompakt, ist gut für die Bearbeitung mit Rechenprogrammen geeignet und öffnet nebenbei noch alle Zugänge zur mathematisch gesicherten Welt der linearen Algebra mit einigen nützlichen „Nebenwirkungen“. Wählt man als Basis des Vektorraums k linear unabhängige Codewort-Vektoren, z. B. die 4 in Tabelle 3.1. durch "*" markierten, so ergeben sich die restlichen 12 jetzt als Linearkombinationen (Additionen immer MOD 2 !!). Es gibt 10 Codewörter, die aus zwei Summanden und 4, die aus drei Summanden hervorgehen. Die restlichen beiden sind das Nullwort und das Einswort (Summe aller k Basisvektoren). Die Codewörter erfüllen übrigens die Eigenschaften einer mathematischen Gruppe, siehe Unterkapitel 2.2, Seite 36. Die Addition zweier oder mehrerer Codewörter ergibt immer eines der 16 Co-
3.4 Hamming-Code dewörter, aber keines der mit 7 Stellen durchaus möglichen restlichen 128 - 16 = 112 Kombinationen. Die Addition der Basisvektoren wird gewöhnlich durch eine Vektor-Matrix-Multiplikation ausgeführt. Da mit einer geeigneten Matrix alle Codewörter generiert werden können, nennt man sie Generatormatrix G. Sie hat k Zeilen und n Spalten, ihr Aufbau ist vollständig durch die bereits abgeleiteten Beziehungen (hier für k=4, n=7) gegeben:
[
v=[ v1 v2 v3 v 4 v 5 v6 v7 ]=uG=[ u1 u2 u3 u4 ]
1 0 0 0
0 1 0 0
0 0 1 0
0 0 0 1
1 1 0 1
1 0 1 1
]
0 1 MOD 2 1 1
G setzt sich wegen des systematischen Codewortaufbaus (links die k Infostellen, rechts die m Prüfstellen) aus einer k·k-Einheitsmatrix und dem k-m-Prüfteil zusammen.
3.4.3
Paritätsprüfmatrix H Zur Decodierung werden die Syndromgleichungen ausgewertet. In Matrix-Schreibweise lässt sich das – wieder für den Fall k=4, m=3 - über
[]
s=[ s1 s 2 s3]= wH=[ w1 w2 w3 w 4 w 5 w6 w7 ]
1 1 0 1 1 0 0
1 0 1 1 0 1 0
0 1 1 1 MOD 2 0 0 1
ermitteln. Ähnlich wie G besteht die Paritätsprüfmatrix H ebenfalls aus zwei Untermatrizen, hier dem k·m- Prüfteil, der auch in G erscheint, und einer m·m-Einheitsmatrix. s1 0 0 0 0 1 1 1 1
s2 0 0 1 1 0 0 1 1
s3 0 1 0 1 0 1 0 1
Fehlerposition fehlerfrei 5 6 1 7 2 3 4
Tabelle 3-3: Zuordnung der Syndromwerte zur Fehlerposition
61
3 Fehlerbeseitigung Die fehlerhaften Syndromgleichungen erhalten den Wert 1, die fehlerfreien einen solchen von 0. Die Fehlerposition kann im einfachsten Fall durch eine entsprechende Zuordnung erfolgen, siehe Tabelle 3-3. Damit ist die eigentliche Arbeit auch hier erledigt.
3.4.4
Syndrom und Fehlerposition bei HD-Decodierung Für den praktischen Einsatz lässt sich noch eine zwar kleine, aber angenehme Verbesserung vornehmen. Man baut die Syndromgleichungen dazu so um, dass sie, als Binärzahl interpretiert, die Fehlerposition direkt angeben. Dann spart man sich den Umweg über die Tabelle. Die Kombination [0 0 1] muss also 5 ergeben, [0 1 0] die Position 6 usw. Dies wird erreicht, wenn man den Aufbau des Codewortes v entsprechend anpasst. Aus v= [u1 u2 u3 u4 y1 y2 y3 ] wird v'= [y1 y2 u1 y3 u2 u3 u4 ] und aus w = [w1 w2 w3 w4 w5 w6 w7] wird w' = [w5 w6 w1 w7 w2 w3 w4] Diese Vertauschung lässt sich rechentechnisch durch eine Vertauschungsmatrix T erreichen.
w '=[ w '1 w '2 .... w '7]= wT=[ w1 w 2 .... w 7]
[ ] 0 0 0 0 1 0 0
0 0 0 0 0 1 0
1 0 0 0 0 0 0
0 0 0 0 0 0 1
0 1 0 0 0 0 0
0 0 1 0 0 0 0
0 0 0 1 0 0 0
Wenn man Elemente in w vertauscht, muss man die zugeordneten Zeilen in der Paritätsprüfmatrix H ebenfalls vertauschen, das Ergebnis ist H'. Dies wird durch Multiplikation von H mit der zu T inversen Matrix T-1 erreicht. Die Inverse zu T ist in diesem einfachen Fall identisch mit der transponierten Matrix TT , also T·TT = T·T-1 = I (Einheitsmatrix):
62
3.4 Hamming-Code
[ ] [ ][ ] [ ]
0 0 1 T1=TT = 0 0 0 0 Damit wird
0 0 1 H'=T TH= 0 0 0 0
0 0 0 0 1 0 0
0 0 0 0 1 0 0
0 0 0 0 0 1 0
0 0 0 0 0 1 0
0 0 0 0 0 0 1
0 0 0 0 0 0 1
1 0 0 0 0 0 0
1 0 0 0 0 0 0
0 1 0 0 0 0 0
0 1 0 0 0 0 0
0 0 0 1 0 0 0
0 1 1 0 1 0 0 0 1 0 1 0 1 0 0 0 1 1 1 1 0 1 1 1 1 = 0 0 1 0 1 0 0 1 0 1 0 0 1 0 0 1 1 0 0 0 1 1 1 1
Für den Syndromvektor s ändert sich zwar nichts, da s = w·T·TT·H = w'·I·H' = w'·H' ist, aber das Ergebnis muss jetzt auf den geänderten Aufbau des Codewortvektors angewendet werden. Dass die über das Syndrom ermittelte Fehlerposition nur von der Position des Fehlers, nicht aber vom Codewort abhängt, kann man erkennen, wenn man die theoretische Zusammensetzung des Empfangswortes w aus Codewort v und Fehlerwort e betrachtet: w=v+e Die Berechnung des Syndroms s ergibt s = w·H = (v + e)·H = v·H + e·H = [0 0 0] + e·H = e·H Ein Beispiel verdeutlicht dies: Im Codewort v
= [0 1 1 0 0 1 1]
wurde auf dem Übertragungsweg das fünfte Bit gekippt, so dass w
=v+e
= [0 1 1 0 1 1 1]
ankommt. Man multipliziert dieses empfangene Wort nun mit H und wertet das Syndrom aus:
63
3 Fehlerbeseitigung
[]
1 1 0 s=wH=[ 0 1 1 0 1 1 1] 1 1 0 0
1 0 1 1 0 1 0
0 1 1 1 MOD2= [1 0 1] 0 0 1
Aber aufgepasst: Dieses algebraische Verfahren zur Bestimmung der Fehlerposition erzeugt immer ein Ergebnis, egal, wie viele Fehler tatsächlich passiert sind. Es setzt voraus, dass entweder kein Fehler oder genau ein Fehler auftrat. Bei zwei oder mehr Fehlern wird eine falsche Fehlerposition ermittelt. Es gibt für den Empfänger im Rahmen des beschriebenen Verfahrens keine Möglichkeit, dies zu erkennen.
3.4.5
Soft Decision-Decodierung Bei der Hard Decision-Decodierung wird das Empfangssignal ws eigentlich „brutal“ zurecht gestaucht, um die weitere Auswertung zu vereinfachen. Dabei geht allerdings wertvolle Information verloren, die zur statistischen Verbesserung des Ergebnisses beitragen könnte. Das Soft Decision-Verfahren nutzt deshalb noch weitere Informationsanteile. Vom Empfangssignalvektor ws werden dabei nacheinander die möglichen Sendesignalvektoren vsi, mit i = 1, 2, …. 2 k , subtrahiert und die Summe dwsi der Quadrate der Differenzelemente gebildet (das Skalarprodukt der Differenzvektoren mit sich selbst):
dwsi=[ wsvsi ][ wsvsi ] , T
k
i=1,2, ......., 2
Besser geht's Das Codewort vsi mit der kleinsten Abweichungssumme nicht, doch leider vs dwsi minimal ein teures Vergnügen .... wird als das am besten geeignete gewählt. Für mittelwertfreie, normal verteilte Rauschsignale als auf das Sendesignal vs einwirkende Störungen ist diese Wahl die günstigste überhaupt. Das Verfahren selbst wird auch als ML-Verfahren (= (Maximum Likelihood-Verfahren) bezeichnet. Das Ergebnis kann im Mittel bis zum Faktor 2 besser ausfallen als bei der HD-Decodierung. Leider ist es in dieser Form bei steigender Zahl der Codewörter aber nicht praktikabel. Beim bisher benutzten Beispielcode mit n=7 muss jedes Empfangswort ws zwar nur mit den 16 möglichen Sendewörtern vsi i
64
3.4 Hamming-Code verglichen werden, beim nächst längeren Hamming-Code mit n=15 und k=11 sind es aber bereits 211 = 2048 Berechnungen. Der Einsatz von Näherungsverfahren, z. B. nach David Chase, (siehe S. 212) oder durch alternative Lösungsverfahren, z. B. dem Dual Code nach Elke Offer und Emina Soljanin (An Algebraic Description of Iterative Decoding Schemas, 1999, unterstützt durch German-American Networking Research Grant), kann den Aufwand bei etwas verringerter Korrekturleistung allerdings erheblich verkleinern.
3.4.6
Technischer Gebrauch des Hamming-Codes In den letzten Kapiteln stand das Codierungsverfahren von Hamming im Blickfeld und es besteht nun – hoffentlich – Klarheit darüber, wie es zu gebrauchen ist. Ausgangspunkt wird immer die gewünschte Zahl von Informationsstellen ui sein, die wir gesichert übertragen oder speichern wollen. Man legt also die erforderliche Zahl von Prüfstellen fest. Im Allgemeinen wird es nötig sein, die Gesamtzahl aller Stellen so aufzuteilen, dass die "passende" Größe entsteht. Nach der im Unterkapitel 3.2 aufgestellten Beziehung zwischen der Zahl m der Prüfstellen und der Zahl k der Informationsstellen gilt bei m = 3: k = 4, n = 7, bei m = 4: k = 11, n = 15, bei m = 5: k = 26, n = 31,
Spezialist für besondere Verhältnisse
bei m = 6: k = 57, n = 63, usw. Aber Vorsicht: die Informationsrate R wird mit wachsendem n zwar drastisch größer, zugleich steigt jedoch auch die Wahrscheinlichkeit für das Auftreten von mehr als einem Einzelfehler! Und nur Einzelfehler werden korrigiert. Genau genommen muss man also zunächst untersuchen, wie häufig Einzelfehler bei der Übertragung oder Speicherung überhaupt auftreten, d. h., wie störanfällig das gewählte Übertragungs- oder Speicherverfahren ohne Fehlerkorrektur ist. Hier spielen die Kosten eine entscheidende Rolle. Möchte man für die Konstruktion einer Recheneinrichtung z. B. sehr preiswerte dynamische RAMs einsetzen, so ist möglicherweise die Zuverlässigkeit geringer als bei technologisch aufwendigeren, aber teureren Speichern. Dann muss man voraussichtlich eine kleine Codewortlänge n wählen. Die Frage für den Ingenieur ist eben, wie klein n sein muss, um die Gesamtzuverlässigkeit zu erhöhen und ob der Mehraufwand durch die höhere Zahl der Prüfstellen den Vorteil einer billigen Speichertechnologie nicht wieder aufzehrt. Sind m und k einmal festgelegt, so bildet man die Generatorma-
65
3 Fehlerbeseitigung trix, die immer so viele linear unabhängige Zeilen k hat, wie es Informationsstellen gibt. Die lineare Unabhängigkeit lässt sich sehr einfach sicherstellen, wenn in den Beziehungen zur Festlegung der Prüfstellen nach Kapitel 3.2.1 nacheinander die Tupel (x1 = 1, x2 = 0, ..., xk = 0), (x1 = 0, x2 = 1, x3 = 0, ..., xk = 0) usw. eingesetzt werden. Die Tabelle zur Ermittlung der m Prüfstellengleichungen hat immer m Spalten und m ist deshalb auch die Länge des Syndromvektors. Über die Generatormatrix G wird die Paritätsprüfmatrix H bestimmt. Mit diesen beiden Informationsbausteinen können wir nun unseren Codierungs- und Decodierungsalgorithmus aufbauen. Das wird meistens ein Maschinencode- oder C-Programm sein, z. B. im Controller einer Speichereinheit. Aber auch der Einsatz im Rahmen einer Anwendung auf höherer Ebene ist denkbar. In ausgeführten technischen Anlagen wird das Hamming-CodeVerfahren übrigens häufig eingesetzt, oft in Varianten, mit denen noch weitere Anforderungen erfüllt werden können, siehe auch Unterkapitel 3.6.1. So etwa benutzen es die Arbeitsspeichereinheiten der heute aktuellen PCs und Serversysteme.
3.4.7
Was blieb? 1. 2.
3.
4.
5. 6.
7.
8.
66
Mit welchem einfachsten Verfahren kann man das ASCIIZeichen 0100 1101 gegen 3 Einbitfehler absichern? Welchen Hammingabstand müssen die Wörter eines für die Antwort auf Frage 1 geeigneten Korrekturcodes mindestens haben? Wie ist ein Hamming-Codewort zur Einbitfehler-Korrektur an 64-Bit Arbeitsspeicherworten aufgebaut (Infostellen, Prüfstellen)? Welche notwendige Bedingung muss erfüllt sein, damit bei einem Codewort der Länge n 3 Einbitfehler korrigiert werden können? Welche hinreichende Bedingung ist zusätzlich zur Antwort auf Frage 4 erforderlich? Wie oft muss der Hammingabstand bei einem Code der Länge 18 berechnet werden, um im Rahmen eines Suchverfahrens eine vollständige Liste der Abstände aller möglichen Paarungen zu erhalten? Wie könnte man die beiden Parameter Standardabweichung und Mittelwert des Rauschens rs in einem Übertragungskanal messen? Welche Maßnahme ist am Empfangssignal ws zu treffen, wenn das Rauschsignal nicht mittelwertfrei ist?
3.4 Hamming-Code 9.
3.5
Warum ist vom Ergebnis her betrachtet, das SD-Verfahren einer HD-Lösung überlegen?
Leistungsbeurteilung von Codes Nachdem nun zwei verschiedene Codes bekannt sind und weitere in der „Pipeline“ stehen, taucht vielleicht die Frage auf, wie man diese Codes eigentlich vergleichen kann. Denn für eine gegebene Aufgabe will man sicher nicht irgendeinen Code herausgreifen, von dem man zufällig gehört hat, sondern es geht schließlich darum, mit welchem Verfahren sich unter gegebenen Randbedingungen das Maximum herausholen lässt. Was aber ist das Maximum?
3.5.1
Beschreibung fehlerbehafteter Übertragungssysteme Vor dem Versuch einer Antwort ist ein Blick auf die Umgebung, mit der man es zu tun hat, nützlich. Gemäß den Bildern 3.1 und 3.2 gibt es: a) Das gesendete binäre Nutzsignal vs(t) = vs(iYT), z. B. als Rechteckspannung der Dauer T mit +1 Volt für die „1“ und –1 Volt für die „0“ mit einer mittleren Signalleistung Sm in Watt. An einem Empfängereingangswiderstand von Z=1 Ohm wäre für die angegebenen Spannungen diese Leistung wegen Sm = U2/Z gerade 1 Watt. Im übrigen sind auch andere Modulationsverfahren als die hier gewählte Pulscodemodulation (PCM) einfachster Art möglich, wesentliches lässt sich aber bereits an diesem Beispiel erkennen. b) Den Übertragungskanal mit einer ausreichenden Bandbreite B in Hz, um die Rechteckspannung so zum Empfänger zu bringen, dass dieser die 0/1-Pegel trotz der unvermeidlichen Signalverformungen (z. B. durch Tiefpasseigenschaften) fehlerfrei identifizieren kann. Der anspruchsvollste Fall liegt dann vor, wenn vs(t) eine gleichförmige Rechteckspannung ist, bei der in jeder Periode T gerade ein 0- und in 1-Bit übertragen wird. Ein Tiefpass mit der Bandbreite von 1000 Hertz könnte in einer Sekunde also gerade 2000 Bits „verkraften“. Dies gilt aber nur für das hier betrachtete Binärsignal mit den zwei Stufen 0 und 1. Eine stärkere Quantisierung gestattet höhere Bitraten, mit 4 Stufen wären es zum Beispiel 4000 Bits. Allerdings steigt zugleich auch die Fehleranfälligkeit bei Störungen. c) Das ebenfalls unvermeidliche Störsignal rs(iYT) (in der angelsächsischen Literatur auch mit n(iYT), „noise“, bezeichnet), z. B. als mittelwertfreies, weißes Gauß-verteiltes Rauschen mit der mittleren Rauschleistung Nm in Watt. Die Bezeichnung
67
3 Fehlerbeseitigung „weißes“ Rauschen heißt, dass das diskrete Frequenzspektrum von rs(iYT) konstant ist, jeder Spektralanteil der Fourier-Transformierten – siehe Unterkapitel 6.2 – also die gleiche Größe hat. d) Die schon bekannte Informationsrate R = k/n als Verhältnis der Informationsstellen zu den Codewortstellen. e) Das Signal/Stör-Verhältnis SNR=Sm/Nm (=Signal to Noise Ratio) der mittleren Leistungen von Nutz- und Störsignalen, kurz Störabstand genannt und oft ausgedrückt in db (=dezibel, siehe Seite 17), wobei für zeitdiskrete Signale vs(t) = vs(iYT),
i = 1, 2, ......, ne
definiert ist: ne
SNR=
Sm Nm
=
1 vsi2 ne i=1 ne
1 rsi2 ne i=1
=
vs2 2 rs
Das Empfangssignal ws(t) ist die Summe von Nutzsignal und Störsignal, also ws(t) = vs(t) + rs(t) – oder ws(t) = us(t) + rs(t), siehe Seite 15. Es führt in der Schmidt-Triggerstufe des Empfängers – je nach Amplitude und Vorzeichen – als w(t) zur richtigen oder falschen Zuweisung der Sendesignal-Bits. In letzterem Fall wird ein Fehler erzeugt. Dessen Ort ist zwar im praktischen Betrieb unbekannt, unter Laborbedingungen kann man ihn aber messen, indem man die Differenz v(t) – w(t) bildet. Überall dort, wo das Sendesignal richtig beim Empfänger ankommt, ist der Fehler Null, sonst nimmt er die Werte –2 oder +2 an.
Bild 3.3: Bitfehlerwahrscheinlichkeit EBR als Funktion von SNR
68
3.5 Leistungsbeurteilung von Codes Die Wurzel des Bösen
nützliche Verzerrungen
Je größer die Amplituden des Störsignals im Mittel sind, desto mehr Fehler wird man erwarten. Man stellt den theoretischen oder durch Messung gewonnenen Einfluss des Störsignals auf die Fehlerhäufigkeit oft als statistische, d. h. über eine große Zahl von Einzelwerten gewonnene Funktion dar. Diese heißt Fehlerbitrate EBR (Error Bit Rate = Verhältnis von Fehlerbits zu Gesamtbits) und hängt von SNR sowie von weiteren Parametern ab. Natürlich soll EBR möglichst klein sein, was wir in diesem Rahmen vor allem durch geeignete Verfahren zur Fehlerbeseitigung erreichen wollen. Der tatsächliche Verlauf wird von der Art der Verteilungsdichtefunktion p(x) des Rauschsignals, den eingestellten Triggerschwellwerten des HD-Demodulators, sowie anderen Parametern beeinflusst und sinkt mit wachsendem Störabstand gegen Null. Zur besseren Übersicht wählt man für die grafische Darstellung oft logarithmische Achsensysteme. Bei normal verteiltem Rauschen, binären Sendesignalen vs(t) und durch Hard DecisionDemodulation aus den Empfangssignalen ws(t) ohne Korrektur hervorgegangenen Bitfolgen w(t) hat EBR den in Bild 3.3 dargestellten Verlauf. Man beachte die logarithmische „Dimension“ von SNR in dB, die Umrechnung in SNR als reine Verhältniszahl geschieht gemäß der Formel auf Seite 17 mit SNR=10 SNR[dB]/10
Verbaldefinitionen: ein Versuch
Wie kommt dieser Verlauf von EBR(SNR) zustande? Er ist eng verknüpft mit der Wahl der Triggerschwelle für die HD-Demodulation. Sieht man sich die Verteilungsdichtefunktion in Bild 1.1 auf Seite 15 an, so gibt es Rauschsignalwerte, die kleiner als -1 und größer als +1 sind. Trifft bei der Überlagerung des Sendesignals vs ein Wert < -1 Volt auf ein „Signalbit“ -1 Volt, so wird das Empfangssignal noch kleiner als -1 Volt und die HD-Dekodierung ergibt trotzdem den richtigen Wert -1 Volt, bzw. das Bit „1“. Trifft dieses Rauschsignal aber auf ein Signalbit +1 Volt, so ist das Empfangssignal negativ und die HD-Dekodierung liefert das falsche Bit. Entsprechend verhält es sich bei Rauschsignalen > +1 Volt. Im Bild 3.2 auf Seite 51 kann man das für t=4, 8 und 11 sehen. Man muss also nur noch feststellen, wie hoch der Anteil der Rauschsignale mit rs < -1 Volt und rs > +1 Volt ist. Wegen der Symmetrie der Verteilungsdichte verursacht die Hälfte hiervon die gesuchten Fehler. Da die Fläche unter der Kurve auf Seite 15 nach Definition den Wert 1 hat, ergibt die Hälfte der beiden Flächenanteile links von –1 Volt und rechts von +1 Volt den gewünschten Wert. Wegen der Symmetrie reicht also die Integration der Funktion in den Grenzen von -f bis -1 oder von +1 bis +f. Eine analytische Lösung als „Formel“ gibt es hierzu nicht,
69
3 Fehlerbeseitigung also wird numerisch integriert. In Abhängigkeit vom Effektivwert V erhält man einen Ausdruck, welcher der berühmten Gauß'schen Fehlerfunktion eng verwandt ist: 2
1
EBR=
x 2 2
1
e
2 2
2
dx= 1
1
2 2
e
x 2 2
dx
2 2 Da die mittlere Rauschleistung Nm=rs = [Watt] beträgt, SNR
durch die Formel auf Seite 16 definiert ist und die mittlere 2 Sendesignalleistung vs = 1 Watt aufweist (warum?), lässt sich der Effektivwert auch durch =
1 SNR
ausdrücken: 1
2
x
2
x
SNR 2 SNR SNR 2 SNR EBRSNR= dx= dx e e 2 1 2
idealisiert, doch nicht wirklichkeitsfremd
3.5.2
Bild 3.3 zeigt den Verlauf. Zum Beispiel beträgt EBR für SNR = 0 dB etwa 15%, für SNR = 10 dB etwa 0.1%. Noch eine Bemerkung: Bei der hier betrachteten Normalverteilung für das Rauschen handelt es sich zunächst um eine Annahme. Ob die auf einem realen Kanal (einer Leitung, einer Satellitenstrecke, einem Netz) angetroffenen Störungen diese Verteilung tatsächlich aufweisen, kann nur durch Messungen festgestellt werden. Allerdings stellt diese Annahme meistens eine brauchbare Näherung dar. Die Rauschsignale rs entstehen als Summe verschiedener, im Kanal verteilter Quellen mit unterschiedlichen Verteilungsdichten. Der Grenzwertsatz der Statistik besagt nun gerade, dass sich die Verteilung eines solchen Summensignals auf eine Normalverteilung zubewegt. Im übrigen ist der soeben ermittelte Verlauf von EBR unabhängig von der Struktur des binären Sendesignals vs, es kann sich also um codierte oder uncodierte Signalfolgen mit ±1 Volt handeln.
Verteilung der Fehler auf die Codeworte Im vorhergehenden Unterkapitel hatten wir die Frage beantwortet, wie der mittlere Fehler von der Rauschleistung (oder von SNR) abhängt. Aufschlussreich ist aber auch, wie sich die Fehler auf die einzelnen Wörter eines Codes oder eines Infoblockes
70
3.5 Leistungsbeurteilung von Codes verteilen, da dies erste Rückschlüsse auf seine Leistungsfähigkeit erlaubt. Hierzu hilft folgende Überlegung: a) Die Wahrscheinlichkeit für ein fehlerhaft empfangenes Bit beträgt EBR. b) Die Wahrscheinlichkeit für ein fehlerfrei empfangenes Bit beträgt dementsprechend (1 - EBR). c) Die Wahrscheinlichkeit für ein fehlerhaft und ein fehlerfrei empfangenes Bit ist die Verbundwahrscheinlichkeit beider Ereignisse, also EBR(1 - EBR). d) Hat ein Wort die Länge n, so ist die Wahrscheinlichkeit für ein fehlerhaftes und n-1 fehlerfreie Bits an bestimmten Posin1 tionen im Wort EBR1EBR e) Für ein fehlerhaftes Bit gibt es in diesem Wort n mögliche Fehlerpositionen – genauer ausgedrückt mit dem Binom
n1
– die Wahrscheinlichkeit für ein fehlerhaftes Bit an
allen n möglichen Positionen ist also Verteilungskämpfe
n EBR1EBRn1 . 1
n EBR21EBRn2 2
f) Für zwei fehlerhafte Bits:
n EBRn1EBRnn n
g) Für n fehlerhafte Bits: = h) Für n fehlerfreie Bits:
=
EBR n. (1-EBR)n.
Dass überhaupt eine der genannten Konstellationen auftritt, stellt natürlich ein sicheres Ereignis dar, die Summe wird also den Wert 1 erhalten. Für ein bestimmtes Parameterpaar EBR(SNR) und n kann man sich die Ergebnisse zum Beispiel als Balkendiagramme darstellen, wie es in Bild 3.5 für den (7,4,3)-HammingCode und drei verschiedene SNRs gemacht wurde. Für starke Störungen mit SNR=1 oder SNR = 0.2 wird der Anteil fehlerbehafteter Wörter groß, hier ist der Hamming-Code, der ja nur einen Fehler korrigieren kann, unbrauchbar. Nur der links neben der gestrichelten Linie gelegene Anteil bleibt nach der Korrektur als fehlerfrei übrig, die rechten Anteile sind weiterhin
71
3 Fehlerbeseitigung fehlerbehaftet. Dagegen sieht die Lage bei dem schwächeren Rauschen mit SNR=5 deutlich besser aus.
Bild 3.4: Anteile der fehlerfreien und fehlerbehafteten Wörter der der Länge n =7 Unterschied BitÜbrigens wurden hier stillschweigend zwei verschiedene Fehlerfehler - Wortfehler arten betrachtet, die aber deutlich auseinander gehalten werden müssen: a) Die Bitfehler als nicht erkannte Fehler in den Schätzwerten û für die Informationen u. Sie sind mit der Fehlerbitrate EBR bewertet und eignen sich am ehesten zum Vergleich verschiedener Codierungsverfahren, da die möglichen Folgen unterschiedlicher Codewortlängen auf das Endergebnis nicht einbezogen werden. b) Die Wortfehler als nicht erkannte fehlerhafte Bitblöcke der Länge n. Hier sind zwei Blockarten von Interesse. Einmal die Blockung der Information selbst, die sich zum Beispiel in der
72
3.5 Leistungsbeurteilung von Codes Blockung von je 7 oder 8 Bits zu einem ASCII-Zeichen zeigt. Dabei ist es egal, wieviele unerkannte Fehler sich in einem 8Bit-Block befinden, dieser Block wäre immer fehlerhaft (und zum Beispiel der von einer Bank übertragene Kontostand eines Kunden). Zum anderen sind die Infobitblöcke von Codes im allgemeinen weder ganzzahlige Teile noch ganzzahlige Vielfache von Codes. Eine der wenigen Ausnahmen stellt der (7,4,3)-Hamming-Code dar, der pro Codewort ein Halbbyte an Informationen transportiert. Die Auswirkung von Bitfehlern auf die Infowort-Blockung muss also in Abhängigkeit der Codewortlängen n und der darin enthaltenen Infobits untersucht werden.
3.5.3
B größer o Rauschen stärker
Gebot der Fairness
Einfluss der Informationsrate auf die Übertragungsrate Durch die Codierung werden den k Informationsbits im Codewort m Prüfbits hinzugefügt, die Informationsrate R beträgt k/(mk) = k/n. Wenn die Informationsbits unabhängig vom gewählten Code und damit auch unabhängig von R immer mit einer vorgegebenen Geschwindigkeit in Bits pro Sekunde auf dem Kanal übertragen werden sollen, muss die Geschwindigkeit der Signalbits im Verhältnis von R angepasst werden. Soll ein Info-Bitstrom zum Beispiel 1 MegaBit/s betragen, so ist die Geschwindigkeit für die Codewort-Bits bei einer (7,4,3)-Hamming-Codierung um den Faktor 1/R =7/4Yauf 1.75 Megabit/s zu erhöhen, damit die Info-Bits mit 1 Megabit/s beim Empfänger eintreffen. Für den Kanal muss dazu die Bandbreite B um den Faktor 1/R = 1.75 vergrößert werden. Das erfordert einerseits entsprechende technische Maßnahmen für die Ausführung des Kanals (z. B. andere Leitungskonstruktionen), andererseits verschlechtert es das Signal/Störverhältnis um die Rate R, was wiederum die mittlere Fehlerrate erhöht. Nach den Gesetzen der Nachrichtentechnik benötigt man zur Übertragung von Signalbits mit 1 Megabit/s eine Bandbreite B von 0.5 Megahertz. Hat der Kanal hier ein SNR = 10, so erfordert die Übertragung der (7,4,3)-HammingCodewörter eine Bandbreitenerhöhung auf 0.85 Megahertz, wobei SNR auf 0,57 # 7.6 db absinkt. Die Kanalfehlerrate ECR erhöht sich damit von 0.0008 um etwa den Faktor 10 auf 0.008, siehe Bild 3.4. Damit verändern sich auch die Anteile der fehlerfreien und fehlerbehafteten Wörter, wie Bild 3.5 zeigt. Für einen Vergleich der Leistungsfähigkeit verschiedener Codes ist es nur „fair“, von jeweils gleichen Übertragungsgeschwindigkeiten der Info-Bits auszugehen, nur dafür bezahlt der Kunde schließlich. Um die Leistungsfähigkeit verschiedener Codes vergleichen zu können, geht man also am besten vom EBR-Verlauf eines uncodierten Bitstromes, also mit Runcodiert=1 aus. Für ein bestimmtes SNR = SNR1 ist EBR1 = EBR(SNR1). Nun ermittelt man
73
3 Fehlerbeseitigung für einen Code a an der Stelle SNRa=Ra SNR1, das zugehörige EBRa und trägt den Wert an der Abszisse SNR1 ein. In gleicher Weise ergeben sich Punkte für weitere Werte SNR2, SNR3, ....., und man erhält einen ähnlichen Verlauf wie für die EBR des uncodierten Signals, der sich gut für den gewünschten Vergleich eignet.
Korrekturergebnis für ein codiertes Signal mit Bandbreiten-Anpassung
Bild 3.5: Mittlere Fehlerverläufe für ein uncodiertes Signal (durchgezogene Linie, wie in Bild 3.3) und ein Hamming-codiertes Signal bei gleicher Übertragungsgeschwindigkeit der InfoBits Achsen vermessen Bei einer durchgehenden Kurve, die man etwa durch eine und richten Funktion oder durch interpolierte Messpunkte gewonnen hat, ist nun allerdings die Zuordnung des tatsächlichen SNR nicht mehr sichtbar. Diese kann man zurückholen, wenn den Abszissenwerten nicht SNR, sondern SNR/Ra zugewiesen wird. Für uncodierte Signale zeigen die Achsenwerte wegen R=1 weiterhin SNR an, für Code a den für die Ermittlung von EBR a verwendeten Wert SNRa geteilt durch Ra. Daher muss der abgelesene Wert noch mit Ra multipliziert werden. Für den (7,4,3) Hamming-Code aus Unterkapitel 3.4 ist das Ergebnis in Bild 3.5 dargestellt. Wie wird der Verlauf für das Hamming-codierte Signal bestimmt? Wir benutzen dazu die Fehlerverteilung aus Unterkapitel 3.5.2, siehe Bild 3.4. • Durch die Korrektur fallen alle 1-Fehlerbits weg, übrig bleiben die Fehler rechts der Linie. Operation ge• Die Korrektur führt nur bei den 1-Bit-Fehlern pro Wort zum lungen, Patient Erfolg, bei allen Mehrbit-Fehlern fügt sie fälschlich sogar ein tot weiteres Fehlerbit hinzu. • Wir multiplizieren also die Anteile der Worte mit i Fehlern mit dem Faktor (i+1), summieren alle und erhalten die mittleren Fehler pro Wort.
74
3.5 Leistungsbeurteilung von Codes •
perfekt getarnt: Fehler als Codewort
•
•
Für den Vergleich wird allerdings nicht der mittlere Fehler pro Wort sondern pro Bit benötigt, weshalb das Ergebnis durch n zu teilen ist. Fehlermuster, die einem der 15 Codeworte (außer dem Nullwort) in Tabelle 3-2, Seite 59, entsprechen, werden bei der Syndrombildung, s. S. 61, nicht erkannt. Das dekodierte Empfangswort w ist ja die Summe aus Codewort und Fehlerwort w = v + e und wegen der Gruppeneigenschaft (Seite 36) des Hamming-Codes entsteht bei der Addition zweier Codewörter wiederum ein Wort dieses Codes. Da in diesen Fällen keine Korrektur durchgeführt wird, entsteht auch kein zusätzliches Fehlerbit, weshalb dieser Anteil aus der Gesamtsumme wieder abzuziehen ist. Es handelt sich dabei um alle 7 Codewörter mit dem Hamminggewicht (s.S. 18) g = 3 , alle 7 mit g = 4 und das „1“-Wort mit g = 7. Daher gehen diese jeweils mit dem Faktor 7 bzw. 1 ein. Die Berechnung erfolgt mit EBR(SNR·4/7) auf Seite 70 über n
EBR7,4,3 SNR/4/7 =
Korrektur schafft neue Fehler
anderer Name, gleiche Aussage
1 i 1 ni EBRi1EBRni n i= 2
1 7EBR3 1EBRn3 7EBR4 1EBRn 4 EBRn n
Die durch falsche Korrektur zusätzlich hinein gekommenen Fehler bewirken leider, dass die in diesem Fall ohnehin nur winzige Verbesserung sich für schlechtere SNR unterhalb von etwa SNR = 8 # 9 db sogar ins Gegenteil verkehrt, wie man in Bild 3.5 erkennt. Ein (7,4,3)-Hamming-Code ist also in diesem Bereich unbrauchbar. Zu günstigeren Störabständen SNR hin wird der „Gewinn“ etwa 0.5 # 3 db sein – nicht berauschend, aber immerhin bemerkbar. Wir sehen, dass unsere Suche nach brauchbaren Codes noch um einiges vom Ziel entfernt ist. In der Literatur findet man übrigens bei Diagrammen zu Bitfehlerraten als Abszissenbezeichnung oft Eb/N0 statt das hier verwendete SNR/R. Beide Bezeichnungen hängen aber auf einfache Weise über die auf Seite 17 abgeleitete Beziehung zusammen und lassen sich deshalb in einander umrechnen. Eb ist die künstlich definierte Energie für jedes ausgesendete Informationsbit, dem zusätzlich zur physikalisch investierten Energie noch der Anteil für die gesendeten Prüfbits im Verhältnis 1/R zugerechnet wird. Der Sendevorgang wird damit so betrachtet, als würden statt aller n Sendesignalbits wsi eines Codewortes nur die Info-Bits usi, diese aber mit um 1/R höherer Energie erzeugt.
75
3 Fehlerbeseitigung E SNR = 2 b R N0
Achs-Manipulation
oder
E SNR = b 2R N0
Verwendet ein Diagramm als Abszisse Eb/N0, so muss man die Werte mit 2 multiplizieren, um den äquivalenten Wert in einer SNR/R-Darstellung zu erhalten. Meistens sind jedoch Abszissenwerte in db angegeben. Dann gilt
E E SNR SNR = 2 b entspricht 10 log10 db = 10 log10 2 b db R N0 R N0 = 10 log10 2 db 10 log10
Eb E db = 3db 10 log10 b db N0 N0
In Kurzform: E SNR [ db ] = 3 b [ db ] R N0
und
Eb N0
[ db ] = SNR [ db ]3 R
Beispiel: 7 db in Eb/N0 sind 10 db in SNR/R. Für Puristen noch eine Anmerkung: Genau genommen ist 10 log10 2 =3.0103, aber ...
3.5.4
Konkurrenz
76
Kriterien: asymptotisches Verhalten bei langen Codes Mit den bisher gewonnenen Erkenntnissen lassen sich einige Feststellungen treffen, die ein „guter“ Code leisten müsste: 1. Er soll möglichst viele Fehler korrigieren, d. h., die BitfehlerRate EBR des decodierten Empfangssignals muss gegen Null gehen. 2. Aus Punkt 1 folgt, dass die Codewörter möglichst lang sein sollen, damit viele Prüfbits untergebracht werden können. 3. Er soll eine möglichst große Informationsrate R aufweisen, damit Bandbreite und Rauschen klein bleiben können. 4. Codierung und Decodierung sollen möglichst wenig Aufwand kosten. 5. Das Codierungsverfahren soll sich in einfacher Weise an verschiedene Umgebungsbedingungen wie den Störabstand SNR, die Verteilungsdichte, das gebündelte Auftreten von Fehlern (das hatten wir noch nicht) und andere anpassen lassen. Hier wird bereits klar, dass konkurrierende Wünsche an den Code vorliegen. Bereits der sehr einfache (7,4,3)-Hamming-Code, der im Mittel 1/7 = 14.3% Fehler korrigiert, und damit – wieder im Mittel – einen Kanal mit SNR = 1.3 bzw. 14% Fehlern „locker“
3.5 Leistungsbeurteilung von Codes
Die Suche nach Vollkommenheit
Ziel klar, Weg mühevoll
in die Tasche stecken könnte, leidet unter seiner Kürze. Er liefert erst ab SNR = 7.3 überhaupt Verbesserungen, die dazu noch recht bescheiden sind. Hierzu ein Gedankenexperiment: Wenn man den (7,4,3)-Hamming-Code so „aufbohren“ könnte, dass er z. B. bei 100-facher Länge und gleicher Rate 100 Fehler korrigierte, käme er der Korrektur der wesentlichen Fehleranteile schon sehr nahe. Leider lässt sich die Vervielfachung der korrigierbaren Fehlerzahlen t durch Vergrößern der Länge n bei Aufrechterhaltung von R nicht erreichen, da die in Unterkapitel 3.2 beschriebenen notwendigen Bedingungen wegen zu weniger Prüfbits m nicht mehr erfüllt sind. Beispiel: Bei n = 14, m = 6 und t = 2 stehen den (14 über 2) + 14 = 105 Fehlermustern im Codewort nur 26 = 64 Zustände der 6 Paritätsgleichungen gegenüber, abgesehen davon, dass damit noch nicht einmal bereits deren Unabhängigkeit sicher gestellt wäre. In der Tat gibt es bis heute leider kein wirklich direktes Verfahren, um „gute“ Codes zu finden. Ein Grund zur Verzweiflung besteht aber trotzdem nicht. Was uns im Augenblick fehlt, sind Kriterien, an denen man die Eigenschaft „gut“ messen kann. Eines davon beantwortet die Frage nach der Leistung eines Codes, wenn man seine Länge n erhöht, was bei praktisch allen möglich ist. Den Hamming-Code gibt es z. B. für alle n = 2m – 1. Die folgende Tabelle 3-4 verschafft einen Eindruck: n
m
Verbesserung gegen uncodierte Übertragung (R=1) setzt ein bei
Verbesserung bei
Verbesserung bei
EBR[10 db]
EBR[12 db]
SNR/R [db] = Eb/N0[db] - 3 7
3
8,9
0,800
0,440
15
4
7,1
0,290
0,060
31
5
7,2
0,199
0,021
63
6
7,6
0,196
0,014
127
7
8,1
0,250
0,015
255
8
8,6
0,360
0,020
Tabelle 3-4: Leistungsverhalten des Hamming-Codes Die beste Leistung zeigt der Hamming-Code für n = 63, für längere Wörter wird sie wieder schlechter. Es ist das Ergebnis zweier gegenläufiger Wirkungen: • Mit wachsendem n verbessert sich die Info-Rate und senkt damit das Rauschen.
77
3 Fehlerbeseitigung Zugleich steigt aber der Anteil nicht korrigierbarer Wörter mit mehr als einem Fehler. Dieser negative Einfluss übertrifft ab n = 63 den der positiven Entwicklung von R. Leider zeigen einige Codes dieses ungünstige Verhalten, sie werden als „asymptotisch schlecht“ bezeichnet. Das trifft auch für den BCH-Code und den Reed-Muller-Code zu. Ein asymptotisch guter Code ist zum Beispiel der Reed-Solomon-Code. Das heißt allerdings nicht, dass asymptotisch schlechte Codes prinzipiell unbrauchbar sein müssen. Der Hamming-Code etwa ist besonders geeignet in Umgebungen, wo das Auftreten von ein bis zwei Fehlern das Maximum darstellt. Bei Speicherchips liegt eine solche Umgebung vor. •
Schwarze Schafe, weiße Schafe
3.5.5
Was sagt das Experiment?
Ein Beispiel Zum Schluss betrachten wir noch ein Beispiel, bei welchem der Einfluss des Rauschens auf die Verfälschung eines Textes aus 1730 ASCII-Zeichen deutlich wird. Diese Zeichen erzeugen einen Infosignalstrom von 13860 Bits. Mit einem Simulationsprogramm (als Programmier-Werkzeug wurde hier das Paket Mathematica eingesetzt, es eignen sich aber auch elementare Sprachen wie C oder C++) können praktisch alle denkbaren technischen Umgebungen mit verschiedensten Parametern nachgebildet und bis ins kleinste Detail rechentechnisch untersucht werden. Solche Simulationen stellen ganz entscheidende Hilfsmittel bei der Analyse und Synthese auch sehr komplexer technischer Aufgaben dar. Ingenieuren und Informatikern kann der Einsatz solcher Simulationen wärmstens empfohlen werden. Aber zurück zum Beispieltext, einem kleinen Gedicht von K.P. Schreiner/Jürgen Scheller vom Münchner Kabarett „Lach- und Schießgesellschaft“. Sendet man ihn zunächst uncodiert als bipolare Bitfolge über einen Kanal mit dem Störabstand SNR = 10 db, so erhält man nach HD-Decodierung das folgende Ergebnis (die Fehler sind fett markiert): Kam ein Mann ins Kabarett, fand die Räqmlichkeiten nett, zahlte seinen Obulus, ohne jeglichen Verdruß. Legte Mantel ab und Hut, fand sogar den Sitzplatz gut. Winkte sich den Kellner her, zwecks Bestellung von Verzehr. Wählte eine Extra Dry, fand dieselbe einwandfrei. Trank die ersten Gläser ex, sah sich um nAch etwas Sex. Lächelte verführerisch dreimal kurZ zuM Nebentisch. Brachte einen Flirt in Gang, freute sich, weil's ihm gelang. Streifte, als das Licht ausging, heimlich ab den Ehering. Dvehte dann mit frohem Sinn seinen Stuhl zur Bühne hin. Labhte mehrmals ungeniert über das, was dort passiert. Brach schon bei dem Namen Strau× ohne Grund in
78
3.5 Leistungsbeurteilung von Codes Beifall aus. Schlug sich auf die Schenkel dann, oder seinem Nebenmann. Flirtete mit einer Frau,- einer andern-, wurde blau. Ließ sich in der Pause nun, statt das Gegenteil zu tun, eine zweite Extra Dry, kommen, denn er blieb dabei. Sprach:$Na, ist das nicht grandios, hier ist endlich eal was los. Nie mehr seh ich mir so'n Mist an, wie den Hamlet oder Tristan! Klatschte, als das Liãht ausging und der zweite Teil anfing. War erst geistig noch ganz fit, sang dann aber manchmal mit. Lachte sich so gut wie tot. Kam dann plötzlich sehr in Not. Spürte einen bösen Drang. Wünschte einen Abgesang und dac Ende des Programms. Zog die Uhr aus seinem Wams, prüfte, ob's nicht bald vorbei/ Trank den letzten Extra Dry. Brannte sich ein Loch in's Hemd. Saß am Ende ganz verklemmt. Spendete geq}ält Applaus als dano feststand, es ist aus. Lachte über ein Bonmot, seinerseiôs und ging auf's Klo. Sah dann später an der Bar, daß kein Flirt mehr möglich war. Zog sich Mantel an und Hut, fand die frische Luft nicht gut. Kam zu spät zur letzten Tram. Sprach zu sich: Ein0Scheiß-Programm! Setzen, sechs!
Es entstanden 16 fehlerhafte ASCII-Zeichen (aus 16 Einzel-Bitfehlern, die hier alle zufällig in unterschiedlichen 8-Bit-Blöcken liegen, was aber nicht zwingend ist). Werden die Textbits nun in einen (7,4,3)-Hamming-Code abgebildet und bei 7/4 = 1.75-fach höherer Bandbreite mit der gleichen Geschwindigkeit auf diesem Kanal übertragen, so hat der tatsächliche Störabstand den Wert SNRY4/7 = 7.6db (SNR' ist nach wie vor 10 !). Das Ergebnis: Kam ein Mann ins Kabarett, fand die Räumlichkeiten nett, zahlte seinen Obulus, ohne jeglichen Verdruß. Legte Mantel ab und Hut, fand sogar den Sitzplatz gut. Winkte sich den Kellner her, zwecks Bestellung von Verzehr. Wählte eine Extra Dry, fand dieselbe einwandfrei. Trank die ersten Gläser ex, sah sich um nach etwas Sex. Lächelte vewführerisch dreimal kurz zum Nebentisch. Brachte einen Fl`rt in Gang, freute sich, weil's ihm gelang. Streifte, als das Licht ausging, heimlich ab den Ehering. Drehte dann mit frohem Sinn seinen Stuhl zur Bühne hin. Lachte mehrmals ungeniert über das, was dort passiert. Brach schon bei dem Namen Strauß ohne Grund in Beifall aus. Schlug sich auf die Sch`nkel dann, oder seinem Nebenmann. Flirtete mit einer Frau,- einer andern-, wurde blau. Ließ sich in der Pause nun, statt das Gegenteil zu tun, eine zweite Extra Dry, kommen, denn er blieb dabei. Sprach: Na, ist das nicht grand9os, hier ist endlich mal was los. Nie mehr seh ich mir sO'n Mist an, wie den Hamlet oder Tristan! Klatschte, als das Licht ausging und der zweite Teil anfing. War erst geistig noch ganz fit, sang dann aber
79
3 Fehlerbeseitigung manchman mit. Lachte sich so gut wie tot. Kam dann plötzlich sehr in Not. Spürte einen bösen Drang. Wünschte#einen Abgesang und das Ende des Programms. Zog die Uhr aus seinem Wams, prüfte, ob's nicht bald vorbei. Trank den letzten Extra Dry. Brannte sich ein Loch in's Hemd. Saß am Ende ganz verklemmt. Spendete gequält Applaus als dann feststand, es ist aus. Lachte über ein Bonmot, seinerseits und ging auf's Klo. Sah dann später an der Bar, daß kein Flirt mehr möglich war. Zog sich Mantel an und Hut, fand die frische Luft nicht gut. Kam zu spät zur letzten Tram. Sprach zu sich: Ein Scheiß-P2ogramm!
Na, geht doch ...
... aber geht’s noch besser?
Wegen des stärkeren Rauschsignals r entstehen hier nach der HD-Demodulation zunächst 199 Fehlerbits von insgesamt 24220 Codewortbits. Von diesen 199 Bits liegen 106 ( 4/7 ]199) in der Menge der 13840 Infobits . Nach Ausführung der 1-Bit-Fehlerkorrektur bleiben 15 Fehlerbits übrig. Einige davon befinden sich zu zweit in einem 8-Bit-Block, so dass effektiv nur die markierten 8 fehlerhaften ASCII-Zeichen in Erscheinung treten. Trotz des ungünstigeren Störabstandes wurde also eine – in der englischen Literatur „Coding Gain“ genannte – Verbesserung – um den Faktor 2 – entsprechend 3 db – erzielt. Dieses Ergebnis ist sicher noch bescheiden, zeigt aber doch deutlich die prinzipiellen Leistungen, die selbst mit einem sehr anspruchslosen Korrekturverfahren erzielt werden können. Eine weitere Steigerung lässt sich bewirken, wenn man statt der HD-basierten algebraischen Decodierung das im Unterkapitel 3.4.5 beschriebene SD-Verfahren verwendet. Damit „holt“ man bei normal verteiltem Rauschen das überhaupt bestmögliche Ergebnis für den vorliegenden Code heraus, da zusätzliche, in den Schwankungen des Empfangssignals ws verborgene Informationen genutzt werden, die bei HD-Decodierung im wahrsten Sinn des Wortes abgeschnitten werden. Damit man sich eine Vorstellung vom Ablauf dieses Verfahrens machen kann, ist im Folgenden der erste Schritt skizziert: Das ASCII-Zeichen für den Buchstaben „K“ wird zunächst in zwei Halbbytes zerlegt und das erste „Nibble“ 0100 in das Sendewort vs = 1.00,1.00, 1.00, 1.00,1.00, 1.00,1.00
codiert. Mit den ersten 7 Werten des Rauschens rs rs = 0.18, 0.21,0.12, 0.31,0.76, 0.14, 0.14
erhält der Empfänger ws = 1.18,0.79, 0.88, 1.31,1.76, 1.14, 0.86
Er weiß, dass dieses Ergebnis nur mit einem der insgesamt 16
80
3.5 Leistungsbeurteilung von Codes verschiedenen Codewörtern (s. Tabelle 3-2 auf Seite 59) entstanden ist – und genau dieses möchte er finden. Dazu zieht er von ws nacheinander alle 16 Codewörter ab und berechnet die Summe der 7 Differenzquadrate, s. S. 64, mathematisch gesehen das Skalarprodukt des Differenzvektors. Dabei erhält er folgende Liste:
[ wsvsi ][ wsvsi ]
T
Super! (Fast) perfekt!
Vergleichende Werbung
= 14.4, 13.7, 19.0, 16.11, 0.8, 21.0, ... i=1, 2, 3, .... , 16
An der fünften Stelle steht mit 0.8 der kleinste Wert, und er nimmt an, dass das Codewort Nr. 5 aus Tabelle 3-2 das richtige ist – was hier stimmt! Es passt also ähnlich wie ein Schlüssel am besten in das durch ws gegebene „Schloss“. Allerdings ist ihm klar, dass zufällig durchaus ein anderes Codewort den kleinsten Wert ergeben kann und damit auch dieser Weg nicht völlig sicher sein wird. Im Beispiel sind von den 13840 Infobits bei diesem als Maximum Likelihood Verfahren bezeichneten Weg (= das Suchergebnis ist mit der maximalen Wahrscheinlichkeit das richtige) nur noch zwei fehlerhaft. Zufällig liegen sie in einem einzigen 8-BitBlock, weshalb sogar nur ein ASCII-Zeichen verfälscht wird. Allerdings darf man nicht vergessen, welcher Aufwand zur Bestimmung der jeweils „besten“ Codewörter zu treiben ist. Der deutliche Erfolg hat leider einen sehr hohen Preis. Alle Ergebnisse auch für weitere Störabstände sind in Tabelle 3-5 gezeigt. Die Bit-Angaben beziehen sich immer auf die Informationsbits, da die Paritätsbits für das Endergebnis natürlich uninteressant bleiben: SNR'
SNR für Code = 4/7 SNR
Fehler bei uncodiertem =f(rs) Signal V
Fehler bei codiertem Signal HD (v.K. = vor Korrektur)
Fehler bei codiertem Signal SD (ML)
db
-
db
-
-
Bit
Wort
v.K.
Bit
Wort
Bit
Wort
10
10
7,6
5,7
0,31
16
16
106
15
8
2
1
9
7,9
6,6
4,5
0,47
37
36
219
39
22
3
2
8
6,3
5,7
3,6
0,53
90
88
383
78
44
24
15
7
5
4,6
2,7
0,59
178
165
625
219
117
70
41
6
4
3,6
2,3
0,66
335
305
925
444
240
169
98
Tabelle 3-5: Simulationsergebnisse für die Übertragung des auf Seite 79 gezeigten Textes bei verschieden starken Rauschsignalen ohne Codierung, mit HD- und mit SD-Decodierung
81
3 Fehlerbeseitigung
3.5.6
Grenzen: Das Theorem von Shannon Die Identifizierung asymptotisch guter und schlechter Codes bietet schon Anhaltspunkte für Beurteilung und Auswahl. Eine noch grundlegendere Frage aber ist die, ob es überhaupt Grenzen für die Leistung eines Codes gibt. Die verblüffende Antwort hierauf hat der Nachrichtentechniker und Informationstheoretiker Claude Elwood Shannon 1948 in seinem berühmten Aufsatz „A Mathematical Theory of Communications“ (Bell Systems Technical Journal, Vol. 27, Seiten 379 – 423 und 623 – 656) mit folgender einfachen Beziehung für den Zusammenhang zwischen den drei Kenngrößen Kanalkapazität C (Bit/s), Bandbreite B (Hz=1/s) und Störabstand SNR =Sm/Nm gegeben: C = Blog 2 1 SNR
Kapazitäts-Engpass
gnadenloses Gesetz
Sie gilt in dieser Form für den Fall normal verteilter Sendesignale vs und Rauchsignale rs. Sie kann und muss für andere Signalverteilungen noch angepasst werden, liefert aber bereits grundlegende Erkenntnisse und lässt sich außerdem besonders einfach herleiten. Zur Erinnerung: Auf Seite 17 wurde definiert, dass die Kapazität eines bandbegrenzten Kanals diejenige Menge von Informationsbits bezeichnet, welche unter den besten Bedingungen fehlerfrei, also mit EBR = 0, übertragen werden kann. Nach dem ShannonGesetz hängt die Kapazität also nur von der Bandbreite und dem Störabstand ab. Die „besten“ Bedingungen sind dann gegeben, wenn sowohl das Sendesignal vs als auch das Rauschen rs mittelwertfreie, normal verteilte Quellen darstellen. Auf realen Kanälen kann dies für das Rauschsignal angenähert zutreffen, das hier betrachtete bipolare Sendesignal weist aber eine diskrete Gleichverteilung mit P(-1 Volt) = P(+1 Volt) auf, weshalb das Shannon-Gesetz noch angepasst werden muss. Dazu eignet sich die auf Seite 17 dargestellte Entropie-Betrachtung von Shannon. Die auf einem binären Kanal bei gleich wahrscheinlichen Symbolen P(vs=+1) = P(vs=1) = 0.5 mit der Fehlerwahrscheinlichkeit p(rs) übertragbare Information ist gleich der Entropie des Sendesignals vs
H vs=P vs= 1log 2 P vs= 1P vs=1log2 P vs=1=0.5 0.5=1
abzüglich der bedingten Entropie Hws(vs) des Sendesignals, wenn man das Empfangssignal ws bereits kennt und damit auf vs rückschließen kann. Wird z. B. eine „0“ empfangen, ist die Wahrscheinlichkeit dafür, dass eine „0“ gesandt wurde, wegen des Rauschens rs gleich 1p(rs), aber dafür, dass eine „1“ gesendet wurde, p(rs). Die be-
82
3.5 Leistungsbeurteilung von Codes dingte Entropie ist dann die Summe beider Einzelereignisse: Hws vs=prs log2 prs1prslog2 1prs= 0.067 0.014=0.081
Entropie: pur und bedingt
Hierbei wurde für p(rs) = 0.01 angenommen. Von 1000 gesendeten Bits pro Sekunde könnten also 819 fehlerfrei empfangen werden, wenn man die besten Codierungsverfahren einsetzen würde. Dieser Kanal hätte dann eine Kapazität von 819 Bits pro Sekunde. Wäre ein Codewort 1000 Bit lang, so würde es mit 81 Prüfbits die mittlere Fehlerzahl von 10 Bits sicher beseitigen. Das ist eine beachtliche Aussage, die durch die bisher bekannten Verfahren nur angenähert erfüllt wird. Wie entsteht jetzt aber das Theorem? Shannon ist dafür nicht von diskreten, sondern von kontinuierlichen Signalen ausgegangen. Die Signal-Entropien sind dann keine Summen, sondern Integrale. Die Übertragungsrate ist wie auf Seite 17 auch hier • die Differenz der Sendesignal-Entropie und der bedingten Entropie des Sendesignals vs, wenn ws gemessen wurde, wenn also eine – meist fehlerbehaftete – Kenntnis des Sendesignals vorliegt Rc = H vsHws vs •
oder – komplementär – die Differenz der EmpfangssignalEntropie und der bedingten Entropie des Empfangssignals, wenn das Sendesignal gemessen wurde, also eine – meist fehlerbehaftete – Kenntnis über das Empfangssignal vorliegt: Rc = H wsHvs ws
Übertragungsrate: Für uns ist die zweite Version einfacher auszuwerten. Für konti2 Gesichter nuierliche Signale vs, ws und rs nimmt sie die Form
Rc= pwslog2 pwsdws pws,vslog2
pws, vs dvsdws pvs
an. Das kompliziert aussehende Doppelintegral vereinfacht sich entscheidend, wenn Sendesignal vs und Rauschen rs statistisch unabhängig sind und das Empfangssignal außerdem als Summe ws = vs + rs aus Sendesignal und Rauschen entsteht, was bei uns angenommen werden kann. Dann ist die bedingte Entropie Hvs(ws) identisch mit der Entropie H(rs) des Rauschens, die leicht bestimmt werden kann: Im Vollrausch
Rc= pwslog2 pwsdws prslog2 prsdrs
Wie Shannon gezeigt hat, nimmt Rc über alle möglichen Verteilungsdichten p(vs) dann den Maximalwert an, wenn p(vs) eine
83
3 Fehlerbeseitigung Normalverteilung darstellt (s. S. 14). So eine Quelle ist technisch nur angenähert und aufwändig herzustellen, als Referenz aber nützlich. Die Auswertung des ersten Integrals vereinfacht sich außerdem erheblich, da die Verteilungsdichtefunktion p(ws) der Summe zweier mittelwertfreier, normal verteilter Signale vs und rs wiederum eine Normalverteilung ergibt. Zunächst erhält man ein Faltungsintegral
pws=pvs rs= pvspwsvsdvs
das mit 2
p vs=
Rauschzustände
1
2
2 vs
e
2
vs 2 2 vs
und p wsvs=prs=
1
2
2 rs
e
rs 2 2 rs
schließlich auf 2
p ws=pvs rs=
1
2
2 vsd
rs2
e
ws 2 2 2 vs rs
führt. Damit ist 2
H ws=
1
2 2vsd 2rs
e
2
ws 2 2 2 vs rs
1
log2
2 2vsd rs2
e
ws 2 2 2 vs rs
dws
und 2
Hvs ws=Hrs=
1
2
2 rs
e
rs 2 2 rs
log2
2
1
2
2 rs
e
rs 2 2 rs
drs
Bestimmte Integrale dieser Art sind vom Typ
2 2
x 2 ea x dx
=
Die Mathematik des Rausch(en)s
2a3
und ergeben hier die Lösungen
2
2
2
H ws = log2 2 e vs rs und Hrs = log2 2e rs
so dass bei Anwendung der Rechenregeln für Logarithmen die gesuchte Übertragungsrate Rcn für normal verteile Signale schließlich
84
3.5 Leistungsbeurteilung von Codes
Rcn = HwsHrs = log2
Mittelwert = 0 ? o Effektivwert = Standardabweichung
2vs rs2 2rs
=
2 2 1 log 2 vs 2 rs 2 rs
lautet. Die Standardabweichungen V sind die Effektivwerte der zufälligen Spannungen und ihre Quadrate deshalb proportional zur mittleren Leistung Sm des Sendesignals vs bzw. zu Nm des Rauschens rs. Die Übertragungsrate wird also Rcn = HwsHrs =
S N 1 1 log2 m m = log 21 SNR 2 Nm 2
und wir sind dem Shannon-Theorem schon ganz nahe. Obige Beziehung sagt aus, welcher Anteil eines gesendeten Bits trotz des Rauschens fehlerfrei rekonstruiert werden kann. Fragt man nach der Übertragungsgeschwindigkeit, muss man diesen Anteil auf die Zeit beziehen, was auch für den praktischen Einsatz interessant ist. Ein realer technischer Kanal hat immer eine bestimmte Bandbreite B, die durch konstruktive Maßnahmen beeinflusst werden kann.
Bild 3.6: Sendesignal vs'(t) für das ASCII- Zeichen „e“ Vorsichtig abtasten
An dieser Stelle hilft das Abtasttheorem, s. S. 21: Wenn man ein Signal durch Addition von N sinusförmigen Anteilen der Grundfrequenz fg und ihrer Vielfachen fi = iYfg mit i = 1, 2, 3, ..., N zusammensetzt, muss man pro Anteil eine Amplitude und einen Phasenwinkel oder je eine Amplitude für einen sinus- und einen cosinusförmigen Anteil festlegen. Sind diese beiden Parameter irgendwelche codierten Informationen, so werden sie damit in ein analoges Signal abgebildet, das nun über den Kanal geschickt
85
3 Fehlerbeseitigung werden kann. Wenn die „schnellste“ Signalkomponente die Frequenz fmax = fN = NYfg = B besitzt, wird das Signal vollständig übertragen. Bei Messung des Signals im Abstand von dt = 1/(2B) Sekunden gewinnt man gerade 2N Abtastwerte, aus denen der Empfänger mit Hilfe der Fourier-Transformation wieder die 2N Amplituden- und Phasenwerte bestimmen kann. Als Beispiel dient die Übertragung des ASCII-Zeichens „e“ # 0110 0101, es wird als Spannungsfolge (+1, -1, -1, +1, +1, -1, +1, -1) dargestellt. Die 8 Elemente modulieren 4 Cosinus- und 3 Sinussignale mit der Frequenz fg = 1 Hz sowie deren Vielfache und ein Mittelwertsignal und ergeben als Summe vs'(t), siehe Bild 3.6 : 2-mal abtasten reicht ....
vs' t = 1cos f gt1cos 2f gt1cos3f gt 1cos 4f gt 1sinf gt1sin 2f gt 1sin3f gt 1
Die Bandbreite beträgt B = 4 Hz. Entnimmt man diesem Signalverlauf am Empfangsort 2N= 8 Abtastwerte im Abstand von dt = 1/8 s = 0.125 s, beginnend bei t = 0 (siehe die senkrechten Gitterlinien in Bild 3.6) Abtastwerte = 1.00 0.17 1.00 1.00 1.00 5.83 1.00 1.00 so lassen sich daraus die 7 Amplituden und der Mittelwert über die diskrete Fourier-Transformation berechnen, Einzelheiten hierzu findet man im Unterkapitel 6.2.2. Die für N=4 geltenden Beziehungen sind 2N1
acos =
1 N
acos 4 =
1 2N
bsin =
1 N
vs'dtcos =0 2N1
, N
vs' dtcos =0
2N1
vs 'dtsin =0
Mittelwert = acos0 =
1 2N
= 1, 2, 3
4 N
, N
= 1, 2, 3
2N1
vs' dt =0
Fourier bringt's .. Die 4 Cosinus-Amplituden ergeben sich hieraus als +1, -1, +1, -1, die 3 Sinus-Amplituden als +1, -1, +1. Der Mittelwert ist der Koeffizient für O =0, acos0 = -1. In der Tat können also mit 2N Abtastwerten genau 2N Signalkomponenten ermittelt werden – und umgekehrt. Dieses Verfahren zur Erzeugung eines modulierten Sendesignals ist aus verschiedenen Gründen für den praktischen Einsatz
86
3.5 Leistungsbeurteilung von Codes
Spitzenleistung – unerreicht
allerdings weniger gut geeignet, es dient hier nur der Illustration zur Wirkungsweise des Abtasttheorems. Noch zwei Hinweise: • Wenn man als Grundfrequenz statt fg z. B. fg' = fg/2 wählt, könnte man zwar ein weiteres Amplitudenpaar hinzufügen, dies ließe sich aber wegen der dann gegebenen Unterbestimmtheit (mehr Unbekannte als Gleichungen) nicht mehr über die Fourier-Transformation zurück gewinnen. Die Grundfrequenz ist also durch fg = 1/(2n·dt) festgelegt. • Die Amplituden sind nicht auf binäre Werte beschränkt, zur Modulation können beliebige Größen verwendet werden. Dadurch ist dann auch die pro Wert übertragbare Informationsmenge größer, allerdings steigt zugleich die Anfälligkeit gegen Verfälschungen durch das Kanalrauschen Nun zurück zum Shannon-Theorem: Bei einer Übertragungsrate Rc und unter Ausnutzung der besten Codierungsverfahren können beim Empfänger pro Sekunde demnach
Rcn * = Cn =
1 1 1 log 1 SNR = 2B log2 1 SNR = Blog2 1 SNR T 2 2 2
Bits fehlerfrei ankommen. Bild 3.7 zeigt den auf die Bandbreite B normierten Verlauf (durchgezogene Linie). Er bietet keine Überraschungen, denn für einen schlechten Störabstand wird die Kapazität Cn sehr klein, sie wächst stetig und theoretisch sogar unbegrenzt, wenn sich der Abstand verbessert. Man kann aber quantitative Aussagen machen: Bei einer Bandbreite von 10 MegaHertz und einem Störabstand von 0 db hat der Kanal eine Kapazität von 10 MegaBit/s, bei SNR = 5 db bereits das Doppelte.
Bild 3.7: Shannon-Theorem für normal verteilte (durchgezogene Linie) und bipolare Sendesignale (gestrichelte Linie).
87
3 Fehlerbeseitigung Noch einmal: Dies gilt für den Fall normal verteilter Signale vs und rs. Jetzt passen wir das Shannon-Theorem an den Fall des bipolaren Sendesignals an und verwenden wieder die allgemeine Beziehung von Seite 84:
Rcbp = p wslog 2 p ws dws
normal und diskret
prslog 2 prsdrs
Die (diskrete) Verteilungsfunktion einer bipolaren, gleich verteilten Größe hat die beiden Werte P(vs=+1) =P(vs=-1) = 0.5. Daher ist das Empfangssignal ws = vs + rs = +/-1 + rs. Man kann es auch so interpretieren, dass die eine Hälfte von allen eine Normalverteilung mit dem Effektivwert Vrs und dem Mittelwert +1, die andere mit dem Effektivwert Vrs und dem Mittelwert -1 aufweist.
Bild 3.8:: Verteilungsdichte p(ws) bei bipolarem Sendesignal und normal verteiltem Rauschen rs mit Vrs=0.4 oder SNR =6.25 =8 db normierte Fläche
Die Verteilungsdichte p(ws) ist dann die auf die Fläche 1 normierte Summe dieser beiden Verteilungsdichten, siehe Bild 3.8,
1 1 p ws = e 2 2 2rs
2
rs1 2 2 rs
2
e
rs 1 2 2 rs
und die Entropie wird
H ws =
rs1 2 2 rs
1 1 e 2 2 2rs
2
2
e
rs 1 2 2 rs
1 1 log2 e 2 2 2rs
2
rs1 2 2 rs
2
e
rs 1 2 2 rs
drs
Für derartige Integrale gibt es im allgemeinen keine ge-
88
3.5 Leistungsbeurteilung von Codes schlossenen Ausdrücke, man berechnet sie daher numerisch mithilfe eines Programms. Wer sie dennoch etwas weiter zerlegen möchte, kann die folgenden Hinweise verwenden: Zunächst kann man den logarithmischen Anteil umformen, wobei die Umwandlung log2 x = log2 eln x =
ln x ln 2
Eine Menge Rech- hilft. Der logarithmische Term ist nungen rs1 rs 1 1 1 2 2 log2 e e 2 2 2rs
2
2
2 rs
2 rs
rs 1
rs 1
2
1 = 1 log2 2 2rs log2 eln e 2
2
2
2 rs
e
2
rs 1 2
2 rs
=
2 rs
2rs
1 2 2 2 = 1 log2 2 2rs log2 eln e e e 2
2 rs
2 rs
rs 1 2 2 rs
2 cosh
2
2
1 = 1 log2 2 2rs log2 eln e 2
2 rs
rs 2 rs
1 rs 1 rs = 1 log2 2 2rs 2 log2 e ln 2 cosh 2 log 2 e 2 2 rs rs 2
1 rs rs = 1 log2 2 2rs 1over2 2rs 2 ln 2cosh 2 log2 e 2 2 rs rs Er lässt sich in 5 Summanden zerlegen. Der zweite Summand hebt sich in Rcbp gegen H(rs) weg. Damit besteht Rcbp noch aus 3 vom Typ her unterschiedlichen Beiträgen Rcbp = H ws Hrs
= k1 pws drs k 2 rs 2 p wsdrs k 3 p wsln 2cosh
= 1
Geschlossene Lösung ausgeschlossen
rs drs 2
1 1 rs2 pws drslog 2 e p ws ln 2cosh rs2 drs 2 2rs 2 2rs
Für die beiden verbleibenden Integrale findet man keine geschlossene Lösung, daher werden sie numerisch ausgewertet. Der Verlauf ist in Bild 3.7 auf Seite 87 als gestrichelte Linie eingetragen. Für schlechte Störabstände nähert sich Cpb der Kapazität Cn, bei großen Abständen hat sie einen Wert von 2 Bit/s pro Hertz Bandbreite. Auch dies ist nicht überraschend, da eine
89
3 Fehlerbeseitigung Quelle von gleich verteilten Binärsignalen mit der Entropie 1 Bit sendet und auf einem Kanal mit der Bandbreite B pro Sekunde 2 Bits (Vorsicht: Signalbits, oder auch Codewortbits, aber nicht Infobits) übertragen werden können: Rcbp *=Cbp =
Antwort auf Grenzfragen
Rate bestimmt Grenze
90
1 R =2BRcbp =2B H wsHrs dt cbp
Für einen Zahlenvergleich dienen folgende Werte aus Bild 3.7: SNR [db] = 10 log10 SNR B = 10 MegaHertz
-5
0
5
10
15
Cn (MegaBit/s)
4
10
20
35
50
Cbp (MegaBit/s)
4
10
17
20
20
Auf einem Kanal mit 10 MegaHertz Bandbreite können also bei normal verteilten Sendesignalen und SNR = 0 db im Idealfall 20 MegaBit/s an Informationen fließen, bei bipolaren sind es 17 MegaBit/s usw. Die zu Anfang dieses Unterkapitels gestellte Frage nach möglichen Grenzen für die Kanalkapazität ist nun beantwortet. Interessant bleibt noch, welche Auswirkungen dies auf die Restfehlerwahrscheinlichkeit EBR(SNR') hat, zum Beispiel gemäß Bild 3.6 auf Seite 74. In Diagrammen dieser Art spielt die Übertragungszeit keine unmittelbare Rolle, daher hilft die Betrachtung der Kapazität C hier nicht weiter, wohl aber die zu ihrer Berechnung verwendete Übertragungsrate Rc. Sie gibt ja an, wie viel Bits über einen Kanal im besten Fall fehlerfrei beim Empfänger ankommen, wenn die Quelle mit einer Entropie H(vs) Bits sendet. Bei bipolaren Sendesignalen hat die Quelle eine Entropie von 1 Bit, daher gibt Rc hier zugleich auch die Informationsrate R wieder, R = Rc. Ein paar Beispiele: • Der (7,4,3)-Hamming-Code weist eine Informationsrate R = 4/7 = 57%. auf. Das Shannon-Theorem zeigt, dass die Übertragungsrate Rc für SNR = 1.1 = 1.3 db gerade 0.57 beträgt (= halber Wert des gestrichelten Verlaufs in Bild 3.6, warum?). Ein Code mit R = 4/7 kann also bei schlechterem Störabstand als 1.3 db prinzipiell keine fehlerfreien (genauer: keine beliebig fehlerarmen) Ergebnisse mehr bringen. Dies ist die untere Grenze. Der in Unterkapitel 3.5.3 für Vergleiche mit anderen Codes empfohlene, auf die Inforate R bezogene Störabstand SNR' = SNR/R ist hier SNR'=2.3 = SNR' = 3.6 db. Wenn man bedenkt, dass der (7,4,3)-Hamming-Code überhaupt erst ab SNR' = 9 db einen ersten, zudem äußerst bescheidenen Gewinn bei der Fehlerkorrektur bringt, sieht man, dass man
3.5 Leistungsbeurteilung von Codes noch weit von der theoretisch erreichbaren Grenze entfernt ist. Im Diagramm Bild 3.9 markiert eine senkrechte Linie bei 3.6 db, dass alle rechts davon liegenden Störabstände theoretisch ohne Einfluss auf die Fehlerarmut des Korrekturverfahrens bleiben.
Shannongrenze für R 0
Shannongrenze für R = 4/7
Bild 3.9: Shannon-Grenze bei einem (7,4,3)-Code mit R = 0.57: Die senkrechte, strichpunktierte Linie zeigt die Shannon-Grenze für R = 0.57. Nimmt man ein EBR von 10-9 als sehr fehlerarm an, so beträgt der Abstand zur Shannon-Grenze 15 -3.6 = 11.4 db. Eingetragen ist auch die Shannon-Grenze, wenn R gegen den Wert 0 läuft.
Bei einem (15,5,7)-BCH-Code liegt die Grenze bei SNR = 0.6 = -2.3 db. Dann ist SNR' = 1.8 = 2.5 db. SNR' sinkt also mit kleinerer Inforate R ebenfalls ab. Dabei stellt sich die Frage, ob dies unbegrenzt geschieht. Die Antwort ist „nein“. Wenn die Übertragungsrate mit sinkendem Störabstand zurückgeht, so nähert sich SNR' dem Grenzwert 2 ln 2 = 1.39 = 1.42 db. Für normal verteilte Sendesignale kann dieser Grenzwert aus Rcn von Seite 85 auch direkt ermittelt werden. Setzt man die Entropie des Senders willkürlich auf den Wert 1 (= 1 Bit), dann erhält der Empfänger Rcn fehlerfreie Bits pro gesendetem Bit, und Rcn stellt zugleich den Wert der Informationsrate R dar:
•
Absoluter Tiefpunkt
Rc Hvs 22R 2R 2 1 R für R 0
Rc 1 = R = log2 1 SNR'R 1 2 = 1 SNR'R 22R1 = SNR'R =
= SNR' , wird SNR' = 2ln 2=20.69 = 1.38
91
3 Fehlerbeseitigung Für den bipolaren Fall lässt sich zwar kein geschlossener Ausdruck angeben, doch kann man anhand der folgenden Tabelle 3-6 auch hier die Entwicklung zu diesem Grenzwert bei sinkender Informationsrate R beobachten: R
SNRSh
SNRSh(db )
SNRSh/R
SNRSh/R (db)
Beispielcode mit R
0,900
3,80100
5,80
4,2020
6,23
(63,57,3)-Hamming
0,570
1,28000
1,10
2,2500
3,50
(7,4,3)-Hamming
0,333
0,59500
-2,25
1,7900
2,50
(15,5,7)-BCH
0,194
0,30900
-5,10
1,5960
2,03
(31,25,11)-BCH
0,010
0,01400
-18,50
1,4125
1,50
----
0,001
0,00138
-28,50
1,3860
1,42
(Grenzwert)
Tabelle 3-6 und Diagramm: Asymptotisches Verhalten der Shannon-Grenzen SNR/R(R) bis zum absoluten Minimalwert 1,41 db für sinkende Inforaten R. Wegen SNR/R = 2 Eb/N0 läge der Minimalwert in der Eb/N0-Darstellung bei -1.6 db Im Tiefpunkt sind Während sich für den Bereich guter Störabstände die Kapazitäten sie alle gleich normal verteilter und bipolarer Sendesignale stark auseinander entwickeln, siehe Bild 3.6, nähern sie sich im technisch interessanteren Fall kleiner Störabstände gegenseitig an. Für R o 0 streben sie gegen denselben Grenzwert SNR/R = SNR'= 2 ln 2 = 1,386. Zwei Werte, eine In der Literatur findet man alternativ die Angabe Eb/N0 =0.693 = Aussage -1.6 db. Aus der Umrechnung auf Seite 76 ergibt sich das unmittelbar: E SNR =2 b R N0
oder
SNR Eb = 2R N0
Damit sind zwar nicht alle, aber doch ein paar wesentliche Überlegungen zur Leistungsbeurteilung von Codes abgeschlossen,
92
3.5 Leistungsbeurteilung von Codes und wir können uns weiteren Code-Varianten zuwenden.
3.5.7
Was blieb? 1. 2. 3.
4. 5. 6. 7. 8.
3.6
Welche Fehlerrate EBR weist ein unkorrigierter Bitstrom bei SNR = -4 dB auf? Wie verteilen sich die Bitfehler bei SNR = -4 dB auf Bitblöcke der Länge n = 15? Wieviele Bitfehler enthält ein Informationsbit-Strom, wenn der beste nach dem Shannon-Theorem mögliche Korrekturcode mit R = 0.8 angewendet würde und der Kanal ein SNR von 10 aufwiese? Ist das Ergebnis zur Antwort auf Frage 3 in der Realität erzielbar? Ist die Shannongrenze unabhängig von der Informationsrate R? Gilt die Shannongrenze unabhängig von der Statistik des Sendesignals? Was sagt das Kapazitätstheorem aus? Ist die Kanalkapazität bei großen, als günstigen Störabständen für alle Verteilungen eines Sendesignals gleich?
Erweiterungen des Hamming-Verfahrens Gerade deshalb, weil das Verfahren zur Bildung des HammingCodes so einfach ist, lohnt es sich, nach Möglichkeiten für weitere Leistungen zu suchen. Hier gibt es einmal die mehr theoretisch interessierende Verallgemeinerung auf andere Ganzzahlbasen, zum anderen die auch praktisch nützliche Erweiterung zur zusätzlichen Zwei-Bit-Fehlererkennung.
3.6.1
Verallgemeinerung auf andere Ganzzahlbasen Bleiben wir zunächst noch im Bereich der Binärzahlen (mit den Elementen 0 und 1 des Ganzzahlkörpers Z2, s.S. 32) und fragen uns, ob es nicht auch einen Hamming-Code gibt, mit dem man zwei Fehler und mehr korrigieren kann. Die Antwort liefern die im Unterkapitel 3.2 gemachten Überlegungen zum Zusammenhang zwischen der Anzahl von Prüf- und Informationsstellen. Man geht davon aus, dass sich mit m Prüfstellen yi gerade 2m verschiedene Zustände unterscheiden lassen. Was aber muss eigentlich unterschieden werden? Einmal die Möglichkeit der Fehlerfreiheit, des weiteren der Fall, dass ein Einzelfehler auftritt, was sich bei n Stellen also durch n Zustände beschreiben lässt, und schließlich noch die Fälle, dass zwei und mehr Fehler auf-
93
3 Fehlerbeseitigung traten. Die Auswertung der hierfür in 3.2 abgeleiteten Ungleichungen ergibt einige wenige Paarungen für m und k, mit denen zunächst die notwendigen Bedingungen erfüllt sind. Golay hat im Jahre 1949 für m = 11 und k = 12 nachgewiesen, dass diese Bedingungen sogar hinreichen. Es gibt also mindestens so viele unterscheidbare Syndromwerte wie Fehlerpostionskombinationen. Da außerdem das Gleichheitszeichen gilt, ist der nach ihm benannte (23,12,7)-Code für 3-Bit-Fehlerkorrektur perfekt, s. auch S. 54:
23 23 23 = 23 253 1771 = 2111 = 2047 1 2 3
perfekt ist selten
Weitere, auf diese Weise konstruierbare Codes haben technisch keine Bedeutung erlangt. Die bisher geübte Beschränkung auf binäre Signale hat den praktischen Grund, dass die technische Darstellung von Digitalsignalen überwiegend binär erfolgt. Mathematisch gesehen kann man auch andere Ganzzahlkörper verwenden. Manchmal liegt darin sogar ein Vorzug, weil nicht jedes beliebige Codierungsverfahren in jedem Ganzzahlkörper arbeitet. So ist z. B. der heute viel benutzte, leistungsfähige Reed-Solomon-Code nicht im Binärzahlenbereich definiert. Allerdings lassen sich die damit erzielbaren Ergebnisse wiederum binär darstellen. Wie sieht es im Fall eines Einzelfehlers bei einem Code über das p-Zahlensystem aus? Ein Einzelfehler tritt hier wie bei binären Codes an einer der n Codewortstellen auf, ist aber kein 1-Bitfehler mehr, sondern einer, der p verschiedene Werte von 0 bis p-1 annehmen kann. Davon abgesehen unterscheidet sich der formale Aufbau eines Codewortes aber nicht: v = u1, u2, ......., uk , y1, y 2, ...... , ym = v 1, v2, ......, vn
tragfähige Untergründe
Als Basis p kommt im übrigen nur eine Primzahl (s.S. 38) in Frage, denn im Bereich der natürlichen Zahlen kann nur über diese ein Zahlenkörper aufgebaut werden, s.S. 38. Es genügt jetzt nicht mehr, ausschließlich die Fehlerposition im Codewort zu betrachten, man muss auch den Fehlerwert, also die Differenz zum korrekten Wert in dieser Stelle ermitteln. Im p-System kann diese Differenz die Werte 1,2,...,p-1 annehmen. Die Beziehung zwischen Prüf- und Informationsstellen muss dies berücksichtigen. Jede fehlerhafte Position hat einen von p-1 Differenzwerten, so dass weitere Zustände zur Erkennung dieses Sachverhalts verbraucht werden. Allerdings lassen sich nun mit m Prüfstellen auch mehr Zustände darstellen: pm 1 mp1 k p1
94
3.6 Erweiterungen des Hamming-Verfahrens Daraus berechnet sich Anzahl der Informationsstellen mit k
binär ist nicht alles
pmmp11 p1
Das Gleichheitszeichen lässt sich in jedem Zahlensystem Zp für jede Anzahl m von Prüfstellen erfüllen, so dass der verallgemeinerte Hamming-Code ebenfalls perfekt ist (genauer: sein könnte, da noch der Nachweis auf eine genügende Anzahl unabhängiger Syndromkombinationen fehlt). Das Verfahren zur Berechnung der Prüfstellen ist für den Z3 mit den 3 Elementen 0, 1 und 2 in Tabelle 3-7 gezeigt. Jedes Codewort v hat bei zwei Prüfstellen (m = 2) nach obiger Formel k = 2 Informationsstellen: v = u1, u2, y1, y2
Fehler in Stelle
Syndromzustand
s1
s0
kein Fehler
00
-
-
y1=1
01
y1
y1=2
02
y1
y2=1
10
y2
y2=2
20
y2
u1=1
11
u1
u1
u1=2
22
u1
u1
u2=1
12
u2
2u2
u2=2
21
u2
2u2
Tabelle 3-7: Syndromzustände bei einem 4-stelligen Code im Z3 Zur Bestimmung der Prüfstellenwerte müssen, wie im binären Fall, die Summen in den Syndromspalten den Wert 0 erhalten: y1 u1 2u2 = 0 y1 = u12u 2 MOD3 = 2u1 u2 MOD 3 y 2 u1 u2 = 0 y1 = u1u2MOD 3 = 2u 1 2u 2MOD 3
Wie in der Musik: Die Vorzeichen sind hier im Gegensatz zum Rechnen im Z2, wo Vorzeichen begenerell die Regel „+“ = „ - „ gilt, zu beachten! Die einzelnen achten Tabellenzeilen kann man so lesen: Bei Fehlerfreiheit haben die beiden Komponenten s0 und s1 des Syndromvektors den Wert 0. Ist in der Stelle y1 ein Fehler mit dem Wert 1 aufgetreten, so wird s0=1, hat dieser Fehler den Wert 2, so wird s0 = 2. Hat u1 den Fehlerwert 1, so ist s0 = 2 und s1 = 1 usw.
95
3 Fehlerbeseitigung Beziehungskisten
Auch hier lässt sich der ganze Code wieder aus den Paritätsprüfbeziehungen konstruieren. Die neun vierstelligen Codewörter sind in Tabelle 3-8 dargestellt. Werte für u1 und u2
Codewort v
00
[0 0 0 0]
10
[2 2 1 0]
20
[1 1 2 0]
01
[1 2 0 1]
11
[0 1 1 1]
12
[1 0 1 2]
20
[1 1 2 0]
21
[2 0 2 1]
22
[0 2 2 2]
Tabelle 3-8: Codewörter des vierstelligen Codes in Z3 Man bestimmt sie aus der Generatormatrix G. Zwei hierzu erforderliche, linear unabhängige Codewörter sind z. B. die mit u1=1, u2=0 und u1=0, u2=1. Damit erhält man sowohl G als auch die Paritätsprüfmatrix H: G =
Jetzt hat der Fehler einen Wert!
[
]
1 0 2 2 MOD 3 und 0 1 1 2
H =
[
]
21 1 0 MOD 3 22 0 1
Der Rechengang läuft genauso ab, wie er bereits im Unterkapitel 3.4 für den binären Hamming-Code beschrieben wurde. Für G und H gilt wiederum HGT = 0, so dass jeder fehlerfreie Codewortvektor v den Nullvektor als Syndrom ergibt, wenn man ihn in transponierter Form vT von rechts mit der Paritätsprüfmatrix H multipliziert. Tritt andererseits ein Fehler e auf, so kann man aus dem empfangenen Wort w = v + e und der Matrix H den Syndromvektor s berechnen und daraus sowohl die Fehlerposition als auch den Fehlerwert entnehmen. Letzteres ist neu! Ein Beispiel: Man sendet das Codewort v = [1 1 2 0]
dessen erste Stelle durch eine Störung mit dem Wert 2 auf 0 gekippt wurde (MOD 3 beachten!). Es kommt also, nach HDDemodulation, das Empfangswort w = [0 1 2 0]
an. Der Fehlervektor ist e = [2 0 0 0]. Der Syndromvektor wird
96
3.6 Erweiterungen des Hamming-Verfahrens
[]
0 1 0 2 2 1 4 2 s = Hw = MOD 3 = ' MOD 3 = 0 1 1 2 2 3 0 0 T
Syndrom, der Schlüssel zum Erfolg
[
]
[ ]
[]
Ein Blick in die Syndromwert-Tabelle 3-7 zeigt in der dritten Zeile, dass es sich um einen Fehler in der ersten Position der Größe 2 handelt. Um das empfangene Wort zu korrigieren, braucht man diesen Fehlerwert nur noch abzuziehen und das Ergebnis MOD 3 zu nehmen. Damit erhält man v = [2 1 2 0] MOD 3 = [1 1 2 0]
Für andere Ganzzahlkörper läuft das Verfahren ganz ähnlich ab, was hier aber nicht fortgeführt wird.
3.6.2
Erweiterung um zusätzliche Fehlererkennung Wir betrachten jetzt noch Erweiterungen des Hamming-Codes, bei welchen sowohl ein Einzelfehler korrigiert als auch ein Zweifachfehler erkannt wird. Das Verfahren ist im übrigen vom Hamming-Code unabhängig und kann daher auch für nahezu beliebige andere verwendet werden. Wegen dmin tkor t erk 1
1-Bitfehler: geht noch mehr?
s. S. 19, ist ein Mindest-Hammingabstand d=4 notwendig. Eine Vorüberlegung zeigt zunächst, dass es nur darauf ankommt, wofür man einen Code mit einem gegebenen Mindestabstand d einsetzen will. Der 1-Bitfehler-korrigierbare Code mit d=3 kann auch zur 2-Bitfehlererkennung benutzt werden. Dann allerdings ist er für die 1-Bitfehlerkorrektur nicht mehr brauchbar. Wie erklärt sich der scheinbare Widerspruch in diesen Aussagen, bei denen immer vom selben Code ausgegangen wird? Die 1-Bitfehlerkorrektur funktioniert nur dann zuverlässig, wenn mit Sicherheit auch nur 1-Bitfehler auftreten können. Das empfangene Wort w hat dann genau den Hammingabstand 1 von dem einen richtigen Codewort v, aus dem es durch den Fehler e verfälscht wurde. Tritt ein weiterer Fehler hinzu, so hat das empfangene Wort nun den Hammingabstand 1 von einem anderen Codewort, und die Korrektur führt zu einem falschen Ergebnis. Das ist aber am Syndrom nicht erkennbar. Erwarten wir dagegen von vornherein, dass zwei Fehler (gemeint ist ein beliebiger 2-Bitfehler) auftreten können, so darf man das Syndrom nicht benutzen, um die Fehlerposition festzustellen, da diese Information in diesem Fall unsicher ist. Wohl aber kann man einem von Null verschiedenen Syndromvektor
97
3 Fehlerbeseitigung
Abstand: nicht halten erweitern!
die Auskunft entnehmen, dass ein oder zwei Fehler aufgetreten sind und muss dann die Wiederholung des Sendevorgangs anfordern. Wenn also auf jeden Fall ein 1-Bitfehler zu korrigieren ist, man zugleich aber noch einen 2-Bitfehler erkennen muss, so bleibt nur die Wahl eines Codes mit einem Mindesthammingabstand von d = 4. Erfreulicherweise kann man sich das Leben hier einfach machen, indem der 1-Bitfehler-korrigierbare HammingCode aus Kapitel 3.4 um eine zusätzliche Prüfstelle erweitert wird. Man benutzt diese zur Paritätsprüfung für alle Informationsstellen gemeinsam. Im Beispiel gemäß Unterkapitel 3.4 kommt also eine vierte Prüfstelle hinzu: y 4 = y1 y 2 y3 u1 u 2 u3 u4 MOD 2 = u1 u2 u 4 u1 u3 u 4 u2 u3 u4 u1 u2 u3 u4 MOD 2 = u1 u2 u 3 MOD2
kleine Ergänzung Jedes Codewort hat damit folgenden Aufbau: v=[u1 u2 u3 u4 y1 y2 y3 y 4]
Da bei den 4 Basiscodewörtern immer nur eine Informationsstelle "1" ist, die anderen aber "0" sind, hat y4 bei den ersten drei Basiscodewörtern den Wert 1, für das vierte den Wert 0. Die Generatormatrix G wird daher um die Spalte "1 1 1 0" erweitert. Damit gibt es die in Tabelle 3-9 aufgelisteten 16 Codewörter: u1 u2 u3 u4 0 0 0 0 0 0 0 1 0 0 1 0 0 0 1 1 0 1 0 0 0 1 0 1 0 1 1 0 0 1 1 1 1 0 0 0 1 0 0 1 1 0 1 0 1 0 1 1 1 1 0 0 1 1 0 1 1 1 1 0 1 1 1 1
Codewort v [0 0 0 0 0 0 0 0] [0 0 0 1 1 1 1 0] [0 0 1 0 0 1 1 1] [0 0 1 1 1 0 0 1] [0 1 0 0 1 0 1 1] [0 1 0 1 0 1 0 1] [0 1 1 0 1 1 0 0] [0 1 1 1 0 0 1 0] [1 0 0 0 1 1 0 1] [1 0 0 1 0 0 1 1] [1 0 1 0 1 0 1 0] [1 0 1 1 0 1 0 0] [1 1 0 0 0 1 1 0] [1 1 0 1 1 0 0 0] [1 1 1 0 0 0 0 1] [1 1 1 1 1 1 1 1]
Basiswort * * *
*
Tabelle 3-9: Die 16 Wörter eines (8,4,4)-Hamming-Codes für zusätzliche 2-Bitfehler-Erkennung
98
3.6 Erweiterungen des Hamming-Verfahrens Die Generatormatrix lässt sich z. B. wieder aus den 4 Basiscodewörtern konstruieren:
[
1 0 G = 0 0
paritätische Mitbestimmung
0 1 0 0
0 0 1 0
0 0 0 1
1 1 0 1
1 0 1 1
0 1 1 1
]
1 1 MOD 2 1 0
Für die Paritätsprüfmatrix H gilt folgende Überlegung: Tritt kein Fehler oder genau ein Einzelfehler auf, so soll der (nun vierelementige) Syndromvektor s entweder der Nullvektor sein, oder er enthält als letztes Element eine "1" und in den ersten drei Elementen die Binärdarstellung der Fehlerposition so, wie es für den Fall der Einzelfehlerkorrektur abgeleitet wurde. Erscheint die "1" nur im vierten Element, so ist die achte Codewortposition fehlerhaft. Enthält das vierte Element von s aber eine "0" und sind die übrigen drei Elemente teilweise oder alle "1", so liegt ein Doppelfehler vor. Eine Korrektur ist dann nicht mehr möglich. Die (transponierte) Paritätsprüfmatrix HT besteht also aus der von der 1-Bitfehlerkorrektur bekannten Matrix, die jedoch um eine vierte "1"-Spalte (jedes Codewort hat 8 und nicht nur 7 Stellen) erweitert wurde. Damit sehen der Syndromvektor s und die Paritätsprüfmatrix H folgendermaßen aus:
s = [ s1 s2 s3 s 4] = wH = [ w1 w2 w 3 w 4 w 5 w6 w7 w 8]
Hamming Open: Doppelfehler
[ ] 1 1 0 1 1 0 0 0
1 0 1 1 0 1 0 0
0 1 1 1 0 0 1 0
1 1 1 0 MOD 2 0 0 0 1
Betrachten wir zwei Beispiele für die Auswirkung von Einzelund Doppelfehlern und gehen dabei vom Informationswort u = [1 1 0 1] aus. Das Codewort ist dann: v = [11 011 00 0]
Ein Fehler in der fünften Stelle kippt das "1"-Bit auf "0": w = [11 01 00 00]
Mit der Paritätsprüfmatrix H berechnet man das Syndrom:
99
3 Fehlerbeseitigung s = [100 1]
Die ersten drei Elemente von s sind nicht alle "0", das vierte Element hat den Wert "1". Also liegt ein Einzelfehler vor, dessen Position aus den drei ersten Elementen von s als fünfte Stelle abzulesen ist. Nehmen wir nun einen weiteren Fehler in der zweiten Position an, so dass das empfangene Wort w = [1 001 00 00]
ist. Das Syndrom hat hier den Wert s = [00 10]
Ein Syndrom für alle Fälle
Da s nicht der Nullvektor ist, das vierte Element jedoch den Wert „0“ hat, liegt ein Zweifachfehler vor, den man allerdings nur erkennen und nicht auch korrigieren kann. Man sieht das u. a. daran, dass die 28 hier möglichen Syndrome 7 Gruppen zu je 4 gleichen Elementen bilden. Eine eindeutige Zuordnung zum jeweiligen Fehlerpaar ist damit unmöglich. So hat z. B. das empfangene Wort w = [0 10 010 00]
dasselbe Syndrom. Falls die achte Stelle selbst verfälscht wurde, also w = [11 011 00 1]
dann weist das Syndrom eine „1“ nur in der letzten Position auf, s = [00 01]
AbsturzVerhinderer
100
und man erkennt, dass die achte Stelle der "Übeltäter" ist. In vielen Arbeitsspeichertechnologien werden Varianten dieses einfachen Kombinationsverfahrens zur gleichzeitigen Fehlererkennung und Fehlerkorrektur verwendet. Der Nutzen für ein solches Verfahren liegt darin, dass einerseits bei Vorliegen nur eines 1-Bitfehlers keine Wartungs- oder Austauschaktivitäten ergriffen werden müssen, bei 2-Bitfehlern aber immerhin noch eine eindeutige Diagnose möglich ist. Würde man auf Letztere verzichten, so ergäben sich unter Umständen beim Auftreten von 2-Bitfehlern verhängnisvolle Falschinterpretationen durch den Prozessor, was meistens zu „Systemabstürzen“ führt. Es gibt noch weitere Möglichkeiten, um Hamming-Codes zu ergänzen (oder zu kürzen) und dadurch zusätzliche Leistungsmerkmale des Codes zu erzeugen. Da der im Beispiel gezeigte Fall aber der am häufigsten verwendete ist, wird auf eine weitere Erörterung verzichtet.
3.6 Erweiterungen des Hamming-Verfahrens
3.6.3
Was blieb? 1.
2. 3.
3.7
Wie sieht das ASCII-Zeichen 1011 0110 in den Zahlensystemen Z3, Z5 und Z7 aus? Wäre auch eine Darstellung im Z4 und Z6 möglich und sinnvoll? Lässt sich die Mehrbit-Fehlererkennung auch in nicht binären Zahlenkörpern verwirklichen? Welchen Aufbau weist ein Code auf, mit dem ein 64-Bit RAM-Wort auf 1-Bitfehlerkorrektur und 2-Bitfehlererkennung abgesichert ist?
Zyklische Codes Unser Hauptziel ist es, praktikable Codes zu finden, mit denen sich mehr als nur 1-Bitfehler korrigieren lassen. Ein guter Weg dorthin, wenn auch nicht der einzige, erschließt sich in den zyklischen Codes. Ihr Name entstand aus der Eigenheit, dass alle aus einem einmal gefundenen Codewort durch zyklische Verschiebung erzeugten Wörter wiederum Codewörter sind. Hierunter fallen z. B. die in vielen Datenübertragungsprotokollen (z. B. im TCP/IP des Internet) benutzten Codes zur Bündelfehler-Erkennung oder die BCH-Codes, mit denen man jede vorgebbare Anzahl von Fehlern korrigieren kann. Ein bedeutsamer Vertreter dieser Klasse ist etwa der Reed-Solomon-Code. Er wird verwendet, um bei Massenspeichersystemen wie Festplatten, CDROMs, DATs und ähnlichen die Wirkung von Fehlstellen in der Oberflächenbeschichtung des Bandmaterials zu beseitigen, dient aber auch als Basis für die Turbo-Produkt-Codes.
3.7.1
Reste-Verwertung
Der Weg und die Mittel: Generatorpolynome und Reste Das Konstruktionsprinzip der Hamming-Codes ist sehr klar und zielgerichtet: Man gibt eine Anzahl von Prüfstellen vor und bestimmt, wie und wie viele Codewortstellen sich hiermit prüfen lassen. Ein ganz anderes, sehr wirkungsvolles Verfahren verbindet sich mit dem „Zauberwort“ Divisionsrest. Das Prinzip ist denkbar einfach. Hier ein Beispiel für das Informationswort u = 10000111 im Z2: • Wahl einer festen Primzahl als „Generatorzahl“ g, z. B. g = 11012 = 1310. Generatorzahl heißt g deshalb, weil damit der Code generiert (= erzeugt) wird. • Anhängen von Nullen an u entsprechend der Stellenzahl von g, um Platz für die folgende Operation zu schaffen, hier also u' = 100001110000,
101
3 Fehlerbeseitigung Modulo-Division u'MOD g = 210 • Addition von u' und (g – 2 10) =10112 ergibt v = 1000011110112 . • v ist nun ohne Rest durch g teilbar, v MOD g = 0. • Da g als Primzahl gewählt wurde, ergibt ein 1-Bitfehler in v immer einen von 0 verschiedenen Rest, damit ist die Erkennung eines 1-Bitfehlers möglich. • Sind die Reste unterschiedlich und kann jeder fehlerhaften Bitposition ein anderer Rest zugeordnet werden, lässt sich sogar eine Korrektur durchführen. Damit ist der prinzipielle Weg des Divisionsrest-Verfahrens zwar vollständig beschrieben, die Eigenschaften der hier verwendeten „normalen“ Zahlen reichen aber für den Zweck der Korrektur nicht aus, da gleiche Reste immer für 2 verschiedene Fehlerpositionen auftreten können und aus zahlentheoretischen Gründen weitere Mängel bestehen. Ideale Partner findet man dagegen bei den Polynomen, genauer bei Polynomen mit Koeffizienten aus endlichen Körpern. Beschränkt man sich zunächst auf den endlichen Ganzzahlkörper Z2, so ist die Zuordnung der Info- und sonstigen Bits besonders einfach. Die k Infobits des Informationswertes •
Aufmarsch der Divisionen
Partnersuche
u = uk1 ,u k2 , ...., u1, u0
werden auf das Infopolynom ux = uk1 x k1 uk2 xk2 .... u1 x1 u0 x0 = uk1 xk1 uk2 x k2 .... u1 x u0
abgebildet. Übrigens kann auch die unbestimmte Variable x hier nur die Werte „0“ oder „1“ des Z2 annehmen, dies ist aber für die weitere Betrachtung belanglos. Der wesentliche Nutzen von x besteht darin, dass über die Potenzen die Position des zugehörigen Koeffizienten ui eindeutig festgelegt wird. Die Generatorzahl g mit den mG Koeffizienten g = gm 1 ,gm 2 , ......., g1, g 0 G
G
= 1, gm 2 ,....... ,g1, 1 G
kein Generatoren- wird entsprechend auf das Generatorpolynom konflikt m 1 m 2 g x = 1x gm 2x .... g1x 1 G
G
G
abgebildet, wobei der erste und der letzte Koeffizient stets den Wert 1 hat, wie wir noch sehen. Mit u(x) und g(x) stehen die beiden „Lego-Steine“ zur Verfügung, aus denen die zyklischen
102
3.7 Zyklische Codes Codes aufgebaut werden. Sie haben jeweils k bzw. mG relevante Koeffizienten und bestehen aus den Codewortpolynomen v x = v n1 x n1 v n2 xn2 .... v1 x v0
Polynome und (Dienst-) Grade
vom Grad n-1. Hier sind im übrigen auch führende „0“-Koeffizienten zu beachten, da sie von ihrer Bedeutung her gesehen ja Informationen und keine Zahlenwerte tragen. Jetzt werden wir folgende Fragen klären: a) Welcher Zusammenhang besteht zwischen k und mG? b) Welche Codewortlängen n sind möglich? c) Wie entsteht der Divisionsrest als Träger des Prüfanteils? d) Wie setzt sich das Codewortpolynom v(x) aus u(x) und dem Divisionsrest zusammen? e) Welche Eigenschaften muss g(x) haben, damit eine gewünschte Fehleranzahl t korrigiert werden kann? Man ahnt vielleicht schon, dass dem Generatorpolynom bei diesem Vorhaben eine große Bedeutung zukommt
3.7.2
Bildung der Codewörter Beantworten wir zunächst Frage c) und gehen davon aus, dass bereits ein Generatorpolynom g(x) vom Grad mG gewählt wurde. Da der zu berechnende Divisionsrest als Restpolynom h(x) im Codewortpolynom v(x) untergebracht werden muss, ist zunächst ausreichender Platz zu schaffen. Nach den Regeln der Polynomdivision hat h(x) höchstens den Grad mG-1 und damit mG Koeffizienten. Wir benötigen also mG zusätzliche Stellen bei u(x). Am mG
einfachsten erreicht man dies durch Multiplikation mit x : mG
u' x = ux x k1 k 2 m = uk1 x uk 2 x .... u1 x u0 x
G
= uk1 x
Bildungsauftrag
mG k1
uk2 x
mG k 2
.... u1 x
mG 1
mG
u0 x 0 x
mG1
0 x
mG2
0 x 0
Damit ergibt sich das Codewortpolynom v(x) als Summe v x = u' x Restpolynom = u' x hx =u' x u ' x MOD g x = u x x [ u x x mG
mG
] MOD gx
Das Restpolynom h(x) entsteht aus u'(x) über die Modulofunktion (s.S. 32) bezüglich g(x). Ein Beispiel mit k = 4, mG = 3:
103
3 Fehlerbeseitigung u = 1 001 g = 110 1
Hier sind die Polynome folgende Ausdrücke: ux = 1x 3 0x2 0x 1 6 5 4 3 2 u' x = 1x 0x 0x 1x 0x 0x 0 3 2 g x = 1x 1x 0x 1
nicht immer bringt's 'ne Panzerdivision
Die Modulo-Division u'(x) MOD g(x) ergibt das Restpolynom h(x). Die vollständige Rechnung wird für die ersten Schritte in Bild 3.10 gezeigt. Die einzelnen Schritte sind denen der Division von normalen Zahlen ganz ähnlich. Es gelten folgende Regeln:: • Der Divisor g(x) wird stellenweise (= potenzweise) vom Dividenden u'(x) subtrahiert • Da wir im endlichen Körper Z2 arbeiten, gilt für die Koeffizienten „Addition = Subtraktion“ oder „1 = -1“ Es wird nur das Restpolynom h(x) benötigt, die Antwort auf die Frage „wie oft geht g(x) in u'(x) hinein“ ist also ohne Bedeutung
u' xMOD g x = 1x 6 0x5 0x 4 1x 3 0x2 0x 0 : 1x3 0x 2 1x 1 = 1x3 1x2 ... 1x 6 1x 5 0x4 1x 3 0x2 0x 0 ----------------------------------------------------0x6 1x5 0x 4 0x3 0x2 0x 0 1x5 1x4 0x 3 1x2 0x 0 -------------------------------------------0x5 1x 4 0x3 1x2 0x 0 usw. ........................ Bild 3:10: Modulo-Division Divide et Impera!
Mit dem Schema in Bild 3.11, das die hier relevante Entwicklung der Koeffizienten berücksichtigt, kann man sich das Leben erleichtern. Es sind nur die Zuordnungen zu den x-Potenzen aufgeführt, das Operationszeichen „+“ wurde weggelassen. Das Restpolynom hat sich also zu hx = 0x 2 1x 1
ergeben. Damit ist Frage c) aus dem vorigen Unterkapitel beantwortet und auch Frage d) lässt sich erledigen, da das Codewortpolynom v(x) ja die Summe aus u'(x) und h(x) darstellt: v x = u' x h x oder in Kurzschreibweise: v x
104
= 1x6 0x 5 0x4 1x3 0x 2 1x 1 = 1001011
3.7 Zyklische Codes x6
x5
x4
x3
x2
x
1
1
0
0
1
0
0
0
1
1
0
1
0
1
0
0
0
o u'(x)-g(x) · x3
1
1
0
1
o g(x) · x2
0
1
0
1
0
o Differenz
1
1
0
1
o g(x) · x
1
1
1
0
o Differenz
1
1
0
1
o g(x)
0
0
1
1
o Rest h(x)
o u'(x) o g(x) · x3
Bild 3-11: Schema zur Modulo-Division u'(x) MOD g(x) Grundlegendes
Durch diese Konstruktion erhält jedes Codewort eine elementare Eigenschaft: v(x) ist durch g(x) ohne Rest teilbar oder – gleichbedeutend – v(x) ist ein Vielfaches des Generatorpolynoms: v xMOD g x = [ uxx u xx MOD g x ] MOD g x mG
= [u xx MOD g x uxx MOD gx ] MODg x = 0 = q xgx mG
und
kein schlechter Einfluss
v x
mG
mG
Da das Empfangswortpolynom w(x) die Summe aus v(x) und dem -synthetischen – Fehlerpolynom e(x) darstellt, fällt bei der Bildung des Syndrompolynoms s(x) der Anteil des Codewortpolynoms weg. Dadurch „filtert“ man also den Einfluss des Fehlers aus dem Empfangswortpolynom heraus: s x = w xMOD g x = [ v x e x] MODg x = [ v xMOD g x e xMOD g x ] MOD gx = ex MOD gx
Die Codewortlänge beträgt n = k + mG, damit ist Frage b) aber nicht wirklich beantwortet, da der Zusammenhang zwischen k und mG gemäß Frage a) noch nicht geklärt wurde. Versuchen wir uns erst an Frage e), also der nach den Eigenschaften des Generatorpolynoms g(x). Sie erfordert besondere Aufmerksamkeit. Die Aussagen der Zahlentheorie ergeben hier Folgendes, wobei die Begründungen erst in Unterkapitel 3.7.3
105
3 Fehlerbeseitigung und 3.7.4 erfolgen: Irreduzible Poly- • Für die Zusammensetzung des Generatorpolynoms spielen irnome = Verwandreduzible Polynome über Z2 eine entscheidende Rolle. Irrete der Primzahlen duzible Polynome sind vergleichbar mit den Primzahlen: Sie lassen sich nicht als Produkte von Teilpolynomen kleineren Grades darstellen. Teile meine Kreise • Für t zu korrigierende Fehler ist g(x) das Produkt aus t genicht ... eigneten irreduziblen Polynomen. Nach dem Fermat'schen Satz gibt es zu jedem m mit m = 1, 2, 3, 4, .... ein so genanntes Kreisteilungspolynom m
f x = x 2 11
•
welches sich in eine bestimmte Anzahl von irreduziblen Polynomen zerlegen lässt. Genau aus diesen Mengen werden solche geeigneten Teilpolynome entnommen. Die Länge n des Codes ergibt sich aus dem Grad m des größten Teilpolynoms von g(x) als n = 2m1
zyklische Verwandtschaft
womit Frage b) auch beantwortet wäre. Im Fall t = 1 für 1-Bitfehlerkorrigierbare Codes ist mG = m, dies entspricht z. B. den Verhältnissen beim Hamming-Code. Mit dem oben beschriebenen Verfahren zur Bildung zyklischer Codes kann also eine zyklische Variante des Hamming-Codes aufgebaut werden. Die Antwort zu a) nach der Anzahl der Infostellen k in Abhängigkeit von mG folgt nun aus n als k = nmG = 2m1mG
Der Grad mG des Generatorpolynoms g(x) ist die Summe des Grades seiner irreduziblen Teilpolynome g1(x), g2(x), ...., gt(x): t
mG =
grad gi x
i=1, grad g ixm
Allerdings sind die Grade der irreduziblen Teilpolynome gi(x) bei gegebenem m nicht frei wählbar, sondern unterliegen der Fermat'schen Gesetzmäßigkeit. So gelten für m = 4 folgende Zusammenhänge: t = 1:
mG = m1 = 4
t = 2:
mG = m1 + m2 = 4 + 4 = 8
t = 3:
mG = m1 + m2 + m3 = 4 + 4 + 2 = 10
Für m= 5 sind es:
106
3.7 Zyklische Codes
Hier wird geschoben ....
t = 1:
mG = m1 = 5
t = 2:
mG = m1 + m2 = 5 + 5 = 10
t = 3:
mG = m1 + m2 + m3 = 5 + 5 + 5 = 15
t = 4:
mG = m1 + m2 + m3 + m4 = 5 + 5 + 5 + 5 = 20
t = 5:
mG = m1 + m2 + m3 + m4 +m5 = 5 + 5 + 5 + 5 + 5 = 25
usw. Man wird bereits hier ahnen, dass es Codes für die Korrektur beliebig vieler Fehler t gibt, allerdings hat dies auch einen hohen Preis. Nachdem nun einige Gesetzmäßigkeiten zum Aufbau zyklischer Codes behandelt wurden, soll hier noch einmal genauer auf die Eigenschaft „zyklisch“ verwiesen werden. Liegt bereits das Codewort va = (vn-1, vn-2, ....., v2, v1, v0) vor, so gehören auch die Wörter vb = (vn-2, vn-3, ....., v1, v0, vn-1) oder vc = (v0, vn-1, vn-3, ....., v2, v1) zu diesem Code. Ist z. B. va = 0001011, so wären auch vb = 0010110 und vc= 1000101
... und rotiert!
Codewörter. Warum? Wenn die linke Position vn-1 in va mit „0“ besetzt ist, wird das Wort durch Multiplikation mit x einfach nach links verschoben, das neue Wort vb behält dabei g(x) als Teiler, daher liegt auch mit vb ein Codewort vor. Hat vn-1 dagegen den Wert „1“, so hilft folgende Überlegung: Wie kurz zuvor festgestellt, kann va als Produkt mit g(x) als Faktor dargestellt werden. Durch Multiplikation mit x ist va x zwar kein Codewort mehr, besitzt aber weiterhin den Teiler g(x). Auf der rechten Seite subtrahiert man die Terme xn-1 und -1 und addiert sie gleich wieder, womit sich nach außen nichts ändert: vax = [ qaxg x xn 1 ] xn 1
Der Ausdruck in den eckigen Klammern hat nun höchstens den Grad n-1 und die linke 1 wurde auf die durch die Verschiebung entstandene ganz rechte Nullposition plaziert. Genau dieses wäre auch das Ergebnis einer zyklischen Linksverschiebung gewesen. Die linke Seite des Ausdrucks ist, wie festgestellt, ein Vielfaches von g(x). Nach dem Fermat'schen Satz gilt das auch
107
3 Fehlerbeseitigung
alles Schiebung oder was ...
Schieben und Rückkoppeln = Dividieren
Universalgenie Schieberegister
108
für das Polynom xn–1 auf der rechten Seite. Wenn in einer Gleichung zwei Terme von insgesamt Dreien einen gemeinsamen Primfaktor haben, so enthält auch der dritte Term einen solchen. Also ist der Ausdruck in den eckigen Klammern wieder ein Codewort. Übrigens ist der denkbare Schluss, dass nämlich der gesamte Code nur aus dem einen Codewort und seinen zyklischen Verschiebungen bestehen könnte, falsch; es gibt immer mehrere Basis-Codewörter, die nicht durch zyklische Verschiebung auseinander hervorgehen. Sonst wäre die Menge an verschiedenen Codewörtern auch recht klein. Allerdings gilt folgende Aussage, deren Nützlichkeit sich noch erweisen wird: Ist ein Wort kein Codewort, so trifft dies auch für alle daraus durch zyklische Verschiebung hervorgegangenen Wörter zu, siehe Unterkapitel 3.7.10. Die Besonderheit bezüglich der zyklischen Vertauschung gestattet eine sehr einfache technische Erzeugung zyklischer Codes, zumindest für die in Binärdarstellung. Man kann nämlich ein rückgekoppeltes Schieberegister als MOD-Dividierer für Polynomausdrücke benutzen, was sich elektronisch mit Standard-Logikbausteinen leicht aufbauen lässt. Ein Beispiel ist im Bild 3.12 gezeigt. Das Schieberegister besteht, dem Grad des Generatorpolynoms entsprechend, aus 3 Speicherzellen. Überall dort, wo in g(x)=1011 die Koeffizienten gleich 1 sind, gibt es eine Rückkopplungsverbindung über eine Exclusiv-Oder-Verknüpfung. Das ist nichts anderes als ein MOD 2-Addierer: Der Ausgang geht auf 0, wenn die beiden Eingangssignale gleich sind, also 0 und 0 oder 1 und 1, dagegen wird er 1, wenn diese sich unterscheiden, also bei 0 und 1 oder bei 1 und 0. Zur Taktzeit i = 0 haben alle drei Speicherelemente den Zustand 0. Von rechts läuft mit jedem Zeittakt die Eingangsfolge u(i) hinein, in diesem Fall die 7 Koeffizienten des um 3 Stellen nach links verschobenen Info-Polynoms u(x) = 1000000. Nach 7 Schritten steht der Rest h(x)=101 der Polynomdivision u(x) x3 MOD g(x) in den Speicherzellen. Das Schieberegister hat also wie ein MOD g(x)-Dividierer gewirkt. Der Rest wird dem Infopolynom angehängt und ergibt das Codewort-Polynom v(x) = 1000101. Dieses Verfahren wirkt natürlich für jedes beliebige Polynom u(x) x3 . Insbesondere ergibt sich der Rest h(x)=000, wenn man statt u(x) x3 ein Codewortpolynom v(x) einspeist. Da sich Schieberegister vielseitig einsetzen lassen, werden sie in Kapitel 4 noch ausführlicher behandelt.
3.7 Zyklische Codes
g3=1
h(i)
g2=1
s0
ssm-2 1
sm-2 s2(i)
Takt i
g2=1
g2=0
s1(i)
u(i)
s0(i)
Inhalt s2(i)
Inhalt s1(i)
Inhalt s0(i)
0
0
0
1
0
0
1
1
2
0
1
0
0
3
1
0
0
0
4
0
1
1
0
5
1
1
0
0
6
1
1
1
0
1
0
1
0
Inhalt s2(i)
Inhalt s1(i)
Inhalt s0(i)
u(i)
0
0
0
1
0
0
1
1
2
0
1
0
0
3
1
0
0
0
4
0
1
1
0
5
1
1
1
1
6
1
0
1
0
0
0
0
1
0
7
Start
Rest
Takt i 0
7
Start
Rest
u(i)
Bild 3.12: Division u(x) x3 MOD g(x) mittels Schieberegister für g(x) = 1011, oben u(x) = 1000, unten v(x) = 1000101 Die auf dem beschriebenen Weg ermittelten Codewörter sind in Tabelle 3-10 gezeigt. Sie haben einen anderen Aufbau als der über die Generatormatrix G gemäß Tabelle 3-2 erzeugte Code, besitzen aber gleichwertige Eigenschaften.
109
3 Fehlerbeseitigung Info-Poly- Basisnom u(x) Polynom u1 u2 u3 u4
0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1
0 0 0 0 1 1 1 1 0 0 0 0 1 1 1 1
0 0 1 1 0 0 1 1 0 0 1 1 0 0 1 1
0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
ja ja ja
ja
Codewort-Polynom v(x) u(x)x3 + u(x)x3 MOD g(x) u(x)g(x) systematisch nicht systematisch 0000000 0001011 0010110 0011101 0100111 0101100 0110001 0111010 1000101 1001110 1010011 1011000 1100010 1101001 1110100 1111111
0000000 0001011 0010110 0011101 0101100 0100111 0111010 0110001 1011000 1010011 1001110 1000101 1110100 1111111 1100010 1101001
Tabelle 3-10: Mithilfe des Schieberegisters von Bild 3.12 erzeugter zyklischer , systematischer (7,4,3)-Code und durch Multiplikation erzeugter nicht systematischer (7,4,3)-Code nicht systematisch Man erhält einen nochmals gleichwertigen zyklischen Code üb= nicht (so) gut rigens auch dann, wenn man das Generatorpolynom direkt mit allen möglichen Informations-Polynomen u(x) maximal 3. Grades multipliziert, also v(x) = u(x)Yg(x). In der Tabelle 3-10 ist dies durchgeführt. Allerdings werden wir diese Spielart nicht verwenden, da sich damit ein nicht systematischer Code ergibt, bei dem man den Informationsteil nicht unmittelbar aus den Codewörtern ablesen kann, was man an den fett markierten Codewörtern sieht. Für den praktischen Gebrauch ist dies ungünstig, da nach der Decodierung noch ein Zuweisungschritt zu den Info-Polynomen durchgeführt werden muss. HochleistungsDie Ausführung von Polynom-Multiplikationen „Modulo 2 in den Generatoren Koeffizienten“ wird aber im Zusammenhang mit der Bildung von Generatorpolynomen g(x) für Mehrfachfehler-Korrektur benötigt, weshalb hier der Ablauf skizziert werden soll. Wie bei der Modulo-Division lassen sich die wenigen erforderlichen Operationen wieder mit Hilfe von Schieberegistern bearbeiten. Ein Beispiel für die beiden Faktoren u(x) = 1001 und g(x) = 1011 zeigt Bild 3.13, wobei auch hier das Polynom u(x) zunächst mit xgrad gx multipliziert wird.
110
3.7 Zyklische Codes u(x)x3
Aktion
+ u(x)x3g3
x6
x5
x4
x3
x2
x1
x0
1
0
0
1
0
0
0
0
0
0
1
0
2
+ u(x)x g2 1
+ u(x)x g1 0
+ u(x)x g0 = v(x)
g(x)
1
0
1
x3
x2
x1
x0
0
1
0
1
1
0
0
0
1
0
Alle Operationen MOD 2
1
0
0
1
0
0
1
1
Bild 3.13: Schema einer Polynom-Multiplikation Abstandswahrung: erfüllt
Nach diesem Schema, das im übrigen ganz dem in der Schule für „normale“ Zahlen erlernten entspricht, wurden auch die 16 Codewörter der rechten Spalte in Tabelle 3.10 ermittelt. Die beiden gleichwertigen Codes weisen einen Minimalabstand von d = 3 auf, sind also 1-Bitfehler-korrigierbar und entsprechen dem Hamming-Code aus Kapitel 3.4. Da es noch weitere Gemeinsamkeiten gibt, bezeichnet man einen solchen zyklischen Code manchmal auch als zyklischen Hamming-Code. Allerdings liegt nach den bisher gewonnenen Erkenntnissen der Vorteil eigentlich nur in der nochmals einfacheren Erzeugung durch das Generatorpolynom g(x) statt über die Generatormatrix G. Wir werden den eingeschlagenen prinzipiellen Weg jetzt jedoch weiter gehen, um zusätzliche, sehr nützliche Eigenschaften zu heben.
3.7.3
Generatorpolynom, irreduzible Polynome und Dekodierung Von den auf Seite 103 gestellten 5 Fragen zu Generatorpolynomen blieb bisher die nach den Eigenschaften von g(x) offen, damit eine gewünschte Fehleranzahl t korrigiert werden kann. Schauen wir zunächst auf den 1-Bitfehler-korrigierbaren Code. Es war behauptet worden, dass g(x) hierfür irreduzibel sein müsse. Warum? Die Fehlerkorrektur oder Decodierung erfolgt mit Hilfe des Syndrompolynoms s(x): s x = w xMOD g x
Empfangswort: 2 Zutaten
Das HD-decodierte Empfangswort-Polynom w(x) kann als Summe des Codewort-Polynoms v(x) und eines (nur unter Laborbedingungen bekannten) Fehler-Polynoms e(x) dargestellt werden: w x = v x e x = q xg x e x
Für die Annahme von 1-Bitfehlern im Codewort besteht e(x) nur aus einer einzigen x-Potenz mit einem Exponenten i, der die Fehlerposition kennzeichnet. Diese ist, von rechts aus gezählt,
111
3 Fehlerbeseitigung dann i+1. Beispiel für n=7: e = 0010000 e x = x 4
Für v(x) sind zwei gleichwertige Ausdrücke möglich, wie im Unterkapitel 3.7.2 zu sehen war: v x = uxxgrad gx [ uxx gradg x ] MOD g x = q xgx
Es bleibt nichts übrig
Beide werden von g(x) aufgrund ihrer Bildung ohne Rest geteilt, eine sehr wesentliche Eigenschaft! s x = w xMOD g x = 0 e xMOD g x = ex MOD g x
Wenn m der Grad von g(x) ist, so hat das Syndrompolynom höchstens den Grad m-1 und damit maximal m Koeffizienten. Damit lassen sich höchstens 2m verschiedene Zustände darstellen. Da der Fall der Fehlerfreiheit bei e(x) = 0 bereits den Zustand s(x) = 0 belegt, bleiben 2m-1 Zustände für die Kennzeichnung von 2m-1 1-Bitfehler-Positionen übrig. Eine größere Codewortlänge ist also nicht sinnvoll. Allerdings stellt dies zunächst nur eine notwendige Bedingung dar, hinreichend ist erst die paarweise Unterscheidbarkeit aller dieser 2m-1 Zustände. Das genau wird aber nur durch ganz bestimmte irreduzible Polynome g(x) gewährleistet. Das Fehlerpolynom e(x) kann durch e x = q xg x s x
Länge begrenzt
dargestellt werden. Lassen wir zunächst für größere Allgemeinheit die Bedingung fallen, dass ein Codewort-Polynom v(x) eine maximale Länge 2m-1 aufweisen darf. Da die Zahl der verschiedenen Syndrompolynome maximal 2m-1 beträgt, wird man beim systematischen Ausrechnen für verschiedene Fehlerpolynome dann auch einmal auf ein gleiches treffen, wir nennen es s*(x). Bei zwei verschiedenen Fehlerpositionen xi und xk mit k > i ist ei x = x î = qi xg x s x* ek x = xk = qk xg x s x *
Für i z k gilt qi z qk,, da die anderen Beiträge auf den rechten Seiten gleich sind. Die Addition ergibt: xi xk = xixki 1 = [ qi x qk x]gx
Linke und rechte Seite besitzen denselben Teiler. Das Generatorpolynom ist kein Teiler von xi, da es einen „1“-Koeffizienten in der kleinsten Potenz enthält. Also muss es Teiler von xk-i+1 sein.
112
3.7 Zyklische Codes Der Fermat'sche Satz besagt nun, dass bestimmte irreduzible Polynome g(x) ein Polynom xr - 1 teilen, wenn r 2m 1
Fette (Aus-) Beute erfüllt wird. Diese ergeben die maximale „Ausbeute“ an verschiedenen Syndromen für 1-Bitfehler-Korrektur. Aber Vorsicht: Dies ist zwar eine notwendige, jedoch keine hinreichende Bedingung, die automatisch für jedes irreduzible Polynom zutrifft. Für m=3 und das irreduziblen Generatorpolynom g(x) = 1011 etwa werden sich die Syndrompolynome erst wiederholen, wenn die Fehlerpositionen wenigstens 8 Stellen auseinander stehen. Die folgende Tabelle 3-11 zeigt dies für m=3 und g(x) = 1011: Fehlerposition
e(x)
s(x) = e(x) MOD g(x)
kein Fehler
0
0
1
1
1
2
x
1
x1
3
x2
x2
4
x3
x1 + 1
5
x4
x2 + x1
6
x5
x2 + x 1 + 1
7
x6
x2 + 1
8 (nicht zulässig)
x7
1
Tabelle 3-11: Die 7 unterscheidbaren Syndrompolynome s(x) des 1-Bitfehler-korrigierbaren zyklischen Codes der Länge n=7
Viele sind berufen, aber nicht alle sind würdig
Ein Fehler in der Position 8 ergibt dasselbe Syndrompolynom wie einer in Position 1. Allerdings gehören Codewörter der Länge 8 wegen n = 7 nicht zu diesem Code. Diese allgemeinen Überlegungen gelten für jeden Grad spezieller irreduzibler Generatorpolynome, eine wichtige Eigenschaft, die uns im Folgenden besonders nützen wird. Da man solche Polynome mit Koeffizienten im Z2 für die weitere Arbeit benötigt, sind in Tabelle 3-12 einige für verschiedene Grade m angegeben. Man findet sie wie Primzahlen über das „Sieb des Eratosthenes“: Das irreduzible Polynom kleinsten, also ersten Grades über Z2 ist (x + 1). Im ersten Schritt berechnet man alle möglichen Polynome zweiten Grades, wobei nur diejenigen in Frage kommen, die als Koeffizient bei x0 eine „1“ aufweisen, sonst wären sie durch x teilbar. Es gibt die beiden Polynome
113
3 Fehlerbeseitigung x 2 x 1
Wer wird Millonär?
und
x 2 1
Diese werden durch alle bisher gefundenen irreduziblen Polynome kleineren Grades geteilt, in diesem ersten Schritt also durch (x + 1). Ohne Rest ist dies nur bei (x2 + 1) möglich. Demnach bleibt (x2 + x +1) als irreduzibel übrig. Nun geht man zu allen möglichen Polynomen dritten Grades über, teilt diese durch (x + 1) und (x2 + x + 1). Es bleiben die übrig, die einen Rest ergeben usw. Die beiden Polynome mit m=3 und die beiden äußeren mit m=4 sind zueinander reziprok. Ein reziprokes Polynom f*(x) ist das, bei dem x in f(x) durch x-1 ersetzt wird, also f*(x) = f(1/x). f*(x) besitzt z. B. die gleichen Nullstellen wie f(x) und ist bei irreduziblem f(x) ebenfalls irreduzibel. Das gilt wieder für jeden Grad m. m m m m
= = = =
1: 2: 3: 4:
x1 1 x2 x1 1 x 3 x1 1 und x3 x 2 1 x4 x 1 1 und x4 x 3 x2 x1 1 und x 4 x3 1
Tabelle 3-12: Einige irreduzible Polynome über Z2 Voreilige Wiederholung
Noch eine Bemerkung: Es wurde mehrfach darauf verwiesen, dass nur spezielle irreduzible Polynome für unsere Zwecke geeignet sind. Das lässt sich z. B. an den oben genannten 3 Polynomen für m = 4 sehen. Fehlerposition
e(x)
s(x) = e(x) MOD g(x)
kein Fehler
0
0
1
1
1
2
x1
x1
3
x2
x2
4
x3
x3
5
x4
x3 + x2 + x1 + 1
6
x5
1
7
x
6
x1
8
x7
x2
.......
.......
......
Tabelle 3-13: Die 5 unterscheidbaren Syndrome zu g(x) = 11111 Während g1 = 10011 und g3 = 11001 (das reziproke Polynom) die Maximalzahl von 15 unterschiedlichen Syndromen für die 15
114
3.7 Zyklische Codes verschiedenen Fehlerfälle erzeugen und sich damit für eine EinBitfehler-Korrektur eignen, trifft dies für g2 = 11111 nicht zu, siehe Tabelle 3-13. Dieses Polynom liefert nur fünf von Null verschiedene Syndrome, die sich jeweils in gleicher Reihenfolge wiederholen. Das bedeutet allerdings nicht, dass es in Kombination mit seinen „Schwestern“ für die Mehrbitfehler-Korrektur unbrauchbar wäre. Die beiden folgenden Unterkapitel werden dies aufklären.
3.7.4
Generatorbau
Generatorpolynome für Mehrbitfehler-Korrektur Aus den bisherigen Überlegungen und Ergebnissen ist zu sehen, dass den 1-Bitfehler-korrigierbaren Codes enge Grenzen gesetzt sind. Insbesondere das Shannon-Limit kann damit nicht annähernd erreicht werden, so nützlich diese Codes für spezielle Einsatzgebiete auch sind (z. B. 1-Bitfehler-Korrektur und zusätzliche 2-Bitfehler-Erkennung bei RAMs). Auf Seite 106 wurde bereits angedeutet, dass Generatorpolynome für Codes zur t-Bitfehler-Korrektur das Produkt t geeigneter irreduzibler Polynome sein müssen. Jetzt werden wir auch den Grund verstehen und solche Polynome richtig zusammensetzen können. Das Generatorpolynom g(x) hat den Aufbau t
g x = g1 xg2 x ........ gt x =
g i x i
Dienstgrade
Sein Grad mG ist die Summe der Grade mi aller Teilpolynome mG = grad gx = gradg1 x gradg2 x ........ gradg t x t
=
gradgi x i
Die Codelänge n berechnet sich ähnlich wie bisher aus dem höchsten Grad m der in g(x) enthaltenen Teilpolynome n = 2m1,
m = Max grad g1 x, g2 x,........, gt x
Für die Codewörter v(x) gilt auch hier die Vorschrift v x = uxx
mG
[ uxx
mG
] MOD g x
so dass eine Modulo-Division mit g(x) auszuführen ist. Das Syndrompolynom s(x) eines Empfangswortpolynoms w(x) hat gemäß Seite 111 den Aufbau s x = w xMOD g x = [ v x e x] MODg x = e xMOD g x
115
3 Fehlerbeseitigung oder auch s1 x s 2 x ....... s t x Die Teile machen das Ganze
= e xMOD g1 x = e xMOD g2 x = ................... = e xMOD gt x
Das Generatorpolynom ist nun aus solchen Teilpolynomen zusammen zu setzen, dass es zu jedem Fehlermuster mit 1-Bit-, 2Bit-, ...., t-Bitfehlern • entweder ein eindeutig zuordenbares Syndrom s(x) • oder eine eindeutig zuordenbare Kombination der Teilsyndrome s1(x), s2(x), ....., st(x) gibt. Sehen wir uns ein Beispiel für m=4 an. Dann ist n = 15, und Tabelle 3-14 zeigt die Anzahl der theoretisch korrigierbaren Fehlermuster bis t = 3. t
Anzahl Fehlermuster bei n=15
notwendiger Grad des Generatorpolynoms mindestens
1
15
4, da 24 =16 (und 23 = 8)
2
15 + 105 = 120
7, da 27 = 128 (und 26 =64)
3
15 + 105 + 455 = 575
10, da 210 = 1024 (und 29 =512)
Tabelle 3-14: Permutationen verschiedener Fehlermuster
unelegant, doch sicher
116
Zu diesen Fehlermustern muss es also eine wenigstens gleich große Anzahl verschiedener Syndrome als notwendige Bedingung geben. Oder: Der Grad des Generatorpolynoms muss mindestens die notwendige Anzahl verschiedener Syndrome bereitstellen können. Die Antwort zur Wahl geeigneter Teilpolynome liefert in diesem Fall ein zwar wenig elegantes, aber doch sicheres Verfahren, das sich allerdings wegen des mit n stark anwachsenden Aufwandes nur für kurze Codes eignet. Es arbeitet folgendermaßen: • Aus den für m=4 zur Verfügung stehenden irreduziblen Polynomen werden alle dem notwendigen Grad entsprechenden Teilpolynome gewählt und zu jedem möglichen Fehlermuster bis t die Syndrome berechnet. • Die Anzahl unterschiedlicher Syndrome muss wenigstens der Anzahl der Fehlermuster entsprechen. Dann ist das Verfahren prinzipiell zur Korrektur von t Fehlern geeignet, andernfalls nicht. Für t = 1 wurde durch Probieren bereits festgestellt, das nur g1
3.7 Zyklische Codes und g3 brauchbar sind. Lässt man auch irreduzible Polynome kleineren Grades als m zu, so erhält man für t =2 und t=3 die in Tabelle 3-15 dargestellten Ergebnisse. s(x)
g(x)
g(x)
s(x)
zu unterscheiden
notwendiger Grad
realisierbar (in Klammern: tatsächlicher Grad von g)
unterscheidbar
2
120
7
10011Y11111 = 111010001 (8)
120
2
120
7
10011Y11001 =110111011 (8)
105
2
120
7
11111Y11001 =100010111 (8)
120
3
575
10
10011Y1111111001=
545
1001001001001 (12) 3
575
10
10011Y11111Y111 =
575
10100110111 (10) 3
575
10
10011Y11001Y111=
375
10000100001 (10) 3
575
10
11111Y11001Y111=
575
11101100101 (10) Tabelle 3-15: Notwendige und tatsächliche Anzahlen unterscheidbarer Syndrome Nur die Besten bilden ein Team
Es sind also nicht alle Kombinationen irreduzibler Polynome brauchbar, nur die grau unterlegten. Als Besonderheit kommt hinzu, dass offensichtlich auch Teilpolynome kleineren Grades (hier in Kurzform 111) als m nützlich sind. Dies hat zusätzlich den Vorteil, dass die mit den aus diesen Zusammensetzungen gebildeten Codewörter mehr Infobits enthalten. Spätestens an dieser Stelle erhebt sich die Frage, ob man das Austesten geeigneter Kombinationen von irreduziblen Teilpolynomen für das Generatorpolynom auch mit geringerem Aufwand durchführen kann. Die Antwort ist „ja“ und wird im nächsten Unterkapitel gegeben.
3.7.5
Eignungstest für g(x) zur t-Bitfehlerkorrektur Jede Codewortmenge enthält das „Nullwort“, also ein Codewort, welches nur aus „0“-Elementen besteht. Der Grund liegt darin, dass der Infoteil immer auch ein Wort enthalten kann, welches nur aus „0“-Elementen besteht. Wegen der speziellen Codewortbildung mithilfe des Generatorpolynoms ist dann auch das Codewort eines nur aus „0“-Elementen bestehendes.
117
3 Fehlerbeseitigung
Generatorpolynom = Codewort
Andererseits hat jedes Codewort eines zulässigen Codes zu jedem anderen den Mindestabstand dmin = 2Yt + 1, also auch zum „Nullwort“. Weist nur eines der Codewörter einen kleineren Abstand zum Nullwort auf, wäre dieser Code bereits ungeeignet zur Korrektur von t-Bitfehlern. Das Generatorpolynom g(x) selbst bildet aber – nach links bis zur Gesamtstellenzahl n mit „0“-Elementen aufgefüllt – bereits das Codewort für das Infowort 0.....0001. Daraus lässt sich die notwendige Bedingung ableiten, dass das Generatorpolynom wenigstens ein Gewicht von dmin = 2Yt +1 aufweisen muss, damit der daraus erzeugte Code brauchbar ist. t
g(x)
g(x)
g(x)
notwendiger Grad
realisierbar
Gewicht
in Klammern:tatsächlicher Grad
„1“-Codewörter (= Basis-Codewörter) kleinstes Gewicht
2
7
10011Y11111 = 111010001 (8)
5
5
2
7
10011Y11001 =110111011 (8)
7
3
2
7
11111Y11001 =100010111 (8)
5
5
3
10
10011Y1111111001=
5
5
7
7
3
3
7
7
1001001001001 (12) 3
10
10011Y11111Y111 = 10100110111 (10)
3
10
10011Y11001Y111= 10000100001 (10)
3
10
11111Y11001Y111= 11101100101 (10)
Tabelle 3-16: Kleinste Gewichte der Basis-Codewörter als Eignungstest der Codes auf t Fehler-Korrekturfähigkeit Dies stellt eine notwendige, aber keineswegs hinreichende Bedingung dar. Ein Code kann also durchaus ein Generatorpolynom mit dem Gewicht 2t + 1 besitzen, ohne dass hierzu ein brauchbarer Code gehört. Wenn aber g(x) ein kleineres Gewicht aufweist, ist der damit verbundenen Code auf jeden Fall unbrauchbar. Hinreichend wird die Bedingung erst, wenn nicht nur
118
3.7 Zyklische Codes
Die Parteibasis bestimmt ...
das mit dem Generatorpolynom erzeugte „1“-Codewort, sondern alle Codewörter, die im Infoteil ein einziges „1“-Element enthalten, den erforderlichen Mindestabstand zu Nullwort aufweisen. Dies sind die „Basiswörter“ des Codes, da hieraus durch Linearkombinationen (= Additionen) alle Codewörter berechnet werden können. Die Menge der nun zu prüfenden „1“-Codewörter ist mit k = n grad[g(x)] dramatisch kleiner, als die Anzahl möglicher Fehlermuster. Betrachten wir Beispiele gemäß Tabelle 3-16 für m = 4, n = 15. Danach sind dieselben Kombinationen für das Generatorpolynom geeignet, wie diejenigen, welche über die wesentlich aufwändigere Auswertung der Syndrome erzielt wurden. Noch deutlicher ist dies zu erkennen, wenn man die Basiscodewörter selbst betrachtet. Für den Code zur ersten Zeile in obiger Tabelle sind diese Wörter in Tabelle 3-17 als Testbeispiel „a“ dargestellt: Nr.
Basiscodewörter zu g(x) = 111010001
Gewicht
1
0000001 11010001
5
2
0000010 01110011
6
3
0000100 11100110
6
4
0001000 00011101
5
5
0010000 00111010
5
6
0100000 01110100
5
7
1000000 11101000
5
Tabelle 3-17: Testbeispiel „a“ für die Gewichte von Basiscodewörtern ... mit ihrem Gewicht
Alle haben wenigstens ein Gewicht von 5, weshalb mit diesem Code eine 2-Bitfehler-Korrektur durchführbar ist. Beim Code zur zweiten Zeile in Tabelle 3-16 sieht es anders aus, wie es Testbeispiel „b“ in Tabelle 3-18 zeigt. Das Wort Nr. 1 besitzt zwar ein Gewicht von 7, die Wörter 3, 4 und 5 weisen aber nur eines von 3 auf: Nr. Basiscodewörter zu g = 110111011
Gewicht
1
0000001 10111011
7
2
0000010 11001101
6
3
0000100 00100001
3
4
0001000 01000010
3
119
3 Fehlerbeseitigung Nr. Basiscodewörter zu g = 110111011
Gewicht
5
0010000 10000100
3
6
0100000 10110011
6
7
1000000 11011101
7
Tabelle 3-18:: Testbeispiel b für die Gewichte von Basiscodewörtern Das bisherige Probierverfahren lässt zwar schon weitgehende Aussagen und Tests zu geeigneten Generatorpolynomen zu, es gibt aber noch systematischere Wege, wie das folgende Unterkapitel zeigt.
3.7.6
Der Wert der Null (-stellen)
Irreduzible Polynome über Z2 und Galoisfelder GF(2m) Eine der vielen genialen Ideen des französischen Mathematikers Evariste Galois (1811 – 1832) war es, Nullstellen von irreduziblen Polynomen zu definieren (und zu zeigen, dass solche sowohl überhaupt existieren als auch nicht im Widerspruch zur übrigen Mathematik stehen). Für die Fehlerkorrektur erweist sich das als fundamental. Zur Erinnerung: Die Nullstelle eines Polynoms f(x) ist derjenige Wert x1, für den das Polynom den Wert „0“ annimmt, also f(x1) = 0. In der vertrauten Welt der reellen Zahlen hat das Polynom f x = x 2 3x 2
die beiden Nullstellen x1=1 und x2=2, wovon man sich durch Einsetzen überzeugen kann. Für f x = x 2 x 1
findet man allerdings keine Nullstelle, jedenfalls nicht unter den reellen Zahlen. Lässt man dagegen für die Nullstellen auch den Wertebereich der komplexen Zahlen mit seinem imaginären Element i zu, so erhält man die beiden konjugiert komplexen Werte: x1 = 0.5 0.5 3i und
Galois = Genie!
x2 = 0.50.5 3i
mit
i=1
Galois hat diesen Weg auf Polynome über endliche Koeffizientenkörper übertragen. Sehen wir uns dazu das schon bekannte irreduzible Polynom 3. Grades an, welches als Generatorpolynom einen Code der Länge n=7 erzeugt: g x = x 3 x 1 = 1011
Es hat im Z2 keine Nullstellen. Die beiden möglichen Werte für
120
3.7 Zyklische Codes x, nämlich „0“ und „1“, ergeben g(0) = 1 und g(1) = 1. Überhaupt hat ein irreduzibles Polynom nie Nullstellen in seinem Koeffizientenkörper, da man andererseits einen Linearfaktor abspalten könnte und g(x) damit nicht mehr irreduzibel wäre. gar nicht so primitiv, diese Elemente
Galois hat nun ein künstliches Element D definiert, welches nicht zum Z2 gehört, aber die Eigenschaft einer Nullstelle besitzt: Def.
g x==3 1 = 0,
3= 1= 1
daraus :
Damit wird der Wertebereich für x um das Element D erweitert und umfasst nun x = {0, 1, D}. Die Koeffizienten liegen nach wie vor im Z2, weshalb alle Operationen MOD 2 durchzuführen sind und insbesondere „Addition = Subtraktion“ gilt. eins nach dem andern
Über die obige Definition steht D zusätzlich mit seiner nullten und dritten Potenz in Beziehung, wenn man „1“ als D0 schreibt. Der Wertebereich von x beinhaltet jetzt x = {0, 1, D, D3} und kann vielleicht noch weitere Elemente aufnehmen, etwa D2, D4 usw. Um dies zu untersuchen, fertigen wir die Tabelle 3-19 an und bringen darin zugleich verschiedene, gleichwertige Formen unter: Nr.
Element
1
0
alternativ =
=
0
=
000
=
0
1
0D + 0D +1D
=
001
=
D0D
=
0D2+ 1D1+0D0
4
2
=
010
=
1
D D
=
0
D
1D + 0D +0D
=
100
5
D3
=
D2D
=
0D2+ 1D1+1D0
=
011
6
4
D
=
3
D D
=
0
1D + 1D +0D
=
110
7
D5
=
D4D
=
1D2+ 1D1+1D0
=
111
8
6
D
=
5
D D
=
0
1D + 0D +1D
=
101
9=2
D7
=
D6D
=
0D2+ 0D1+1D0
=
001
10= 3
8
D
=
7
D D
=
0D + 1D +0D
=
010
....
....
...
....
....
....
....
....
2
0
D
=
3
D1
0
Kurzform
als Polynom in D
2
1
2
1
2
1
2
1
2
1
0
Tabelle 3-19: Das Galoisfeld GF(2 ) für das definierende Polynom g(x) = 1011 3
Die beiden auffälligsten Ergebnisse sind vermutlich, dass
121
3 Fehlerbeseitigung •
sich die Potenzen von D ab D7 wiederholen,
sich jede Potenz von D als Polynom in D von höchstens 2. Grad darstellen lässt. primitive Es gibt also nur das Element „0“ und die 7 unterscheidbaren PoElemente = starke tenzen D0, D1, .... D6. Alle anderen Potenzen können auf diese zuFamilien rückgeführt werden. Da außerdem Polynome bis zum höchsten Grad 2 mit ihren dann 2+1=3 Koeffizienten in 23 = 8 verschiedenen Formen auftreten, sind die 7 Potenzen von D die überhaupt größte mögliche Anzahl. Ein Element mit dieser MaximalEigenschaft bezeichnet man als primitives Element der Ordnung ord (D) = 23-1 =7. Die Ordnung ord eines Körperelements gibt an, wie oft es potenziert werden kann, bis es wieder den Wert 1 erreicht. •
Ein primitives Körperelement hat die maximal mögliche Ordnung in diesem Körper.
Inzucht vom Feinsten
Ob es diese Eigenschaft hat, hängt vom definierenden irreduziblen Polynom ab, nicht jedes Polynom erzeugt ein Element maximaler Ordnung. Alle 8 Elemente bilden zusammen einen Körper, s.S. 32, der zu Ehren seines Entdeckers Galoiskörper oder Galoisfeld (ein mathematische Körper wird im Englischen als field bezeichnet). Man kann die Elemente also addieren, subtrahieren, multiplizieren und dividieren, immer ergibt sich dabei wieder ein Element dieses Galoisfeldes. Additionen und Subtraktionen werden wegen des Koeffizientenkörpers Z2 weiter MOD 2 ausgeführt. Da die Elemente „0“ und „1“ im Galoisfeld mit enthalten sind, stellt dieses Feld einen Erweiterungskörper zum Z2 dar. Wie werden die 4 Elementar-Operationen ausgeführt? • Addition (= Subtraktion im Z2): MOD 2-Addition der Polynome mit Hilfe der Tabelle 3-19, z. B. D4 + D6 = 110 + 101 = 011 = D3 •
Multiplikation: Addition der Exponenten, z. B. D3 D5 = D8 = D1. Zu beachten ist dabei, dass die Exponenten wegen der Endlichkeit der Galoisfelder und Wiederholung der Elemente ab dem Exponenten 2m-1 immer MOD (2m-1) zu nehmen sind, im GF(23) also D8 = D8 MOD 7 = D1.
Division: Subtraktion der Exponenten: z. B. D2 / D4 = D2 = D5 Da es zu jedem endlichen Primzahlenkörper Zp (also über Primzahlen p) Galoisfelder gibt und die maximal mögliche Anzahl seiner Elemente sich mit pm aus dem Grad m des definierenden •
122
3.7 Zyklische Codes Polynoms g(x) über Koeffizientenkörper Zp berechnet, gibt man Galoisfelder als GF(pm) an. Dabei stellt p die so genannte Charakteristik des Feldes dar. Hier ist die Charakteristik p=2, im vorliegenden Fall bewegen wir uns im GF(23). Legosteine = Zuta- Die Elemente der Galoisfelder zeigen noch weitere Eigenten der Ursuppe schaften. Bildet man das Produkt aller Linearfaktoren, so erhält man eine besondere Darstellung des Fermat'schen Satzes von Seite 46: 3
x2 x = x0x 0 x1 x2x 3 x4 x5 x6 3
x2 11 0 1 2 3 4 5 6 = x x x x x x x 3 3 2 = x1 x x 1 x x 1 mit
Nicht Quadratur, nein, Teilung des Kreises!
x3 x 1= x1 x2 x4 3 2 3 5 6 x x 1=x x x
Die beiden irreduziblen Polynome vom Grad 3 treten hier als so genannte Kreisteilungspolynome oder zyklotomische Polynome auf. Sie haben die Eigenheit, „trotz“ der Galoisfeldelemente als Nullstellen nur die Koeffizienten „0“ und „1“ des Z2 zu liefern. Die Bezeichnung entstammt denjenigen gleichgearteten Polynomen über die reellen Zahlen, welche Nullstellen besitzen, die auf dem Einheitskreis der komplexen Zahlen liegen und diesen gleichmäßig teilen, z. B.: n n
x 1 =
xe
i2 k1
n
k=1
Da im weiteren Verlauf auch das Galoisfeld GF(24) benötigt wird, werfen wir noch einen Blick hierauf. Als definierendes irreduzibles Polynom vom Grad m = 4 wird von den 3 zur Auswahl stehenden g1 x = x 4 x 1
verwendet. Die Nullstelle bezeichnen wir zur Unterscheidung zum GF(23) mit E: g1 = 4 1=0,
daraus:
4=1 = 1
Das Galoisfeld hat dann die in Tabelle 3-20 dargestellte Struktur, wobei sich die Potenzen von E hier ab dem Exponenten 15 wiederholen und der Körper damit 16 Elemente aufweist.
123
3 Fehlerbeseitigung
Nr.
Element
1
0
alternativ =
0
E
0
E
1
E
2
5
E
3
6
E4
7
E
5
E
6
9
E
7
10
E8
11
E9
12
E
10
E E
E
11
10
E E
14
E
12
11
15
2 3 4
8
=
1
=
0
E E
=
1
E E
=
2
E E
=
E3E
=
4
E E
=
5
E E
=
6
E E
=
E7E
Kurzform
als Polynom in E =
0
=
0E +0E + 0E +1E 3
2
3
2
1
0
=
0000
=
0001
=
0E +0E +1E +0E
0
=
0010
=
0E +1E + 0E +0E
0
=
0100
=
1E +0E + 0E +0E
0
=
1000
=
0E3+0E2+ 1E1+1E0
3
2
3
2
3
1
1 1
=
0011
=
0E +1E + 1E +0E
0
=
0110
=
1E +1E + 0E +0E
0
=
1100
=
1E +0E + 1E +1E
0
=
1011
=
0E3+1E2+ 0E1+1E0
=
0101
2
3
2
3
2
1 1 1
E8E
1E3+0E2+ 1E1+0E0
1010
9
0E +1E + 1E +1E
0
0111
1E +1E + 1E +0E
0
1110
E E
1E +1E + 1E +1E
0
1111
E13
E12E
1E3+1E2+ 0E1+1E0
1101
16
E14
E13E
1E3+0E2+ 0E1+1E0
1001
17
15
13
E
3
2
3
2
3
3
2
1 1 1
0E +0E + 0E +1E
14
E E
2
1
0
0001
Tabelle 3-20: Das Galoisfeld GF(24) für das definierende Polynom g(x) = 10011 Ordnung ist die erste Pflicht der Elemente
Die Nullstelle E ist ein primitives Element der Ordnung e = 2m -1 = 15. Der Fermat'sche Satz nimmt folgende Form an: 4
x2 11 0 1 2 13 14 = x x x ..... x x 2 4 4 3 2 4 3 = x 1 x x 1 x x 1 x x x x 1x x 1 mit
124
x4 x 1 4 3 2 x x x x 1 2 x x 1 4 3 x x 1
= = = =
x1 x2 x 4 x 8 3 6 9 12 x x x x 5 10 x x 7 11 13 114 x x x x
3.7 Zyklische Codes
Nebenbuhler: no! Nullstellen sind einmalig
Hier fällt auf, dass • die Nullstellen mit dem jeweils kleinsten Exponenten des primitiven Elements in jedem Polynom immer ungradzahlig sind, (der Grund wird im folgenden Unterkapitel geklärt), • auch ein irreduzibles Polynom 2. Grades Nullstellen im GF(2m) besitzt (ganz allgemein gilt nach einem Satz aus der Zahlentheorie, dass in der Menge der zu GF(2m) gehörenden irreduziblen Polynome alle enthalten sind, bei denen der Grad durch m ohne Rest teilbar ist) , • offenbar keine Mehrfach-Nullstellen auftreten. Letzteres gilt für die Menge der zu GF(2m) gehörenden irreduziblen Polynome ebenfalls ganz allgemein, da sich mit MehrfachNullstellen keine Kreisteilungspolynome bilden lassen. Wie wir gesehen hatten, ist nach dem Fermat'schen Satz das Produkt der Linearfaktoren mit allen Nullstellen aus den pm Elementen des Galoisfeldes (p = Charakteristik, hier p=2) ein Polynom f x = x n 1x ,
mit
n = p m1
Differenziert man f(x) formal nach dx, so erhält man d[f x] = n 1x n1 = [ pmxn1 ] MOD p = 1 dx
Mehrfache Nullstellen treten in der Ableitung aber stets mit einem um „1“ verminderten Exponenten auf. Dies ist hier nicht der Fall, daher enthält f(x) keine Mehrfach-Nullstellen. Nachdem nun einige Eigenschaften und Besonderheiten der Galois-Körper und der damit in Zusammenhang stehenden irreduziblen Polynome angesprochen wurden, werden wir diese in den folgenden Unterkapiteln für weitere Fehlerkorrektur-Verfahren nutzen. Worin liegt nun aber die besondere Eignung dieses mathematischen Hilfsmittels für die Aufgaben der Fehlerkorrektur? Im folgenden Unterkapitel werden wir diese Frage beantworten.
3.7.7
BCH-Code Der BCH-Code wurde nach seinen drei Entdeckern Bose, Chaudhuri und Hocquenghem benannt. Die Wirkungsweise dieses Codes beruht auf der Tatsache, dass die Nullstellen des Generatorpolynoms eines zyklischen Codes immer auch Nullstellen jedes damit gebildeten Codewortes sind. Warum? Weil, wie es sich im Unterkapitel 3.7.2 gezeigt hatte, jedes Codewortpolynom v(x) = q(x)g(x) ein Vielfaches seines Generatorpolynoms ist und damit zwangsläufig dessen Nullstellen mit enthält.
125
3 Fehlerbeseitigung Setzt man demnach eine Nullstelle des Generatorpolynoms in das Codewortpolynom ein, so nimmt es den Wert 0 an. Damit hat man zugleich eine wichtige Kontrollmöglichkeit. Ist nämlich der Polynomwert ungleich Null, so zeigt dies einen Fehler an. Korrektur-VorausZur Korrektur von „t“ 1-Bitfehlern werden t unabhängige setzung: sehr gut! Gleichungen ausgewertet. Dies entspricht der Lösung eines Gleichungssystems für die t unbekannten Fehlerpositionen Dabei laufen nach Bild 3.14 für die Korrektur von t Einzelfehlern – ausgehend von den Nullstellen – Codierung und Decodierung beim BCH-Code folgendendermaßen ab: Nullstellen im GF(2m)
a1, a2, ..... , at
irreduzible Teilpolynome hierzu
g1(a1) = 0, g2(a) = .0, ....., g(t) = 0
Generatorpolynom
g(x) = g1(x)·g2(x)· ...... gt(x)
Infopolynom
u(x)
Codewortpolynom
u(x)·xgrad g(x) + [u(x)·xgrad g(x)] MOD g(x)
Fehlerpolynom
e(x)
Empfangswortpolynom
w(x) = v(x) + e(x)
Syndrompolynom
s(x) = w(x) MOD g(x) = e(x) MOD g(x)
Werte von s(x) an den Nullstellen: - für x= a1
s(a1) = v(a1) + e(a1) = 0 + e(a1) = e(a1)
- für x = a2
s(a2) = v(a2) + e(a2) = 0 + e(a2) = e(a2)
-.........
.........
- für x = at
s(at) = v(at) + e(at) = 0 + e(at) = e(at)
Bild 3- 14: Ablaufschema für Codierung und Dekodierung beim BCH-Code 1 Fehler: 0 problemo, t-Fehler: 0 problemo
126
Für den besonders einfachen Fall mit t = 1 sieht das so aus: Jeder Einbit-Fehler kann als Fehlerpolynom e(x) dargestellt werden, bei dem nur ein einziger Koeffizient ungleich 0 ist (im Z2 ist dieser Koeffizient also "1"). Ein mit g(x) = 1011 erzeugtes siebenstelliges Codewort
3.7 Zyklische Codes v x = 0x 6 1x5 0x 4 1x 3 1x 2 0x1 0x0 = 0101100
wird gesendet. An der Nullstelle x = D hat es den Wert v(D) = 0, wovon man sich durch Einsetzten der DPotenzen gemäß Tabelle 3-19 überzeugen kann. Das Codewort wird durch den Fehler e x = x 4 = 0010000
verfälscht, so dass beim Empfänger nach Hard Decision das Wort w x = v x e x = 0111100
primitiv, aber stark ....
ankommt. Wenn man das primitive Element D einsetzt, erhält man s = w = v e=0 e =5 4 3 2=s=4
... unabhängig: unschlagbar!
Der Fehler ist also an der fünften Stelle aufgetreten (entspricht x4 !) und lässt sich nun korrigieren. Dieses kleine Beispiel weist zwar schon auf die im Vergleich zum Hamming-Code-Verfahren grundsätzlich andere Wirkungsweise der zyklischen Codes hin, zeigt aber noch nichts von der eigentlichen Leistungsfähigkeit, da hiermit auch kein besseres Ergebnis als beim Einbit-Fehler-korrigierbaren Hamming-Code erzielt wird. Die wahre Stärke offenbart sich erst, wenn man den BCH-Code zur Mehrbit-Fehler-Korrektur einsetzt. Allerdings muss hier, wie bei allen Gleichungssystemen für t Unbekannte die notwendige Bedingung erfüllt sein, dass die t Gleichungssysteme voneinander unabhängig sind. Da diese Gleichungen, wie oben gezeigt, mit Hilfe der SyndrompolynomWerte für die einzelne Nullstellen festgelegt werden, ist also zunächst die Frage zu klären, wie man solche unabhängigen Nullstellen findet, die dann ihrerseits unabhängige Gleichungen ergeben. Die Antwort liefern die Rechenregeln für die Charakteristik p eines endlichen Körpers. Danach gilt für alle mit p gebildeten Potenzen eines Summenausdrucks und insbesondere bei einem Polynom immer die Beziehung [f x] p = xn1 xn2 ...... x2 x 1p n1 p n2 p 2 p p = x x ...... x x 1
Wer an dieser Stelle skeptisch ist, der schreibe einfach die binomische Formel (x + y)2 hin und werte sie mit der MOD 2Funktion aus (wir arbeiten im Z2 !): x y2 = x2 2xy y2 MOD 2 = x 2 y 2
127
3 Fehlerbeseitigung Zurück zum obigen Polynom: Da man die Exponenten jeweils vertauschen darf, lässt sich dieser Ausdruck für f(x) in [f x] p = xp n1 xp n2 ...... x p2 xp 1
umformen. Setzt man für x die Nullstelle D ein, so entsteht [f] p = p n1 p n2 ...... p 2 p 1 = 0
und daraus für p=2 im Z2 [f] 2 = 2 n1 2 n2 ...... 2 2 2 1 = 0
Charakteristik: Aufdeckung von Abhängigen
Das heißt aber nichts anderes, als dass mit der Nullstelle D auch D2 eine Nullstelle darstellt. Würde man also D2 in das Empfangswortpolynom w(x) einsetzen, so bekäme man genau den quadrierten Wert heraus und hätte damit keine neue, unabhängige Aussage über den Fehler zur Verfügung: w 2 = s 2 10 8 6 4 3 6 4 4 2 8 = = = = =
Da die Rechenregeln mit der Charakteristik p für alle Potenzen von p gelten, ist mit p2 = 4 [f]4 = 4 n1 4 n2 ...... 4 2 2 1=0
und man erkennt, dass auch die Nullstelle D4 von D abhängt: w 4 = s 4 20 16 12 8 6 2 5 2 4 4 16 = = = = =
Quadrate: Falsche Wiederum enthält das so gebildete Syndrompolynom im VerHelfer gleich zu s(D) keine neuen Informationen zur Bestimmung der Fehlerposition. Für endliche Körper GF(pm) mit p als Primzahl gilt: Ist G als Element des Feldes Nullstelle eines irreduziblen Polynoms g(x), g(x=G) =0, so sind auch alle mit dem Exponenten k = p j, j = 0, 1, 2, 3, 4,.... potenzierten g(x) Elemente Gk Nullstellen von Wenn man als Generatorpolynom zur Erzeugung eines zyklischen Codes im GF(23) das irreduzible Polynom g1 x = x3 x 1 = xx 2 x4
wählt, dann lässt sich zur Fehlerpositionsbestimmung also nur die Nullstelle D nutzen, die restlichen beiden sind als zusätzliche Informationsquellen wertlos. Es hat andererseits auch keinen
128
3.7 Zyklische Codes Sinn, nur das Teilpolynom (x - D) zu verwenden, da sich hiermit kein realer Code bilden ließe. Zur Erinnerung: Jedes Codewort ist das Produkt v(x)=q(x)Yg(x). Daher besitzt jedes Codewortpolynom immer auch alle Nullstellen des Generatorpolynoms und mit g(x) = (x - D) enthielte v(x) nicht nur die Koeffizienten 0 oder 1. m=3
GF(23)
n = 23-1 = 7
definierendes Polynom für das primitive Element D: g = g1 = 1011, ord(D) = 7 unabhängige Nullstelle
irreduzibles Polynom
D
g1(x) = 1011
ja
3
D
g2(x) = 1101
ja
k = n – grad[g]
Kombination für Mehrbitfehler-Korrektur (ausser Wiederholungscode)
für t=2?
keine, da das Produkt g = g1·g2 bereits den Grad 6 hat (ergibt den Wiederholungscode)
---
(R=k/n) ---
für t =1?
k = 4 (R = 0,57)
Tabelle 3-22: Generatorpolynome im GF(23) Endlich handlungsfähig
Jetzt sind wir in der Lage, geeignete Kombinationen irreduzibler Polynome aus einem Galoisfeld GF(2m) gezielt auszuwählen, um Generatorpolynome für Codes zur Korrektur von t = 1, 2, 3, 4, 5, ... Einbitfehlern zu finden. Dabei gilt: • Die Codelänge beträgt dabei immer n = 2m – 1, was zugleich auch der Ordnung des primitiven Elements entspricht. • Bei den möglichen Kombinationen kann der Grad von g(x) nicht größer werden, als grad[g(x)] = 2m – 2, das Generatorpolynom kann höchsten so „lang“ wie ein Codewort v(x) selbst sein. Wiederholungsco- • Die Kombination maximalen Grades erzeugt als Sonderfall de: schwächster den Wiederholungscode. Er ist zwar zur Korrektur 2m-1 Kandidat Fehlern geeignet, hat aber wegen seiner mit wachsendem m schnell ungünstig werdenden Info-Rate 1/(2m-1-1) keine praktische Bedeutung. Untersuchen wir jetzt die 3 Fälle für Codes in GF(23), GF(24) und GF(25), und stellen die geeigneten Generatorpolynome in den Tabellen 3-22, 3-23 und 3-24 dar.
129
3 Fehlerbeseitigung m=4
GF(24)
n = 24-1 = 15
definierendes Polynom für das primitive Element E: g = g1 = 10011, ord(E) = 15 unabhängige Nullstelle
irreduzibles Polynom
E
g1(x) = 10011
ja
3
g2(x) = 11111
nein, da ord = 5
E5
g3(x) = 111
nein, da ord = 3
E7
g4(x) = 11001
ja
k = n – grad[g]
Kombination für Mehrbitfehler-Korrektur (ausser Wiederholungscode)
für t = 2 ?
7 (0,47)
g = g1·g2 = 111010001
ja
---
g = g1·g3 = 1111001
nein
---
g = g1·g4 = 110111011
nein
7 (0,47)
g = g2·g4 = 100010111
ja
E
(R=k/n)
für t = 1 ?
k = 11 (R = 0,73)
für t =3 ? 5 (0,33)
g = g1·g2·g3 = 10100110111
ja
---
g = g1·g2·g4 = 1001001001001
nein
---
g = g1·g3·g4 = 10000100001
nein
5 (0,33)
g = g2·g3·g4 = 11101100101
ja
Tabelle 3-23: Generatorpolynome im GF(24) Viele sind berufen, aber nicht jeder ist geeignet
Wie bei g2 in Tabelle 3-23 zu sehen ist, liefert also nicht jedes irreduzible Polynom des Grades m ein primitives Element. Deshalb ist hier besondere Aufmerksamkeit erforderlich. Immer dann, wenn für ein gegebenes m die maximale Ordnung 2m -1 keine Primzahl darstellt, gibt es bei den irreduziblen Polynomen des Grades m solche mit der Ordnung der Primzahlfaktoren von 2m- - 1, die damit zugleich kleiner ist, als die maximale.
Allein kann er's nicht
130
Im vorliegenden Fall ist es g2 mit E3. Bei m =3 gab es diese Besonderheit nicht und auch im folgenden Fall für m = 5 liegt mit 25 – 1 = 31 eine Primzahl vor.
3.7 Zyklische Codes m=5
GF(25)
n = 25-1 = 31
definierendes Polynom für das primitive Element J: g = g1 = 100101, ord(J) = 31 unabhängige Nullstelle
irreduzibles Polynom
J
g1(x) = 100101
ja
3
g2(x) = 111101
ja
J5
g3(x) = 110111
ja
J7
g4(x) = 101111
ja
J )
g5(x) = 111011
ja
15
J )
g6(x) = 101001
ja
k = n – grad[g]
Kombination für Mehrbitfehler-Korrektur (ausser Wiederholungscode)
für t = 2 ?
21 (0,68)
g = g1·g2 = 11101101001
ja
21 (0,68)
alle Zweierkombinationen
ja
J
11
(R=k/n)
für t = 1 ?
k = 26 (R = 0,84)
für t = 3 ? 16 (0,52)
g = g1·g2·g3 = 1000111110101111
ja
16 (0,52)
alle Dreierkombinationen
ja für t = 4 ?t
11 (0,35)
g = g1·g2·g3·g4 = 101100010011011010101
ja
11 (0,35)
alle Viererkombinationen
ja für t = 5 ?
6 (0,19)
g = g1·g2·g3·g4·g5 = 11001011011110101000100111
ja
*) die hier eigentlich erwartete Nullstelle J9 ist bereits Nullstelle von Polynom g3 **) die hier eigentlich erwartete Nullstelle J13 ist bereits Nullstelle von g5 Tabelle 3-24: Generatorpolynome im GF(25) Spezialisten an die Front!
Aus diesen Ergebnissen lässt sich folgendes ablesen: • Wie in den Unterkapiteln 3.7.5 und 3.7.6 beschrieben, gibt es nur ganz spezielle geeignete Paarungen irreduzibler Polynome für das Generatorpolynom. Diese erfüllen die hinrei-
131
3 Fehlerbeseitigung chende Bedingung, dass die Syndromwert-Kombinationen für die Nullstellen eindeutig den Fehlermustern zugeordnet werden können. so wird’s gemacht • Für den Aufbau eines Generatorpolynoms zur Korrektur von ... „t“ 1-Bitfehlern nimmt man die irreduziblen Teilpolynome in aufsteigender Reihenfolge der ungeraden Potenzen des primitiven Elements im verwendeten Galoisfeld, also z. B. E, E 3, E 5, .... im GF(24). • Die gleichmäßige Reihenfolge der ungeraden Potenzen des primitiven Elements wird dann unterbrochen, wenn eine Potenz bereits in einem bereits vorhergehend ausgewählten irreduziblen Teilpolynom als Nullstelle enthalten war, z. B. J9 und J13 gemäß Tabelle 3-24 Um auch ein nicht triviales Beispiel zu sehen, arbeiten wir nun einen Fall durch, bei dem ein BCH-Codewort der Länge n = 15 (Galoisfeld GF(24)) codiert, auf dem Übertragungskanal mit t = 3 Einbitfehlern verfälscht und anschließend mit einem schnellen Verfahren decodiert wird. Beispiele sagen Gemäß Tabelle 3-23 benötigen wir das Generatorpolynom mehr als 1000 g(x) = 10 100 110 111 Worte ... mit den 3 unabhängigen Nullstellen E, E 3, E 5. Die Anzahl der Infostellen ist k = 15 – 5 =10, als Infopolynom wird: u(x) = 101 111 gewählt und daraus mit g(x) das Codewortpolynom v(x) = 101 110 000 101 001 berechnet. Einsetzen der Nullstelle E zur Kontrolle liefert v() = 14 + 12 + 11 + 10 + 5 + 3 + 0 = 0 Der Grund lässt sich der folgenden Aufstellung entnehmen: v(0010)
=
1001
entspricht E 14
+1111
entspricht E 12
+1110
entspricht E 11
+0111
entspricht E 10
+0110
entspricht E5
+1000
entspricht E3
+0001
entspricht E0
________
132
3.7 Zyklische Codes v(0010)
=
1001
entspricht E 14
=0000
entspricht 0
MOD 2 !
Entsprechend ist v(3) = 42 + 36 + 33 + 30 + 15 + 9+ 0 = 12 + 6 + 3 + 0 + 0 + 9+ 0 = 0 qualvolles Rechnen
weil v(1000)
=
1111
entspricht E12
+1100
entspricht E6
+1000
entspricht E3
+0001
entspricht E0
+0001
entspricht E0
+1010
entspricht E3
+0001
entspricht E0
________
=0000
entspricht 0
MOD 2 !
und auch für die dritte Nullstelle trifft die Aussage zu: v(5) = 70 + 60 + 55 + 50 + 25 + 15+ 0 = 10 + 0 + 10 + 5 + 10 + 0+ 0 Die Hoffnung stirbt zuletzt ...
=0
Nun muss noch ein Weg gefunden werden, der das Decodieren bzw. das Korrigieren von Fehlern gestattet. Dazu stellt man den Fehler als Polynom e(x) des Grades n – 1 = 14, bzw. der Länge n = 15 dar und nennt es e(x). Innerhalb des Fehlerpolynoms können schlimmstenfalls 3 Stellen von 0 verschieden sein, da wir annehmen, dass höchstens 3 Fehler auftreten. Wenn genau 3 Fehler vorhanden sind, hat jedes Fehlerpolynom die Gestalt e(x)
= xi + xj + xk
Bei weniger Fehlern sind entsprechend weniger Potenzen von x enthalten. Die Aufgabe ist also die Bestimmung der drei Exponenten i, j und k. Als einzige Informationsquelle steht dafür das empfangene Wort w(x) zur Verfügung, das sich aus dem Codewort v(x) und dem Fehler e(x) zusammensetzt, im Syndromwert aber nur den Beitrag des Fehlers (oder der Fehler) zeigt, wenn in w(x) die Nullstellen eingesetzt werden. Für das empfangene Wort bedeutet dies s(E) = w() = v() + e() = s1
= 0 + i + j + k
133
3 Fehlerbeseitigung
... auf gutem Wege
s(E 3) = =
w(3) = v(3) + e(3) s3
= 0 + 3i + 3j + 3k
s(E 5) = =
w(5) = v(5) + e(5) s5
= 0 + 5i + 5j + 5k
wobei die s1, s3 und s5 die Syndromwerte darstellen. Damit liegt ein System aus 3 (nichtlinearen) Gleichungen für die 3 unbekannten Exponenten i, j und k vor. Wir nehmen jetzt an, dass Fehler in den Positionen 3, 7, und 12 aufgetreten sind. Das entspricht den Polynomexponenten 2, 6 und 11 und man empfängt w(x)
= v(x) + e(x)
= 101 110 000 101 001 + 000 100 001 000 100 = 101 010 001 101 101 .
Das Syndrom s1 hat damit den Wert = w() s1 = 14 + 12 + 10 + 6 + 5 + 3 + 2 + 0
=. E5
Dieser Wert entspricht der Summe der Beiträge der 3 Einbitfehler: s1
= w() = E5
= e()
= 11 + 6 + 2
Bekannte Zutaten Allerdings kennen wir die Einzelbeiträge noch nicht, sondern neu gemixt wollen sie ja gerade erst ermitteln. Für s3 und s5 gelten: s3
= w(3) = 42 + 36 + 30 + 18 + 15 + 9 + 6 + 0 = 12 + 6 + 0 + 3 + 0 + 9 + 6 + 0 = 6 = 1100.
In der Realität unbekannt, aber als Anschauung hierzu: e(3)
= 33 + 18 + 6 = 3 + 3 + 6 = 1100.
sowie s5
= w(5) = 70 + 60 + 50 + 30 + 25 + 15 + 10 + 0 = 10 + 0 + 5 + 0 + 10 + 0 + 10 + 0 = 0
134
3.7 Zyklische Codes = 0001. und wieder nur zur Anschauung, da unbekannt: e(5)
= 55 + 30 + 10 = 10 + 0 + 10 = 0001.
Ehemann in Salz- Wie lässt sich so ein Gleichungssystem lösen? Da wir in endlichen säure: ein gelöstes Körpern arbeiten, kann man zum Beispiel alle möglichen KombiProblem nationen der i, j und k von 0, 1, 2 .... bis 14 einsetzen. Sind nicht mehr als 3 Fehler aufgetreten, so findet man auf diesem mühsamen und aufwändigen Weg systematisch die richtige Kombination, auch dann, wenn nur 2 oder 1 Fehler passierten. Die notwendige maximale Anzahl von Berechnungen lässt sich sogar genau angeben, es ist die Summe aller 1-, 2- und 3-Bitfehler. In diesem Fall erreicht sie trotz der verhältnismäßig kleinen Codelänge von n = 15 schon den stattlichen Wert von 15 + 120 + 455 = 575. so ging's, Im Mittel müssen also pro Empfangswort 575/2 Syndromwerte aber so geht’s berechnet werden. Wenn man bedenkt, dass heutige Hochleisnicht tungscodes Längen von vielen hundert bis einigen tausend Bits besitzen, deren Codierung und Decodierung auch noch in Echtzeit mit einigen 100 Megabit/s durchzuführen ist, wird die Aussichtslosigkeit dieses Weges klar. Ein wesentlich schnellerer Weg ist im Buch von Peterson, Kapitel 9.4 ff., beschrieben. Er erinnert ein wenig an die Polynombestimmung zur Ermittlung von näherungsweisen Kennlinienfunktionen bei Meßwertgebern: Man schätzt den Grad m eines Polynoms, welches den gemessenen Kennlinienverlauf gut annähert und bestimmt dann aus m Kennlinienpunkten die m unbekannten Polynomkoeffizienten mithilfe eines linearen Gleichungssystems. Nimmt man z. B. für den Zusammenhang zwischen Meßgröße (etwa Druck) und Ausgangssignal (etwa elektrische Spannung) eine quadratische Abhängigkeit an, so lässt sich dafür ein allgemeines Polynom 2. Grades ansetzen: f(x) = x2 + 1x + 0. Der Königsweg
Die beiden Koeffizienten V1 und V0 sind natürlich noch unbekannt. Um sie zu bestimmen, benötigt man im einfachsten Fall zwei möglichst genaue und unabhängige Paare der Messgröße x und des Ausgangssignals f(x). Das könnten z. B. die Paare [x1, f(x1)] und [x2, f(x2)] sein. Daraus lässt sich ein lineares Gleichungssystem für V1, V2 aufstellen: 1x1 + 0
= f(x1) - x12
1x2 + 0
= f(x2) - x22.
Nach Auflösung dieses Systems ist auch das Polynom f(x) voll-
135
3 Fehlerbeseitigung
... könnte was werden ....
ständig bestimmt, und gewöhnlich haben wir damit die Arbeit beendet. Wenn erforderlich, könnte man aber noch zusätzlich die Nullstellen von f(x) ermitteln. Bei der Berechnung der 3 unbekannten Fehlerpositions-Exponenten i, j und k steht man vor einer ähnlichen Aufgabe, hier allerdings muss ein nichtlineares Gleichungssystem gelöst werden. Ein Trick hilft dabei: Fasst man die drei 3 Potenzen E i, Ej und E k als Nullstellen eines Polynoms 3. Grades auf, so lässt sich darüber eine Aufgabe mit linearem Charakter erzeugen. Formal startet man mit (x - i)Y(x - j)Y(x - k)
= x3 + 2x2 + 1x + 0 .
Da man die „E's“ nach wie vor nicht kennt, ist man mit diesem Schritt allerdings noch nicht schlauer. Das ändert sich, wenn man die 3 Syndrome s1, s3 und s5 zu Hilfe nimmt, deren Werte ja bekannt sind. Die Umwandlung in eine Aufgabe mit linearem Charakter gelingt hier aber nur deshalb, weil man wieder einmal eine besonders nützliche Eigenheit der Rechenregeln in endlichen Körpern verwenden kann. Diese Eigenheit äußert sich in der einfachen Darstellung von Summen-Potenzen genau dann, wenn der Exponent den Wert der Charakteristik p des Zahlenkörpers hat, siehe Seite 127. Die gemischten Anteile verschwinden dann, wie wir gesehen hatten, in unserem Beispiel wird: s1 2
= (i + j + k)2 = (i2 + j2 + k2 + 2ij + 2ik + 2jk) = 2i + 2j + 2k,
s1 4
= (s12)2
= (2i + 2j + 2k)2 = (4i + 4i + 4k + 22i2j + 22i2k + 22j2k) = 4i + 4j + 4k,
s3 2
= (3i + 3j + 3k)2 = (6i + 6j + 6k + 23i3j + 23i3k + 23j3k) = 6i + 6j + 6k
alles alte Bekann- usw. Alle diese Potenzen liegen aber als Werte der bekannten te Syndrome vor. s1
136
= 0110
= 5
s1 2
= 10
s1 4
= 20
= 5.
3.7 Zyklische Codes
= 1100
s3
= 6 = 12
s3 2 s5
= 0001
= 0
Mit diesen Ergebnissen kehren wir zum Polynom 3.Grades zurück, das oben bereits aufgestellt wurde: (x – i)Y(x – j)Y(x – k) Die Trickkiste
= x3 + 2x2 + 1x + 0.
Man erzeugt jetzt durch Multiplikation dieses Polynoms mit geeigneten Potenzen von und gezieltem Einsetzen der Nullstellen insgesamt 9 Gleichungen und fasst diese so zusammen, dass zum Schluß ein lineares Gleichungssystem 3. Ordnung zur Bestimmung der 3 Unbekannten mit den Syndromen als Koeffizienten entsteht. Im ersten Schritt multipliziert man die linke und die rechte Seite jei i weils mit und setzt für x die erste Nullstelle ein. Dann wird die linke Seite 0: (x - i)Y(x - j)Y(x - k) i
= (x3 + 2x2 + 1x + 0) i
und nach Einsetzen von x =
i
0 = 3ii + 22ii + 1ii + 0i
= 4i + 23i + 12i + 0i.
j
Das gleiche macht man mit : (x - i)Y(x - j)Y(x - k) j
= (x3 + 2x2 + 1x + 0) j
und nach Einsetzen von x = j 0 = 3jj + 22jj + 1jj+ 0j
= 4j + 23j + 12j + 0j.
k
Für schließlich entsteht: 0 = 3kk + 22kk + 1kk+ 0j
= 4k + 23k + 12k + 0k.
Im nächsten Schritt multipliziert man beidseitig mit 2i, bzw. 2j oder 2k und setzt für x wieder i, bzw. j oder k ein: 0 = 3i2i + 22i2i + 1i2i + 02i
= 5i + 24i + 13i + 02i
0 = 3j2j + 22j2j + 1j2j + 02j
= 5j + 24j + 13j + 02j
0 = 3k2k + 22k2k + 1k2k + 02k
= 5k + 24k + 13k + 02k.
Im letzten Schritt wird beidseitig mit 3i, 3j, bzw. 3k multipliziert usw.: 0 = 3i3i + 22i3i + 1i3i + 03i
= 6i + 25i + 14i + 03i
0 = 3j3j + 22j3j + 1j3j + 03j
= 6j + 25j + 14j + 03j
0 = 3k3k + 22k3k + 1k3k + 03k
= 6k + 25k + 14k + 03k.
137
3 Fehlerbeseitigung Nun addiert man die ersten 3 Gleichungen, dann die nächsten drei und schließlich die letzten: 0 = (4i + 4j + 4k) + 2(3i + 3j + 3k) + 1(2i + 2j + 2k) + 0(i + j + k) 0
= (5i + 5j + 5k) + 2(4i + 4j + 4k) + 1(3i + 3j + 3k) + 0(2i + 2j + 2k)
0
= (6i + 6j + 6k) + 2(5i + 5j + 5k) + 1(4i + 4j + 4k) + 0(3i + 3j + 3k).
Die Ausdrücke in den Klammern sind ausschließlich durch die Syndrome und deren Potenzen gegeben, die wir bereits oben berechnet hatten:
... ganz nahe ....
0
= s14 + s3 2 + s12 1 + s1 0
0
= s5 + s14 2 + s3 1 + s12 0
0
= s32 + s5 2 + s14 1 + s3 0 .
Dies ist ein lineares Gleichungssystem 3.Ordnung, aus dem die unbekannten Koeffizienten 2, 1 und 0 direkt berechnet werden können. Setzt man die oben gefundenen Werte für die Syndrome ein und stellt dieses Gleichungssystem in Matrixform dar, so ergibt sich:
[
][ ] [ ]
6
10
5
5
6
0
5
10 1 6 0
5
2
=
0
12
Genaugenommen muss man noch sicherstellen, dass die 3·3-Matrix regulär, das Gleichungssystem also überhaupt lösbar ist. Im Buch von Peterson, Kapitel 9.4, wird gezeigt, dass dieses gegeben ist, wenn drei verschiedene Fehler auftraten. Da wir dieses in unserem Beispiel angenommen hatten, gibt es also eine Lösung, die man mit den Mitteln der Elementarmathematik leicht herausbekommt – in diesem Fall z. B. über die so genannte Sarrusregel. Dazu wird zunächst die Systemdeterminante D ermittelt:
138
3.7 Zyklische Codes
[
6
10
D = 5 0
5
6 5
]
6 6 6 10 10 0 5 5 5 10 = + 6 5 6 0 5 10 6 5 10 6
=18 20 + 15 11 =3 5 0 11= ... aber Knochenarbeit ....
0
Danach wird die Lösungsdeterminante für 2 bestimmt. Das heißt, dass man die erste Spalte in der Systemdeterminante D durch die drei Elemente des Lösungsvektors (= rechte Seite im obigen Gleichungssystem) ersetzen muss. Zur Berechnung von 1 ist entsprechend die zweite Spalte in D, für 0 die dritte Spalte durch den Lösungsvektor zu ersetzen. Sehen wir uns diese Berechnung bei der Lösungsdeterminante zu 2 einmal genauer an:
[
5
D = 0 2 12
10
6 5
5
]
5 6 6 10 10 12 5 0 5 10 = 6 5 6 120 10 6 5 10 5
=17 32 10 231620
= 2 2 10 8 1 5=
5 .
Damit ist nach den Regeln zur Auflösung von linearen Gleichungssystemen: 2 =
D D
2
=
D D 5 5 1 6 4 = , 0 0 = = , = 1 0 D D
=
Diese Koeffizienten setzt man in das Polynom 3.Grades ein und erhält f(x) ... uff, geschafft!!!
= x3 + 5x2 + 6x + 4
Die drei Nullstellen dieses Polynoms sind nun endlich die gesuchten -Potenzen, aus denen man die Fehlerposition entneh men kann. Man findet diese Nullstellen mit geringem Aufwand durch systematisches Suchen, indem man nacheinander alle Elemente
139
3 Fehlerbeseitigung des Erweiterungskörpers GF(24) einsetzt (also 0, 0 =1, , 2, 3, ...) und prüft, bei welchen drei Elementen sich 0 ergibt. In unserem Beispiel sieht das so aus: x=0:
f(0)
= 4
x=0 =1:
f(0) = 0 + 5 + 6 + 4
= 3
x=1:
f(1) = 3 + 7 + 7 + 4
= 7
x=2:
f(2) = 6 + 9 + 8 + 4
= 0 !
............................................................................................ ............................................................................................ x=6: 11
x= :
... doch nicht fertig? Fallunterscheidungen ...
... aber nichts neues
140
f(6) = 18 + 17 + 12 + 4 11
33
27
17
f( ) = + + +
4
= 0 ! = 0 !
Damit ist man fertig und kann das empfangene Wort zum richtigen Codewort korrigieren. Der beschriebene Weg zeigt die Decodierung, wenn 3 Einbitfehler aufgetreten waren. Was passiert, wenn 2 oder 1 Fehler einwirkten?. Dann nimmt die Systemdeterminante D den Wert 0 an, das Gleichungssystem ist nicht lösbar. Man testet nun die Determinante für den Fall von t = 2 Fehlern, wenn dies nicht zum Ergebnis führt, denjenigen für t = 1 Fehler, und bearbeitet den dann übrig bleibenden Fall ähnlich wie den für t = 3. Haben alle Determinanten den Wert 0, obwohl die Syndromwerte von 0 verschieden sind, so liegt eine Konstellation mit mehr als 3 Fehlern vor, eine Korrektur ist dann unmöglich. Aber Vorsicht: Es gibt auch Fehlermuster mit t > 3, die einem Codewort entsprechen. Das Empfangswort täuscht dann Fehlerfreiheit vor, die Fehler gehen unkorrigiert in das Gesamtergebnis ein. Dies ist nicht zu vermeiden. Da der gezeigte Rechnungsgang insgesamt verhältnismäßig lang war, wird sich mancher vielleicht fragen, ob ein geschicktes Einsetzen aller möglichen 1-Bit-, 2-Bit- und 3-Bit-Fehler am Ende nicht doch schneller zum Ziel führt. Dies ist nicht der Fall, denn von den einzelnen Schritten, die wir im Beispiel durchlaufen haben, werden natürlich nur diejenigen benötigt, die das Endergebnis bringen. Im wesentlichen umfasst das für jedes empfangene Wort die Berechnung • der 3 Syndrome s1, s3, s5 und der drei Potenzen s12, s14, s32, • der 4 Determinanten des Gleichungssystems 3.Ordnung und die inverse Determinante D-1,
3.7 Zyklische Codes der 3 Nullstellen des Polynoms f(x). Die notwendigen Algorithmen lassen sich für jeden Code optimieren. Gewöhnlich wird man diese dann in einem eigenen kleinen und genügend schnellen Prozessor (VLSI-Chip) implementieren. Der Informatik-Markt bietet derartige Chips in verschiedenen Ausführungen an. Darüber hinaus existieren auch noch andere Lösungsverfahren. So ist z. B. eines im Unterkapitel 3.8.2 oder auch im Buch von Adamek im Kapitel 13 beschrieben. Adamek gibt außerdem Verweise auf eine Vielzahl weiterer Veröffentlichungen. Um sich eine Vorstellung von der Leistungsfähigkeit der BCH-Codes machen zu können, zeigt Bild 3.15 die Restfehlerdiagramme für das uncodierte Signal und zu verschieden langen BCH-Codes. Zu einer gegebenen Codelänge n ist dabei immer der Verlauf mit dem besten Ergebnis gewählt. Man sieht, dass die Leistungen sich mit längeren Codes verbessern. Asymptotisch wird die Leistung zum Vorgänger aber relativ schlechter, wie im Unterkapitel 3.7.10 erläutert ist. Daher erreicht man mit den BCH-Codes auch nicht annähernd die eingezeichnete Shannon-Grenze. •
es geht noch schneller ...
Leistungsprofil
Bild 3.15: verschiedenen BCH-Codes. Die Linienarten bedeuten: •
durchgezogen
: uncodiert
•
gestrichelt
: (7,4,3)-BCH-Code
•
1-Punkt-Strich
: (15,5,7)-BCH-Code
•
2-Punkt-Strich
: (31,11,9)-BCH-Code
•
3-Punkt-Strich
: (63,15,13)-BCH-Code
•
4-Punkt-Strich
: (127,78,15)-BCH-Code
•
5-Punkt-Strich
: (255,171,23)-BCH-Code
141
3 Fehlerbeseitigung
3.7.8
Reed-Solomon-Code für Mehrfach-Bündelfehler-Korrektur
Der Reed-Solomon-Code wurde 1960 – und damit früher als der BCH-Code – von I.S. Reed und G. Solomon entdeckt („Polynomial Codes Over Certain Finite Fields“, Journal Soc. Ind. Appl. Math., Vol. 8, S. 300 – 304) und stellte sich später als Sonderfall des letzteren heraus. Er besitzt eine außerordentlich große praktische Bedeutung, da er einen asymptotisch guten Code darstellt, siehe auch Unterkapitel 3.7.10, und als Fehlerkorrekturverfahren bei sehr vielen Massenspeichertechniken (Platte, Band, DATBand, Audio-CD, Daten-CD) verwendet wird. Zur Erinnerung: Ein asymptotisch guter Code verbessert seine Korrekturleistung mit wachsender Codelänge n. Dies ist z. B. beim BCH-Code nicht der Fall. Der Musterschüler Wenn man die Haupteigenschaft des Reed-Solomon-Codes betrachtet, wird man sich seine Bedeutung zunächst nicht recht erklären können. Schauen wir uns dazu einmal den Aufbau des Generatorpolynoms eines Reed-Solomon-Codes an. Will man hiermit einen zyklischen Code für die Korrektur von t Fehlern konstruieren, so müssen darin wie beim BCH-Code genau 2·t unabhängige Nullstellen enthalten sein. Diese Nullstellen bestehen aber beim Reed-Solomon-Code nur aus den Elementen des Grundkörpers GF(p), nicht wie beim BCH-Code aus solchen eines Erweiterungs-Körpers GF(pm). Ein Beispiel: wählt man als Grundkörper den Z5 (entspricht GF(5)) und will man einen 4-stelligen Code aufbauen, so sucht man, wie gewohnt, zunächst nach einem primitiven Element in Z5, welches die Ordnung 4 hat. Ein solches Element ist die Zahl 3, weil sich alle Körperelemente des Z5 (außer der Null) daraus durch Potenzierung bilden lassen:
Körperwelten
30
= 1 MOD 5
=1
3
1
= 3 MOD 5
=3
3
2
= 9 MOD 5
=4
3
3
= 27 MOD 5
=2
3
4
= 81 MOD 5
= 1.
Zugleich sind alle diese Elemente immer auch Nullstellen der über den Grundkörpern aufstellbaren Polynome 1.Grades: (x - 3) (x - 32)
= (x - 4)
(x - 33)
= (x - 2)
4
(x - 3 )
142
= (x - 1).
(32 MOD 5 = 4 !)
3.7 Zyklische Codes Bezeichnet man ein allgemeines Element des Grundkörpers mit , so hat das Generatorpolynom für den t Fehler-korrigierbaren Code also den Aufbau = (x - 1)(x - 2)(x - 3)......(x - 2t)
g(x)
und ein damit gebildetes Codewortpolynom besitzt auch alle diese Nullstellen , 2, 3, ...., 2t. Daher gelten wie beim BCHCode für jedes Codewort die Beziehungen v()
=0
2
=0
3
=0
v( ) v( ) .
.
.
. 2t
v( )
= 0,
Geschwister: Posi- welche wie gewohnt zur Bestimmung der Fehlerpositionen und tion und Wert – dies ist hier neu und auch notwendig – zur Bestimmung der Fehlerwerte benutzt werden können. In unserem Beispiel mit = 3 für einen 4-stelligen 1-Fehler-korrigierbaren Code wird das Generatorpolynom = (x - 31)(x - 32)
g(x)
= (x - 3)(x - 9) = x2 - 12x + 27
= x2 +3x +2.
Aufgebohrt: Das Ein Informationspolynom hat in diesem Fall 2 Stellen, die CodeCodewortpolynom wortpolynome bildet man nach dem bekannten Verfahren, wobei alle Rechnungen MOD 5 zu erledigen sind. Für ein Infopolynom u(x) = 3x + 2 ergibt sich das Codewortpolynom v(x) auf folgende Weise: 3x3
+
2x2
+
0x
3x3
-
6x2
+
6x
+0
: x2 - 2x + 2 = 3x + 3 + h(x)
__________________________ 0
3x2 3x
2
+
4x
+0
-
6x
+6
___________________ 0
0x
+4
o Rest mit h(x)
= r(x)
=4 2
= r(x)/(x - 2x + 2).
Wenn man die Koeffizienten des Restpolynoms noch MOD 5 nimmt, so ist das Codewort also
143
3 Fehlerbeseitigung v(x)
= 3x3 + 2x2 + 0x + 1.
(Man beachte: das Restpolynom muss abgezogen werden, nur im Z2 ist Addition = Subtraktion !). Zwei Nullstellen dieses Polynoms müssen wegen der Konstruktion mit dem Generatorpolynom die beiden Zahlen 3 und 4 sein. Probe:
neue Körper braucht die Welt
v(3)
= 327 + 29 + 03 + 1
= 100 MOD 5 = 0
v2(4)
= 364 + 216 + 04 + 1
= 225 MOD 5 = 0.
Das geschilderte Vorgehen ist eigentlich vom BCH-Code her gut vertraut. Leider hat es wegen seiner besonderen Konstruktionsweise eine unangenehme Folge: Da man für jeden zu korrigierenden Fehler immer 2 verschiedene Nullstellen im Generatorpolynom braucht, kann es im Grundkörper Z2 überhaupt keinen Reed-Solomon-Code geben. Das einzige primitive Element im Z2 ist die Zahl 1 und diese stellt damit (außer der Null als Sonderfall) auch die einzige mögliche Nullstelle dar. Die Auflösung dieses scheinbaren Widerspruchs besteht darin, dass man als Grundkörper des Reed-Solomon-Codes nicht den Z2, sondern ein Galoisfeld GF(2m) – oder ganz allgemein GF(pm) – wählt. Die bisherige Einteilung in Grund- und Erweiterungskörper war ja nur eine gedankliche Unterscheidungshilfe, letztlich kommt es ausschließlich darauf an, dass die Rechenregeln eines Körpers erfüllt sind. Betrachten wir wieder den Körper GF(24) mit den 16 Elementen 0, 0=1, , 2,..., 14 und fassen ihn als neuen Grundkörper auf. Die Koeffizienten von Polynomen über diesem Grundkörper können nun nicht nur die Werte 0 oder 1 sondern auch , 2 usw. haben. Übrigens ist dies nichts neues, denn im Unterkapitel 3.7.7 wurde beim Polynom 3. Grades zur Bestimmung der Nullstellen bereits fleißig vom Rechnen mit derartigen Polynomen Gebrauch gemacht. Wir erinnern uns: f(x)
Verbindung gefragt
144
= x3 + 5x2 + 6x + 4.
Jetzt heißt es nicht mehr "ein Polynom über Z2 oder GF(2)" sondern "ein Polynom über GF(24)". Das ist schon fast alles. Wie schafft man die Verbindung von den 16 Elementen des GF(24) zu einem binären Code? Das erscheint zunächst unlösbar, denn in der Tat sind die Elemente , 2,... keine Zahlen, die man mit der realen Welt in Verbindung bringen könnte. Es gibt zwar 0 oder 1 oder 2 oder 3 Äpfel, jedoch nicht Bananen. Andererseits war zu sehen, dass jedes Element des GF(24) als Element eines so genannten endlichen Polynomringes (bezüglich des definierenden irreduziblen Polynoms über Z2 festgelegt ist. Das Element nimmt hier die Position der unabhängigen Va-
3.7 Zyklische Codes
.. und es geht ....
riablen ein. Im GF(24) lassen sich alle 16 Elemente als Polynome 3.Grades in der unabhängigen Variablen und mit den Koeffizienten 0 oder 1 darstellen, siehe Tabelle 3-20 auf Seite 124. Man kann einen binären Code einfach so aufteilen, dass jeweils 4 Binärstellen (die Zahl 4 gilt nur für dieses Beispiel im GF(2 4) !) einem Element des GF(24) zugewiesen werden. Ein Beispiel: Die Binärfolge 0111
0100
1111
2
12
0000
1011
0001
wird zu 10
7
0
1.
Alle Rechnungen führt man im GF(2 ) durch und weist das Endergebnis wieder einer Binärfolge zu. Ein Code als Polynom mit 15 Stellen über dem Galoisfeld GF(24) kann demnach als Binärcode mit 415 = 60 Stellen betrachtet werden. Sehen wir uns ein Beispiel an, bei dem in einem solchen 15-stelligen Code 3 Fehler korrigiert werden sollen. Da die Codelänge der Ordnung e des primitiven Elements entspricht, sind wir im GF(2 4) offenbar schon gut aufgehoben. Ein Code, der 3 Fehler im GF(2 4) korrigieren kann, korrigiert damit 34 = 12 Binärstellen, allerdings mit der Besonderheit, dass immer Pakete von 4 Binärstellen gemeinsam behandelt werden. Das ist sehr wohl ein Unterschied zu einem normalen 12-Bit-Fehler-korrigierbaren BCH-Binärcode, denn bei diesem wären die 12 Fehlerstellen voneinander unabhängig. Das Generatorpolynom für t=3 ist 4
... zum Beispiel: Reed-Solomon ...
g(x)
= (x - ) Y(x - 2)(x - 3)Y(x - 4)(x - 5)Y(x - 6) = x6 + 10x5 + 14x4 + 4x3 + 6x2 + 9x + 6
oder in Kurzschreibweise =1
10
14
= 0001 0111 1001
... ganz schön lang ...
4
6
9
6
0011 1100 1010 1100.
Bei der Berechnung von g(x) muss wieder berücksichtigt werden, dass beim Galoisfeld GF(24) die Charakteristik p=2 ist. Summanden der Vielfachheit 2, 4, 6, ... ergeben zusammen daher immer den Wert 0. Weiterhin gilt aus diesem Grund: Addition gleich Subtraktion im GF(2m). Da man einen 15-stelligen Code erhält, lassen sich 15-6 = 9 Informationsstellen nutzen. Liegt darin nicht ein Widerspruch zum 15-stelligen BCH-Binärcode, bei dem wegen des Generatorpolynoms von zehntem Grad nur 5 Informationsstellen zur Verfügung standen? Die Antwort ist "nein", denn man muss bedenken, dass der vergleichbare Binärcode ja nur 3 Fehlerbündel zu je 4 Stellen korrigiert. Die Korrekturleistung ist also nicht so hoch, dafür wird
145
3 Fehlerbeseitigung die Informationsrate besser. R15-stelliger BCH-Binärcode
= 5/15= 33,3%
R15-stelliger Reed-Solomon-Code
= 9/15= 60,0%.
Fahren wir im Beispiel fort. Die Codewörter werden wie üblich gebildet. Ein binäres Informationswort hat 49 = 36 Bits. Damit sich der Aufwand in Grenzen hält, nehmen wir ein solches, bei dem die ersten fünf Viererblöcke den Wert 0000 aufweisen: u(x)
=0000 0000 0000 0000 0000 1011 0100 1111 0101 = 0
Schon Darwin sagte: Schieben und geschoben werden (oder so)
0
0
0
0
7
2
12
8 .
Dieses wird um 6 Viererblöcke nach links geschoben und anschließend durch das Generatorpolynom dividiert, wobei man der besseren Übersicht wegen die 5 führenden 0-Blöcke nicht mit hinschreibt und vom Ergebnis nur das Restpolynom angibt: 7 2 12 8 0 0 0
0 0 0: 1 10 14 4 6 9 6
7 17 21 11 13 16 13 ________________________________ 0 0
4 7 13 16 13 0 0 4 14 18 8 10 13 10 _____________________________ 0
8 10 9 13 10 0 11 15 5 7 10 7
_____________________________ 0 ... wir ham's ....
7
5 6 5 0 7
o Restpolynom.
Damit ist das Codewort v(x) = 7 2 12 8 7 5 6 5 0 7. Man überzeuge sich, dass dieses Codewort wirklich die Elemente , 2, usw. als Nullstellen besitzt! Für x = wird zum Beispiel v() = 16 10 19 14 12 9 9 7 0 7 = 0000 = 0. Nun ist klar, wie man Codewörter erzeugt, und im nächsten Schritt wird ein fehlerbehaftetes Empfangswort decodiert. Dazu nehmen wir an, dass Fehler in den Stellen 3, 8 und 11 aufgetreten sind. Gegenüber dem rein binären Fall heißt das jetzt, dass jeder Fehler einen "Wert" zwischen 0 und 14 haben kann, nicht nur den Wert "1". Dies entspricht den binären 4-er Blöcken 0001 bis 1111 (der Block 0000 wäre natürlich kein Fehler). Das Decodierverfahren vom vorhergehenden Kapitel lässt sich ohne Änderung über-
146
3.7 Zyklische Codes
Position: nicht ausreichend!
nehmen, wenn die auf die 4-er Blöcke bezogenen Fehlerpositionen zu bestimmen sind. Schauen wir uns aber noch an, welche Änderungen die Fehlerwerte eigentlich nach sich ziehen. Zuvor reichte es aus, einen Fehler nur durch seine Position zu kennzeichnen, jetzt kommt noch die Angabe des Wertes hinzu. Man muss also auch berechnen, um welchen Betrag ein Fehler den ursprünglichen Wert geändert hat. Fehler in den Stellen 3, 8 und 11 sind im Fehlerpolynom mit ganz bestimmten Fehlerwerten verbunden. Es wird angenommen, dass die Stelle 3 durch e2 = 0111 = 10, die Stelle 8 durch e7 = 1101 = 13 und die Stelle 11 durch e10 = 1001 = 14 "verbogen" ist. Das Fehlerpolynom e(x) sieht dann so aus: e(x)
= 14x10
+ 13x7
+ 10x2 ,
oder über die Indices i, j, k mit allgemeinen Fehlerpositionen und Fehlerwerten ausgedrückt e(x)
= eixi + ejxj + ekxk .
Das empfangene Wort setzt sich wieder aus dem Codewort und dem Fehler zusammen: w(x)
= v(x) + e(x)
oder w(x)
= 14x10
+ 7x9 + 2x8 + (12+13)x7 + 8x6 + 7x5
+ 5x4
+ 6x3 +
(5+10)x2 + 7
bzw. w(x)
= 14x10 + 7x9 + 2x8 + 1x7 + 8x6 + 7x5 + 5x4 + 6x3 + 1x2 + 7.
Wertbestimmung
Die Syndrome stellen den Wert der empfangenen Worte jeweils für x=, x=2, ..., x=6 dar. Also ist s1
= w()
= 1410 + 79 + 28 + 17 + 86 + 75 + 54 + 63 + 12 + 7 = 9 + 1 + 10 + 8 + 14 + 12 + 9 + 9 + 3 + 7
s2
= w(2)
= 4
= 1420 + 718 + 216 + 114 + 812 + 710 + 58 + 66 + 14 + 7
147
3 Fehlerbeseitigung = 4 + 10 + 3 + 0 + 5 + 2 + 13 + 12 + 5+ 7 s3
= w(3)
= 8
= 1430 + 727 + 224 + 121 + 818 + 715 + 512 + 69 + 16 + 7 = 14 + 4 + 11 + 7 + 11 + 7 + 2 + 0 + 7 + 7
s4
= w(4)
= 3
= 1440 + 736 + 232 + 128 + 824 + 720 + 516 + 612 + 18 + 7 = 9 + 13 + 4 + 14 + 2 + 12 + 6 + 3 + 9 + 7
s5
= w(5)
= 6
= 1450 + 745 + 240 + 135 + 830 + 725 + 520 + 615 + 110 + 7 = 4 + 7 + 12 + 6 + 8 + 2 + 10 + 6 + 11 + 7
s6
= w(6)
= 13
= 1460 + 754 + 248 + 142 + 836 + 730 + 525 + 618 + 112 + 7 = 14 + 1 + 5 + 13 + 14 + 7 + 14 + 9 + 13 + 7
= 8 .
... sieht gut aus ... Andererseits lässt sich aber jedes dieser Syndrome durch den jeweiligen Wert des Fehlerpolynoms ausdrücken (den wir nicht kennen !):
148
s1
= e()
= ei i + ej j + ek k
s2
= e(2)
= ei 2i + ej 2j + ek 2k
s3
= e(3)
= ei 3i + ej 3j + ek 3k
s4
= e(4)
= ei 4i + ej 4j + ek 4k
s5
= e(5)
= ei 5i + ej 5j + ek 5k
s6
= e(6)
= ei 6i + ej 6j + ek 6k .
3.7 Zyklische Codes Nun erinnern wir uns an das Fehlerpositions-Polynom 3.Grades beim BCH-Code, wo die den Fehlerpositionen zugeordneten Potenzen als Nullstellen angesetzt waren: (x - i)(x - j)(x - k)
= x3 + 2x2 + 1x + 0.
Auch hier erzeugt man wieder durch Multiplikation dieses Polynoms mit geeigneten Potenzen von und gezieltem Einsetzen der Nullstellen insgesamt 9 Gleichungen und fasst diese so zusammen, dass zum Schluss ein lineares Gleichungssystem 3.Ordnung zur Bestimmung der 3 Unbekannten i mit den Syndromen als Koeffizienten entsteht. Rechenkunststückchen
Allerdings multipliziert man nicht nur mit i, j oder k, sondern erweitert diese Positionsfaktoren jeweils noch um die Fehlerwerte ei = 14, ej = 13 oder ek = 10. Im ersten Schritt ist also die linke und die rechte Seite jeweils mit ei i zu multiplizieren und für x die erste Nullstelle i einzusetzen. Dann nimmt die linke Seite den Wert 0 an: (x - i)(x - j)(x - k) ei i
= (x3 + 2x2 + 1x + 0) ei i
und nach Einsetzen von x = i 0
= ei 3ii
+ 2 ei 2ii
+ 1 ei ii
+ 0 ei i
= ei 4i
+ 2 ei 3i
+ 1 ei 2i
+ 0 ei i .
Das gleiche geschieht mit ej j: (x - i)(x - j)(x - k) ej j
= (x3 + 2x2 + 1x + 0) ej j
und nach Einsetzen von x = j 0
= ej 3j
j
= ej 4j
+ 2 ej 2j
j
+ 2 ej 3j
+ 1 ej j
j
+ 0 ej
j
+ 1 ej 2j
+ 0 ej j .
Für ek k schließlich entsteht: 0
= ek 3kk
+ 2 ek 2kk
+ 1 ek kk
+ 0 ek j
= ek 4k
+ 2 ek 3k
+ 1 ek 2k
+ 0 ekk .
Im nächsten Schritt wird beidseitig mit ei 2i, bzw. ej 2j oder ek2k multipliziert und für x wieder i, bzw. j oder k eingesetzt:
Greifbares Ziel
0
= ei 5i
+ 2 ei 4i
+ 1 ei 3i
+ 0 ei 2i
0
= ej 5j
+ 2 ej 4j
+ 1 ej 3j
+ 0 ej 2j
0
= ek 5k
+ 2 ek 4k
+ 1 ek 3k
+ 0 ek 2k .
Im letzten Schritt erfolgt die Multiplikation beidseitig mit ei 3i, ej 3j, bzw. ek 3k usw.:
149
3 Fehlerbeseitigung 0
= ei 6i
+ 2 ei 5i
+ 1 ei 4i
+ 0 ei 3i
0
= ej 6j
+ 2 ej 5j
+ 1 ej 4j
+ 0 ej 3j
0
= ek 6k
+ 2 ek 5k
+ 1 ek 4k
+ 0 ek 3k .
Nun fasst man die ersten 3 Gleichungen zusammen und addiert sie, dann die nächsten drei und schließlich die letzten: 0
0
0 Bekannte Pfade
= (ei4i + ej4j + ek4k)
+ 2(ei3i + ej3j + ek3k)
+ 1(ei2i + ej2j + ek2k)
+ 0(eii + ejj + ekk)
= (ei5i + ej5j + ek5k)
+ 2(ei4i + ej4j + ek4k)
+ 1(ei3i + ej3j + ek3k)
+ 0(ei2i + ej2j + ek2k)
= (ei6i + ej6j + ek6k)
+ 2(ei5i + ej5j + ek5k)
+ 1(ei4i + ej4j + ek4k)
+ 0(ei3i + ej3j + ek3k) .
Die Ausdrücke in den Klammern sind ausschließlich durch die Syndrome s1, s2, ..., s6 gegeben, die zuvor schon berechnet wurden: 0
= s4 + s3 2
+ s2 1
+ s1 0
0
= s5 + s4 2
+ s3 1
+ s2 0
0
= s6 + s5 2
+ s4 1
+ s3 0 .
Wieder liegt ein lineares Gleichungssystem zur Bestimmung der Fehlerpositionen vor:
[
Gleich haben wir's, durchhalten
3
8 4
6
3
13
6
][ ] [ ] 6
2
8 1 = 13 3 8 0
Nun berechnet man die Systemdeterminante D so, wie es bereits im Beispiel für den BCH-Code gemacht wurde. Außerdem braucht man auch hier die drei Lösungsdeterminanten für die noch unbekannten Koeffizienten 2, 1 und 0. Man erhält:
[
3
8
4
D = 6
3
8
6
3
13
]
= 9 29 16 20 1717
= 9 14 1 5
150
= 10
3.7 Zyklische Codes und
[
6
D = 13 2 8
8
3 6
4
8 3
]
= 12 9 80 9 5 = 13
Nach Bestimmung der beiden restlichen Lösungsdeterminanten sieht das Ergebnis so aus: 2 =
D
2
D
=
13 3 = , 10
1 =
D D
1
=
10 = 1, 10
0 =
D
0
=
D
4 14 = 10
Das Polynom 3. Grades zur Bestimmung der Fehlerposition ist = x3 + 3x2 + x + 4
f(x) Die Drei von der Nullstelle
und die drei Nullstellen sind die gesuchten -Potenzen. Man findet sie wieder durch systematisches Suchen, indem man nacheinander alle Elemente des Erweiterungskörpers GF(24) einsetzt (also 0, 0=1, , 2, ..) und prüft, bei welchen drei Elementen sich 0 ergibt. Für unser Beispiel: x=0:
f(0)
= 4
x=0 =1:
f(0)
= 0 + 3 + 0 + 4
= 7
x=1:
f(1)
= 3 + 5 + 1 + 4
= 12
x=2:
f(2) = 6 + 7 + 2 + 4
.
. 7
x= : 10
x= : wertvoller Fehlerwert
=0
=0 !
.
.
7
21
17
7
10
30
23
10
4
f( ) = + + +
4
f( ) = + + +
=0 ! =0 !
Diesmal ist man mit diesem Ergebnis allerdings nicht fertig, da noch die Fehlerwerte ei, ej und ek zu bestimmen sind. Dieser Vorgang stellt aber keine großen Anforderungen mehr, denn bei der Festlegung des Fehlerpolynoms traten die Fehlerwerte e10, e7, e2 als Faktoren bei den Fehlerpositions-Elementen auf, die ihrerseits durch die soeben durchgeführte Rechnung bekannt sind. Dazu nimmt man 3 Syndrome und setzt sie den Fehlerpolynomen gleich: s1 = e()
= e10 10 + e7 7 + e2 2
= 4
s2 = e(2)
= e10 20 + e7 14 + e2 4
= 8
s3 = e(3)
= e10 30 + e7 21 + e2 6
= 3
Es ergibt sich also ein lineares Gleichungssystem 3.Ordnung in den Unbekannten e10, e7 und e2, was sich in ähnlicher Weise auflösen lässt, wie zuvor bei den Koeffizienten . In Matrixschreibweise:
151
3 Fehlerbeseitigung
[ Ziel erreicht, fertig!
][ ] [ ]
2
7
10
4
14
6
6
5 e7 0 e2
4
e10
8
=
3
Als Lösung erhält man schließlich die 3 gesuchten Fehlerwerte. Diese müssen an den Fehlerpositionen noch zum Empfangswort addiert werden. Damit ist die Korrektur beendet. e10 =
De D
10
=
10
11
1
=
14
= ,
e7 =
De
7
D
=
9 2 13 = = , 11
De 6 e2 = 2 = 11 = 5 = 10 D
Wie zu sehen ist, können die fehlerhaften Blöcke frei im Codewort verteilt sein, was die Bildung mehrerer längerer Blöcke oder eines einzigen besonders großen Blocks einschließt. Das kommt den Verhältnissen bei Speichermedien entgegen, wo häufig größere zusammenhängende Bereiche im mikroskopischen Sinne unbrauchbar sind, weil z. B. die bezahlbaren Fertigungsverfahren für magnetische Beschichtungen einfach keine lupenreine Zonen garantieren. In unserem Beispiel lässt sich also -- theoretisch -- auch ein 4-Bit- und ein 8-Bit- oder nur ein einziger 12-Bit-breiter Block korrigieren. Erzfeinde: Theorie Praktisch zerstören im ungünstigen Fall allerdings bereits 2-Bit-breiund Praxis te Fehlerbündel zwei Codewortstellen und 6-Bit-breite Blöcke drei Stellen, wenn sie zufällig auf den Codewort-Grenzen liegen, an denen sich die theoretisch durch das RS-Verfahren festgelegten Fehlerbündel natürlich nicht orientieren. Die sichere Korrekturleistung umfasst also entweder drei 1Bit-Fehler oder einen 1-Bit-Fehler und ein 2- bis 5-Bit-breites Fehlerbündel (warum 2 bis 5 Bit?) oder einen einzigen 6- bis 9-Bit-breiten Block. Der gezeigte Lösungsweg zur Bestimmung von Fehlerpositionen und Fehlerwerten gilt hier für den Fall von 3 Fehlerbündeln. Sind es weniger, was man ja nicht weiß, nehmen die System-Determinanten den Wert 0 an und man reduziert die Betrachtung auf den Fall von zwei Fehlerbündel oder nur von einem. Dies entspricht dem Vorgehen wie beim BCH-Code. Moderne Codier- und Decodier-Chips (Codecs) wie die der Baureihe AHA 401x oder AHA 4210 RSVP von comtech aha corporation arbeiten z. B. mit Reed-Solomon-Codes, die auf dem Galoisfeld GF(28) aufbauen. Ein solcher Körper hat mit dem definierenden
152
3.7 Zyklische Codes Polynom x8 + x7 + x2 + x + 1 KorrekturLeistungsträger
256 Elemente, womit schon sehr beachtliche Codewortlängen und Korrekturleistungen verwirklicht werden können, zumal jedes Element einen Block von 8 Bit darstellt. Die Codier/Decodierleistung beträgt z.Z. bis zu 100 MegaBit/s beim AHA 4013. Weitere Einzelheiten kann man den sehr informativen Internetseiten unter www.aha.com entnehmen.
Bild 3.16: Korrekturleistung eines (255, 239)-Reed-Solomon-Codes (dicke schwarze gestrichelte Linie). Der Verlauf wurde einem Datenblatt der Firma AHA entnommen. Kampf der Giganten
Eine – mit Vorsicht durchzuführende – vergleichende Sicht auf die Leistung eines solchen (255, 239)-RS-Codes für die Korrektur von 8 Fehlerbündeln der Breite 8 Bit (= 64 Bit) sowie der Inforate R = 0,94 und der bereits behandelten BCH-Codes ist in Bild 3.16 dargestellt. Zwar liegt dieser RS-Code bei beliebig statistisch verteilten Fehlern nicht besser als die dafür ausgelegten BCH-Codes, • aber er hat mit R = 0.94 eine wesentlich günstigere Inforate • und spielt außerdem seine Stärke bei den im praktischen Einsatz sehr viel häufiger auftretenden Fehlerbündeln voll aus. Dort ist er dem BCH-Code überlegen.
3.7.9
Vergleich zwischen BCH- und Reed-Solomon-Codes Für jedes Galoisfeld GF(2m) korrigiert der BCH-Code innerhalb seines durch die maximale Fehlerzahl t gegebenen Arbeitsbereiches beliebige, im Codewort verteilte 1-Bitfehlermuster, während dies beim Reed-Solomon-Code auf Fehlerbündel der Breite m beschränkt ist. Insofern lassen sich die beiden Codetypen nicht
153
3 Fehlerbeseitigung
Warentest
unmittelbar vergleichen, weil der BCH-Code ein größeres Fehlerspektrum abdeckt. Mit den im Unterkapitel 3.5.4 angestellten Überlegungen gibt es aber doch ein interessantes Unterscheidungsmerkmal, wenn man die Frage beantwortet, wie sich die Codes bei wachsender Länge n verhalten. Ein Weg, um die Code-Leistungen bei verschiedenen Längen zu beurteilen, besteht darin, die Korrektur-Rate jeweils konstant zu halten und die Informationsrate zu betrachten. Die Korrektur-Rate RKr ist das Verhältnis der in einem Codewort korrigierbaren Fehler der Anzahl t zur Codelänge n. Für den BCH-Code sieht das gemäß Tabelle 3-24 so aus: t
m
n=2m-1
k
Rkr = t/n
R =k/n
1
3
7
4
0,14
0,57
2
4
15
7
0,13
0,46
4
5
31
11
0,13
0,35
9
6
63
16
0,14
0,25
16
7
127
15
0,13
0,12
32
9
255
13
0,13
0,05
Tabelle 3-24: Kennzahlen von BCH-Codes verschiedener Länge bei konstanter Korrektur-Rate RKr BCH: Punkteabzug für lange Wörter
Bei in etwa gleich großen Korrektur-Raten nimmt die Informationsrate mit wachsender Codelänge dramatisch ab. Das wirkt sich bei jeweils gleicher Übertragungsrate der Infobits wegen der zu vergrößernden Kanalbandbreite und der damit wachsenden Störungen gegenläufig zur Zahl der korrigierbaren Fehler aus. Obwohl eine größere Codelänge n wegen der im Unterkapitel 3.5.2 beschriebenen der Fehlerverteilung für die Korrigierbarkeit der Codewortblöcke günstig ist, wird dieser Vorteil wegen der sinkenden Inforate wieder vernichtet. Der BCH-Code ist also asymptotisch (= für große Codelängen) schlecht. Anders verhält es sich beim Reed-Solomon-Code, wobei sich die Angabe für „t“ hier auf Fehlerbündel der Breite m bezieht und die jede der n Codewortstellen eine Anzahl von m Bits umfasst. Wie Tabelle 3-25 zeigt, bleibt die Inforate bei praktisch unveränderlicher Korrekturrate nahezu konstant, weshalb die Vorteile wachsender Codelänge im vollen Umfang in die Korrekturleistung eingehen. Der Reed-Solomon-Code ist asymptotisch gut.
154
3.7 Zyklische Codes Testsieger
Der RS-Code wird bevorzugt in technisch ausgeführten Codecs verwendet, z. B. in der schon erwähnten Serie AHA 401x von comtech aha corporation, sowie als Teilcode in den in Unterkapitel 3.12 beschriebenen Turbo-Produkt-Codes, für die es am Markt ebenfalls fertige Codecs gibt. Für höchste Übertragungsraten gibt es mittlerweile (Juni 2006) sogar den 40 GigaBit/s RSCodec AHA G709D-40 FEC Core. t
m
n=2m-1
k
Rkr = t/n
R =k/n
1
3
7
5
0,14
0,71
2
4
15
11
0,13
0,73
4
5
31
23
0,13
0,74
8
6
63
47
0,13
0,75
16
7
127
95
0,13
0,75
32
9
255
191
0,13
0,75
Tabelle 3-25: Kennzahlen von RS-Codes verschiedener Länge bei konstanter Korrektur-Rate RKr BCH: Spezialist Der BCH-Code ist deshalb aber nicht abgeschrieben. Wegen seiner für schwere Jungs speziellen Eignung für die Korrektur beliebiger Fehlermuster ist er als Teilcode in den z.Z. modernsten Codecs AHA 4702 für den Video-Standard DVB-S2 (Digital Video Broadcasting over Satellites) vorgesehen. Diese Codecs erreichen Übertragungsraten von bis zu 233 Mbit/s. Aufgrund der Aufgabenteilung innerhalb der Struktur des Gesamtcodes weist der BCH-Code mit dieser speziellen Eignung eine besondere Stärke auf.
3.7.10
Erkennung von Fehlerbündeln Bisher lag der Schwerpunkt unserer Aufgabe darin, geeignete Verfahren zur Fehlerkorrektur zu finden, während die bloße Fehlererkennung nur als ergänzende Leistung auftrat. Im Unterkapitel 3.6.3 wurde dazu ein erweiterter Hamming-Code betrachtet, mit dem man zugleich einen 1-Bit-Fehler korrigieren und einen 2-Bit-Fehler erkennen kann. Solche Codes sind für den Einsatz in Halbleiterspeichern sehr gut geeignet, weil sie bei geringem Aufwand sehr brauchbare Leistungen bei der Fehlerbehandlung erbringen. Etwas andere Verhältnisse findet man bei der Übertragung von Daten zwischen einem Sende- und einem Empfangsort. Hier kann es zu zufälligen Störungen kommen, die eine andere Fehlerstruktur nach sich ziehen. Ein Störimpuls auf einer Leitung,
155
3 Fehlerbeseitigung
Sieben auf einen Streich
welcher z. B. durch einen atmosphärischen Entladevorgang hervorgerufen wurde, verändert in erster Linie zusammenhängende Teile eines gerade übertragenen Informationsstromes, während zufällig verteilte Einzelfehler weitaus seltener sind. Die Länge des gestörten Bereiches im Informationsstrom hängt dabei noch von der Übertragungsgeschwindigkeit ab. Ein Beispiel: Wirkt auf einen Strom von 100 MegaBit/s ein Störimpuls über eine Zeit von 50 ns ein, dann sind hiervon 100 MegaBit/s ] 0.5]10-7 s = 5 Bits betroffen. Nehmen wir an, es werde soeben der folgende Bitstrom übertragen .... 1000110100000011011111110010010110011000001101011 .... und ein Störimpuls "kippe" die 5 als unterstrichen und fett markierten Stellen in den Zustand "1": .... 1000110100000011011111110011111110011000001101011 .... Dann ist hierbei ein Fehlerbündel der Länge 5 entstanden, wobei je nach der ursprünglichen Besetzung Teile oder auch alle Stellen des Fehlerbündels betroffen sein können. Bei einer Übertragungsgeschwindigkeit von 200 MegaBit/s würde der gleiche Störimpuls aber bereits 10 Stellen treffen ... 1000110100000011011111110011111111111000001101011 ....
Kleckern, nicht Klotzen
156
Man sieht, dass solche Fehlerbündel eine beträchtliche Anzahl von Stellen verfälschen und muss sich überlegen, wie sich diese Fehler mit möglichst geringem Aufwand beseitigen lassen. Naheliegend wäre es, nach unseren bisher gewonnenen Erkenntnissen ein passendes Fehlerkorrektur-Verfahren einzusetzen. Wahrscheinlich würde uns der zuvor behandelte Reed-SolomonCode einfallen, der sich ja besonders für die Behandlung von Fehlerbündeln eignet. Auch das Verfahren des im Unterkapitel 3.10 noch erläuterten Interleavings würde hier helfen, da sich hiermit die Fehlerbündel in kleinere Abschnitte „auseinander ziehen“ lassen Dennoch kann es im vorliegenden Fall unzweckmäßig sein, einen Fehlerkorrektur-Code einzusetzen, weil man das Ziel einer möglichst fehlerfreien Übertragung hier vielleicht auch mit wesentlich geringerem Aufwand erreichen kann. Korrigieren wird man in erster Linie dann, wenn einzelne Bits oder ganze Bereiche systematisch und unwiderruflich unbrauchbar sind, wie z. B. bei zerstörten Zellen in einem Halbleiterspeicher oder bei "Drop-Outs" in der Beschichtung von Magnetspeicher-Oberflächen. In solchen Fällen lassen sich Korrekturverfahren rechtfertigen, da man dadurch höhere Fertigungskosten für bessere Qualitäten vermeiden und Wartungsaufwendungen verringern kann. Bei der Daten-Übertragung liegen die Verhältnisse deshalb
3.7 Zyklische Codes Erneute Zustellung
kleines Geld – starker Service
anders, weil eine gesendete Nachricht in der Sendestelle solange aufbewahrt werden kann, bis sie nicht mehr benötigt wird. Wenn sich der Empfänger auf die bloße Erkennung von Fehlern beschränkt, kann er sich die Sendung so oft wiederholen lassen, bis eine unverfälschte Nachricht eingetroffen ist. Er braucht also nur ein geeignetes Hilfsmittel, welches ihm anzeigt, dass irgendetwas in der Nachricht verändert wurde, ohne wissen zu müssen, was dies ist. Dass der Aufwand zur reinen Fehlererkennung bedeutend kleiner ausfällt als zur Fehlerkorrektur, sieht man schon an den geringeren erforderlichen Hamming-Abständen der Codewörter. Ein Code zur Korrektur von t Fehlern Code muss einen MindestHammingabstand von d t 2·tkorr + 1 besitzen, ein solcher zur bloßen Erkennung von t Fehlern aber nur den viel kleineren von d t terk + 1
Das wirkt sich einerseits in einem wesentlich einfacheren Decodierverfahren für fehlererkennende Codes aus, andererseits erhöht sich vor allem auch deren Informationsrate. Gerade letzteres liefert einen angenehmen Beitrag zur Senkung der Übertragungskosten, da man eine – bei sonst gleichem Aufwand – höhere "Nutzlast" transportieren kann und geringere Kanalbandbreiten benötigt. Feind aller Fehler- Zyklische Codes eignen sich in besonderer Weise für die Erbündel kennung von Fehlern und Fehlerbündeln. Nehmen wir einen Code an, der mit dem Generatorpolynom g(x) gebildet wurde. Im Gegensatz zu den aufwändig zu konstruierenden Generatorpolynomen für fehlerkorrigierende Codes kann dieses hier ein beliebiges Teilprodukt des Kreisteilungspolynoms f(x) = xn - 1 sein. Ein Fehlerpolynom a(x) von kleinerem Grad als g(x) wird bei der Division des empfangenen Wortes w(x) durch g(x) mit Sicherheit erkannt, da es als Rest übrigbleibt: w(x)
= v(x)
+ a(x)
w(x) MOD g(x)
=0
+ a(x).
= q(x)·g(x) + a(x)
Ein Fehlerbündel kann aber auch jedes zyklisch verschobene Polynom xa(x), x2a(x), x3a(x), .... sein, sofern sein Grad denjenigen des Codewortpolynoms nicht übersteigt. So, wie jedes Polynom mit g(x) als Faktor immer ein Codewort darstellt, gilt auch die Aussage, dass jedes Polynom, was g(x) nicht enthält, kein Codewort ist.
157
3 Fehlerbeseitigung Zyklisches Verschieben heißt nie "Multiplikation mit g(x)", wenn für g(x) ein irreduzibles Polynom oder ein Produkt irreduzibler Polynome gewählt wurde. Ist also das Fehlerbündelpolynom aF(x) eines, welches aus einer zyklischen Verschiebung von a(x) hervorging, so gilt
Fehler erkannt, Fehler gebannt
w(x)
= v(x) + aF(x),
w(x) MOD g(x)
= 0 + aF(x) MOD g(x)
z0
Demnach erkennt man ein Fehlerbündel aF(x) sofort am Rest, allerdings kann man weder dessen Position noch dessen Wert angeben. Für ein Beispiel wählen wir einen 7-stelligen Code und benutzen das altbewährte Generatorpolynom g(x)
= x3 + x + 1
= 1011
Da es den Grad 3 hat und 4 Stellen besitzt, kann man damit 3stellige Fehlerbündel erkennen. Zwei mögliche Kandidaten sind a1(x) a2(x) Verschiebebahnhof
Alle Register ziehen
158
= x2 + x + 1 2
=x +1
= 0000111 = 0000101.
Diese Bündel lassen sich innerhalb eines 7-stelligen Codes genau 7-mal zyklisch verschieben. Die Modulo-Divisionen mit g(x) ergeben dabei folgende Reste: 0000111 MOD 1011 = 111
0000101 MOD 1011 = 101
0001110 MOD 1011 = 101
0001010 MOD 1011 = 001
0011100 MOD 1011 = 001
0010100 MOD 1011 = 010
0111000 MOD 1011 = 010
0101000 MOD 1011 = 100
1110000 MOD 1011 = 100
1010000 MOD 1011 = 011
1100001 MOD 1011 = 011
0100001 MOD 1011 = 110
1000011 MOD 1011 = 110
1000010 MOD 1011 = 111
Die Fälle in den beiden letzten Zeilen gehören dabei ebenfalls zur Menge der zyklisch verschobenen Fehlerbündel, stellen allerdings keine physikalischen Fehlerbündel dar. Die technische Ausführung sowohl der Codierung als auch der Decodierung ist sehr einfach: Man benötigt beim Sender und beim Empfänger je ein Schieberegister, welches im Rückkopplungszweig durch die Anordnung der „1“-Koeffizienten des Generatorpolynoms g(x) strukturiert ist, siehe auch Bild 3.12 auf Seite 109 im Unterkapitel 3.7.2. Dem Informations-Bitstrom wird beim Sender der Inhalt des Schieberegisters angefügt, dieser Inhalt stellt den Divisionsrest dar. Da hierdurch das ganze "Paket" durch g(x) teilbar gemacht wurde, braucht der Empfänger nur nachzusehen, ob bei der Division seines Empfangspaketes durch g(x) zum Schluß nur noch Nullen im Schieberegister stehen. Ist
3.7 Zyklische Codes
Nominierung der Besten
das der Fall, so nimmt er fehlerfreie Übertragung an, andernfalls fordert er vom Sender eine Wiederholung. Wegen der Bedeutung dieses einfachen Verfahrens hat man sich international auf einige wenige Generatorpolynome geeinigt, um einen übergreifenden Gebrauch zu erleichtern. So ist z. B. für die europäischen Postdienste das so genannte CRC-CCITT-Polynom vereinbart worden. In dieser Abkürzung bedeutet CCITT die Bezeichnung für den internationalen Postverband, CRC heißt Cyclic Redundancy Check und drückt aus, dass es sich um ein Fehlerprüf-Verfahren handelt, bei dem die notwendige Redundanzerhöhung des Informationspaketes durch Bildung eines zyklischen Codes entsteht. Das CRC-CCITT-Generatorpolynom hat den Grad 16 und den Aufbau: g(x) = x16 + x12 + x5 + 1
= 10001000000100001.
Wie man sich durch Division leicht überzeugen kann, setzt es sich aus zwei Anteilen zusammen: g(x) = (x15 + x14 + x13 + x12 + x4 + x3 + x2 + x1 + 1)(x + 1).
Super Leistungskatalog
Das Teilpolynom 15. Grades ist irreduzibel, man findet es z. B. in der Tabelle im Anhang des Buches von Peterson und hat dort die Oktalzahlen-Darstellung: 1700378okt. Es definiert ein primitives Element für den Erweiterungskörper GF(215). Dieses primitive Element hat die Ordnung ord =215 - 1, der zyklische Code besitzt damit 32767 Stellen (die aber nicht ausgenützt werden müssen). Welche Rolle spielt das Polynom (x + 1)? Ganz einfach: Es stellt im Codewort eine gerade Parität her, d. h. eine gerade Zahl von „1“-Bits. Fehler mit einer ungeraden Zahl von Einsen erzeugen im empfangenen Wort dann ebenfalls immer eine ungerade Parität und werden deshalb erkannt. Der mit diesem Generatorpolynom erzeugte Code hat also folgende Eigenschaften: • Man erkennt damit alle Fehlerbündel bis zur Breite von 16 Bits, da das Generatorpolynom den Grad 16 hat. • Man erkennt alle 1-Bit-Fehler (Sonderfall eines Fehlerbündels). • Man erkennt alle 2-Bit-Fehler, denn es gibt innerhalb des Codebereiches kein Polynom mit genau zwei von Null verschiedenen Stellen, welches g(x) als Faktor enthält. Nach dem schon mehrfach verwendeten Fermat'schen Theorem ist dies erst bei e(x)
= x32767 + 1
der Fall, weil dieses Polynom den Anteil
159
3 Fehlerbeseitigung x15 + x14 + x13 + x12 + x4 + x3 + x2 + x + 1
Gültig auf alle Fälle!
besitzt. Er gestattet die Erkennung aller Fehler mit einer ungeraden Zahl von Einsen. Diese Aussagen lassen sich auf der vollkommen sicheren Grundlage allgemeiner mathematischer Eigenschaften zyklischer Codes treffen. Die tatsächliche Länge eines Codes spielt daher überhaupt keine Rolle. Eine Überprüfung durch Berechnung aller (endlich vielen) Fälle ist weder notwendig noch durchführbar, es wären astronomisch großen Mengen zu durchforsten!
3.7.11
Was blieb?
•
1.
Woran erkennt man, dass sich bei Multiplikation von Info-Polynomen mit einem Generatorpolynom ein nicht systematischer zyklischer Code ergibt. 2. Ist jedes irreduzible Polynom über Z2 vom Grad m zur Bildung eines zyklischen Codes der Länge n = 2m – 1 geeignet? 3. Welche Eigenschaft muss ein irreduzibles Polynom über Z2 vom Grad m haben, damit es einen Code der Länge n = 2m – 1 zur 1-Bitfehlerkorrektur erzeugt? 4. Stellen Sie eine Tabelle der ersten 10 Elemente eines Galoisfeldes GF(28) auf, dessen Struktur durch das irreduzible Polynom 8. Grades vom RS-Codec von AHA gemäß Seite 152 gegeben ist. 5. Wie kann man feststellen, ob ein Generatorpolynom g(x) in der Lage ist, einen zyklischen Code zu erzeugen, der eine ausreichende Zahl unterscheidbarer Syndromwerte aufweist, um damit die gewünschte Anzahl von Fehlern korrigieren zu können? 6. Kann ein RS-Code prinzipiell auch beliebig im Codewort verteilte 1-Bitfehler korrigieren? 7. Aus welchen Teilpolynomen ist das Generatorpolynom aufgebaut, welches alle 1-Bit- und 2 Bit-Fehler sowie alle Fehlerbündel der Breite m=6 erkennbar macht? 8. Welche notwendige Bedingung muss ein Generatorpolynom für einen zyklischen Code erfüllen, mit dem 3 Einbitfehler korrigierbar sind? 9. Warum ist der BCH-Code asymptotisch schlecht, der RSCode asymptotisch gut? 10. Wie viele (nicht welche) irreduziblen Polynome über Z2 gibt es vom Grad m = 6?
160
3.8 Goppa-Code
3.8
Goppa-Code V.C. Goppa hat im Jahr 1970 einen Code veröffentlicht, der als Verallgemeinerung des BCH-Codes angesehen werden kann (Originalaufsatz in russischer Sprache: V.C. Goppa, "A New Class of Linear Error-Correcting Codes", Probleme Peredatshi Information (=Titel der Zeitschrift), Band 6, Seiten 24-30, Jahrgang 1970). Seine praktische Bedeutung für die Fehlerkorrektur ist – zur Zeit wenigstens – noch gering. Da das Verfahren zur Codeerzeugung aber eine interessante Ergänzung der schon bekannten Techniken darstellt und es auch für die später zu behandelnden Verschlüsselungsmethoden Bedeutung hat, ist ein Blick auf das Arbeitsprinzip nützlich. Im übrigen kann man den BCH-Code als zyklischen Spezialfall des im allgemeinen nicht-zyklischen Goppa-Codes betrachten.
3.8.1
Erzeugung der Codewörter Sehen wir uns zuerst an, wie man die Codewörter erzeugt, und beschränken uns dazu auf den binären Fall. Die Codelänge entspricht beim Goppa-Code der Anzahl von Elementen im gewählten Erweiterungskörper GF(2m). Ein Codewort v hat also 2m Elemente und kann z. B. als n-Tupel geschrieben werden: v = (v1 v2 v3 ........ vn)
Konkurrenz für BCH?
Wenn man wie gewohnt die höchste zu korrigierende Fehlerzahl mit t bezeichnet, so besteht die Grundidee darin, 2m verschiedene Polynome hi(z) über GF(2m) mit dem Grad t-1 zu finden und jedes einzelne mit einem solchen vi zu multiplizieren, dass die Summe m
n=2
z vh i i
= v 1h1 z v2h2 z ..... v nhn z
i=1
den Wert Null annimmt. Da die Polynome hi(z) den Grad t-1 haben, weist jedes einzelne davon genau „t“ Koeffizienten auf: hi(z) = hi,t-1·zt-1 + hi,t-2·zt-2 + ....... + hi,1·z + hi,0 . Für ein Beispiel wird das Galoisfeld GF(24) zugrunde gelegt, wobei die Codewörter die Länge n = 16 haben. Wenn man t=3 Fehler korrigieren können will, müssen 16 Polynome 2.Grades über GF(24) gefunden werden. Natürlich sind nur ganz bestimmte Polynome dafür geeignet und Goppa hat hierzu Berechnungsvorschriften angegeben. Wir nehmen uns diese Vorschriften etwas später vor und geben hier zunächst nur die ersten vier an (zur Erinnerung: die Koeffizienten E, E 2 usw. des GF(24) und deren Struktur findet man in der Tabelle 3-20 auf Seite 124):
161
3 Fehlerbeseitigung h1(z) =
z2
h2(z) =
2
z 8
h3(z) =
+
2
z
h4(z) = .
+1
z
z 9
+
3
+ 2
+ z 2
+ z
.
.
Summe cum Lau- Der obige Summenausdruck für die Polynome hi(z) lässt sich de auch als
n
n
n
n
t1 t2 vh i i, t1 z vh i i, t2 z ... vh i i ,1 z vh i i, 0=0 i=1
i=1
i=1
i=1
schreiben. Der Summenausdruck ist also selbst ein Polynom in z vom Grad t-1, welches in allen Koeffizienten die Codewortelemente vi enthält. Ein Polynom kann unabhängig von z nur dann den Wert Null annehmen, wenn alle Koeffizienten verschwinden. Mit einer entsprechenden Wahl der Codewortelemente v1, v2, ..., vn lässt sich das erreichen. Da „t“ Koeffizienten vorhanden sind, stehen t Gleichungen zur Verfügung, denen die Codewortelemente genügen müssen. Im vorliegenden Beispiel sind das 3, die sich mit Hilfe der Tabelle 3-16 zusammenstellen lassen. Für den Koeffizienten bei z2 gilt Parität im Koeffizientenpelz
v1
+ v2
+ 8 v3
+ v 4
+ 11v5
+ 2v6
+ 10v7
+ 7v8
+ 10v9
+ 4v10
+ 13v11
+ 5v12
+ 5 v13
+ 14v14
+ 10v15
+ 5v16 = 0
für den Koeffizienten bei z1 0v1 •
+ v2
+ 9 v3
+ 3v4
+ 14v5
+ 6v6
+ v7
+ 13v8
+ 2v9
+ 12v10
+ 7v11
+ v 13
+ 11v14
+ 8v15
+ 4v16 = 0,
v12
und für den Koeffizienten bei z0 = 1 gilt schließlich v1 •
+ 0v2
+ v 3
+ 2v4
+ 9v5
+ 4v6
+ v7
+ 3v8
+ 13v9
+ 8v10
+ 12v11
+ 14v13
+ 6v14
+ 7v15
+ 11v16 = 0 .
v12
Diese 3 Gleichungen sind nichts anderes als die bereits vom Hamming-Code her bekannten Paritätsgleichungen. Codewörter stellen demnach alle diejenigen Kombinationen der vi dar, für
162
3.8 Goppa-Code welche die Paritätsgleichungen erfüllt sind. Damit liegt ein lineares Gleichungssystem zur Bestimmung der Codewort-Elemente vi vor. Alle Rechenoperationen werden im GF(24) ausgeführt. Da die Informationen aber als Bits erscheinen, ist es wie schon beim Reed-Solomon-Code zweckmäßig, die binäre Polynomdarstellung für die E-Elemente gemäß Bild 3.17 zu verwenden:
Bild 3.17: Paritätsgleichung eines 16-stelligen Goppa-Codes im GF(24) in Matrizen-Schreibweise Wege durch's Dickicht
NutzlastTransporter
Wie erhält man hieraus eine Rechenvorschrift zur Bestimmung der Codewörter und wie viele Codewörter sind es? Antworten auf diese Fragen geben die mathematischen Standardverfahren. Nach Bild 3.17 liegen zur Bestimmung der 16 Codewortelemente vi insgesamt 12 Gleichungen vor, d. h., unser Gleichungssystem ist unterbestimmt. Denn mit 12 Gleichungen lassen sich natürlich immer nur 12 Unbekannte berechnen. Allerdings kann man die restlichen 4 willkürlich festlegen, sie sind dann eben nicht unbekannt. Genau das ist aber notwendig, da man auf jeden Fall auch frei wählbare Informationsanteile im Code unterbringen muss. Damit steht folgendes fest: Von den 16 Variablen können 4 vorgegeben werden, mit denen sich 24 = 16 Informationswörter erzeugen lassen. Das ist zugleich die Anzahl der Codewörter. Jetzt besteht die Aufgabe noch darin, diese Codewörter zu berechnen (sie werden übrigens für t=3 einen Mindesthammingabstand von d=7 haben). Um das Gleichungssystem in Bild 3.17 zu lösen, bringt man es zunächst auf obere Dreiecksform. Dazu wird aus der Matrix H durch elementare Zeilenoperationen MOD 2 eine obere Dreiecks-ähnliche Form erzeugt, die in Bild 3.18 mit H' bezeichnet ist (der Berechnungsvorgang ist an sich sehr einfach, es empfiehlt sich aber wegen der verhältnismäßig großen Zahl von Teilschritten, diese mühsame Arbeit einem Pro-
163
3 Fehlerbeseitigung gramm zu überlassen).
Bild 3.18: veränderte Paritätsgleichung gemäß Bild 3.17 auf obere Dreiecks-ähnliche Form Auf Biegen und Vertauschen
Wenn jetzt noch die Spalten 12 und 13 vertauscht werden, erhält man die echte obere Dreiecksmatrix H'' in Bild 3.19. Man beachte, dass durch den Spaltentausch auch die Codewortelemente v12 und v13 ihre Plätze wechseln und der Codewortvektor v in v' übergeht. Jetzt nimmt man die Elemente v12, v14, v15 und v16 als die 4 unabhängigen, frei wählbaren Informationsanteile. Dadurch werden für die Bildung der 12Y12-Systemmatrix des Gleichungssystems in der Matrix H'' die 4 letzten Spalten abgetrennt und auf die rechte Seite geschafft.
Bild 3.19: Paritätsgleichung in oberer Dreiecksmatrixform
164
3.8 Goppa-Code
Bild 3.20: Matrizengleichung zur Erzeugung eines Goppa-Codes im GF(24) von hinten her aufrollen
Das durch den Rest, nämlich durch die ersten 12 Spalten, gebildete Gleichungssystem lässt sich jetzt von der letzten Zeile her schrittweise lösen. Als Ergebnis erhält man die Generatormatrix G' in Bild 3.20, aus der sich durch Multiplikation mit den Informationsvektoren vi die 16 Codewortvektoren bilden lassen. Das Verfahren ist bereits vom Hamming-Code her bekannt. In Bild 3.21 sind die Codewörter v' aufgelistet. Man beachte, dass nach wie vor die Elemente v12 und v13 vertauscht sind.
Bild 3.21: Die 16 Codewörter des Goppa-Codes im GF(24)
165
3 Fehlerbeseitigung
Bild 3.22: Paritätskontrolle der 16 Codewörter Schon Lenin wusste: Vertrauen ist gut, Mißtrauen ist besser
Zur Kontrolle stellt man durch Multiplikation aller Codewörter mit der Paritätsprüfmatrix H (bei der gegenüber H die Spalten 12 und 13 vertauscht wurden) fest, dass tatsächlich jedesmal der Nullvektor herauskommt. In Bild 3.22 wurden dazu die Codewortvektoren aus Bild 3.21 zur transponierten Matrix V'T zusammengefasst. Genau genommen weiß man damit allerdings nur, dass man das Gleichungssystem richtig gelöst hat. Um festzustellen, dass die Codewörter auch wirklich einen Mindest-Hammingabstand von d=7 aufweisen, berechnet man, wie in Unterkapitel 3.7.5 für zyklische Codes gezeigt, das Gewicht der 4 Basiswörter, also derjenigen, die im Infoteil jeweils nur eine „1“ besitzen. Hier sind das v'(1), v'(2), v'(4) und v'(8), die alle die erforderlichen Gewichte von mindestens 7 aufweisen. ParitätsgleiNachdem nun bekannt ist, wie die Codewörter zu berechnen sind, chungen: Stars in muss noch geklärt werden, wie man zu den Paritätsgleichungen in der Manege Bild 3.17 kommt. In diesen liegt der eigentliche "Pfiff" des GoppaCodes. Ein wesentlicher Teil der Aufgabe besteht in der Bestimmung der 2m Polynome hi(z) vom Grad t-1. Goppa ging dabei von folgenden Überlegungen aus: • Ein Polynom mit t Koeffizienten hat den Grad t-1. In unserem Fall ist t=3, ein geeignetes Polynom hat also den Grad 2. • Ein Polynom (t-1)-ten Grades ist im GF(2m) immer ein so genanntes modulares inverses Polynom zum linearen Polynom (z - i) ersten Grades bezüglich eines Polynoms t-ten Grades. Die Bezeichnung i bedeutet hier willkürlich, aber ohne Einschränkung der Allgemeinheit: 1
166
= 0,
3.8 Goppa-Code •
Polynome – mal umgekehrt
•
i
= i-2
für i = 2, 3, 4, ......, 16
Zur Kennzeichnung von n Codewortbits werden n verschiedene ( = unabhängige) Polynome (t-1)-ten Grades benötigt, in unserem Fall also n=16. c(z) dient dazu, die bezüglich c(z) inversen Polynome hi(z) zu den linearen Polynomen (z – i) zu berechnen. Wie ist das zu verstehen? Mathematisch betrachtet heißt es nichts anderes, als dass der Ausdruck hi(z)(z – i) MOD c(z)
=1
gleich 1 ist. Von "normalen" Rechnungen her ist das bekannt: Wenn man eine Zahl mit ihrem inversen Partner multipliziert, kommt immer das Ergebnis 1 heraus. In endlichen Körpern Zp verhält es sich genauso, nur muss das Ergebnis der Multiplikation noch MOD p genommen werden. Im Z5 gilt etwa: 3Y2 MOD 5 = 1, also ist 2 das inverse Element zu 3 (aber nur im Z5 !), siehe auch Kapitel 3.2, Seite 37. Bei Polynomen über endlichen Körpern verhält es sich nicht anders. Sehen wir uns das am Beispiel unseres Codes an und wählen als Polynom c(z) c(z) = z3 + z + 1,
Euklids Wunderwaffe
welches in den 16 Elementen des GF(24) nach Tabelle 3-20 auf Seite124 tatsächlich keine Nullstellen hat (man prüfe das nach, indem man für z jedes der 16 „i“ einsetzt). Zur Berechnung des modularen inversen Polynoms hi(z) zu (z - i) bezüglich c(z) verwendet man den Euklidischen Algorithmus, siehe Kapitel 3.2, Seite 43 und bestimmt zunächst das größte gemeinsame Teilerpolynom. Das Ergebnis lässt sich hierfür bereits abschätzen, da die beiden Polynome so gewählt wurden, dass sie keine gemeinsamen Nullstellen haben, also teilerfremd sind. Dann muss ihr größtes gemeinsames Teilerpolynom ein Polynom nullten Grades, bzw. eine skalare Zahl sein. Mit der Festlegung r0 r1
= c(z)
= z3 + z + 1, =z–
i
ergibt die unten als Nebenrechnung angegebene Polynomdivision ein Restpolynom vom Grad 0: r2(z) Bewährte Rezepte
= 1 + i+
i
3
Der Euklidische Algorithmus wurde also im ersten Schritt bereits vollständig durchlaufen, so dass sich abkürzend schreiben lässt: c(z)
= q1(z – i) + r2(z).
167
3 Fehlerbeseitigung Nebenrechnung (Polynomdivision): + z+1 z3 __________________ z3
+ i z2
+ z
+ i z2
- i2z
:z–
i
= z2 + i z + (1 + i2) + h(z)
________________ (1+ i2)z + 1 (1+ i2)z + i(1+ i2) _______________ + 1+ i+
i
3
o Rest mit h(z)
Die Suche nach dem Inversen
= r2(z), = r2(z)/(z – i)
Zur Bestimmung des gesuchten inversen Polynoms teilt man die Gleichung des ersten Schrittes zunächst durch den Rest r2(z): c(z)r2(z)-1
= (z2 + i z + (1 + i2))r2-1(z – i) + 1
und bildet links und rechts MOD c(z). Dabei erhält man 1
= 1 MOD c(z) = (z2 + i z + (1 + i2))r2-1(z – i) MOD c(z)
wobei wegen der Charakteristik 2 im GF(24) die Vorzeichen nicht beachtet werden müssen. Man sieht, dass der Ausdruck Wertvoller Fund!
(z2 + i z + (1 + i2))r2-1 = h i(z) das gesuchte modulare inverse Polynom ist. Erweitert man die linke Seite oben und unten mit (z – i) und macht sich noch klar, dass der Rest r2 nichts anderes als der Wert des Polynoms c(z) an der Stelle z = i ist, so erhält man nach Ausmultiplikation von (z2 – i z + (1 – i2))(z – i)
= z3 + z – i –
i
3
= z3 + z + 1 - r2 die gleichwertige Darstellung hi z =
c z - c i c i -1 , 1 = 0, i = i-2 für i=2, 3, . .. , n . z - i
Man beachte, dass der Teilausdruck (c(z) – c( i)) immer eine Nullstelle in z = i besitzt, da bei Einsetzen von z = i der Wert 0 herauskommt. Er ist demnach durch (z - i) ohne Rest teilbar, und man erhält aus ihm umgekehrt das Polynom (z2 + iz + (1+i2)) vom Grad (t-1) = 2.
168
3.8 Goppa-Code pralle Fundgrube
Die Auswertung einer dieser beiden Darstellungen ergibt nun die 16 modularen inversen Polynome, welche in Tabelle 3-26 aufgelistet sind und bereits ausgiebig zur Bildung des Codes benutzt wurden. h1(z) =
z2
h2(z) =
2
z 8
+ 0z + 1 + z
+0
2
+ z+
2
+ 3 z + 2
h5(z) = 11z2
+ 14z + 9
h6(z) = 2 z2
+ 6 z + 4
h7(z) = 10z2
+
h3(z) = z h4(z) = z
7
2
9
z +1 13
h8(z) = z
+ z + 3
h9(z) = 10z2
+ 2 z + 13
h10(z) = 4 z2
+ 12z + 8
h11(z) = 13z2
+ 7 z + 12
h12(z) = 5 z2
+ z +1
h13(z) = 5 z2
+ z + 14
h14(z) = 14z2
+ 11z + 6
h15(z) = 10z2
+ 8 z + 7
h16(z) = 5 z2
+ 4 z + 11
Tabelle 3-26: modulare inverse Polynome im GF(24) zu (z - i) bezüglich des Polynoms c(z) = z3 + z + 1 Da man das modulare inverse Polynom hi(z) formal mit (z - i)-1 bezeichnen kann, lässt sich die Paritätsbeziehung auch sehr kompakt mit der Formel in Bild 3.22a beschreiben. n
v
zi MOD c z=0, i=1
Alles Gute ist einfach
1=0, i= i2
für i = 1, 2, ..... , n
i
Bild 3.22a: Kompaktdarstellung der Paritätsgleichung des GoppaCodes Man sieht – vielleicht nach anfänglichen Zweifeln – dass die Grundgedanken, auf denen der Goppa-Code aufbaut, letztlich einfach sind. Zwei große Schönheitsfehler gibt es im Vergleich zu den bisher untersuchten Codierungsverfahren aber doch: • Die Wahl des Polynoms c(z) ist innerhalb der gegebenen Grenzen (Teilerfremdheit zu (z - i) und Grad c(z) = t-1), willkürlich. Das heißt, dass mit größerem Umfang des Erweiterungskörpers
169
3 Fehlerbeseitigung GF(2m) und wachsender Anzahl zu korrigierender Fehler auch die Zahl wählbarer Polynome c(z) wächst, ohne dass ein technisch eindeutiges Kriterium vorhanden wäre, um ein ganz bestimmtes nehmen zu müssen. die Informationsrate R ist für kleine zu korrigierende Fehlerzahlen (< 100) geringer als etwa beim BCH-Code. Unser Beispiel aus Unterkapitel 3.7.7 bot für 3-Fehler-Korrektur bei einer Länge n=15 Platz für 5 Informationsstellen. Das entspricht einer Informationsrate von R = 33,3%, während wir bei unserem Goppa-Code nur über 25% verfügen. Der vergleichbare BCHCode transportiert also mit der gleichen Anzahl von Bits immerhin die Hälfte mehr an Informationen! Daher lohnt sich der Einsatz des Goppa-Codes eigentlich nicht, wenn man ausschließlich nur Fehler korrigieren will. Anders sieht es dagegen aus, wenn man ihn zum Verschlüsseln von Klartexten in Geheimtexte benutzt, siehe Unterkapitel 5.7. Hier stellt die willkürliche Wahlmöglichkeit für c(z) einen Zusatzvorteil für die "Verschleierung" dar, den man wie einen Geheimschlüssel gebraucht. Die weniger gute Informationsrate stört in diesem Zusammenhang ohnehin nicht so sehr.
BCH: Sieger nach Punkten
•
Goppa-Special: Geheimhaltung
•
3.8.2
Zwei Lösungswege für die Decodierung
Nun folgt ein Blick auf das Decodieren des Goppa-Codes. Es gibt hierfür zwei verschiedene Lösungswege, von denen der zuerst behandelte (hoffentlich) ein einfacheres Verständnis gestattet, während der zweite sich besser für die Abarbeitung mit Rechenprogrammen eignet, weil hier der Großteil der erforderlichen Operationen numerisch gelöst werden kann. Zwei Wege führen Zunächst betrachten wir noch die für beide Lösungen gemeinsam nach Goppa zugrunde zu legenden Ausgangsbeziehungen. Wie bisher üblich bezeichnet man den mit einem Fehlervektor e verfälschten Codewortvektor v als Empfangswortvektor w: w
=v+e
oder in Polynom-Schreibweise: n
wz = i=1
wi z i
n
MOD cz= i=1
vi zi
n
= i=1
ei zi
ei zi
MOD c z
MOD c z = s z
Eine Verfälschung erkennt man daran, dass diese Paritätsgleichung nicht mehr Null ist, was sie bei Fehlerfreiheit aber sein müsste. Da
170
3.8 Goppa-Code die Paritätsgleichung ein Polynom in z vom Grad (t-1)=2 darstellt, erhält man daraus nach Einsetzen der bekannten Empfangswortelemente wi (statt der unbekannten Codewortelemente vi) ein Syndrompolynom = s2 z2 + s1 z + s0
s(z) Wo liegt der Fehler?
Mit dessen Hilfe lassen sich die unbekannten Fehlerpositionen bestimmen. Dazu definiert man das Fehlerpositions-Polynom (z)
Partnervermittlung für das Syndrompolynom
= (z - j)Y(z - k)Y(z - l)
= z3 + 2z2 + 1z + 0
in welchem die Indices j, k und l die Fehlerpositionsnummern und j, k und l die zugehörigen Potenzen des primitiven Elements sind, also j = j usw. Das Syndrompolynom s(z) kennt man nur in der oben dargestellten Form s(z) = s2 z2 + s1 z + s0, da sich die Koeffizienten aus den empfangenen Elementen wi berechnen lassen. Die zuvor aufgestellte Summenschreibweise aus den Fehleranteilen ist dagegen in dieser Form nicht zugänglich! Allerdings erhält man ein sehr nützliches Ergebnis, wenn man das Syndrompolynom s(z) mit dem Fehlerpositions-Polynom (z) multipliziert: ei s z z= z jzk zl i= j ,k, l zi
= zk zl z jzl z jzk =
d z dz
= '
Ableiten ohne Dif- Das Produkt ergibt also nichts anderes als die Ableitung des ferenzieren Fehlerpositions-Polynoms nach dz. Hinweis: die Ableitung eines Produktausdruckes y(z)
= (z-a)(z-b)(z-c)
nach dz erfolgt nach der Produktregel y'(z)
= (z-b)(z-c) + (z-a)(z-c) + (z-a)(z-b).
Da man einerseits den Wert dieses Ausdrucks aus den zugänglichen Empfangswortelementen wi berechnen kann, nämlich
n
s z z =
w
z- i i=1
i
z3 2 z 2 1 z+ 0 MOD c z
andererseits aber auch die Ableitung '(z) kennt, also ' z = 3 z2 + 2 2 z + 1 = z2 + 1
171
3 Fehlerbeseitigung lässt sich hieraus eine Beziehung aufstellen, mit der die Fehlerpositionswerte i berechenbar werden. Man beachte dabei, dass bei der Bildung der Ableitung des Fehlerpositions-Polynoms wegen der Charakteristik p=2 alle Vielfachen von 2 verschwinden. Es ist:
n
s z z =
w
z- i i=1
i
z3 2 z 2 1 z+ 0 MOD c z
= z2 1
Das Syndrompolynom s(z) liegt nach Auswertung der „wi's“ auch in der Form s(z) = s2z2 + s1z + s0 vor, wobei die Koeffizienten s0, s1 und s2 ganz bestimmte Werte annehmen, welche von den aufgetretenen Fehlern abhängen. Daher lässt sich schreiben: s z z= s2 z2 s 1 z s0 z3 2 z2 1 z 0 MOD c z =z2 1
Die großen Unbe- Hierin sind nur die drei Koeffizienten des Fehlerpositions-Polykannten noms (z) unbekannt. Beim ersten Lösungsweg benutzt man einen Koeffizientenvergleich der in dieser Beziehung enthaltenen Polynome, um daraus ein lineares Gleichungssystem zu ihrer Bestimmung zu gewinnen. Zunächst multipliziert man das Syndrom-Polynom mit dem Fehlerpositions-Polynom: (s2 z2 + s1 z + s0)(z3 + 2 z2 + 1 z + 0) = s2 z5 + (s1+s2 2) z4 + (s0+s1 2+s2 1) z3 + (s0 2+s1 1+s2 0) z2 + (s0 1+s1 0) z + s0 0 . Divisionen marsch ins Gefecht!
Auf dieses Ergebnis wendet man die MOD c(z)- Funktion an, d. h., man sucht den Rest bezüglich c(z) = z3 + z + 1. Die dazu auszuführende Polynomdivision (negative Vorzeichen haben, wie immer im GF(2m), die gleiche Bedeutung wie positive, und man kann sich daher auf letztere beschränken) führt auf s(z)(z) : c(z)
= s2 z2 + (s1+s2 2) z+ (s0+s1 2+s2 1+s2) + Rest/c(z),
wobei der Rest ein Polynom 2.Grades in z darstellt: Rest
= [(s0+s2) 2 + s1 1 + s2 0 + s1 + s2] z2 + [(s1+s2) 2 + (s0+s2) 1 + s1 0 +s0 + s1 + s2] z + [s1 2 + s2 1 + s0 0 + s0 + s2].
172
3.8 Goppa-Code Tolle Vergleiche
Ein Beispiel sagt mehr als alle Theorie
Bei einem Koeffizientenvergleich mit dem abgeleiteten Fehlerpositions-Polynom '(z) = z 2 + 1 entsteht schließlich ein lineares Gleichungssystem 3.Ordnung in den Unbekannten 2, 1 und 0: (s0+s2) 2
+ s1 1
+ s2 0
= 1+ s1+ s2
(s1+s2) 2
+ (s0+s2) 1
+ s1 0
= s0+ s1+ s2
s1 2
+ (1+s2) 1
+ s0 0
= s0 + s2.
Wir überprüfen dieses Ergebnis mit Hilfe eines Beispiels und nehmen dazu an, dass gemäß Bild 3.21 das Codewort v'(3) gesendet wurde, welches aber mit einem 3-Bit-Fehler e verfälscht ist, so dass der Empfänger das Wort w
= v'(3) + e
erhält. Das Empfangswort w sieht dann folgendermaßen aus: v'(3)
= [1 1 1 1 0 1 0 0 1 1 0 1 0 0 1 1]
e
= [0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0]
__________________________________________ w
= [1 0 0 0 0 1 0 0 1 1 0 1 0 0 1 1].
Dieses Empfangswort wird von rechts an die Paritätsprüfmatrix H aus Bild 3.22 heran multipliziert, so dass das Syndromwort s
Gleichungen mit System
= [0 1 1 0 0 0 1 1 0 1 1 0]
entsteht, welches nach Zusammenfassung von je 4 Stellen gleichwertig auch als Syndrompolynom 2. Grades aufgefaßt werden kann. Da das Tupel 0110 die Polynom-Darstellung von 5 und das Tupel 0011 die von 4 ist (siehe Tabelle 3-20 auf Seite 124), haben wir als Syndrompolynom also s(z) = s2 z2 + s1 z + s0 = 5 z2 + 4 z + 5. Damit nimmt das Gleichungssystem die Form
[
][ ] [ ]
0
4
5
8
0
4 1 5 0
4
10
2
2
= 4 0
an. Die Lösung erfolgt wieder so, wie sie schon im Unterkapitel 3.7.7 für den BCH-Code beschrieben wurde. Die drei unbekannten Koeffizienten ermittelt man dabei als 2
= 10
1
= 11
0
= 3.
173
3 Fehlerbeseitigung Damit liegt auch das Fehlerpositions-Polynom (z)
= z3 + 10 z2 + 11 z + 3
vor, und man kann daraus die Nullstellen j, k und l bestimmen. Das geschieht am einfachsten durch systematisches Durchprobieren aller Elemente des GF(24). Ergebnis: (z) = 0 für z1
= 0
z2
= 1
z3
= 2.
Interpreten gesucht ...
Wie ist dieses Ergebnis zu interpretieren? Jede Nullstelle ist derjenigen Code-Elementposition zugeordnet, für die mit ihr das entsprechende modulare inverse Polynom berechnet wurde, siehe Bild 3.22a, siehe Seite 169. Das hört sich komplizierter an, als es ist. Der Wert "0" steht danach für die 1. Position, 0 für die 2. Position, 1 für die 3.Position, 2 für die 4. Position usw. Also sind im Beispiel die Fehler an der 2., 3. und 4. Stelle im empfangenen Wort w aufgetreten und können korrigiert werden. Erinnerung an Aufpassen muss man mit den vertauschten Stellen 12 und 13. vertauschte Rollen Durch die Vertauschung ist 10 für die Stelle 13 und 11 für die Stelle 12 "zuständig". Ein Beispiel: Angenommen, der Fehler kippe wieder 3 Bits, die folgendermaßen verteilt sind: e
= [0 0 0 0 0 1 0 1 0 0 0 1 0 0 0 0].
Das Syndrom liefert s
= [1 0 0 1 0 0 1 1 0 0 1 0]
und entspricht damit dem Syndrompolynom s(z)
= 14 z2 + 4 z + 1.
Die Auswertung auf dem beschriebenen Weg gibt das Fehlerpositions-Polynom (z)
= z3 + z2 + 1z + 6,
wozu die drei Nullstellen z
= 4
z
= 6
z
= 11
gehören. Diese wiederum entsprechen den Fehlerpositionen 6, 8 und 12 (nicht 13!). Die somit erarbeitete Lösung eignet sich zunächst nur für den Fall, dass genau 3 Fehler aufgetreten sind. Was aber passiert, wenn es nur 2 oder 1 Fehler sind? Dann lässt sich das Gleichungssystem, welches ja für den Fall von 3 Fehlern aufgestellt wurde, nicht mehr
174
3.8 Goppa-Code lösen, da weniger als 3 unabhängige Gleichungen vorliegen. Man erkennt das daran, dass die Systemdeterminante den Wert 0 annimmt. Dann müssen die abhängigen Gleichungen entfernt werden, oder man schaltet auf einen bereits vorbereiteten Lösungsalgorithmus für 2 Fehler um usw. ... damit die Fälle Man kann alles weiter vereinfachen, wenn man sich eine allgenicht wegmeine Lösung für lineare Gleichungssysteme beliebiger Ordnung schwimmen im GF(2m) aufbaut, was nach dem bisher Erarbeiteten nicht schwer fallen dürfte. Lästig bleibt bei diesem Vorgehen allerdings immer die Notwendigkeit, die Bildungsvorschriften für die System-Koeffizienten für jede Maximalzahl zu korrigierender Fehler und für jedes Polynom c(z) neu aufstellen zu müssen. Wenn dies auch stets ohne weiteres möglich ist, lohnt es sich doch, nach weiteren Verfahren zu suchen, die zur Entlastung beitragen. Es geht auch Der nun betrachtete zweite Lösungsweg ist hierfür ein interessanter, anders aussichtsreicher Kandidat und wurde von N.J. Patterson vorgeschlagen ("The Algebraic Decoding of Goppa Codes", IEEE Transactions on Information Theory, Volume IT-21, Nr.2, Kapitel V, Seite 207, März 1975). Das Verfahren geht von der bereits benutzten Beziehung s(z)(z) MOD c(z) Leckerbissen für unsere digitalen Freunde
= '(z)
aus und löst diese mit Hilfe des Euklidischen Algorithmus direkt, s.S. 43. Der Vorteil gegenüber dem ersten Lösungsweg liegt vor allem darin, dass er nicht so vieler Vorbereitungen bedarf und sich statt dessen in größerem Umfang numerisch – und damit auf einem Rechner – bearbeiten lässt. Patterson stellt zunächst fest, dass sich das Fehlerpositions-Polynom in der Form (z)
= (2 z2 + 0)
+ z(3 z2 + 1)
= 2(z)
+ z 2(z)
schreiben lässt, wobei der Koeffizient 3 im allgemeinen 1 ist. Beide Teilpolynome 2(z) und 2(z) enthalten nur geradzahlige Potenzen von z: 2(z)
=
12 z2 + 02
2(z)
=
12 z2 + 02.
Bei Bildung der formalen Ableitung nach z verschwinden diese Teilpolynome, da die geradzahligen Exponenten als Faktoren vor die Summanden wandern und bei MOD 2-Ausführung den Wert 0 annehmen. Deshalb ist '(z)
= 2' + z' 2(z) + z 2'(z) = 2(z).
Damit kann die obige Ausgangsbeziehung auch in der Form
175
3 Fehlerbeseitigung s(z)(z) MOD c(z)
= '(z) = s(z)( 2(z) + z 2(z)) MOD c(z) = 2(z)
Der EA und seine Inversen
geschrieben werden. An dieser Stelle sei daran erinnert, dass sich der Euklidische Algorithmus dann mit Vorteil einsetzen lässt, wenn man zu teilerfremden Polynomen das modulare inverse Polynom berechnen will. Dieses Prinzip lässt sich noch weiter "ausschlachten", wenn man nicht f(z) in s(z)f(z) MOD c(z)
=1
sondern (z) in s(z)(z) MOD c(z)
= 2(z)
sucht. Man läuft dann den Euklidischen Algorithmus nicht bis zu demjenigen Schritt durch, bei dem der Rest ein Polynom nullten Grades (eine "Zahl") ist, sondern beendet ihn bereits, wenn als Rest ein Polynom des Grades von 2(z) auftritt. Da die Lösung für einen vorgegebenen Polynomgrad eindeutig ist, wäre das dann die gesuchte. Man muss also c(z)
= q1(z)s(z) + r2(z)
berechnen, was numerisch ohne weiteres gelingt, da sowohl c(z) als auch s(z) vollständig bekannt sind. Eine kurze Überprüfung zeigt uns allerdings, dass wir mit dieser Ausgangsform unmittelbar noch nicht weiterkommen, da hier der Grad des Restpolynoms r2(z) wegen Grad s(z) = 2 nur kleiner als 2 sein kann, was im Widerspruch zur allgemeinen Form von 2(z) steht. Patterson macht daher zunächst eine passende Umformung und verwendet in dieser das modulare inverse Polynom f(z) zu s(z): s(z)f(z) MOD c(z)
= 1.
Muss sein: Saube- Man sieht, dass f(z) rein numerisch ermittelt werden kann, da re Vorbereitung das Syndrompolynom s(z) bekannt ist. Nun multipliziert man f(z) an f(z)s(z)(z) MOD c(z)
= f(z)s(z)( 2(z) + z 2(z)) MOD c(z) = 1( 2(z) + z 2(z)) MOD c(z) = f(z) 2(z)
heran und erhält nach Umstellung (f(z) + z) 2(z) MOD c(z)
= 2(z).
Nach den Rechenregeln für die MOD-Funktion ist (f(z) + z) 2(z) MOD c(z)
= ((f(z) + z) MOD c(z)) ( 2(z) MOD c(z)) MOD c(z) = 2(z),
176
3.8 Goppa-Code wobei sich für (f(z) + z) MOD c(z) auch das Quadrat eines Polynoms (z) einsetzen lässt (siehe Patterson, S. 207). Hinweis: Das Polynom (f(z) + z) enthält in seinen Koeffizienten zwar alle Informationen zur Fehlerposition, es ist im allgemeinen aber weder von seinem Aufbau her noch nach seinem Grad zur Weiterverwendung in dem eingeschlagenen Lösungsweg geeignet. Die nachstehend beschriebene Umformung ergibt eine passende Darstellung bei vollständigem Erhalt aller Informationen: (f(z) + z) MOD c(z)
= 2(z) MOD c(z).
Uff, ganz schön Dieses Hilfspolynom (z) kann immer eindeutig durch einen entviel, aber bald sprechenden Ansatz gibt es eine satte .. (z) = 2z2 + 1z + 0 gefunden werden. Die Quadrate 22, 12 und 02 der Koeffizienten ergeben sich als lineare Funktionen aus der obigen MOD c(z)-Beziehung. Mit 2(z)
= 22z4 + 12z2 + 02
kann diese als (f(z) + z) 2(z) MOD c(z)
= 2(z) 2(z) MOD c(z)
= 2(z)
geschrieben werden, und unsere Aufgabe hat sich in die Lösung von (z) (z) MOD c(z)
= (z)
verwandelt, da diese Form wegen ((z) (z) MOD c(z)) 2
= ((z) (z)) 2 MOD c(z) = (2(z) 2(z))2 MOD c(z) = 2(z)
... Aufwandsentschädigung
mit ihrer quadratischen "Schwester" gleichbedeutend ist. Nun lässt man den Euklidischen Algorithmus ablaufen und sucht denjenigen Schritt, bei dem sich als Restpolynom eines vom Grad (z) ergibt. Dann hat man ein Polynompaar gefunden, welches – in eindeutiger Weise – die Beziehung (z) (z) MOD c(z)
= (z)
erfüllt. Damit liegt auch das Fehlerpositions-Polynom (z) vor Hinweis: Das Rechnen mit Quadraten ist in Galoisfeldern GF(2m) deshalb vorteilhaft, weil es sowohl zu jedem Element eindeutig ein quadratisches Element gibt, als auch umgekehrt zu jedem Element eindeutig eine Wurzel existiert. Das wird hier ausgenutzt. Beispiele: (8)2 = 16 = 1, (3)-2 = (18)-2 = 9. Führen wir ein Beispiel aus und verwenden wieder unser Syndrompolynom für die bereits gemachte Annahme dreier Fehler. Es ist in diesem Fall
177
3 Fehlerbeseitigung s(z)
= 5 z2 + 4 z + 5.
1. Schritt Ein Beispiel, bitte! Das modulare inverse Polynom f(z) berechnet sich aus c(z) und s(z) als c(z)
= q1(z)s(z) + r2(z)
s(z)
= q2(z)r2(z) + r3(z)
usw., wobei c(z)
= (10z+9)s(z)
+ (13z+3)
s(z)
= (7z+4)(13z+3)
+ 13
ist. Die zweite Gleichung löst man nach 13 auf und multipliziert beide Seiten mit -13 = 2: 1
= -13s(z) - -13(7z+4)(13z+3).
Die erste Gleichung liefert r2(z)
= (13z+3) = c(z)
- (10z+9)s(z)
und dieses Ergebnis wird in die zweite Gleichung eingesetzt: 1
= -13s(z)
- -13(7z+4)(c(z) - (10z+9)s(z)).
Eine kleine Umformung ergibt 1
= -13(1 +(7z+4)(10z+9))s(z) - -13(7z+4)c(z)
und die MOD c(z)- Bildung auf beiden Seiten zeigt, dass mit f(z)
= -13(1 +(7z+4)(10z+9)) = 4z2 + 9z + 8
Bestätigung
tatsächlich das modulare inverse Polynom zu s(z) vorliegt. 2. Schritt Wir berechnen ein Polynom (z) so, dass 2(z) MOD c(z)
= f(z) + z
= 4 z2 + 7 z + 8
herauskommt. (Hinweis: Auf die rechte Seite f(z) + z muss in diesem Fall die MOD c(z)-Funktion nicht angewendet werden, da f(z) + z bereits einen kleineren Grad als c(z) hat). Versuchen wir dazu den Ansatz (z)
= 2z2 + 1z + 0 ,
was beim Quadrieren das Polynom 2(z)
= 22z4 + 12z + 02
ergibt. Nach MOD c(z)-Bildung erhält man
178
3.8 Goppa-Code (12+22)z2 + 22z + 02
= 4z2 + 7z + 8.
Ein Koeffizientenvergleich liefert
Schritt für Schritt
02
= 8
o 0 = 4
22
= 7
o 2 = 11
12
= 22 + 4 = 3
o 1 = 9 .
Das ist übrigens die einzige Stelle in diesem Algorithmus, an der "analytisch" gearbeitet werden muss, d. h. wo eine formale Rechnung auszuführen ist. Diese verlangt allerdings wesentlich weniger Aufwand als diejenige im ersten Lösungsweg. 3. Schritt Nun kann man den oben erwähnten Ausdruck (z) (z) MOD c(z)
= (z)
mit Hilfe des Euklidischen Algorithmus lösen. Dazu setzt man c(z)
= q1(z)(z) + r 2(z)
an und erhält mit
Der Charme des (Dienst-) Grades
(z)
= 11 z2 + 9 z + 4
z3 + z + 1
= (4 z+2)(11 z2+9 z+4) + (9 z+13)
im ersten Schritt als Rest bereits ein Polynom vom Grad (z) = 1 z + 0, so dass die Lösung r2(z) MOD c(z)
= c(z) MOD c(z) + q1(z)(z) MOD c(z) = q1(z)(z) MOD c(z)
die gesuchte sein wird. Damit stehen aber auch die beiden Teilpolynome (z)
= 9z + 13
(z)
= 4z + 2
und ihre Quadrate fest, so dass nun das Fehlerpositions-Polynom (z)
= 8 z3 + 3 z2 + 4 z + 11
entsteht. Da die Nullstellen eines Polynoms unabhängig von einem gemeinsamen Faktor in den Koeffizienten sind, können wir es noch mit -8 = 7 multiplizieren und erhalten das Ergebnis a(z)
= z3 + 10 z2 + 11 z + 3,
was genau dem auf dem ersten Lösungsweg ermittelten entspricht. Über die Nullstellen im GF(24) gibt es ebenfalls die Fehlerpositionen 2, 3 und 4 richtig an.
179
3 Fehlerbeseitigung Was passiert, wenn weniger als 3 Fehler aufgetreten sind, was aus dem Syndrompolynom nicht zu erkennen ist? Sehen wir uns zunächst den 1-Bit-Fehlerfall an, der das Codewort mit dem Fehler e Geht’s auch mit etwas weniger?
= [0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0]
verfälscht. Das Syndrompolynom ist dann = 8 z2 + 9 z + ,
s(z) wozu das inverse Polynom f(z) f(z)
=z+
gehört. Damit kann man im 2. Lösungsschritt aufsetzen und berechnet die Koeffizienten des Polynoms (z) als 02
=
22
=0
1
2
2
= 2 + 0 = 0
0
= 8
2
=0 = 0.
1
Das Hilfspolynom (z) = "entartet" hier also zu einem solchen Der Hilfssheriff und seine Grenze nullten Grades. Wenn man hiermit den Euklidischen Algorithmus ablaufen lässt, kommt man scheinbar nicht weiter, da 8
c(z)
= (c(z)-8)(z) + 0
entsteht. Damit gibt aber der Euklidische Algorithmus indirekt einen Hinweis, dass die Lösung von (z) (z) MOD c(z)
= (z)
ohne Bildung der MOD c(z)-Funktion zu finden ist, da in dem Ausdruck links gar keine Potenzen von z größer als 2 auftreten. Anders ausgedrückt heißt dies, dass man einfach einen unmittelbaren Koeffizientenvergleich der links und rechts stehenden Polynome durchzuführen hat: 8( 1 z + 0)
= 1 z + 0.
Da für die 4 unbekannten Koeffizienten nur 2 Bestimmungsgleichungen vorhanden sind, setzt man einen Koeffizienten willkürlich auf 0 und wählt dazu denjenigen, welcher im Fehlerpositions-Polynom (z) bei der höchsten z-Potenz steht, nämlich 1. Damit wird aber automatisch auch 1 = 0 und es bleibt 8 0
= 0.
Das Fehlerpositions-Polynom sieht nun so aus (z) ... und klappt ...
180
= 02 z + 02,
und man erkennt an seinem Grad, dass nur ein 1-Bit-Fehler aufgetreten war. Da man zur Nullstellenbestimmung einen gemeinsamen Faktor herausziehen darf, ohne an der Nullstelle etwas zu verändern, kann 0 willkürlich auf den Wert 1 gesetzt werden, und
3.8 Goppa-Code für den anderen Koeffizienten ergibt sich
02
= (1-8)2
= 14.
Die Nullstelle hat also den Wert = 1,
z0
was tatsächlich der 3. Position im Codewort entspricht. Für den Fall zweier 1-Bit-Fehler versuche man einmal, selbst die Lösung zu finden und gehe dazu z. B. vom Fehler e
= [0 0 1 0 0 0 0 0 1 0 0 0 0 0 0 0],
aus, der das Syndrompolynom s(z)
= 1 z2 + 11 z + 12
liefert. Kontrollinformationen und Hinweise: •
f(z) + z
= 1 z2 + 9 - 2
=12 ,
•
1
•
Man führe einen direkten Koeffizientenvergleich ohne MOD c(z)-Bildung durch (wie zuvor), da der Euklidische Algorithmus nicht auf eine verträgliche Lösung führt und damit ein "Signal" gibt.
•
Man setze 1 auf 0. Ergebnisse:
=,
1 = 1 (willkürlich), Grade, gerade und ungerade
=0,
8
0
0
= 4 ,
0
= 7 .
Allgemein gibt es Aussagen zum Grad, welchen die Polynome 2(z) und 2(z) gegenseitig aufweisen müssen, damit der Euklidische Algorithmus im 3. Lösungsschritt (nicht zu verwechseln mit einem 3. Schritt innerhalb des Euklidischen Algorithmus) ablaufen kann. Diese Aussagen lassen sich aus folgenden Überlegungen ableiten: • Ist die maximale Anzahl zu korrigierender Fehler ungerade (in unserem Beispiel ist n=3), dann stimmen die Polynomgrade überein, im Beispiel sind beide Polynome vom Grad 2. • Ist die maximale Anzahl zu korrigierender Fehler aber gerade, dann hat 2(z) einen um 2 höheren Grad als 2(z), oder – anders ausgedrückt – , der Grad von (z) ist um 1 höher als der von (z). Lässt man für (z) (z) MOD c(z)
= (z)
den Euklidischen Algorithmus ablaufen, so werden die Polynome q1(z) und r2(z) in der Beziehung
181
3 Fehlerbeseitigung c(z)
= q1(z)(z) + r 2(z)
diese Bedingungen einhalten, wenn sie Lösungskandidaten sind. Andernfalls signalisiert uns das Ergebnis, dass wir die MOD c(z)Funktion nicht ausführen müssen, wie wir es im Beispiel zuvor gesehen hatten. So etwa erhält man für den genannten 2-BitFehlerfall im ersten Schritt des Euklidischen Algorithmus mit c(z)
= (7 z2+11 z+9)(z) + 13,
ein Restpolynom r2(z) vom Grad 0 und ein Polynom q1(z) vom Grad 2, was zu einem direkten Koeffizientenvergleich veranlaßt. Damit sind zwei unterschiedliche Lösungswege bekannt, und wir schließen die Betrachtung des Goppa-Codes mit folgenden Bemerkungen ab: BCH-Code ist Spe- • Der BCH-Code entsteht als Sonderfall aus dem Goppa-Code, zialfall wenn man als erzeugendes Polynom c(z) einfach c(z)
•
3.8.3
Turbo-Lösung
182
= z2t
wählt, wobei t die Anzahl der zu korrigierenden Fehler darstellt. Diese Aussage werden wir im nächsten Unterkapitel noch etwas nutzen, um ein anderes und sogar schnelleres Decodierverfahren für BCH-Codes zu entwickeln. Goppa-Codes sind im allgemeinen nicht zyklisch aufgebaut.
Der BCH-Code als Sonderfall des Goppa-Codes Wir haben gesehen, wie man mit dem Verfahren von Goppa einen Code zur Korrektur von t Fehlern aufbauen kann. Das Kernstück ist dabei das erzeugende Polynom c(z), das man innerhalb weiter Grenzen frei wählen darf, solange es einen Grad von mindestens t besitzt und außerdem keine Nullstellen im gerade benutzten Erweiterungskörper aufweist. Diese Freizügigkeit muss man für den Zweck der Fehlerkorrektur allerdings als Schwäche betrachten, da keine eindeutigen Vorschriften bekannt sind, um ein Polynom für einen möglichst leistungsfähigen, sparsamen Code zu finden, wie es etwa das Generatorpolynom des BCH-Codes bietet. Deshalb bleibt der praktische Wert des Goppa-Codes in diesem Zusammenhang z. Z. gering. Auch der bereits gegebene Hinweis, dass sich der BCH-Code als Sonderfall des Goppa-Codes ergibt, wenn man als erzeugendes Polynom c(z) = z2t wählt, hilft nicht weiter, da wir mit der Codewörter-Erzeugung über das Generatorpolynom bereits ein sehr vorteilhaftes Verfahren gefunden haben. Einzig die Möglichkeit, zum "schnellen" Decodieren den Euklidischen Algorithmus nutzen zu können, lohnt es, den BCH-Code nochmals unter diesem Blickwinkel zu betrachten. Um hierfür ein geschlossenes
3.8 Goppa-Code Verständnis zu erreichen, musste dazu allerdings ein ziemlicher Umweg eingeschlagen werden. Der Erzeuger und Überzeugen wir uns zunächst an einem unserer Beispiele, dass sein Produkt die Behauptung "das Polynom c(z) = z2t ist ein erzeugendes Polynom des Goppa-Codes, welches einen BCH-Code aufbaut" tatsächlich stimmt. Wir bleiben dazu im GF(24) und nehmen wieder einen 3-Fehler-korrigierbaren Code, wobei nun c(z) = z6 sein muss. Da die allgemeine Berechnungsvorschrift aus Kapitel 3.8.1, Seite 168, für die modularen inversen Polynome hi(z) hi z =
c z - c i c i -1 , z - i
i = 1, 2, . .. ... , 2m .
auch das Element 1 = 0 enthält, c(0) aber ebenfalls den Wert 0 annimmt, muss man auf das Polynom h1(z) verzichten, da es in diesem Fall nicht definiert ist. h2
= 0z5
+ 0z4
+ 0z3
+ 0z2
+ 0z + 0
h3
= 9z5
+ 10z4
+ 11z3
+ 12z2
+ 13z + 14
h4
= 3z5
+ 5z4
+ 7z3
+ 9z2
+ 11z + 13
h5
= 12z5
+ 0z4
+ 3z3
+ 6z2
+ 9z + 12
h6
= 6z5
+ 10z4
+ 14z3
+ 3z2
+ 7z + 11
h7
= 0z5
+ 5z4
+ 10z3
+ 0z2
+ 5z + 10
h8
= 9z5
+ 0z4
+ 6z3
+ 12z2
+ 3z + 9
h9
= 3z5
+ 10z4
+ 2z3
+ 9z2
+ 1z + 8
h10
= 12z5
+ 5z4
+ 13z3
+ 6z2
+ 14z + 7
h11
= 6z5
+ 0z4
+ 9z3
+ 3z2
+ 12z + 6
h12
= 0z5
+ 10z4
+ 5z3
+ 0z2
+ 10z + 5
h13
= 9z5
+ 5z4
+ 1z3
+ 12z2
+ 8z + 4
h14
= 3z5
+ 0z4
+ 12z3
+ 9z2
+ 6z + 3
h15
= 12z5
+ 10z4
+ 8z3
+ 6z2
+ 4z + 2
h16
= 6z5
+ 5z4
+ 4z3
+ 3z2
+ 2z + 1.
Tabelle 3-27: Die 15 modularen inversen Polynome im GF(24) zu c(z) = z6 schöne Ausbeute
Es bleiben 15 modulare inverse Polynome übrig, deren mit den Codewortelementen vi gewichtete Summe die Paritätsgleichung
183
3 Fehlerbeseitigung 16
vh i i z
= 0
i=1
erfüllen soll. Die 15 modularen inversen Polynome lässt man sich am einfachsten über ein kleines Programm berechnen, das Ergebnis ist in Tabelle 3-27 angegeben. Verschwinden Sie! Damit die Paritätsgleichung erfüllt werden kann, muss die mit den Elementen vi gewichtete Polynomsumme für jeden ihrer 6 Polynomkoeffizienten verschwinden. Zur Verbesserung der Übersichtlichkeit "übersetzt" man die Elemente des GF(24) in die gleichwertigen Binärpolynome nach Bild 3.21, Seite 165, und erhält die 24 Paritätsgleichungen in Matrixform gemäß Bild 3.23 (für jeden der 6 Polynomkoeffizienten 4 binäre Gleichungen).
Lösungsmittel ....
184
Bild 3.23: Paritätsgleichungen des Goppa-Codes mit c(z) = z6 Dies erscheint ziemlich aufwändig, wenn man es mit dem 3-Fehler-korrigierbaren Goppa-Code aus Kapitel 3.8.1 vergleicht. Hier hatten sich nur 16 Paritätsgleichungen ergeben. Wenn man allerdings die Matrix H durch elementare Zeilenoperationen auf
3.8 Goppa-Code eine rechte obere Dreiecksform bringt (Spaltenoperationen sind in diesem Beispiel nicht erforderlich), wie es in Bild 3.24 geschehen ist, dann sieht man, dass die meisten Gleichungen linear abhängig und damit überflüssig sind. Das Gleichungssystem lässt sich so auf genau 10 Gleichungen vermindern. In der Darstellung mit den Elementen des GF(24) erkennt man das nicht, da die Elemente jeweils zwar 4 Gleichungen in der Binärdarstellung entsprechen, aber durch ihre innere Verkopplung nicht so freizügig "auseinander gezogen" werden können. Bitte endlich festlegen!
Es bleibt also die im Bild 3.25 dargestellte (1015)-Paritätsmatrix H'', mit der man die Generatormatrix G'' des Codes aufbaut. Die Überlegungen dazu sind die gleichen wie schon in Kapitel 3.8.1: Bei 10 unabhängigen Gleichungen und 15 Codewortelementen können 5 Elemente frei vorgegeben werden, um die restlichen 10 festzulegen. Mit diesen 5 Elementen lassen sich 32 Codewörter berechnen.
Bild 3.24: Paritätsgleichungen aus Bild 3.23, auf rechte obere Dreiecksform reduziert
185
3 Fehlerbeseitigung Da die Matrix H'' bereits in Dreiecksform vorliegt, ist das Vorgehen ganz einfach. Die ersten 10 Elemente v1, ..., v10 sind die festzulegenden, die letzten 5 v11, ..., v15 werden vorgegeben. Man beginnt in der letzten Zeile, in der nur das festzulegende Element v 10 steht. Daraus ergibt sich v10
= (v11 + v13 + v15) MOD 2.
In Zeile 9 kommt v9 hinzu, v9
= (v10 + v12 + v14) MOD 2 = (v11 + v12 + v13 + v14 + v15) MOD 2
usw.
Bild 3.25: Die auf 10 Gleichungen reduzierten Paritätsbeziehungen Stufenplan
Damit baut man schrittweise ein Gleichungssystem für die Codewortelemente v1, ....., v10 auf, was sich am übersichtlichsten anhand der Generatormatrix G'' sehen lässt, siehe Bild 3.26. Da jede Zeile der Generatormatrix, bzw. jede Spalte der transponierten Generatormatrix G''T) ein linear unabhängiger Codewortvektor ist, sind damit nebenbei schon 5 Basis-Codewörter gefunden, z. B.: v1
= u1 G''
= [0 0 0 0 1] G''
= [0 1 0 0 1 1 0 1 1 1 0 0 0 0 1]
v2
= u2 G''
= [0 0 0 1 0] G''
= [1 0 0 1 1 0 1 1 1 0 0 0 0 1 0]
usw. Weitere Codewörter entstehen daraus als Linearkombinationen. Natürlich erfüllen alle die Paritätsbeziehung H vT = H' vT = H'' vT = 0. Insbesondere gilt deshalb auch H'' G''T = 0 . Solche Codewörter sind etwa
186
v3
= u3 G''
= [0 0 0 1 1] G''
= [1 1 0 1 0 1 1 0 0 1 0 0 0 1 1]
v5
= u5 G''
= [0 0 1 0 1] G''
= [0 0 1 1 0 1 1 1 0 0 0 0 1 0 1]
v7
7
= [0 0 1 0 1] G''
= [1 0 1 0 1 1 0 0 1 0 0 0 1 1 1]
= u G''
3.8 Goppa-Code Enge Verwandte
Wenn man diese Wörter mit denjenigen vergleicht, die über das BCH-Code-Verfahren in Unterkapitel 3.7.2 berechnet wurden, so stellt man fest, dass der Code zwar nicht dieselbe Zuordnung zu den Informationswörtern hat, die Menge aller Codewörter aber insgesamt gleich ist. Vor allem ist dieser Sonderfall des Goppa-Codes zyklisch.
Bild 3.26: Generatormatrix für den (15,5)-Goppa-Code
Langer Weg, Ziel in Sichtweite
Beide Aussagen prüfen wir stichprobenweise. So geht z. B. v2 durch einen zyklischen Links-Schiebevorgang aus v1 hervor, v5 nach einem weiteren Schiebevorgang aus v2. Das Codewort v7 entsteht seinerseits durch zyklische Rechtsverschiebung aus v3 usw. Nachdem jetzt an einem Beispiel nachvollzogen wurde, dass der Goppa-Code im GF(24) mit dem erzeugenden Polynom c(z) = z6 tatsächlich den 3-Fehler-korrigierbaren BCH-Code im GF(24) ergibt, kann man versuchen, das angekündigte schnelle Decodierverfahren zu finden, dass auf der Lösung der schon verwendeten Beziehung s(z)(z) MOD c(z) = '(z) aufbaut. Das Syndrompolynom s(z) hat hier den Grad 5 und damit 6 Koeffizienten s0, ...., s6, die sich durch Auswertung der Paritätsgleichung nach Bild 3.24 berechnen lassen. Wegen der anderen Darstellungsweise in Matrixform gilt hier zunächst H wT
= H (v + e)T
187
3 Fehlerbeseitigung = H vT + H eT = 0 + H eT
= sT
mit dem Syndromvektor s. Dieser Vektor hat 24 Elemente, denen man von links nach rechts in 4-er Gruppen die 6 Polynomkoeffizienten von s(z) zuordnet. Ein Beispiel: v
= v7 = [1 0 1 0 1 1 0 0 1 0 0 0 1 1 1]
e
= [0 1 1 1 0 0 0 0 0 0 0 0 0 0 0]
w
= v7 + e = [1 1 0 1 1 1 0 0 1 0 0 0 1 1 1].
Das ergibt den Syndromvektor s und mit Hilfe der bewährten Tabelle 3-20 auf Seite 124 das Syndrompolynom s(z)
Ein Weg für alle Fälle
s
= [1101
0000 1101 1001 1001 1011]
s(z)
= 13 z5
+0 z4 +13 z3+14 z2+14 z1+7 z0.
In Unterkapitel 3.8.2 wurde festgestellt, dass der Grad des Fehlerpositions-Polynoms (z) und der Grad seiner Ableitung '(z) immer in bestimmten, von einander abhängigen Wertebereichen liegen müssen, damit eine Lösung für die genannte Gleichung überhaupt möglich ist. Hier liegen die Verhältnisse so: • Sind 3 Fehler aufgetreten, dann hat das Fehlerpositions-Polynom wegen (z) = 3z + 2 z2 + 1 z + 0 auf jeden Fall den Grad 3 und die Ableitung '(z) den Grad 2. Bei letzterer verschwindet außerdem immer der Koeffizient bei z1, da die Ableitung einer geraden Potenz im GF(2m) ein Vielfaches von 2 als Faktor enthält, was MOD 2 stets 0 ist. •
Sind 2 Fehler aufgetreten, dann hat (z) den Grad 2 und '(z) den Grad 0.
Ist 1 Fehler aufgetreten, dann hat (z) den Grad 1 und'(z) den Grad 0. Mit dieser Kenntnis durchläuft man nun schrittweise den Euklidischen Algorithmus: •
Der EA: Nie war er so wertvoll wie heute
c(z)
= q1(z)s(z)
+ r2(z)
s(z)
= q2(z)r2(z)
+ r3(z)
r1(z)
= q3(z)r3(z)
+ r4(z)
.
.
.
usw., bis sich ein Restpolynom ri(z) ergibt, welches eine der drei genannten Bedingungen für den Grad der Ableitung '(z) des
188
3.8 Goppa-Code Fehlerpositions-Polynoms aufweist (der Rechnungsgang selbst wurde in Kapitel 3.8.2 erläutert). Dann rechnet man mit den bis dahin ermittelten Multiplikatorpolynomen qj(z) (mit j = i-1, i-2, ......,2, 1) in der schon beschriebenen Weise zurück, bis man auf die Gleichung ri(z)
= '(z) = f [q1(z), q2(z), ..., qi-1(z)]s(z) + g [q1(z), q2(z), ..., qi-1(z)]c(z)
kommt. Die Modulbildung bezüglich c(z) führt auf f [q1(z), q2(z), ..., qi-1(z)]s(z) MOD c(z)
= ri(z)
und deshalb ist der Polynomausdruck f(z) bei s(z) f [q1(z), q2(z), ..., qi-1(z)]
= (z),
wenn eine der oben angegebenen Bedingungen bezüglich des Grades erfüllt wird. Universell: Schieb- Der Vorteil dieses Lösungsweges liegt einmal darin, dass sich der register Euklidische Algorithmus hier rein numerisch abarbeiten lässt, zum anderen die Auswertung besonders einfach mit Hilfe eines Schieberegisters erfolgen kann, welches nach den Rechenregeln des GF(24) arbeitet. Ein solches Schieberegister ist zwar aufwändiger, jedoch nicht schwieriger als im Z2. Führen wir nun unser begonnenes Beispiel weiter. Der Euklidische Algorithmus startet bei der Gleichung c(z)
= z6 = (2z+0)s(z)
+ (0z4+1z3+1z2+9z1+0)
und wird mit den Schritten s(z)
= (13z +14)r2(z)
+ (8z3+4z2+6z1+7)
r2(z)
= (7z +13)r3(z)
+ (7z2+0z1+5)
fortgeführt. Die Betrachtung des Restes r4(z) = 7z2 + 0z1 + 5 zeigt, dass die Bedingung für 3 Fehler aufgetreten sein könnte, da der Grad der Ableitung '(z) dann 2 wäre und außerdem der Koeffizient bei z1 gleich 0 ist. Die Rückrechnung ergibt (z)
= (q1(z) + q1(z)q2(z)q3(z) + q3(z)) = 7z3 + 3z2 + 5z1 + 13
und r4(z) ist offensichtlich die Ableitung hierzu. Also liegt eine Lösung der Gleichung s(z)(z) MOD c(z) keine Fehlstellen mit Nullstellen
= '(z)
vor (diese Lösung ist sogar eindeutig), mit der die Nullstellen des Fehlerpositions-Polynoms ermittelt werden können. Diese sind
i
= 1
189
3 Fehlerbeseitigung
Ein Weg für alle Fälle
j
= 2
k
= 3.
Wie sieht es aus, wenn nur 2 Fehler aufgetreten sind? Nehmen wir als Beispiel e
= [0 0 0 1 0 0 0 0 1 0 0 0 0 0 0]
(wobei es unnötig ist, hierauf noch einen Codewortvektor v zu addieren, da der von diesem erzeugte Anteil im Syndromvektor ja ohnehin verschwindet). Das ergibt folgenden Syndromvektor s bzw. folgendes Syndrompolynom s(z): s
= [0000
s(z)
= 0z
0111 0101 0000 0011 0100]
5
+10 z4+8 z3 +0 z2 +4 z1 +2 z0.
Speist man damit den Euklidischen Algorithmus, so erhält man im ersten Schritt = (5 z2 + 3 z + 1)s(z) + 3.
c(z) Beste Bedingungen
Eine Überprüfung ergibt, dass von den 3 oben genannten Fehlerbedingungen diejenige für 2 Fehler bereits in diesem ersten Schritt erfüllt ist. Das Fehlerpositions-Polynom lautet demnach = 5 z2 + 3 z + 1
(z)
und die Nullstellen sind i
= 3
j
= 8.
Nun noch ein Beispiel, wo der 1-Bit-Fehler e
= [0 0 0 0 0 1 0 0 0 0 0 0 0 0 0]
auftrat. Er führt auf folgenden Syndromvektor s bzw. auf folgendes Syndrompolynom s(z): s
= [0001
s(z) ... und immer wieder: EA
0 5
= z
0110
0111
5 4
10 3
+ z
+ z
0000 0 2
+ z
0110 0111] +5z1 +10z0.
Auch hier liefert bereits der erste Schritt des Euklidischen Algorithmus die Lösung: c(z)
= (0 z + 5)s(z)
+ 0.
Von den 3 Fehlerbedingungen trifft offenbar diejenige für einen 1-Bit-Fehler zu. Das Fehlerpositions-Polynom lautet demnach (z)
= z + 5
mit der Nullstelle
190
i
= 5
3.8 Goppa-Code
Zu viele Fehler: Ende der Fahnenstange
Zum Abschluss eine letzte Frage: Was passiert, wenn mehr als 3 Fehler aufgetreten sind. Hier lassen sich folgende Fälle unterscheiden: • Einige Fehleranordnungen können das gesendete Codewort v so verändern, dass ein anderes gültiges Codewort v' entsteht, nämlich dann, wenn der Fehler e zufällig selbst ein Codewort ist. Die Linearkombination zweier Codewörter ergibt wegen deren Zugehörigkeit zu einer mathematischen Gruppe immer ein weiteres Codewort (siehe Unterkapitel 3.4.1). Anhand unserer Beispiele ist das gut zu erkennen. So ergibt die Summe von v1 und v2 das Codewort v3: v1 + v2
= [0 1 0 0 1 1 0 1 1 1 0 0 0 0 1] + [1 0 0 1 1 0 1 1 1 0 0 0 0 1 0] = [1 1 0 1 0 1 1 0 0 1 0 0 0 1 1]
Täuschungsversuch
•
= v3.
Kein Decodierverfahren der Welt ist dann in der Lage, dies zu erkennen. Wie oft kann so etwas eigentlich eintreten? Bei unserem (15,5)-Code sind 215 Empfangswörter möglich, aber nur 25 als Codewörter zulässig. Nimmt man das Nullwort aus, das natürlich keinen wirklichen Fehler darstellt, so bleiben für e genau 25 - 1 Möglichkeiten. Da alle denkbaren Fehler ihrerseits in 215 - 1 Varianten auftreten können, beträgt die theoretische Wahrscheinlichkeit (25-1)/(215-1) | 2-10, ist also kleiner als 1/1000. Die praktische Wahrscheinlichkeit sollte allerdings bedeutend geringer sein, was durch die Technologie sicherzustellen wäre. Anders ausgedrückt wird man den Code so wählen, dass das Auftreten von mehr Fehlern, als mit dem Verfahren korrigierbar, so gut wie ausgeschlossen bleibt. Weiterhin kann es sein, dass dem Decodierverfahren "vorgetäuscht" wird, es wären Fehler in einer korrigierbaren Anzahl aufgetreten. Dieser Fall tritt ein, wenn sich der Fehler so interpretieren lässt, als wäre er aus einem zulässigen Codewort v' und einer korrigierbaren Anzahl von Einzelfehlern entstanden. Dann baut sich das Empfangswort w aus w = v + e = v + (v' + e') = v'' + e'
•
auf und wird fälschlicherweise als Codewort v'' decodiert. (Übrigens hat der Fehler e dann ein Gewicht von wenigstens 4 (also 4 Einsen), denn jedes Codewort (außer dem Nullwort) enthält mindestens 7 Einsen (Mindest-Hammingabstand für 3Fehler-Korrigierbarkeit d = 23 + 1 = 7), was bei Addition eines 3-Bit-Fehlers im ungünstigsten Fall 4 Einsen ergibt, meistens natürlich mehr). Alle anderen Fehler führen bei der Verwendung des daraus entstehenden Syndrompolynoms s(z) im Euklidischen Algorithmus zwar auf eine der oben genannten verträglichen Fehlerbe-
191
3 Fehlerbeseitigung dingungen, das Fehlerpositions-Polynom (z) hat im GF(24) dann aber keine Nullstellen, so dass sich Fehler nicht korrigieren lassen. Ein Beispiel mag diesen Sachverhalt ein wenig erläutern. Wir gehen von einem 4-Bit-Fehler e
= [0 1 1 1 1 0 0 0 0 0 0 0 0 0 0]
aus, der den Syndromvektor s und das Syndrompolynom s(z) s s(z)
= [0001 0 5
= z
0111 0100 0001 0010 0101] +10 z4+2 z3 +0 z2 +1 z1 +8 z0.
erzeugt. Der Euklidische Algorithmus wird also mit c(z)
= z6 = (0 z+10)s(z)
+ (1 z4+11 z3+8 z2+7 z1+3)
gestartet und setzt sich mit s(z)
= (14 z+0)r2(z)
+ (12 z3+13 z2+5 z1+8)
r2(z)
= (4z +12)r3(z)
+ (3 z2+0 z1+11)
fort. Im dritten Schritt ergeben sich für (z)
= (q1(z) + q1(z)q2(z)q3(z) + q3(z) = 3 z3 + 4 z2 + 11 z + 3
'(z)
= r4(z)
= 14
Mehr Fehler: manchmal erkennbar
verträgliche Bedingungen, so dass man annehmen könnte, es seien 3 Fehler aufgetreten. Keines der 15 nutzbaren Elemente (0 ausgeschlossen) ist aber eine Nullstelle des FehlerpositionsPolynoms (z). Daraus schließt man das Auftreten von mehr als 3 Fehlern. Insgesamt steht jetzt ein Verfahren zur Decodierung von BCH-Codes zur Verfügung, welches tatsächlich besonders einfach arbeitet und dem im Unterkapitel 3.7.7 beschriebenen überlegen ist. Einen kleinen Wermutstropfen muss man dennoch schlucken: Bei einem BCH-Code zur Korrektur von t Fehlern sind hier doppelt so viele Syndromwerte zu berechnen, ob man das nun über die Paritätsmatrix H oder direkt aus den Paritätsgleichungen im GF(2m) heraus macht. Trotzdem werden die Vorteile überwiegen. Adamek erläutert übrigens im Kapitel 13 seines Buches das Verfahren in allgemeiner Form. Wir begnügen uns mit den geschilderten Grundgedanken, die bereits wesentliche Gesichtspunkte enthalten.
3.9
Reed-Muller-Code Nach all den doch sehr mathematisch geprägten Gedanken zur Erzeugung und Decodierung von zyklischen Codes und GoppaCodes soll nun noch – gewissermaßen zur Entspannung – ein Blick auf einen vollkommen anders arbeitenden Code geworfen
192
3.9 Reed-Muller-Code
Mathe-Wellness pur
Generator-Vollmacht auch hier
werden, der mit einfachster Mathematik auskommt und dennoch recht wirkungsvoll ist, den Reed-Muller-Code. Er geht von einer direkt aufstellbaren Generatormatrix G aus. Die Decodierung der Empfangswörter erfolgt nicht etwa über das vertraute Syndrom, sondern über eine andere pfiffige Technik. Daher gibt es beim Reed-Muller-Code auch keine Paritätsbeziehungen im bisher gebrauchten Sinn. Schauen wir uns zunächst die Erzeugung der Codewörter an und wählen dazu einen Code zur Korrektur von maximal 3 Fehlern. Hierfür eignet sich ein solcher der Länge n = 24 = 16. Die Generatormatrix besteht aus 5 Zeilen, die einen ganz charakteristischen Aufbau haben. Man betrachtet jede Zeile als Zeilenvektor, der mit r bezeichnet und mit dem Index 0 beginnend durchnummeriert wird. Der Erste, also r0, soll lauter "1"-Elemente haben, der Zweite hat abwechselnd "0"- und "1"-Elemente, der Dritte besitzt abwechselnd zwei "0"- und zwei "1"-Elemente usw. Dieses Prinzip lässt sich bis zum 5.Vektor r4 fortführen und man erhält r0
= [1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1]
r1
= [0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1]
r2
= [0 0 1 1 0 0 1 1 0 0 1 1 0 0 1 1]
r3
= [0 0 0 0 1 1 1 1 0 0 0 0 1 1 1 1]
r4
= [0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1].
Diese 5 Vektoren bilden nun die Zeilen der Generatormatrix G für einen Reed-Muller-Code der Länge 16. Die Codewörter erhält man, ganz ähnlich wie beim Hamming-Code, indem man die Informations-Zeilenvektoren u von links mit der Generatormatrix multipliziert (natürlich auch hier immer MOD 2). Da die Informationsvektoren die Länge 5 haben, lassen sich 25 = 32 Codewörter erzeugen. Schauen wir etwas genauer auf das Ergebnis. Die Informationsvektoren weisen den allgemeinen Aufbau u
= [u0 u1 u2 u3 u4]
auf, jedes Element hierin hat wegen v
= u G
genau einen Partner in der Generatormatrix, mit dem es multipliziert wird. Da die Multiplikation mit 0 immer 0 ergibt, die Multiplikation mit 1 aber das entsprechende Element ui selbst belässt, kann man den Berechnungsvorgang eines Codewortvektors auch so sehen, dass man den Generatormatrix-Elementen ihre zugehörigen Informationsvektor-Elemente zuweist und anschließend die Spaltenelemente von G zu den Codewortelementen aufaddiert, wie es Bild 3.26 zeigt.
193
3 Fehlerbeseitigung Durch den Aufbau der Generatormatrix sind bestimmte Informationsvektor-Elemente über einzelne Gleichungen nun immer mit bestimmten Codevektor-Elementen verknüpft. Für die MOD 2Summe der ersten beiden Codevektor-Elemente gilt etwa v1 + v2 Aufbauplan
= 2 u0 + u1
= u1.
Die Summe von v1 und v2 ergibt also das InformationsvektorElement u1. Das trifft auch für die Summe der beiden Empfangsvektor-Elemente w1 und w2 zu, wenn – und das ist der springende Punkt – w1 und w2 fehlerfrei übertragen wurden, denn dann wäre deren Summe ebenfalls gleich u1: w1 + w2
= v1 + v2
= 2u0 + u1
= u1.
Beim Auftreten von Fehlern trifft das nicht mehr zu: w1 + w2
= v1 + v2 + e1 + e2
= 2u0 + u1 + e1 + e2 = u1 + e1 + e2.
raffinierte Mehrheitsentscheidungen
Je nachdem, ob ein oder zwei Fehler passierten, führt deren Wirkung zu einer Verfälschung des Ergebnisses oder sie hebt sich auf (MOD 2 -Addition!). v
= [v1 v2 v3 v4 v5 v6 v7 v8 v9 v10 v11 v12 v13 v14 v15 v16] = [u0 u0 u0 u0 u0 u0 u0 u0 u0 u0 u0 u0 u0 u0 u0 u0] + [0 u1 0 u1 0 u1 0 u1 0 u1 0 u1 0 u1 0 u1] + [0 0 u2 u2 0 0 u2 u2 0 0 u2 u2 0 0 u2 u2] + [0 0 0 0 u3 u3 u3 u3 0 0 0 0 u3 u3 u3 u3] + [0 0 0 0 0 0 0 0 u4 u4 u4 u4 u4 u4 u4 u4].
Bild 3.26: Aufbau eines (16,5)-Reed-Muller-Codewortes aus den Informationsvektor-Elementen Wegen dieser Unsicherheit nützt die genannte Beziehung allein also noch gar nichts. Sehen wir aber weiter. Die Summe der Codevektor-Elemente v3 und v4 ergibt ebenfalls u1, da sich die beiden neu hinzugekommenen Anteile u2 gerade wieder aufheben: w3 + w4
= v3 + v4
= 2u0 + 2u2 + u1
= u1.
Mit Fehlern e3 und e4 wäre die Lage allerdings wieder so unbestimmt wie zuvor. Das gilt genauso für die restlichen 6 Gleichungen, die man zur Bestimmung von u1 aufstellen kann, nämlich die Summen
194
w5 + w6
= v5 + v6
= 2u0 + 2u3 + u1
= u1
w7 + w8
= v7 + v8
= 2u0 + 2u2 + 2u3 + u1 = u1
3.9 Reed-Muller-Code w9 + w10
= v9 + v10
= 2u0 + 2u4 + u1
= u1
w11 + w12
= v11 + v12
= 2u0 + 2u2 + 2u4 + u1
= u1
w13 + w14
= v13 + v14
= 2u0 + 2u3 + 2u4 + u1
= u1
w15 + w16
= v15 + v16
= 2u0 + 2u2 + 2u3 + 2u4 + u1 = u1.
Bisher wurden damit 8 unsichere Gleichungen für u1 gefunden. Unsicherheit erzeugt Sicherheit Doch so unsicher sind sie gar nicht! Es gilt nach wie vor die Festlegung, dass höchstens 3 Fehler auftreten können. Schlimmstenfalls sind dann nur 3 der 8 Gleichungen betroffen. Wenn man also die 16 Empfangswort-Elemente paarweise addiert, so muss derjenige Wert der richtige für das Element u1 sein, der am meisten vorkommt. Der Grundgedanke ist folgender: Jedes Codewortelement vi enthält • immer das Element u0, • eine Kombination je eines der Elemente u1, u2, u3, u4, • und hiervon abhängig bis zu 4 "0"-Elemente. Wenn man nun diejenigen Codewortelemente vi addiert, die ein bestimmtes Informationsvektor-Element nur einmal, die anderen aber zweimal enthalten, dann ergibt sich eine Anzahl von Bestimmungsgleichungen für dasjenige Informationsvektor-Element uj, welches nur einmal vorkommt. Natürlich kann man diesen Weg genauso auch zur Bestimmung anderer Elemente beschreiten. Für u2 etwa sind die Elemente v1 und v3 zu addieren: w1 + w3
= v1 + v3
= 2u0 + u2
= u2.
Ähnliches trifft für v2 und v4 zu: w2 + w4
= v2 + v4
= 2u0 + 2u1 + u2
w6+w8,
w9+w11, .....
= u2,
oder für w5+w7, Spezialbehandlung für u0
Bei u3 nimmt man w1 und w5 usw., man prüfe das selbst nach. Nur zur Bestimmung von u0 eignet sich dieses Verfahren nicht, da es in jedem Summanden genau einmal vorkommt und sich wegen der geraden Anzahl immer aufhebt. Doch auch hierfür gibt es eine einfache Lösung. Da die Elemente u1, ....., u4 bereits ermittelt wurden, lässt sich deren Anteil aus dem Empfangswortvektor beseitigen: w'
=w
- u1r1
- u2r2
- u3r3
- u4r4
=v+e
- u1r1
- u2r2
- u3r3
- u4r4
= u0r0
+u1r1
+u2r2
+u3r3
+u4r4 + e
195
3 Fehlerbeseitigung - u1r1 = u0r0
Leute, bringt Beispiele!
- u2r2
- u3r3
- u4r4
+e.
Die erste Zeile der Generatormatrix G, Seite 193, ist der nur mit "1" besetzte Zeilenvektor r0, das Produkt u0 r0 enthält daher ohne Fehlereinwirkung 16 mal das Element u0. Wenn maximal 3 Fehler auftreten, ist auch hier eine Mehrheitsentscheidung für den Wert von u0 möglich. Mit diesem einfachen Verfahren lässt sich jedes mit höchstens 3 Fehlern verfälschte Empfangswort zum richtigen Codewort decodieren. Sehen wir uns gleich wieder ein Beispiel an. Zum Informationswort u
= [1 0 1 1 1] = [u0 u1 u2 u3 u4]
gehört das Codewort v, welches mit dem Fehler e zum Empfangswort w verfälscht wird: v+ e = [1 1 0 0 0 0 1 1 0 0 1 1 1 1 0 0] + [0 1 0 0 0 1 0 0 0 0 0 0 0 1 0 0] ________________________________________ = [1 0 0 0 0 1 1 1 0 0 1 1 1 0 0 0]
= w.
Nach unserem Schema bestimmt man aus den Elementen von w zunächst je 8 Werte für u1, u2, u3 und u4, wie in Bild 3.27 angegeben ist. Danach ist noch u0 zu berechnen. Dazu bildet man w'
= w - u1r1 - u2r2 - u3r3 - u4r4 = [1 0 0 0 0 1 1 1 0 0 1 1 1 0 0 0] - [0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0] - [0 0 1 1 0 0 1 1 0 0 1 1 0 0 1 1] - [0 0 0 0 1 1 1 1 0 0 0 0 1 1 1 1] - [0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1] = [1 0 1 1 1 0 1 1 1 1 1 1 1 0 1 1].
Die Mehrheit hat immer recht
Der Mehrheitswert bei den Elementen von w' ist „1“ und damit liegt auch u0 fest. Das gesendete Informationswort muss demnach u
= [1 0 1 1 1]
gewesen sein. Zugleich erkennt man an den "0"-Elementen in w' die Fehlerpositionen, was aber im allgemeinen weniger interessiert.
196
3.9 Reed-Muller-Code Für u2
Für u1
Für u3
Für u4
w1+w2
=1,
w1+w3
=1,
w1+w5
=1,
w1+w9
=1
w3+w4
=0,
w2+w4
=0,
w2+w6
=1,
w2+w10
=0
w5+w6
=1,
w5+w7
=1,
w3+w7
=1,
w3+w11
=1
w7+w8
=0,
w6+w8
=0,
w4+w8
=1,
w4+w12
=1
w9+w10
=0,
w9+w11
=1,
w9+w13
=1,
w5+w13
=1
w11+w12
=0,
w10+w12
=1,
w10+w14
=0,
w6+w14
=1
w13+w14
=1,
w13+w15
=1,
w11+w15
=1,
w7+w15
=1
w15+w16
=0,
w14+w16
=0,
w12+w16
=1,
w8+w16
=1
____________________________________________________________ Mehrheit:
=0
=1
=1
=1
Bild 3.27: Bestimmung der Informationswort-Elemente u1, u2, u3 und u4 aus dem Empfangswort w pfui, nicht systematisch ... ... doch Decodieren kaum zu toppen
Mehrheits-Steuer
Man erkennt hier, dass der Reed-Muller-Code offenbar ein nicht systematischer Code ist, da die Informationsstellen innerhalb der Codewörter keine festen Plätze besitzen. Das geschilderte einfache Decodierverfahren zur Fehlerkorrektur lässt sich bequem und schnell mit kleinen Maschinensprache-Programmen bearbeiten. Es werden für die arithmetischen Operationen nur XOR- und Schiebebefehle benötigt, zur Feststellung der Mehrheitswerte reichen die vorhandenen Byte- oder DoppelbyteAdditionen aus. Der hier betrachtete 3-Fehler-korrigierbare (16,5)-Code hat eine Informationsrate R = 31.25%. Diese lässt sich ohne Nachteile noch verbessern, wenn man bei den Codewörtern z. B. die letzte Stelle weglässt. Der (16,5)-Code weist nämlich einen Mindest-Hammingabstand d = 8 auf und kann daher nicht nur zur Korrektur von 3 Fehlern, sondern zusätzlich noch zur Erkennung von 4 Fehlern genutzt werden. Wenn man die Fehlererkennung nicht benötigt und eine Stelle streicht, erhält man einen (15,5)-Code mit R = 33.33%. Warum funktioniert das so einfach? Um einen Mehrheitswert eindeutig bestimmen zu können, ist eine gerade Anzahl von Gleichungen nicht notwendig, es genügt eine ungerade Zahl. Da jedes Empfangswortelement jeweils nur einmal in einem Gleichungssatz vorkommt, macht man durch Streichen eines solchen Elements nur eine einzige der 8 Gleichungen unbrauchbar, so dass 7 übrigbleiben. Durch eine solche Maßnahme wird der (15,5)-ReedMuller-Code genauso leistungsfähig wie der (15,5)-BCH-Code aus Unterkapitel 3.7.7 – aber Vorsicht, diese Feststellung gilt zunächst
197
3 Fehlerbeseitigung nur für den 3-Fehler-korrigierbaren Code. Zyklische Codes bieten eine wesentliche größere Freiheit bei der Wahl von korrigierbarer Fehlerzahl t und Länge n. Allerdings konnten wir dazu – nur auf unser Beispiel gestützt – für den Reed-Muller-Code bisher noch keine Aussage machen. Vielseitig ? Es stellt sich daher die Frage, ob sich Reed-Muller-Codes – z. B. für Na, ja ..... die Codelänge n=16 (oder n=15) – auch für 2- oder 1-Fehler-Korrektur herstellen lassen. Um dies beantworten zu können, muss die Bildungsvorschrift verallgemeinert werden. Bisher haben wir 5 linear unabhängige Basisvektoren r0, r1, ...., r4 genommen und diese als Zeilen der Generatormatrix G auf Seite 193 verwendet. Es lassen sich aber weitere unabhängige Basisvektoren erzeugen und so die Generatormatrix vergrößern. Damit kann man auch längere Informationsvektoren einsetzen, allerdings, wie immer, auf Kosten der Anzahl korrigierbarer Fehler. Die Basis macht's Wie erzeugt man solche zusätzlichen unabhängigen Basisvektoren? Indem man spezielle Vektorprodukte aus den bereits vorhandenen Vektoren bildet. Ein derartiges Vektorprodukt ist durch die elementenweise Multiplikation der beiden Faktoren festgelegt. Da wir im Z2 arbeiten, heißt das nichts anderes, als beide Vektoren durch die logische UND-Funktion zu verknüpfen, und dies sieht z. B. für r1 und r2 folgendermaßen aus: r1 r2
= [0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1] [0 0 1 1 0 0 1 1 0 0 1 1 0 0 1 1] = [0 0 0 1 0 0 0 1 0 0 0 1 0 0 0 1].
Es entsteht also eine ähnlich gleichmäßige Anordnung wie schon bei der Festlegung der ersten 5 Basisvektoren. An dieser Stelle erkennt man auch, dass die Einbeziehung von r0 nicht sinnvoll ist, da die UND-Verknüpfung mit einem "1"-Vektor immer nur eine Kopie des anderen Faktors herstellt. Mit r1r3, r1r4, r2r3 .... usw. erhält man insgesamt 6 neue Basisvektoren, so dass nun für die Generatormatrix deren 11 zur Verfügung stehen:
198
r0
= [1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1]
r1
= [0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1]
r2
= [0 0 1 1 0 0 1 1 0 0 1 1 0 0 1 1]
r3
= [0 0 0 0 1 1 1 1 0 0 0 0 1 1 1 1]
r4
= [0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1]
r1 r2
= [0 0 0 1 0 0 0 1 0 0 0 1 0 0 0 1]
r1 r3
= [0 0 0 0 0 1 0 1 0 0 0 0 0 1 0 1]
3.9 Reed-Muller-Code r1 r4
= [0 0 0 0 0 0 0 0 0 1 0 1 0 1 0 1]
r2 r3
= [0 0 0 0 0 0 1 1 0 0 0 0 0 0 1 1]
r2 r4
= [0 0 0 0 0 0 0 0 0 0 1 1 0 0 1 1]
r3 r4
= [0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1].
Wenn man der Definition folgt, so findet man noch die Basisvektoren r1r2r3, Vektorgerüst
Ordnungshüter
r1r2r4,
r1r3r4,
r2r3r4,
r1r2r3r4,
die an dieser Stelle aber nicht benötigt werden. Dass die neu hinzugekommenen 6 Basisvektoren linear unabhängig sind, sieht man, wenn man sie – zusammen mit den anderen – durch Zeilentausch in eine Reihenfolge bringt, bei der die jeweils führenden "1"-en in der ersten Zeile an erster Stelle, in der zweiten Zeile an zweiter Stelle stehen, usw. Eine solche Form enthält dann nur linear unabhängige Zeilen. In unserer Anordnung ist sie durch die Reihenfolge r0
= [1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1]
r1
= [0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1]
r2
= [0 0 1 1 0 0 1 1 0 0 1 1 0 0 1 1]
r1 r2
= [0 0 0 1 0 0 0 1 0 0 0 1 0 0 0 1]
r3
= [0 0 0 0 1 1 1 1 0 0 0 0 1 1 1 1]
r1 r3
= [0 0 0 0 0 1 0 1 0 0 0 0 0 1 0 1]
r2 r3
= [0 0 0 0 0 0 1 1 0 0 0 0 0 0 1 1]
r4
= [0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1]
r1 r4
= [0 0 0 0 0 0 0 0 0 1 0 1 0 1 0 1]
r2 r4
= [0 0 0 0 0 0 0 0 0 0 1 1 0 0 1 1]
r3 r4
= [0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1].
gegeben. Den ersten Vektor r0 (er ist nur mit "1"-en besetzt) nennt man denjenigen nullter Ordnung. Nimmt man ihn allein als "Generatormatrix", so erhält man offensichtlich den (16,1)-Wiederholungscode, mit dem sich 7 Fehler korrigieren lassen, der aber nur die schlechte Informationsrate R = 1/16 = 6.25% besitzt. Zusammen mit den 4 Vektoren r1, r2, r3 und r4 ergibt sich der ReedMuller-Code erster Ordnung, den wir schon kennengelernt hatten und mit dem sich 3 Fehler korrigieren lassen. Die nächsten 6 Vektoren, nämlich die Zweierprodukte r1r2, r1r3, ....., erzeugen den Reed-Muller-Code zweiter Ordnung. Mit diesem kann man einen Fehler korrigieren. Das Verfahren läuft ganz ähnlich ab. Wegen der 11 Basisvektoren in der Generatormatrix G hat jeder Informations-
199
3 Fehlerbeseitigung vektor ebenfalls 11 Elemente: u Bauplan: genial einfach
= [u0 u1 u2 u3 u4 u12 u13 u14 u23 u24 u34].
Die tiefgestellten Indices verweisen auf den Zusammenhang mit den zugeordneten Basisvektoren. Jeder Codewortvektor setzt sich daraus gemäß Bild 3.28 zusammen. v
= [v1 v2 v3 v4 v5 v6 v7 v8 v9 v10 v11 v12 v13 v14 v15 v16] = [u0 u0 u0 u0 u0 u0 u0 u0 u0 u0 u0 u0 u0 u0 u0 u0] + [0 u1 0 u1 0 u1 0 u1 0 u1 0 u1 0 u1 0
u1 ]
+ [0 0 u2 u2 0 0 u2 u2 0 0 u2 u2 0 0 u2 u2] + [0 0 0 0 u3 u3 u3 u3 0 0 0 0 u3 u3 u3 u3] + [0 0
0 0 0 0 0 0 u4 u4 u4 u4 u4 u4 u4 u4]
+ [0 0 0 u12 0 0 0 u12 0 0 0 u12 0 0 0 u12] + [0 0 0 0 0 u13 0 u13 0 0 0 0 0 u13 0 u13] + [0 0 0 0 0 0 0 0 0 u14 0 u14 0 u14 0 u14] + [0 0 0 0 0 0 u14 u14 0 0 0 0 0 0 u14 u14] + [0 0 0 0 0 0 0 0 0 0 u24 u24 0 0 u24 u24] + [0 0 0 0 0 0 0 0 0 0 0 0 u34 u34 u34 u34] Bild 3.28: Aufbau eines (16,11)-Reed-Muller-Codewortes aus den Informationsvektor-Elementen Mathematik? Nein, danke!
Für das Decodieren sucht man sich wieder passende Gleichungen, die ein Informationselement in ungerader Zahl, die anderen in gerader Zahl enthalten. Der erste Kandidat ist offenbar das Element u12. Es taucht im vierten Codewortelement v4 auf. Eine passende Menge von Empfangswort-Elementen sind die ersten vier, da in der daraus gebildeten MOD 2-Summe das Element u12 bei Fehlerfreiheit als einziges übrigbleibt: w1 + w2 + w3 + w4
= v1 + v2 + v3 + v4 = 4u0 + 2u1 + 2u2 + u12
= u12.
Auch die nächsten vier Empfangswort-Elemente sind geeignet: w5 + w6 + w7 + w8
= 4u0 + 2u1 + 2u2 + 4u3 + 2u13 + 2u14 + u12
= u12
usw. Man erhält 4 Gleichungen zur Bestimmung von u12, wobei jedes der 16 Empfangswortelemente nur ein einziges Mal erscheinen darf. Da höchstens ein Fehler auftritt, kann auch nur eine einzige
200
3.9 Reed-Muller-Code Gleichung hiervon einen falschen Wert liefern. Eine Mehrheitsbetrachtung wird demnach den richtigen Wert erbringen. Zur Bestimmung von u13 eignen sich die Beziehungen w1 + w2 + w5 + w6
= 4u0 + 2u1 + 2u3 + u13
= u13,
w3 + w4 + w7 + w8
= 4u0 + 2u1 + 4u2 + 2u3 + 2u12 + u13
= u13
usw. Hat man auf diese Weise auch u14, u23, u24 und u34 gefunden, so zieht man, ähnlich wie beim vorhergehenden Beispiel, deren Anteile aus dem Empfangsvektor heraus: w'
= w
- u12r12 - u13r13 - u14r14 - u23r23 - u24r24 - u34r34
=v+e
- u12r12 - u13r13 - u14r14 - u23r23 - u24r24 - u34r34
= Gerade? Ungerade? Das reicht ....
Ordnung zählt
+ u0r0 + u1r1 + u2r2 + u3r3 + u4r4 .
Dadurch "behält" man nach Bild 3.28 nur noch die ersten 5 Zeilen und kann die restlichen 5 Elemente genauso ermitteln, wie es im ersten Beispiel gemacht wurde - allerdings mit einem kleinen Unterschied: Bei der Annahme, dass 3 Fehler auftreten können, mussten die jeweils 8 Gleichungen für jedes Element auch alle berücksichtigt werden. Hier geht man aber von höchstens einem Fehler aus, so dass auch nur 4 Gleichungen benötigt werden, z. B. immer die ersten 4. Für u1 sind das w1 + w2,
Konkurrenz für BCH?
e
w3 + w4,
w5 + w6,
w7 + w8.
Wir beenden dieses Beispiel hiermit, werden unsere Erkenntnisse daraus jedoch noch ein wenig verallgemeinern: • Ein Reed-Muller-Code hat die Länge n = 2m mit m = 1, 2 ,3 ,4, ..... Er gestattet die Korrektur einer bestimmten Anzahl von „t“ Fehlern und die Erkennung von (t+1) Fehlern. Er ist weder zyklisch noch systematisch. • Ein um eine Stelle verkürzter Reed-Muller-Code hat die Länge n = 2m -1. Er gestattet die Korrektur der gleichen Anzahl von „t“ Fehlern wie beim Code mit der Länge n = 2m, jedoch keine Erkennung von (t+1) Fehlern. Dafür hat er eine etwas bessere Informationsrate R. Er ist zyklisch (bitte prüfen), jedoch nicht systematisch. • Die Anzahl „t“ der korrigierbaren Fehler wird beim ReedMuller-Code durch die Länge n und die Ordnungszahl ordRM festgelegt. Damit ist auch die Zahl der Basisvektoren in der Generatormatrix G sowie die Anzahl der Informationsstellen im Vektor u gegeben. Bei ordRM = 0 wird nur der Basisvektor r0 verwendet. Bei ordRM = 1 kommen m weitere Basisvektoren hinzu, deren Elemente spaltenweise zusammengenommen die Binärzahlendarstellung von 0 bis 2m - 1 wiedergeben. Bei ordRM = 2 werden alle Zweierprodukte rirj der m Basisvektoren r1, ..., rm einbezogen (ausgenommen die Quadrate, weil ri2 = ri ist).
201
3 Fehlerbeseitigung Bei ordRM = 3 sind zusätzlich alle Dreierprodukte rirjrk dabei, usw. Der Mindest-Hammingabstand d wird durch die (immer gerade Zahlen ergebende) Beziehung d = 2
Streichkonzert
m ordRM
bestimmt. Da für die Fehler-Korrektur ein ungerader Hammingabstand ausreicht, sieht man übrigens auch an dieser Beziehung, dass eine Codewortstelle gestrichen werden kann. Wegen d = 2
mordRM
mordRM
2t 1
t 2
1 2
ist die Anzahl korrigierbarer Fehler ("halbe" Fehler gibt es natürlich nicht) t = 2
mordRM
1
Die Anzahl k der Basisvektoren bzw. der nutzbaren Informationssymbole berechnet sich aus ord
k =
i=1
m i
Bei m=4 und n = 16 gilt z. B.:
BCH-Code leicht vorn
202
ordRM
t
k
Bemerkung
0
7
1
-
1
3
5
-
2
1
11
-
3
0
15
hier ist d = 2, daher 1 Fehler erkennbar
4
0
16
hier ist d = 1, daher keine Fehlererkennung, sondern nur Unterscheidung der Codewörter
Wir haben gesehen, dass das "Bauprinzip" des Reed-Muller-Codes auf äußerst einfachen Grundgedanken beruht und sich damit sehr leistungsfähige Codes erzeugen lassen, die mit den zyklischen Codes vergleichbar sind. Da man aber weder die Zahl t korrigierbarer Fehler, noch die Länge n so freizügig wie bei diesen wählen kann, wird der Einsatz des Reed-Muller-Codes nur dort sinnvoll sein, wo der Schwerpunkt auf einer möglichst einfachen Decodierung liegt.
3.9 Reed-Muller-Code Adamek verweist in seinem Buch darauf, dass bei der Mars-Sonde Mariner VI (1969) für die Bildübertragungen ein 32-stelliger ReedMuller-Code erster Ordnung eingesetzt wurde. Mit seinen 6 Informationsstellen konnten 26 = 64 Graustufen übertragen werden. Es ließen sich sowohl 7 Fehler korrigieren als auch 8 Fehler erkennen.
3.10
Fehlerbündel zu Einzelfehlern
Vorbild Skat: Mischen und Verteilen
Interleaving Fehler kommen grundsätzlich in zwei unterschiedlichen Formen als systematische und zufällige Fehler vor. Systematische Fehler sind direkte Folgen eines verwendeten Verfahrens oder einer Technik. Sie lassen sich oft durch Messung bestimmen, ihre Auswirkungen auf das Ergebnis können dann beseitigt werden. Wenn z. B. ein statistisch verteiltes Rauschsignal mit einem konstanten Pegel durch eine Gleichspannung versehen ist, so hat dieses Auswirkungen auf die Fehlerstatistik beim Empfänger. Ist der Gleichanteil, der eine Unsymmetrie des Rauschens hervorruft, meßbar, so kann man das Ergebnis beim Empfänger entsprechend korrigieren. Es bleiben dann nur die Einflüsse der zufälligen Fehler übrig – mit denen man sowieso schon genügend Ärger hat. Die zufälligen Fehler treten, statistisch betrachtet, ihrerseits in unterschiedlichen Formen auf. Eine grobe Einteilung ist die in zufällige Einzelfehler und in zufällige Fehlerbündel einer bestimmten Länge. Alle Codierungsverfahren wie Hamming-, BCH-, Reed-Solomon- Reed-Muller- oder Goppa–Codes können für alle Fälle verwendet werden, für Fehlerbündel bringt aber der ReedSolomon-Code bessere Ergebnisse, weil er speziell auf diesen Fehlertyp angepasst ist. Doch auch für die übrigen Codes lassen sich mit einer einfachen Maßnahme für den Einsatz gegen Fehlerbündel verbessern. Das Verfahren wird als Interleaving bezeichnet. Die Übersetzung „ Verschachteln“ beschreibt es : Die Codewörter werden wie üblich gebildet und vor dem Absenden in eine Folge gebracht (etwa so, wie sie sonst gesendet würden). Aus dieser Folge werden nun jeweils alle ersten Bits hintereinander angeordnet, dann alle zweiten usw., bis die gewählte Verschachtelungstiefe vd erreicht ist. Der so erzeugte „Superblock“ wird gesendet. Fehlerbündel verfälschen zwar nach wie vor entsprechende Blöcke von Bits. Wenn der Superblock aber beim Empfänger wieder „entschachtelt“ wurde, verteilen sich nun die Fehlerbits auf einzelne Codewörter, die ihrerseits zum richtigen Ergebnis decodiert werden können. Die Belastung eines oder weniger Codewörter mit Fehlern wird auf diese Weise auf viele Codewörter verteilt, die mit der geringeren Last besser umgehen können.
203
3 Fehlerbeseitigung Wenn man sich die Codewörter als Spaltenanordnung denkt, wie im folgenden Bild für den (4,7)-Hamming-Code gezeigt I11 I21 I31 I41 I51 I61 I71
I12 I22 I32 I42 I52 I62 I72
I13 I23 I33 I43 I53 I63 I73
I14 I24 I34 I44 I54 I64 I74
P11 P21 P31 P41 P51 P61 P71
P12 P22 P32 P42 P52 P62 P72
P13 P23 P33 P43 P53 P63 P73
Die Macht der Su- so hat bei einer Verschachtelungstiefe von vd =7 der Superblock perblöcke die Anordnung: I11 I12 I13 I14 P11 P12 P13
I21 I22 I23 I24 P21 P22 P23
I31 I32 I33 I34 P31 P32 P33
I41 I42 I43 I44 P41 I42 I43
I51 I52 I53 I54 P51 P52 P53
I61 I62 I63 I64 P61 P62 P63
I71 I72 I73 I74 P71 P72 P73
Ein Fehlerbündel der Breite 5 (es müssen innerhalb dieser Breite nicht wie hier immer alle Bits gekippt werden), welches ohne Interleaving das dritte Codewort beeinflußt und unkorrigierbar macht (fett/kursiv), trifft im Superblock das entsprechende Wort, was sich im entschachtelten Wort beim Empfänger auf 5 einzelne und damit vollständig zum richtigen Ergebnis decodierbare Wörter verteilt. I11 I21 I31 I41 I51 I61 I71 Gut verteilt ist halb gewonnen
204
I12 I22 I32 I42 I52 I62 I72
I13 I23 I33 I43 I53 I63 I73
I14 I24 I34 I44 I54 I64 I74
P11 P21 P31 P41 P51 P61 P71
P12 P22 P32 P42 P52 P62 P72
P13 P23 P33 P43 P53 P63 P73
Die erwartete statistische Fehlerbündelbreite b bestimmt die Verschachtelungstiefe. Wenn als größte Fehlerbündelbreite b = 5 vorkommen kann, reicht in diesem Beispiel für ein vd = 5 aus, um durch Interleaving 7-Bit-Codewörter zu erzeugen, in denen nicht mehr als ein Fehler auftritt (t=1), – der dann auch korrigierbar ist . Allgemein lässt sich die Verschachtelungstiefe berechnen, wenn Fehlerbündelbreite b und Fehlerkorrigierbarkeit t bekannt sind (Interleaving lohnt sich natürlich nur für b > t). Die Fehlerbündelbrei-
3.10 Interleaving te muss kleiner bleiben als das Produkt vd t. Damit ist vd
Zwei Wermutstropfen
Die Krönung: veränderliche Blocklängen
3.11
b t
In unserem Beispiel wäre also vd =5 ausreichend gewesen, wir hatten aber vd =7 gewählt. Dies ist insofern unerwünscht, als dieses an sich einfache Verfahren auch zwei kleine Nachteile mit sich bringt, welche durch ein zu großes vd unnötig verstärkt würden: Die Zerlegung der Codewörter vor dem Senden kostet einerseits Speicherplatz und bewirkt andererseits eine Verzögerung sowohl vor dem Senden als auch nach dem Empfangen des Superblocks. Durch den Einsatz schneller, hierauf optimierter Chips lässt sich dieser Nachteil aber klein halten. Der Codec AHA4501 Astro von comtech aha corporation bietet als eigenständiges Modul bereits eine integrierte Interleaving-Funktion und den benötigten Speicherplatz. Eine feste Blocklänge bringt mit Interleaving bei Fehlerbündeln zwar bereits Vorteile, diese können aber noch gesteigert werden, wenn man die Blocklänge (pseudo)statistisch variiert. Sind Fehlerbündel-Verteilungen und Blocklänge möglichst unkorreliert, so wird die Verteilung der Fehler auf ein Codewort nochmals „flacher“, die Anzahl korrigierbarer Fehlermuster steigt also zu ungunsten der nicht korrigierbaren. Da die „pseudo“-statistische Veränderung aber mit dem Empfänger deterministisch vereinbart werden muss, ist der Aufwand für das Datenaustausch-Protokoll höher als bei fester Blocklänge. Mit dem in Kapitel 4 beschriebenen Schieberegistern lassen sich deterministisch scheinbar regellose Zufallszahlen erzeugen, welche am Sende- und Empfangsort gleiche Folgen variabler Blocklängen gestatten.
Produkt-Codes Zum Schluss werfen wir noch einen Blick auf heute aktuelle CodeEntwicklungen, die, gemessen an den durch das Shannon-Theorem (siehe Unterkapitel 3.5.6) gegebenen Schranken leistungsfähiger als die bisher besprochenen sind. Produkt-Codes wurden 1954 von P. Elias in "Error-Free Coding" IRE Transactions on Information Theory , PGIT-4, pg 29 to 37, 09/1954, beschrieben, 1981 von R.Tanner, in "A Recursive Approach to Low Complexity Codes" IEEE Transactions on Information Theory , Volume IT-27, No. 5, 09/1981 aufgegriffen und inzwischen von vielen Autoren weiterentwickelt. Produkt-Codes wenden auf den Informationsblock statt eine Codierung mehrere an. Im einfachsten Fall sind es zwei. Betrachten wir ein Beispiel mit vier 4-Bit-Informationsblöcken, etwa die folgenden:
205
3 Fehlerbeseitigung 0 1 0 1 Schön der Reihe nach
0 1 1 1
0 0 0 1
0 1 1 1
Im ersten Schritt werden diese zeilenweise codiert, z. B. mit dem (4,7)-Hamming-Code und die berechneten Paritätsbits wie üblich angehängt. Damit entstehen 4 Codewörter, jedes ist 1-Bitfehler-korrigierbar: 0 1 0 1
0 1 1 1
0 0 0 1
0 1 1 1
0 1 0 1
0 0 1 1
0 0 0 1
Im zweiten Schritt stehen die vier vertikalen 4-Bit-Informationsblöcke in den ersten vier Spalten im Blickfeld. Sie werden ebenfalls mit Paritätsbits, diesmal nach unten in vertikaler Richtung zu vier Codewörtern erweitert. Nimmt man hier erneut den (7,4)Hamming-Code, so ensteht: 0 1 0 1 0 1 0 „Checks on checks“
0 1 1 1 0 0 1
0 0 0 1 1 1 1
0 1 1 1 0 0 1
0 1 0 1
0 0 1 1
0 0 0 1
Im dritten Schritt werden die horizontalen oder vertikalen Paritätsbitblöcke so behandelt, als seien es Informationsblöcke und mit eigenen Paritätsbits zu versehen. Nimmt man die horizontalen 4Bit-Blöcke links unten, so ergänzt sich der 77-Block rechts unten zu 0 1 0 1 0 1 0
0 1 1 1 0 0 1
0 0 0 1 1 1 1
0 1 1 1 0 0 1
0 1 0 1 0 1 0
0 0 1 1 1 0 0
0 0 0 1 1 1 1
Man sieht, dass die horizontal berechneten Paritätsbits in den 3 unteren Zeilen dieselben sind wie die vertikal ermittelten in den 3 rechten Spalten. Dies lässt sich über die Paritätsgleichungen nach-
206
3.11 Produkt-Codes vollziehen. Mit der in Unterkapitel 3.4.2 beschriebenen Matrixdarstellung kann ein Codewortblock V'(statt einzelne Codewörter v) über V ' = UG
berechnet werden. Dieser Codewortblock V' wird nach Zeilen- und Spaltentausch (= Transposition) nochmals mit G codiert und das Ergebnis wiederum Zeilen/Spalten-vertauscht. Deshalb kann man den Produkt-Codewortblock V auch kompakt über T
V = UGTG
Code für Inneres, Code für Äußeres
beschreiben. Es wurde also zunächst ein innerer Code erzeugt und dieser dann über den äußeren Code nochmals codiert. Hier zeigt sich im übrigen, wie der Name „Produktcode“ zustandekommt. Elias hat festgestellt, dass die Mindesthammingdistanz eines solchen Wortes das Produkt der Mindesthammingdistanzen der horizontalen und vertikalen Code-Komponenten ist. Bei unserem Beispiel beträgt dieser Mindestabstand also dmin = 33=9, somit lassen sich wenigstens 4 Einzelfehler korrigieren. Außerdem erwähnt Peterson in seinem Buch, Kapitel 5.7, ein Theorem von Burton und Weldon, nach dem sich Fehlerbündel bis zu einer Breite b, b = max nHt V , nVt H
beseitigen lassen, wobei n und t die Längen und Fehlerkorrekturzahlen der Horizontal- und Vertikalkomponenten bedeuten. Demnach ist im Beispiel b=7. Die quadratische Anordnung wird nun zeilen- oder spaltenweise übertragen, allerdings ist bis jetzt keine Verbesserung erkennbar. Im Gegenteil: Statt 47 =28 Bits beim bisher verwendeten Verfahren müssen jetzt für dieselbe Informationsmenge von 16 Bits 77 =49 Bits übertragen werden, die Informationsrate sinkt von 0,57 auf unter 0,32. Neue Perspektiven Das ändert sich, wenn man die zusätzliche „Sicht“ auf den Gesamtblock einbezieht, die durch die vertikale Codierung entstanden ist. Nehmen wir für ein Beispiel an, dass in der ersten Zeile drei Fehler aufgetreten sind, so dass der Empfangswortblock 0 1 0 1 0 1 0
1 1 1 1 0 0 1
0 0 0 1 1 1 1
1 1 1 1 0 0 1
1 1 0 1 0 1 0
0 0 1 1 1 0 0
0 0 0 1 1 1 1
207
3 Fehlerbeseitigung
Mal von links, mal von oben: das bringt's
ankommt. Der Empfänger berechnet die Zeilensyndrome und stellt einen Fehler FH an der 1. Position von links fest. Das Verfahren bringt hier natürlich ein falsches Ergebnis, da es nur für 1-Bit-Fehler konstruiert wurde. Aber es liefert immer irgendein Ergebnis. Ohne weitere Prüfungen muss der Empfänger dieses erst einmal hinnehmen. Bei den folgenden 6 Zeilen-Wörtern ergibt sich „Fehlerfreiheit“. Nun kommen die Spalten dran, wobei man annimmt, dass in den Zeilen zunächst noch keine Korrektur durchgeführt wurde. Spalten 1, 3, 6 und 7 „outen“ sich als fehlerfrei, Spalten 2, 4 und 5 sind mit FV fehlerbehaftet. Die Positionsbestimmung führt jeweils auf das erste Bit von oben, wie es die folgende Darstellung deutlich macht: FH 1 0 1 0 1 0
Widerspruch abgelehnt!
Vorsicht, Sonderfälle!
208
FV 1 1 1 0 0 1
0 0 0 1 1 1 1
Fv 1 1 1 0 0 1
Fv 1 0 1 0 1 0
0 0 1 1 1 0 0
0 0 0 1 1 1 1
Hier liegt ein Widerspruch zum Ergebnis für die erste Zeile. Man muss jetzt solange systematisch probieren, bis alles passt. Dies ist ähnlich wie beim Lösen eines Kreuzworträtsels, wenn sich in den Schnittpunkten waagerechter und senkrechter Suchwörter zunächst keine gleichen Buchstaben ergeben. Wie kann man vorgehen? Ein Weg von mehreren besteht darin, im ersten Schritt alle Zeilen zu decodieren und mit diesem Ergebnis alle Spalten zu behandeln. Danach geht es wieder an die Zeilen. Diesen Weg durchläuft man so oft, bis alle Zeilen- und Spaltensyndrome Null geworden sind, was nach spätestens 2 vollen Umläufen passiert. Im Einzelfall heißt das allerdings nicht unbedingt Fehlerfreiheit, da ein Syndrom auch bei bestimmten 3-Fehler-Konstellationen in einer Zeile oder Spalte den Wert Null annehmen kann. Für das obige Beispiel mit 3 Fehlern in der ersten Zeile ist es nicht geschickt, im ersten Schritt mit der Zeilenkorrektur zu beginnen, da zunächst ein weiterer Fehler hinzugefügt wird, anstatt einen oder mehrere zu beseitigen. Hier beginnt man vorteilhafter mit der Spaltenkorrektur , da diese bereits im ersten Schritt alle Fehler ausmerzt. Wenn Zeilen- und Spaltensyndrome unterschiedliche Fehlerzahlen anzeigen, startet man also dort, wo mehr Fehler bestimmt wurden. Bei gleichen Fehlerzahlen ist dagegen Vorsicht geboten, hier kann ein Sonderfall vorliegen. Falls nämlich innerhalb des Empfangswortblockes 4 Fehler in den Ecken eines Rechtecks stehen, werden im ersten Schritt (Zeilenkorrektur) paarweise neue Fehler erzeugt.
3.11 Produkt-Codes
Problem gelöst
Anschließend sind die Zeilensyndrome Null. Als Folge weisen jetzt aber im zweiten Schritt die Spaltensyndrome gegenüber der ersten Prüfung eine weitere fehlerhafte Spalte vor. Alle als fehlerhaft erkannten Spalten werden nun ihrerseits korrigiert. Die dabei zusätzlich erzeugten 3 Zeilenfehler befinden sich aber in genau derjenigen Konstellation, die wie die anderen den Syndromwert Null ergeben. Damit signalisiert die nun folgende Zeilenprüfung Fehlerfreiheit, und der Vorgang wäre mit falschem Ergebnis abgeschlossen. Das lässt sich vermeiden, wenn man zunächst prüft, ob sich zeilenund spaltenweise gleiche Syndrome ergeben, was ein Hinweis auf eine Rechteckanordnung der Fehler ist. Ein solcher Fall wird zum richtigen Ergebnis korrigiert, wenn man aus allen Paarungen der fehlerhaften Zeilen- und Spaltennummern die Fehler identifiziert. Dies funktioniert sogar, wenn die Fehler sowohl auf den Eckpunkten eines Rechtecks als auch gruppenweise parallel zu den Kanten dazwischen liegen:
F
F
F
F
F
F
Der Abstand Da der Mindesthammingabstand dmin = 9 beträgt, lassen sich 4-Bitallein sagt's nicht Fehler sicher, aber auch einige Anordnungen weiterer Fehler korrigieren. Es können folgende Konstellationen auftreten:
1 2
3 4 5
Korrigierbare Fehlerkonstellation alle 4-Bit-Fehler alle Fehler bis zu 7 Bits, die paarweise in verschiedenen Zeilen und Spalten stehen (diagonale Anordnung und alle Permutationen) alle Bündelfehler bis zu 7-Bit Breite Weitere Konstellationen mit mehr als 4 Fehlern, aber nicht jede Alle Rechteckfehler, also alle, die auf den Ecken oder gruppenweise parallel zu den Kanten dazwischen liegen
Die zuerst recht trübe erscheinende Bilanz sieht also schon besser aus. Das eigentliche Leistungsvermögen erschließt sich allerdings erst in Verbindung mit Soft Decision-Verfahren, was im Unterkapitel 3.12 behandelt wird. Im übrigen gilt: • Praktisch kann jeder innere mit jedem äußeren Codetyp kombiniert werden.
209
3 Fehlerbeseitigung Außer der rechteckigen Anordnung der Verschachtelungen ist jede weitere mit höherer Dimension möglich, also etwa eine quaderförmige Dass auch dieser „kleine“ Beispielcode bereits brauchbar arbeitet, erkennt man an dem folgenden Ergebnis einer Rechnersimulation. Das bereits verwendete Gedicht von Jürgen Scheller wird hier fortgesetzt und der Bitstrom der ASCII-Zeichen mit einem Störsignal verfälscht, so dass sich bei einem Störabstand von SNR = 8.6 folgender Beginn des Empfangstextes ergibt: •
Brach schon bei dem Namen Strauß ohne Grund in Beifall aus. [chlug sichUauf die Schenkel$dann, oder seienm nebenmann. Flirtete mit einer Frau, – einer anderl-, wurde blau. Ließ sich in der pause nun, stitt das Gegentail zu tun, eine zwehte Extra Dry, kommen, denn er blieb dabei. .......
Er kann's besser...
In den insgesamt 1122 Zeichen sind 24 Fehler enthalten, die Blockfehlerhäufigkeit beträgt 0.02. Mit dem (49,16)-Produktcode erhält man bei gleicher Kanalkapazität (und daher wegen SNR'= SNR16/49 nur noch SNR' = 2.7): Brach schon bei dem Namen Strauß ohne Grund in Beifall aus. Schlug sich auf die Schenkel dann, oder seinem Nebenmann. Flirtete mit einer Frau, – einer andern-, wurde blau. Ließ sich in der Pause nun, statt das Gegenteil zu tun, eine zweite Extra Dry, kommen, denn er blieb dabei. Sprach: Na ist das nicht grandios, hier ist endlich mal was los. Nie mehr seh ich mir so’n Mist an, wie den Hamlet oder Tristan! Klatschte, als das Licht ausging und der zweite Teil anfing. War erst geistig noch ganz fit, sang dann aber manchmal mit. Lachte sich so gut wie tot. Kam dann plötzlich sehr in Not. Spürte einen bösen Drang. Wünschte einen Abgesang und das Ende des Programms. Zog die Uhr aus seinem wQms, prüfte, ob’s nicht bald vorbei. Trank den letztUen Extra Dry. Brannte sich ein Loch in’s Hemd. SkÖ am Ende ganz verklemmt. Spendete gequält Applaus als dann feststand, es ist aus. Lacht über ein Bonmot, seinerseits und ging auf’s Klo. Sah dann später an der Bar, daß kein Flirt mehr möglich war. Zog sich Mantel an und Hut, fand die frische Luft nicht gut. Kam zu spät zur letzten Tram. Sprach zu sich: Ein Scheiß-Programm!
Hier sind nur noch 5 Fehler enthalten, die Blockfehlerwahrscheinlichkeit ist auf 0.004 gesunken, eine zwar kleine, aber doch deutliche Verbesserung. Unschlagbare Die bereits erwähnten Quellen zur weiteren Leistungssteigerung Partner: Produkt- in Verbindung mit SD-Verfahren liegen nun darin, den gesamten codes und SD Informationsgehalt der Empfangssignale zu nutzen, auf den man bei HD-Demodulation ja teilweise verzichtet. Als Beispiel dient der folgende Empfangssignalblock eines (7 7)-Produktcodewortes für
210
3.11 Produkt-Codes die beiden ASCII-Zeichen „aß“. Im Kanal überlagern sich den Sendesignalen vs (Pegel –0.5/+0.5 Volt) die Rauschsignale rs mit dem Effektivwert V = 0.2 Volt, so dass der Störabstand SNR = 6.25 = 7.8 db beträgt und Spannungswerte gemäß Bild 3.29 empfangen werden. +0.31 +0.00 -0.27 -0.83 -0.29 +0.63 +0.36
-0.84 +0.27 -0.51 -0.71 +0.25 +0.05 +0.63
+0.02 +0.39 +0.73 -0.89 -0.11 -+0.46 -0.56
+0.42 -0.46 +0.30 -0.45 +1.15 +0.73 -0.38
-0.76 -0.67 -0.39 -1.15 -0.73 -0.59 -0.54
-0.45 -0.60 +0.54 -0.90 -0.39 +0.30 +0.14
+0.51 -1.00 +0.16 -0.38 -0.17 -0.62 +0.71
Bild 3.29 : Produktcode-Empfangssignalblock ws für die 16 Bits der ASCII-Zeichen „aß“ o (0110 00001 1101 1111) HD: einfach und brutal
Bei HD-Demodulation entsteht daraus die fehlerhafte Zuordnung
Verborgene (Info-) Schätze
Im ursprünglichen Empfangssignal sind nicht alle Werte gleich sicher. Für Werte nahe Null besteht größte Unsicherheit darüber, ob das Signal aus -0.5 oder aus +0.5 Volt hervorgegangen ist. Bei Werten „weiter weg“ von Null wächst die Sicherheit zugunsten jeweils nur eines der beiden Bits. Legt man den Grenzbereich auf ±0.2 Volt, so trifft das die grau unterlegten Zellen, 4 von 7 sind demnach „Wackelkandidaten“, während das beim Signalwert in Zeile 3/Spalte 4 noch nicht zu erkennen ist. Die Idee ist jetzt, die Infobits – und nur diese – im ersten Schritt zeilenweise daraufhin zu untersuchen, ob sie aus Sicht der anderen Infobit- und Prüfbit-Signale eher richtig oder eher falsch sein könnten. Mit dem Ergebnis führt man im zweiten Schritt den gleichen Vorgang spaltenweise durch. Falls die Infobit- und Rauschsignale statistisch unabhängig sind, werden damit weitere Informationen genutzt, welche die Sicherheit der „0“/“1“-Entscheidung erhöhen. Im dritten Schritt stehen wieder die Zeilen im Blickfeld usw. Man beendet den Prozess, wenn das Ergebnis als ausreichend sicher angesehen werden kann oder wenn sich keine Änderungen mehr zeigen. Im folgenden Unterkapitel 3.12 wird das Verfahren untersucht. Der Vorgang erinnert an das Prinzip des Turboladers bei Verbrennungsmotoren, bei denen ein Teil der Abgase auf den Lader zurückgeführt wird, um durch die Verdichtung der Ansaugluft
0 0 1 1 1 0 0
1 0 1 1 0 0 0
0 0 0 1 1 0 1
0 1 0 1 0 0 1
1 1 1 1 1 1 1
1 1 0 1 1 0 0
0 1 0 1 1 1 0
211
3 Fehlerbeseitigung einen besseren Wirkungsgrad zu erreichen. Man hat den so behandelten Produktcodes deshalb die Bezeichnung Turbo-Produkt-Codes (=TPC) gegeben. Genauere Ausführungen findet man bei C.Berrou, A.Glavieux, P.Thitimajahima in „Near Shannon limit error-correcting coding and decoding: Turbo-codes (1)“, Proceedings ICC ’93, May 1993 und in vielen weiterführenden Arbeiten, unter anderem wesentlich von J. Hagenauer, TU München. Um sich über die aktuellen Entwicklungen informieren zu können, ist ein Blick in das Internet zu empfehlen. Über Begriffe wie „error correcting code“, „turbo product code“, „maximum likelihood decoder“, „Viterbi decoder“, „Reed Solomon Code“ und weitere findet man viele Dokumente und Verweise.
3.12
Maximum a Posteriori-Prinzip und Turboprodukt-Codes
Die auf der Grundlage des HD-Verfahrens erzielten Ergebnisse bei der Fehlerkorrektur sind zwar beachtlich, erreichen aber nicht das durch die Shannon-Grenze gegebene Ziel. Eine der Hauptursachen liegt darin, dass bei der „harten“ „0“/„1“-Entscheidung aus dem Empfangssignal wertvolle Informationsgehalte zugunsten einer einfachen Rechnung unberücksichtigt bleiben. Wie im Unterkapitel 3.4.5 am Beispiel des ML (= Maximum Likelihood)-Prinzips gezeigt wurde, bietet das SD-Verfahren – theoretisch – eine deutliche Verbesserung bis ungefähr 3 dB im EBR/(SNR/R)-Diagramm, ist aber bei den eigentlich erwünschten langen Codes nicht praktikabel, da hier zu jedem Empfangswort gewaltige Mengen an passenden Codewörtern zu durchsuchen sind. Optimierte Such-Strategien über Entscheidungsbäume können den Aufwand zwar verringern, die erzielbare Entlastung hilft aber bei den gegebenen Größenordnungen letztlich nicht wirklich weiter. Lockruf der Shan- Näherungsverfahren wie die von David Chase in „A class of alnon-Grenze gorithms for decoding block codes with channel measurement information“, IEEE Trans. Inform. Theory, vol IT-18, Seiten 170 -182, können hier bei Verzicht auf einen Teil der theoretisch erzielbaren Ergebnisse helfen, reichen allein jedoch nicht aus.. Ein bemerkenswerter Durchbruch in Verbindung mit solchen Näherungen wurde über die erst vor wenigen Jahren insbesondere vom Team um Hagenauer (J Hagenauer, E.Offer, L.Papke in „Iterative decoding of binary block and convolutional codes“, IEE Trans. Inform. Theory“, vol. 42, Seiten 429-445) entwickelten Lösungen nach dem MAP (= Maximum a Posteriori-Prinzip) erzielt. Im Gegensatz zum ML-Prinzip, bei dem immer ganze Codewörter darauf getestet werden, ob sie nach dem Kriterium des kleinsten mittleren Abweichungs-Quadrates zum Empfangswort „passen“, stehen hier die einzelnen Info-Bits im Blickpunkt.
212
3.12 Maximum a Posteriori-Prinzip und Turboprodukt-Codes
Der Abstand bleibt wichtig
Diese erhalten unter Berücksichtigung der den anderen Infound Prüfbits entsprechenden verrauschten Empfangssignale wsi eines Codewortes ein Wahrscheinlichkeitsmaß, aus dem dann die sichere oder auch unsichere Aussage getroffen wird, ob es sich um ein gesendetes „0“- oder „1“-Bit handelt. Vor der Erläuterung des Weges wird zunächst auf eine Besonderheit aller auf Soft Decision beruhenden Verfahren hingewiesen: • Die Erzeugung der Codewörter v erfolgt mit den in den Unterkapiteln 3.4 bis 3.9 beschriebenen Algorithmen. • Das Ziel bei der Erzeugung der Codewörter ist wie für HD immer die Sicherstellung eines gewünschten minimalen Hammingabstandes dmin • Die Empfangswörter ws werden nicht unter Verwendung der Syndrome und der Bedingung dmin 2tkorr 1
Gültigkeit verloren: das „ohmsche“ Gesetz der Fehlerkorrektur
•
sondern über die Auswertung statistischer Zusammenhänge decodiert. Die vollständige Fehlerkorrektur an einem Empfangswort ws kann auch dann gelingen, wenn die Fehleranzahl t größer als die durch dmin 2tkorr 1
gegebene ist. Insbesondere lassen sich Korrekturen sogar dann erzielen, wenn die Codewörter nur ein einziges Prüfbit enthalten (SPC-Codes = Single Parity Check Codes), mit denen über HD prinzipiell nur Fehlererkennung möglich ist. Anhand eines Beispiels lässt sich nun das grundsätzliche Vorgehen zeigen. Wir wählen dazu den einfachsten überhaupt möglichen Code, nämlich denjenigen, bei welchem die Codewörter nur aus einem Info- und einem Prüfbit bestehen, zugleich der einfachste SPC-Code. Es gibt also bei gerader Parität nur die beiden Codewörter v1 = 0
0
v2 = 1 1
und
und die modulierten Sendewörter vs1 = 1 1
und
vs2 = 1 1
Die statistische Verteilung der Info-Bits wird als gleich angenommen, sie haben also die – diskrete – Verteilung (=Wahrscheinlichkeit)
213
3 Fehlerbeseitigung 1 2
P0 = P1 = P 1 = P1 =
Verteilungskämpfe
Das AWGN-Rauschsignal rs ist durch seine Verteilungsdichtefunktion (= Wahrscheinlichkeitsdichte) 2
prs =
1
2
e
rs 2 2
2
gegeben und wirkt auf die beiden Bits des Sendesignals vs. Wegen der statistischen Unabhängigkeit der einzelnen Signale in weißem Rauschen zeigen die beiden zugeordneten Störsignale jeweils die gleichen statistischen Eigenschaften, haben also für sich betrachtet ebenfalls den Mittelwert 0 und den Effektivwert V, was sich in Form eines räumlichen „Gebirges“ darstellen lässt, siehe Bild 3.30b. Es ist die Verbundwahrscheinlichkeitsdichte 2
prs 1, rs 2 = prs 1prs 2 =
Hoch- und Mittelgebirge
1
2
e
2
2
rs1 2
2
1
2
2
e
rs2 2
2
welche angibt, mit welcher Verteilungsdichte beliebige Paare rs1 und rs2 auftreten. Im Labor kann man diese experimentell angenähert bestimmen, wenn man eine normal verteilte Zufallsfolge rs erzeugt (hier mittelwertfrei und Vrs = 0. 6), diese in Paare unterteilt und abzählt, welche Paare in einem gewählten kleinen Bereich drs/2 um einen Punkt (rs1, rs2) herum liegen. Das Ergebnis ist ein Histogramm, bei dem zur leichteren Vergleichbarkeit die „Treffer“ in den einzelnen Bereichen noch auf die Anzahl aller Treffer im gesamten Gebiet normiert sind.
a
b
Bild 3.30a und 3.30b: Verteilung P(vs) und Verbundverteilungsdichte p(rs1, rs2) Im vorliegenden Beispiel wurden je 50.000 Paare in einem Ge-
214
3.12 Maximum a Posteriori-Prinzip und Turboprodukt-Codes
Glockenspiele
biet zwischen -3 < x < +3 und -3 < y < +3 verwertet, welches in beiden Koordinaten in je 40 Bereiche mit dx = drs= 0.15 aufgeteilt ist. Bild 3.30a stellt die Verteilung P(vs1 = (+1 +1)) = P(vs2 = (-1 -1)) = 0.5 der beiden gesendeten Codewörter dar, p(rs1, rs2) ist eine Gauß'sche Glocke. Das Histogramm Bild 3.31a der Empfangswörter ws = vs rs
zeigt als Verteilungsdichte p(ws) zwei normal verteilte „Gauß'sche Glocken“ um die beiden Codewörter vs1 und vs2. Diese Verteilung wird durch
1 1 p ws = e 2 2 2
HD-Decodierung = Info-Vernichtung
2
rs1 2 2
2
e
rs 1 2 2
beschrieben. Bei HD-Demodulation von ws in wsHD erhält man neben den beiden unverfälschten Wertepaaren wsHD1 = (+1 +1) und wsHD2 = (-1 -1) wegen der zurückbleibenden Fehler auch zwei vom Effektivwert V des Rauschens abhängige Anteile wsHD3 = (+1 -1) und wsHD4 = (-1 +1), wie in Bild 3.31b zu sehen ist. Man erkennt, dass die reichhaltige statistische Information in ws über die Sendewörter vs durch HD-Demodulation stark beschnitten wird und für die Nutzung bei der Fehlerkorrektur nicht mehr zur Verfügung steht.
a
b
Bild 3.31a und 3.31b: Verteilungsdichte p(ws) des Empfangssignals ws und Verteilung P(wsHD) bei HD-Demodulation Wie aber lässt sich dieser Informationsgehalt von ws verwerten? Die Verteilung p(ws) an sich stellt noch keine Hilfe dar. Statistische Größen geben immer nur Mittelwerte über eine Anzahl von Einzelereignissen wieder. Man weiß lediglich, dass gemäß Bild 3.31a ein angenommenes Empfangswort = (+0.5 -1.9) im Vergleich zu allen möglichen anderen Paaren im Mittel mit einer
215
3 Fehlerbeseitigung Wahrscheinlichkeit von etwa p(ws) = 0.001 auftritt. Das verbessert sich grundlegend, wenn man die Betrachtungsweise ändert und die bedingte Wahrscheinlichkeit
P vsws Dopingmittel „bedingte Wahrscheinlichkeit“
als Hilfsmittel einsetzt. Diese gibt an, mit welcher Sicherheit eine Aussage über ein Sendewort vs getroffen werden kann, wenn der Empfänger den zu einem gesendeten Wort vs gemessenen Wert des zugehörigen Empfangswortes ws nutzt. Die statistische Betrachtung lässt ahnen, dass dies in der Tat Vorteile verspricht. Im Beispiel werden dazu zunächst alle Empfangswörter in jeweils einem der 40 40 = 1600 Bereiche bestimmt. Das ergibt die Verteilungsdichte von Bild 3.31a. Nun zählt man zusätzlich noch diejenigen Empfangswörter ws, die im betrachteten Bereich aus einem der beiden Sendewörter, etwa vs1 = (+1 +1) hervorgegangen sind. Dabei erhält man die in Bild 3.32a dargestellte Verteilung.
a
b
Bild 3.32a und 3.32b: Bedingte Verteilung p(ws|vs=(+1 +1)) und Anwendung der Bayes'schen Beziehung für die bedingte Verteilung P(vs=(+1 +1) |ws)) SD-Decodierung, das Power-Gel
216
Sie „schart“ sich um ein Maximum im Gebiet um (+1 +1), für weiter ab liegende Gebiete sinkt einerseits gemäß Bild 3.31a die Häufigkeit der Empfangswörter selbst, andererseits auch die Anzahl derer, die aus einem vs1 hervorgegangen sind. Bezieht man nun für jedes „Kästchen“ in Bild 3.32a die nicht normierte, absolute Anzahl der Treffer auf die für das jeweilige Kästchen gültige Anzahl aller Empfangswörter gemäß Bild 3.31a, so erhält man die gesuchte bedingte Verteilung P(vs = (+1 +1) | ws) in Bild 3.32.b. Die daraus zu ziehende Aussage ist: Hat man ein Signal ws empfangen, welches im rechten oberen Quadranten liegt, so ist die Wahrscheinlichkeit für ein erzeugendes Sendewort vs1 = (+1 +1) durch die angegebene Verteilung gegeben. Oder:
3.12 Maximum a Posteriori-Prinzip und Turboprodukt-Codes Zu einem gemessenen Empfangswort ws lässt sich angeben, mit welcher Sicherheit es einen Schätzwert für das Sendewort vs1 wiedergibt.
Bayes hilft
Entsprechendes gilt für vs2 = (-1 -1). Qualitativ erscheint dieses Ergebnis beinahe trivial, doch kann es erst auf der Grundlage einer derartigen Betrachtung quantitativ verwendet werden. Da im Rahmen eines Fehlerkorrekturverfahrens die direkte Berechnung der bedingten Verteilung P(vs = (+1 +1) | ws) aufwändig wäre, macht man von der Bayes'schen Beziehung Gebrauch, was wir genau genommen soeben bereits getan hatten. Mit Hilfe dieser Beziehung kann mit der einfacher zu bestimmenden bedingten Verteilungsdichte p(ws|vs) weiter gearbeitet werden: P vsws =
Problemlösung durch Aufteilen: Vom Wort zum Info-Bit
pwsvsP vs pws
Die Verteilungsdichte p(ws) wird auch als totale Wahrscheinlichkeitsdichte bezeichnet. P(vs) gibt die diskrete Verteilung der Sendewörter an, die in unserem Beispiel 0.5 beträgt. Für eine direkte Weiterverwendung ist aber auch die Bayes'sche Beziehung in der angegebenen Form noch zu unhandlich, da reale Codewörter aus wesentlich mehr als 2 Bits bestehen. Eine Vereinfachung wird erreicht, wenn man nicht nach der bedingten Verteilung P(vs|ws) von ganzen Codewörtern, sondern nach der von einzelnen Infosignalen usi fragt: Pusws, i
i=1, 2, ........., k
Da jedes Infosignal nur die Werte +1 oder -1 annehmen kann, bleibt die in Betracht kommende Menge überschaubar. Es gibt die beiden bedingten Verteilungen: Pusi= 1ws Pusi=1ws
Verschlungene Pfade
i=1, 2, ......... , k
Diese lassen sich ermitteln, wenn man die Summe der bedingten Verteilungen aller Codewörter bildet, welche an der i-ten Stelle ein Infosignal usi = +1 bzw. usi = -1 haben, da alle diese Codewörter als mögliche Kandidaten in Frage kommen:
Pusi= 1ws=
vs!V gi= 1
Pvsws,
Vgi= 1"vs mit usi= 1
Die etwas geheimnisvoll anmutenden Bezeichnungen in dieser Formel besagen, dass die Summe über alle Codewörter aus der Gesamtmenge Vg zu bilden ist, bei denen das Infobit an der Stelle i den Wert „1“ hat. Der (7,4,3)-Hamming-Code in Tabelle
217
3 Fehlerbeseitigung 3-2 auf Seite 59 hat in Sendesignalform die in Tabelle 3-28 gezeigten 16 Codewörter. Codewort v [0 0 0 0 0 0 0] [0 0 0 1 1 1 1] [0 0 1 0 0 1 1] [0 0 1 1 1 0 0] [0 1 0 0 1 0 1] [0 1 0 1 0 1 0] [0 1 1 0 1 1 0] [0 1 1 1 0 0 1] [1 0 0 0 1 1 0] [1 0 0 1 0 0 1] [1 0 1 0 1 0 1] [1 0 1 1 0 1 0] [1 1 0 0 0 1 1] [1 1 0 1 1 0 0] [1 1 1 0 0 0 0] [1 1 1 1 1 1 1]
Codewort vs 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
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
Tabelle 3-28: Sendewörter vs eines (7,4,3)-Codes Teilergebnis : Gipfel erreicht
Die ersten 8 Zeilen zeigen die Wörter mit einer „+1“ an erster Stelle, also us1 =+1, die letzten 8 Zeile mit einer „-1“ usw. Da nur die 4 Infobits jedes Codewortes zu berücksichtigen sind, genügt die Betrachtung der ersten 4 Spalten. Einsetzen in die Bayes'sche Formel ergibt
PwsvsPvs , Vgi= 1"vs mit usi = 1 pws vs!V gi= 1 PwsvsPvs , Vgi=1"vs mit usi =1 Pusi=1ws= pws vs!V gi=1 Pusi= 1ws=
Leichte Entspannung
Ein Wert P(usi=+1|ws) nahe 1 signalisiert eine hohe Wahrscheinlichkeit für ein gesendetes Nullbit ui =0, ein Wert nahe 0 eine solche für ein gesendetes Einsbit ui = 1. Dagegen weist ein Wert um 0.5 auf eine große Unsicherheit bezüglich eines Null- oder eines Einsbits hin. Eine weitere Vereinfachung lässt sich erzielen, wenn das Verhältnis Q(usi) der beiden bedingten Verteilungen gebildet wird, da die totale Wahrscheinlichkeit in beiden Ausdrücken gleich ist und dann herausfällt: Qus i =
P usi= 1ws P usi=1ws
=
P wsvsP vs
P wsvsP vs
vs!V gi= 1
vs!V gi=1
218
3.12 Maximum a Posteriori-Prinzip und Turboprodukt-Codes
Die Kraft der Logarithmen
Q(usi) wird als Verhältnis auch mit LR (= Likelihood Ratio) bezeichnet. Die beiden Vorzüge bestehen darin, dass einerseits die absoluten Größen der bedingten Verteilungen hier keine Rolle mehr spielen, andererseits die Zahlenwerte „verstärkt“ werden. Ein Wert von Q(usi) bei „0“ signalisiert mit hoher Sicherheit ein Einsbit, ein solcher um „1“ eine große Unsicherheit, ein Wert deutlich über „1“ schließlich mit hoher Sicherheit ein Nullbit. Für den Gebrauch nochmals einfacher wird der Ausdruck, wenn man ihn logarithmiert: Lusi = Log
Pus i= 1ws Pus i=1ws
= Log
P wsvsP vs
P wsvsP vs
vs!V gi= 1
vs!V gi=1
Ab- und UnabHängigkeiten
Der Ausdruck L(usi) ist das logarithmische Wahrscheinlichkeitsverhältnis oder LLR (= Log Likelihood Ratio). Hier gibt das Vorzeichen unmittelbar dasjenige des geschätzten Signalbits usi an, der Betrag ist ein Maß für die Sicherheit, je größer, desto sicherer. Zwei weitere nützliche Veränderungen folgen aus der Annahme, dass Info- und Störsignale sowohl untereinander als auch gegenseitig statistisch unabhängig sind, was in der Wirklichkeit meist in ausreichender Näherung stimmt. Verteilungen und Verteilungsdichten mehrerer Variabler (=Verbundverteilungen und Verbundverteilungsdichten) können bei statistischer Unabhängigkeit als Produkt der Einzelwahrscheinlichkeiten und Einzelwahrscheinlichkeitsdichten dargestellt werden. Bei der Verteilung der Info- und Prüf-Elemente des Codewortes vs vs = us 1, us2, .........,us k , ys1, ys2, ........ , ysm ,
k m=n
liegt eine Funktion der k statistisch unabhängigen Infobitsignale usi vor, da die m Prüfbitsignale ysi ihrerseits Funktionen der Infobits sind und daher statistisch von diesen abhängen: P vs = P us 1, us 2, .........,us k , ys1, ys 2, ........, ysm = P us 1P us 2........P usk
Die Wahrscheinlichkeit P(usi) gibt dabei an, mit welcher Häufigkeit jedes Infobit nach dem augenblicklichen Kenntnisstand ( Schätzwert) innerhalb des vorliegenden Codewortes auftritt. Bei der bedingten Wahrscheinlichkeitsdichte p(ws|vs) liegen die Verhältnisse etwas anders. Da sich die Empfangssignale als Summe aus den Codewort- und Störsignalen zusammen setzen, sind die ws und vs statistisch nicht unabhängig. Für die bedingte Wahrscheinlichkeitsdichte gilt vs aber jeweils als fester Vorgabewert („... unter der Bedingung, dass vs gegeben wurde ....) und
219
3 Fehlerbeseitigung ist – in dieser Hinsicht – keine statistische Variable. Deshalb bleibt in diesem Zusammenhang aus ws nur das Störsignal rs als statistische Komponente übrig, welches nach Annahme aber statistisch unabhängig ist. Daher gilt
p wsvs= p ws1us1 , ....,wskus k , wsk 1ys1 , .... ,wsk mysm = p ws1us1 ...p wskus k pwsk 1ys1 ...p wsk mysm Statistik leicht gemacht: Drei eigenständige Faktoren ....
Die Summanden in Zähler und Nenner von Q(usi) bzw. L(usi) bestehen also aus den soeben berechneten Produkten. Zwar sind diese Summanden Wahrscheinlichkeits-Funktionen jeweils unterschiedlicher Codewörter, jedoch enthält jeder Summand zwei gemeinsame Anteile von usi = +1 bzw. usi = -1, die daher vor die Summen gezogen werden können:
Qusi = =
Pusi= 1ws Pusi=1ws pwsiusi= 1Pus1= 1
P wsvsPvs
P wsvsPvs
vs !V gi= 1 ,ohne i
pwsus i i=1Pus1 =1
vs !V gi=1 ,ohne i
oder
Pusi= 1ws Pusi=1ws pwsiusi= 1Pus1 = 1 = Log pwsiusi= 1Pus1 = 1
Lusi = Log
PwsvsP vs
PwsvsP vs
vs!V gi= 1, ohne i
vs!V gi=1, ohne i
.... drei eigenstän- Nach den Rechenregeln für Logarithmen lässt sich L(usi) als Ausdige Summanden druck dreier Summanden schreiben:
Lusi = Log
P us i= 1 p wsus = 1 i i Log p wsus =1 P us i= 1 i i
Log
P wsvsP vs
P wsvsP vs
vs!V gi= 1, ohne i
vs!V gi=1, ohne i
Diese Beziehungen gelten ganz allgemein für beliebige Verteilungen der Störsignale rs. Im Fall der mittelwertfreien, normal verteilten Störungen mit der Verteilungsdichte p(rs) lassen sich die bedingten Wahrscheinlichkeiten über
220
3.12 Maximum a Posteriori-Prinzip und Turboprodukt-Codes
p wsvs= =
=
Uff, ..... Ziel erreicht
1
2
2
ws1vs 12
e
e
n
1
2 2
2
2
1
2 2
ws1 vs1 2
2
2
ws 2vs2 2 2
e 2
ws2vs 2 2
2
2
1
...
2 2
wsn vsn .... 2 2
2
e
wsnvsn 2 2 2
ausdrücken. Für eine Empfangssignalfolge ist hiermit bei Annahme eines gesendeten Codewortes die Berechnung der zugehörigen bedingten Wahrscheinlichkeitsdichten möglich. Die Quotienten Q(usi) bzw. L(usi) sind dabei die so genannten a posteriori-Ergebnisse der Schätzung, also diejenigen, die bei Einbeziehung der Empfangssignale bestimmt werden können. Sie setzen sich aus drei unterschiedlichen Anteilen zusammen: Qus i = Q a
posteriori
us i = QKanal usi Q a
priori
usi Qextrinsich usi
oder Lusi = La
Einzelbehandlung
posteriori
us i = LKanal us i La
priori
us i Lextrinsich usi
Die weitere Verwendung wird dadurch erleichtert, dass jeder Anteil für sich berechnet werden kann: • Der erste Anteil Qkanal ist das Verhältnis der bedingten Wahrscheinlichkeiten für jedes einzelne übertragene Signalelement, welches durch die Kanalstörung rs verändert wurde. • Der zweite Anteil Qa priori wird aus der Kenntnis der Wahrscheinlichkeit vor der Messung des Empfangssignals gebildet. Ist diese anfangs noch unbekannt, erhält sie ersatzweise zunächst den Wert Pus i= 1 = P us i=1 = 0.5
woraus sich Qa priori(usi) 1 ergibt. • Der dritte Anteil Qextrinsisch stellt den Beitrag dar, der durch die Prüfbits, also durch die Wirkung der Codierung, entsteht (extrinsisch = von außen durch die – über die Prüfbits „mitgegebene“ – zusätzliche Information erzeugt) Wegen der Zweiwertigkeit jedes Infobits ist Pus i= 1ws Pus i=1ws = 1
Daher lassen sich die bedingten Wahrscheinlichkeiten auch über
221
3 Fehlerbeseitigung
Pus i= 1ws =
Qus i
und
1 Qus i
Pus i= 1ws =
1 1 Q usi
bestimmen. Dies hilft, wenn die oben genannten Beziehungen rekursiv ausgewertet werden sollen, da man sich das dauernde Umrechnen in Wahrscheinlichkeiten spart. Für die logarithmische Variante gilt entsprechend: Pus i= 1ws =
Unser stärkstes Pferd im Rennen
Lus i
e Lus 1 e
und
i
Pusi=1ws =
1 Lus 1 e i
Damit kann der extrinsische Anteil über
P wsvsP vs
Lextrinsischusi = Log vs!V gi= 1 ,ohne
i
P wsvsP vs
vs!V gi=1 ,ohne i
k
= Log
vs!V gi= 1 ,ohne i
n
e
0.5L Kanal, j La
priori
j=1, j#i
j=k 1
k
vs!V gi=1 ,ohne i
j=1, j#i
e n
e
0.5L Kanal, j La
priori
e j=k 1
0.5LKanal ,j
0.5LKanal , j
berechnet werden. Vorher.... Die a posteriori-Werte besitzen im Mittel eine größere Sicherheit nachher als die a priori-Werte. Obwohl man mit der Angabe einer im Mittel verbesserten Sicherheit für die einzelnen Bit-Schätzungen bereits einen Erfolg erreicht, lässt sich der eigentliche Vorteil erst nutzen, wenn man diese Verbesserung ihrerseits als Ausgangsbasis für weitere Verbesserungen verwendet. Dafür bieten sich verschachtelte Codestrukturen wie die der Produktcodes an, da man die Infobits hiermit aus verschiedenen unabhängigen Richtungen begutachtet. Das iterativ arbeitende Prinzip könnte folgendes sein: Das Letzte heraus- • Im ersten Schritt setzt man den a priori-Wert Qa priori(usi) für holen alle Infobits auf 1, decodiert bitweise in horizontaler Richtung und erhält für jedes horizontale Teilcodewort einen Schätzwert in Form der horizontalen a posteriori-Wahrscheinlichkeitsverhältnisse Q(usi)h. • Im zweiten Schritt weist man dem Wert Qa priori(usi) den – nun bereits verbesserten – Wert Q(usi)h zu und decodiert bitweise in vertikaler Richtung. Durch die neuen Informationen aus der vertikalen Anordnung kann ein erneut verbessertes Ergebnis Q(usi)v erwartet werden.
222
3.12 Maximum a Posteriori-Prinzip und Turboprodukt-Codes Im dritten Schritt wird Qa priori(usi) auf Q(usi)v gesetzt und wieder in horizontaler Richtung decodiert usw. • Man beendet die Rechnung, wenn das Ergebnis ausreichend sicher erscheint oder sich keine nennenswerten Veränderungen mehr ergeben. Als Beispiel betrachten wir einen Produktcode, der horizontal und vertikal aus je 4 Hamming-Codewörten (7,4,3) aufgebaut ist. Anders als im Unterkapitel 3.11 werden Prüfbits von Prüfbits hier nicht verwendet, da diese stark korreliert sind. Ein Codewort besteht also aus einer rechteckigen Anordnung mit (44) = 16 Infobits (links oben) und 2]34 = 24 Prüfbits. Die Codewortlänge ist n = 40, die Informationsrate beträgt R = 16/40 = 0.4. Mit Hilfe einer Rechner-Simulation wurde bei Vorgabe eines bereits recht ungünstigen Störabstandes SNR = 1.8 ( = 0.75 db) und mit allen 16 auf usi = -1 gesetzten Infobits folgendes Empfangswort ws erhalten, wobei die Vorzeichen den Schätzwert für ein „0“ oder „1“-Bit anzeigen und der Betrag Auskunft über die Sicherheit dieser Anzeige gibt: •
Beispielhaft
Nach Hard-Decision-Demodulation enthielte der Block 7 Fehler, bei den 16 Infobits sind 3 Fehler zu sehen. Wendet man das MAP-Verfahren an, so erhält man im ersten horizontalen Schritt folgende Schätzwerte als Ergebnis für die Infobits (für die Prüfbits werden hier keine Schätzwerte ermittelt, da sie in diesem Zusammenhang nicht interessieren):
Maß der Unsicherheit
Hier ist nur noch ein Fehler in der ersten Zeile übrig. Die anschließende vertikale Decodierung beseitigt diesen Fehler zwar noch nicht, verringert aber dessen Wahrscheinlichkeit:
Die horizontale Decodierung des zweiten Durchlaufs bringt noch
223
3 Fehlerbeseitigung keinen Durchbruch,
wohl aber die vertikale Decodierung:
Ende der Fahnenstange
Nach 4 Iterationen ist keine Veränderung mehr festzustellen, alle Fehler wurden behoben.
In Sichtweite der Shannon-Grenze
Man sieht, dass das Turboverfahren durch die wiederholte Rückführung bereits „vorgereinigter“ Infobits zu einem brauchbaren Ergebnis führen kann. Allerdings benötigen wir auch hier wie beim ML-Verfahren immer alle möglichen Codewörter des verwendeten Codes. Damit stößt dieses Vorgehen bei den praktisch eingesetzten langen Codes auf das gleiche Problem wie bei ML. Die Forschung hat deshalb zum Ziel, durch Einsatz von Näherungsverfahren oder Verwendung anderer Codestrukturen (z. B. duale Codes) den Aufwand bei dennoch gleich günstigen Ergebnissen zu verringern. Die Leistung des heute (Juni 2006) am Markt erhältlichen TPCCodecs AHA4541 ist im Diagramm Bild 3.33 zu sehen. Selbst bei einer Inforate R = 0.88 hat dieser Codec einen Restfehlerverlauf, der nur noch einen Abstand von 3.6 db zur Shannon-Grenze aufweist. Die Übertragungsleistung liegt bei 311 MegaBit/s Außerdem lassen sich zur Anpassung an die durch den vorliegenden Kanal und andere Besonderheiten gegebenen Randbedingungen weitere Parameter wie z. B. die Längen und Inforaten der Teilcodes (constituent codes) sowie die Anzahl der Iterationen einstellen. Damit gelingt es sogar, die Restfehlerwahrscheinlichkeit noch näher an die Shannon-Grenze zu bringen, wenn erforderlich.
224
3.12 Maximum a Posteriori-Prinzip und Turboprodukt-Codes
Bild 3.33: Restfehler eines quadratischen (128, 120)-Turboprodukt-Codes (dicker strichpunktierter Verlauf) im Vergleich zu den Codes aus Bild 3.15 (BCH-Code, Hamming-Code) Bild 3.16 (255,239) RS-Code mit R = 0.89 (dicke gestrichelte Linie)
3.13
... und immer wieder Schieberegister
Faltungs-Codes (Convolutional Codes) Zwar wurden bisher in dieser Darstellung ausschließlich Blockcodes behandelt, in intensivem praktischen Einsatz befindet sich aber auch ein Code-Typ, der prinzipiell anders arbeitet und zur Zeit insbesondere im GMS / UTMS-Mobilfunk sowie bei den laufenden Mars-Sonden-Projekten eingesetzt wird. Es ist der Faltungscode, bei dem das Sendesignal vs durch spezielle Vervielfachungen der Infobits in einer geeigneten SchieberegisterAnordnung entsteht. Das Verfahren wurde 1954 von P. Elias in „Error-Free Coding“, Transactions Information Theory IT-4, Seiten 29-34, vorgestellt. Ein Beispiel für eine Codieranordnung ist im Bild 3.34 dargestellt. Das Schieberegister enthält 2 Speicher x1 und x2, die zum Zeittakt i=0 beide auf 0 gesetzt sind. Zum Takt i = 1 wird das am Eingang anliegende Infobit ui = u1 eingespeist, am Ausgang stehen den Verknüpfungen der Anordnung gemäß (alle Operationen MOD 2) die beiden Codebits v1,1 und v2,1 an. Diese sind der Anfang des Sendesignals vs. Beim Taktzeitpunkt i = 1 passiert außerdem folgendes: • Der vor dem Takt im Speicher befindliche Wert wird auf den Speicherausgang geschaltet. • Der am Speichereingang anliegende Wert wird als Speicherinhalt übernommen.
225
3 Fehlerbeseitigung
ui
Speicher x1,i
Speicher x2,i
v1,i
v2,i
Bild 3.34: Schieberegister als Faltungscodierer Als mögliche Fälle können daher die in Tabelle 3-29 gezeigten auftreten: Eingang
Speicher vor Takt
Speicher nach Takt
Ausgang
ui
x1i
x2i
x1i
x2i
v1i
v2i
0
0
0
0
0
0
0
0
0
1
0
0
1
1
0
1
0
0
0
1
0
0
1
1
0
0
0
1
1
0
0
1
0
1
1
1
0
1
1
0
0
0
1
1
0
1
1
0
1
1
1
1
1
1
1
0
Tabelle 3-29: Mögliche Zustände des Faltungscodierers und Ausgangsfolgen .... einem plötzlichen Impuls folgend ....
Was passiert, wenn zum Zeitpunkt i = 0, die beiden Speicher auf x10 = x20 =.0, das Infobit bei i =1 auf u1 = 1 und für i > 1 wieder auf ui = 0 gesetzt wird und die Anordnung sich dann selbst überlassen bleibt? Man erhält als Ausgangssignal v die in der Systemtheorie als Impulsantwort g bezeichnete Folge, also den Verlauf für u1=1, u2 = u3= ..... = 0. Im vorliegenden Fall ergibt sich v = g = g1 = 11 10 11 00 00 00 .........
Das Infobit u1 = 1 wirkt also noch bis in den Takt i=3 und hat Einfluss bis zum 6. Ausgangsbit. Mit m als Anzahl der Speicher
226
3.13 Faltungs-Codes (Convolutional Codes) bezeichnet man daher b = m+1 als Eindringtiefe, die Position des letzten unter der Wirkung von b stehenden Ausgangsbits als Einflusslänge L = nY(m+1) = nb, wobei n die Anzahl der pro Takt erzeugten Ausgangsbits ist. Im vorliegenden Fall sind: m n b = m 1 L = nm 1 = nb
Falten = Verschieben und Überlagern
=2 =2 =3 =6
Da in der Anordnung nur lineare Operationen durchgeführt werden, erhält man für beliebige Eingangsfolgen u die Ausgangsfolge v durch Überlagerung der taktweise verschobenen und mit den ui multiplizierten Impulsantworten. Für die Eingangsfolge u = 1011101.... etwa entsteht als Ausgangsfolge v eine, in der zu jedem Infobit zwei Codebits erzeugt werden, siehe Tabelle 3-30. Ein solcher Code trägt ähnlich den Blockcodes die Bezeichnung (2,1)-Code, allgemein (n,k)-Code. i
u u·g
1
1
g
2
0
0
3
1
g
4
1
g
5
1
g
6
0
0
7
1
g
..
..
..
pro Takt i sind die Beiträge u·g um 2 Bits verschoben 1 1 1 0 1 1 0 0 0 0 0 0 1 1 1 0 1 1 1 1 1 0 1 1 1 1 1 0 1 1 0 0 0 0 0 0 1 1 1 0 1 1
v Summe 1 1 1 0 0 0 0 1 1 0 0 1 0 0 1 0 1 1
Tabelle 3-30: Ausgangsfolge v als Überlagerung der mit ui gewichteten Impulsantworten Wenn man mit gj, j = 1, 2, 3, ... die um 2Yj Stellen verschobene Impulsantwort bezeichnet, kann die Ausgangsfolge bis zum Takt i kompakt über die Beziehung i
vi=u1g1 u2g2 u3g3 ....... = ug j j j=1
mit
g1=g g2=0 0 g g3=0 00 0g
=11101100000 .... =0011101000000 ..... =000011101000000 .....
227
3 Fehlerbeseitigung
Einfluss der Vergangenheit
ausgedrückt werden. Daher stammt auch die Bezeichnung „ Faltungscode“: Jede Folge v entsteht als Summe der mit den Infobits „gefalteten“, zeitlich verschobenen Impulsantworten. Ein wesentlicher Unterschied der codierten Folge v bzw. des sich daraus ergebenden Sendesignals vs zu den Blockcode-Signalen besteht darin, dass in einem Codewortbit jeweils der Einfluss mehrerer Infobits enthalten ist. Die in den Blockcodes streng gegen die Infobits abgegrenzten Prüfbits erscheinen hier also in jedem Codewortbit mit diesen gemischt. Die Inforate beträgt im vorliegenden Fall R = ½. Die Impulsantwort g liefert mit ihren Bits in einer alternativen Darstellung die Koeffizienten eines Generatorpolynoms gF(x): gF x = 1 1x 1x2 0x 3 1x 4 1x5 = 1 x x2 x 4 x5
Mal anders: Das Generatorpolynom
Es besteht kein unmittelbarer Zusammenhang zu den Generatorpolynomen der zyklischen Codes. insbesondere gibt es leider keine Systematik, um über den Aufbau eines solchen Generatorpolynoms gezielt gewünschte Eigenschaften eines Faltungscodes festzulegen. Nur durch rechnerunterstützte Suche lassen sich aus der unendlichen Menge aller möglichen Generatorpolynome geeignete finden. Möglich heißt hier, dass jedes beliebige Polynom eine Schieberegister-Anordnung beschreibt. Adamek erläutert im Unterkapitel 14.1 seines Buches das Verfahren: • Bei einem (n,1)-Code wird ein willkürlich gewähltes Polynom des Grades grad gF(x) = (nYm -1), m = 2, 3, 4, .... nach steigendem Index der Koeffizienten in m Teilpolynome der Länge n aufgeteilt, in unserem Beispiel gF x = 1 x x2 0 x4 x 5
Der erste Block gibt die direkte Verknüpfung des Infobits mit den ersten n Codebits (Durchschaltung des Eingangs) an. • Der zweite Block definiert die Verknüpfung des ersten Speicherausgangs mit den ersten n Codebits usw. Zu der in Bild 3.34 skizzierten Anordnung hätte man also kommen können, wenn willkürlich das genannte Generatorpolynom bestimmt und daraus die Struktur abgeleitet worden wäre. Decodieren durch Die Erzeugung der „Codewörter“ v und der Sendesignalfolgen vs ist damit beschrieben. Wie sieht die Decodierung aus? Der EmpModellbildung fänger lässt ein gleiches Modell der Schieberegister-Anordnung des Codierers mitlaufen, das er zusammen mit dem Anfangszustand der beiden Speicher ja genau kennt. Anhand der ersten beiden Empfangsbits testet er, welches Infobit dieses Empfangssignal erzeugt hat. Bei Fehlerfreiheit gelingt die exakte Rekonstruktion nicht nur dieses ersten, sondern auch aller weiteren In•
228
3.13 Faltungs-Codes (Convolutional Codes)
Das Prinzip des großen Bellman
Zustand
Takt i=0
fobits, weil die Zuordnungen „Infobits zu Speicherzuständen zu Ausgangsfolgen“ eindeutig sind. Mit Hilfe des zeitlichen Zustandsverlaufes lässt sich das übersichtlich darstellen. Das entsprechende Diagramm hat den Namen Trellis (= Gitter, Spalier, Gitterdiagramm) und geht auf A. J. Viterbi zurück, der 1967 damit ein Verfahren zur Decodierung der Faltungscodes entwickelt hat (A. J. Viterbi, „Error bounds for Convolutional Codes and an Asymptotically Optimum Decoding Algorithm“, IEEE Transactions Information theory IT-13, Seiten 260-269 ). Es gründet sich auf das Bellman'sche Optimalitätsprinzip, was besagt, dass jedes Teilstück eines optimalen Verlaufes selbst optimal ist. Umgekehrt kann ein Verlauf, der nicht optimale Teilstücke enthält, nicht optimal sein. Dieses Prinzip verhilft zu einer entscheidenden Verringerung des Decodieraufwandes. Beim Codieren entstehen noch keine besonderen Anforderungen, da jede Folge von Infobits genau einen Weg durch das Zustandsgitter erzeugt, wie es Bild 3.35 zeigt. Takt i=1
i=2
i=3
i =4
i=5
01
10
i=6
i=7
i=8
i=9
x1,x2 11
10
v1,v2=11
00
01
00
00
10
01
10
v1,v2=00
gangsfolge v !
11 11
10
:
ui = 1
:
ui = 0
00
01
10
01
00
10
11
Bild 3.35: Trellisdiagramm für die Infofolge u = 1011101 Canale Grande: nur Ärger
Der Empfänger allerdings kennt diesen Verlauf nicht und muss wegen des Kanalrauschens rs auch damit rechnen, dass die Empfangssignalfolge ws wegen ws = vs + rs die Sendefolge vs nur unsicher wiedergibt. Nehmen wir zunächst an, dass er sich auf HD-Demodulation beschränkt. Dann sind nach der „0“/“1“ -Zuordnung zur Empfangsfolge w eventuell einige Bits gekippt. Bei ungestörtem Kanal wäre w mit v identisch. Der Hammingabstand d hätte den Wert Null. Erhält z. B. der Empfänger als erstes die beiden Bits v11 =1, v21 = 1, so schließt er aus der Zustandstabelle, dass diese Kombination in Verbindung mit x1 =0, x2 = 0 • erstens zulässig ist
229
3 Fehlerbeseitigung zweitens nur durch ein Infobit u1 = 1 entstanden sein kann Allerdings bleibt eine Unsicherheit zurück, denn die beiden Empfangsbits hätten ja auch gekippt sein können, so dass 00 gesendet wurde. Dann wäre die Schlussfolgerung falsch gewesen und der Sender hätte das Infobit ui = 0 geschickt. Daher bezieht der Empfänger auch diesen Fall mit ein. Beide Fälle überträgt er in das Zustandsdiagramm und schreibt zusätzlich die zugehörigen Hammingdistanzen d dazu. Nehmen wir nun an, es wären tatsächlich zwei Fehler passiert, z. B. beim 3. und 6. Bit. Dann erhält er statt •
Prüfmittel Hammingabstand
w = v =
11 10 00 01 10 01 00 10 11 00 00
die Folge w = Was ist und was sein darf
So geht’s nicht!
Die Lösung: Viterbi's Idee
230
11 00 01 01 10 01 00 10 11 00 00
Er durchläuft jetzt die oben genannten Schritte, hat dabei aber keinen Entscheidungsspielraum: • Zu jedem Speicherzustand x1, x2 vor einem Taktwechsel gibt es gemäß der Zustandstabelle genau einen neuen Zustand für ein Infobit „0“- oder „1“, sowie genau eine Codefolge v. • In jedem neuen Takt bestimmt er für jeden dieser Fälle den Hammingabstand d zum Empfangsbit-Paar und addiert ihn, beginnend im zweiten Takt, als dgi+1 = dgi + d auf. • Dies wiederholt sich für jeden neuen Takt, wobei sich die Anzahl der möglichen Teilverläufe in jedem Takt verdoppelt. Bei „s“ Empfangsbit-Paaren laufen also 2s mögliche Wege auf. • Am Ende wählt er aus den 2s Ergebnissen denjenigen Verlauf mit dem kleinsten Hammingabstand dg aus. Dieser Weg ist wegen des exponentiellen Anwachsens nicht praktikabel. Viterbi hat gezeigt, dass • wegen der auf 2m begrenzten Anzahl verschiedener Speicherzustände ab Takt i = m+1 tatsächlich nur noch je 2m+1 verschiedene Fälle zu berechnen sind • jeder Zustand von 2 Wegen angelaufen wird • von diesen wegen des Optimalitätsprinzips nur derjenige weiter verfolgt werden muss, der den kleineren bis dahin aufgelaufenen Hammingabstand hat, weil der zum größeren Abstand dg gehörende ab dann nicht weiter verbessert werden kann (bei Gleichheit wird eine willkürliche Entscheidung getroffen) • in jedem Takt damit 2m mögliche Wege übrig bleiben • zum Schluss derjenige Weg mit dem kleinsten der 2m Hammingabstände das gesuchte Ergebnis liefert.
3.13 Faltungs-Codes (Convolutional Codes) Für unser Beispiel ist der Rechengang in Bild 3:36 gezeigt, wobei die in jedem Takt übrig bleibenden Kandidaten grau hinterlegt wurden. Im ersten Schritt gibt es nur 2 mögliche Zustände, da wir vom Zustand 00 ausgegangen sind. Eine Auswahl kann noch nicht getroffen werden, da zu jedem der beiden Zustände vom Anfangszustand 00 nur ein Weg hinführt.
u
i=1 w=11 x w d dg
1 10 11 0 0 00 00 2
0 2
1
= û1
u
i=6 w=01 x w d dg
i=2 w=00 x w d dg
u
i=3 w=01 x w d dg
u
i=4 w=01 x w d dg
u
u
i=5 w=10 x w d dg
1 11 10 2 0 01 01 0
3 1
1 11 10 2 0 01 01 0
5 3
1 10 00 1 0 00 11 1
4 4
1 10 00 1 0 00 11 1
2 2
1 10 00 1 0 00 11 1
2 2
1 11 01 2 0 01 10 0
4 2
1 11 01 1 0 01 10 1
1 1
1 11 01 0 0 01 10 2
4 6
1 11 01 0 0 01 10 2
2 4
1 10 11 1 0 00 00 1
3 3
1 10 11 2 0 00 00 0
4 2
1 10 11 1 0 00 00 1
3 3
1 10 11 1 0 00 00 1
3 3
1 11 10 0 0 01 01 2
2 4
0
= û2
u
i=7 w=00 x w d dg
1
= û3
u
i=8 w=10 x w d dg
1
= û4
u
i=9 w=11 x w d dg
1
= û5
u
i=10 w=00 x w d dg
1 10 00 1 0 00 11 1
3 3
1 11 10 1 0 01 01 1
4 4
1 11 10 0 0 01 01 2
4 6
1 11 10 1 0 01 01 1
5 5
1 11 10 1 0 01 01 1
6 6
1 11 10 2 0 01 10 2
5 5
1 10 11 2 0 00 00 0
5 3
1 10 00 1 0 00 11 1
5 5
1 11 01 1 0 01 10 1
5 5
1 10 00 0 0 00 11 2
5 7
1 10 11 1 0 00 00 1
4 4
1 11 10 1 0 01 01 1
5 5
1 10 11 1 0 00 00 1
4 4
1 10 11 0 0 00 00 2
4 6
1 11 01 1 0 01 10 1
5 5
1 11 10 2 0 01 01 0
4 2
1 10 00 0 0 00 11 2
4 4
1 11 01 2 0 01 10 0
6 4
1 10 00 2 0 00 11 0
6 4
1 10 11 2 0 00 00 0
6 4
0
= û5
1 = û7
0 = û8
0 = û9
0 = û10
Bild 3.36: Viterbi-Decodierung der Empfangsfolge w zur optimalen Schätzfolge û = û1, û2, ........, û7. Die Bits û8, û9, û10 entstehen wegen des Ausschwingens der Impulsantwort und können der Kontrolle dienen. Im zweiten Schritt sind es 4 mögliche Kandidaten, im dritten Schritt 8. Jetzt wird jeder der 4 Zustände von je zwei Vorgängern
231
3 Fehlerbeseitigung Überlebenschancen
Es funktioniert ...
angelaufen. (Hinweis: das oberste Zustandspaar des aktuellen Taktes, also Zeilen 7 und 8, haben den obersten, grau hinterlegten Kandidaten aus dem vorherigen Takt zum Vorgänger, das zweite Paar (Zeilen 5 und 6) den zweit obersten „Grauen“ usw.). Wegen des Optimalitätsprinzips „überlebt“ nur der Weg mit dem kleineren Gesamtabstand, bei Gleichheit wird einer willkürlich gewählt. Bei i=10 zeigt der unterste Zustand mit dg = 4 den kleinsten Gesamtabstand und gehört daher als Knoten zum optimalen Weg. Dieser wird gefunden, wenn man schrittweise von hier aus über die Vorgängerknoten bis i=1 zurückgeht. Die optimal geschätzten Infobits liegen damit ebenfalls fest und die Decodierung ist beendet. Trotz der beiden Fehler in der Sendefolge wurde also die richtige Eingangsfolge gefunden. Nun ist noch die Frage zu klären, wieviele Fehler überhaupt korrigierbar sind. Die Antwort erfolgt für HD ähnlich wie bei den Blockcodes über den minimalen Hammingabstand. Da die Codewörter aber keine feste Länge haben, sondern sogar beliebig lang sein können, wird die Definition diesen Verhältnissen angepasst. Man betrachtet eine Codefolge v minimaler Länge. Diese hat gerade die Länge der Impulsantwort g oder des Generatorpolynoms g(x) und es gibt zu den zwei Werten des Infobits u1 die beiden Codefolgen va und vb:
v=u1g und u2=u3=u4= .... =0 : u1=0: u1=1:
va=000000 vb=110111
Auch hier: Immer Der Hammingabstand dieser beiden Folgen (Basis-Folgen, siehe (freien) Abstand auch die Basiswörter in Unterkapitel 3.7.5 zu den zyklischen Codes) legt den so genannten freien Abstand dfr dieses Faltungscohalten des fest, im Beispiel beträgt er dfr = 5. Für die Korrektur von t Ein-Bitfehlern muss der freie Abstand dfr 2t kor 1
sein. Im Beispiel sind in einer Minimalfolge von 6 Codebits t=2 Fehler korrigierbar, was durch unser Ergebnis bestätigt wird. Weitere zwei Ein-Bitfehler dürfen erst in der nächsten Minimalfolge ab dem 4-ten Codefolgen-Paar auftreten usw., sonst bleiben beim Decodieren in der Schätzung nicht korrigierbare Fehler übrig, was ja in ähnlicher Weise auch bei den Blockcodes der Fall ist, wenn bei HD-Demodulation mehr Fehler auftreten als dem Abstandsgesetz entspricht. Adamek führt als Ergebnis einer Rechnersuche einige (n,1)-Codes mit ihren freien Abständen und Impulsantworten bzw. Gene-
232
3.13 Faltungs-Codes (Convolutional Codes) ratorpolynomen auf:
Variantenreichtum
Ideal: SD-Decodierung für Faltungscodes
n
dfr
tkor
g oder g(x)
2
5
2
110111
2
6
2
11110111
2
7
3
1101011011
2
10
4
111011110111
3
10
4
111011101111
4
13
6
11110111110011111
Diese Erläuterungen konnten hoffentlich einige Grundgedanken zu den Faltungscodes klar machen. Weitere Besonderheiten: • Über die (n,1)-Codes hinaus gibt es auch solche, bei denen mehr als ein Infobit pro Takt eingespeist werden kann, diese Codes tragen die Kurzbezeichnung (2,k) und bestehen aus k Generatorpolynomen. • Außer den Schieberegistern ohne Rückführung, die immer endliche Ausgangsfolgen liefern, gibt es auch solche mit Rückführung und unendlich langen Ausgangsfolgen. Wir kennen solche Anordnungen bereits von den MOD-Dividierern bei den zyklischen Codes. • Unter den möglichen Faltungscodes gibt es neben geeigneten Versionen auch als katastrophale Codes bezeichnete, die nicht eingesetzt werden dürfen, da sie kein brauchbares Ergebnis liefern. • Das Viterbi-Decodierverfahren für die Faltungscodes eignet sich beinahe ideal auch für Soft Decision-Decodierung, da der für HD beschriebene Ablauf ohne Änderung übernommen werden kann. Eine vergleichbare Möglichkeit bietet sich bei den Blockcodes nicht. Dem kleinen Nachteil eines höheren Aufwandes für die numerische Berechnung der (quadratischen) Abstände zwischen den verrauschten Empfangsfolgen ws und den möglichen Sendefolgen vs zu jedem Taktzeitpunkt steht der Vorteil einer um bis zu 3 db besseren Restfehlerbeseitigung gegenüber. Da das Viterbi-Verfahren in der SD-Form eine Optimalitätsberechnung über die gesamte Empfangsfolge durchführt, ist es vom Maximum LikelihoodTyp. • Eine Soft Decision-Variante nach dem MAP-Prinzip, bei dem gemäß Unterkapitel 3.12 für jedes Bit ein eigener Schätzwert ûi mit Vorzeichenangabe und Wahrscheinlichkeitsmaß entsteht, wurde 1974 von Bahl, Cocke, Jelinek und Raviv in „Optimal decoding of liear codes for minimizing symbol error
233
3 Fehlerbeseitigung rate“, IEEE Transactions Inf. Theory, vol 20, Seiten 284 – 287, vorgeschlagen. Sie ist heute als BCJR-Algorithmus bekannt. Obwohl es zum Gebiet der Fehlerbeseitigung eine gewaltige Fülle verschiedener, hoch interessanter Ideen, Varianten, Lösungsvorschläge und Lösungen gibt, die fortwährend ergänzt werden, endet hiermit der Versuch zur Darstellung einiger Grundgedanken.
3.14
Was blieb? 1. 2. 3. 4. 5. 6. 7. 8.
9.
10.
11. 12.
13.
14.
234
In welchem Zusammenhang stehen BCH-Codes und Goppa-Codes? Ist der Goppa-Code zyklisch? Ist er systematisch? Durch was wird beim Goppa-Code die Länge n der Codewörter bestimmt? Wie werden beim Goppa-Code die Paritätsbeziehungen gebildet? Welches mathematische Werkzeug spielt beim Decodieren von Goppa-Codewörtern eine wesentliche Rolle? Welches Entscheidungsprinzip wird zur Decodierung von Reed-Muller-Codewörtern angewendet? Warum ist der Reed-Muller-Code rechentechnisch einfacher zu bearbeiten als der BCH-Code? Welche Besonderheit eines Rauschsignals rs kann im ungünstigen Fall den Vorteil des Interleavings verringern? Mit welcher Maßnahme kann dem begegnet werden? Kann ein Produktcode horizontal aus Reed-Solomon-Codewörtern, vertikal aus Goppa-Codewörtern zusammen gesetzt sein? Worin besteht hinsichtlich des Decodierens die theoretische Stärke eines Produktcodes gegenüber einem eindimensionalen Code (Hamming-Code, BCH-Code, RSCode)? Worin besteht die Überlegenheit des MAP-Prinzips gegen das ML-Prinzip? Warum lässt sich eine bedingte Wahrscheinlichkeit oft (aber nicht grundsätzlich) einfacher mit Hilfe der Bayes'schen Formel berechnen Welches Prinzip nutzt das Decodierverfahren nach Viterbi für Faltungscodes und worin besteht der Vorteil gegenüber einem grundsätzlichen Lösungsweg? Gibt es mathematisch begründete Verfahren zur Konstruktion von Generatorpolynomen für Faltungscodes?
4
Jetzt kommt Grund in die Sache
4.1
Rückgekoppelte Schieberegister Rückgekoppelte Schieberegister wurden bereits im Unterkapitel 3.5.3 zur MOD-Division eines Informationspolynoms u(x) oder eines Empfangswortpolynoms w(x) mit einem Generatorpolynom g(x) benutzt, um Wörter für zyklische Codes zu erzeugen oder um Fehler erkennen bzw. korrigieren zu können. Allerdings beschränkte sich das auf kleine Beispiele, an denen man erkennen konnte, dass es tatsächlich funktioniert. Wir erweitern unsere Betrachtung jetzt, um die Besonderheiten von rückgekoppelten Schieberegistern noch besser für unsere Zwecke ausnutzen zu können. Die hiermit herstellbaren Zahlenfolgen (bei uns beschränkt sich das auf "0/1"-Folgen) haben so interessante Eigenschaften, dass man sie sowohl für die Fehlerkorrektur als auch zur Verschlüsselung einsetzen kann. Diese Eigenschaften werden im folgenden Unterkapitel betrachtet.
Eigenschaften Im Unterkapitel 3.7.2 war ein Schieberegister mit 3 Speichern s0, s1, s2 benutzt worden (siehe Bild 3.12 auf Seite 109). Dies wird jetzt für ein Schieberegister mit m Speichern s0, s1, ...., sm-1 verallgemeinert, wie es Bild 4.1 zeigt.
bm-1 a(i)
sm-1 sm-1(i)
bm-2
s0
ssm-2 1
sm-2 sm-2(i)
b0
b1
s1(i)
u(i)
s0(i)
Bild 4.1: Linear rückgekoppeltes Schieberegister mit m Speichern Aufbau: Einfacher geht’s kaum
Der ganz links liegende Ausgang der Speicherkette ist linear auf die einzelnen Speichereingänge rückgekoppelt, je nachdem, ob die m Rückkopplungsfaktoren bj "0" oder "1" sind. Außerdem kann rechts noch ein Eingangssignal u eingespeist werden. Das Ausgangssignal zum Zeitpunkt t = iT trägt die Bezeichnung a(i). Ein Taktsignal (es muss nicht notwendigerweise gleichmä-
235
4 Rückgekoppelte Schieberegister
Taktgefühle
ßig sein, der Einfachheit halber wird dies aber hier angenommen) sorgt dafür, dass bei jedem neuen Takt folgendes passiert: • Das vor dem Taktwechsel am Eingang jedes Speichers liegende Signal se,j(i-1) wird auf den Ausgang durchgeschaltet und erscheint nach dem Taktwechsel als sa, j(i) •
= se, j(i-1).
Vor jedem Taktwechsel werden alle MOD 2-Additionen (= XOR-Verknüpfungen) ausgeführt und an den Speichereingängen bereitgestellt, so dass immer se, j(i-1)
= b j a(i-1) + sa, j-1(i-1)
bzw. für den ersten Speicher se,0(i-1)
= b0 a(i-1) + u(i-1)
gilt. Mit den Abkürzungen sa,m-1(i)
= sm-1(i)
sa,m-2(i)
= sm-2(i)
usw.
erhält man daher folgende m Beziehungen: a(i)
= sm-1(i)
= bm-1 a(i-1) + sm-2(i-1)
sm-2(i)
= bm-2 a(i-1) + sm-3(i-1)
.
.
s1(i)
= b1 a(i-1)
+ s0(i-1)
s0(i)
= b0 a(i-1)
+ u(i-1).
Diese Beziehungen gelten natürlich für jeden beliebigen Taktzeitpunkt, also lässt sich die letzte auch als s0(i-1) Eine Gleichung für alles
= b0 a(i-2)
+ u(i-2)
schreiben. Wenn man dies in die darüberstehende Gleichung übernimmt, wird s0(i-1) beseitigt. Verfährt man Gleichung für Gleichung nach oben hin so fort, dann verschwinden alle Speichergrößen und es bleibt die Rekursionsgleichung a(i) = bm-1a(i-1) + bm-2a(i-2) + ....... + b1a(i-m+1) + b0a(i-m) + u(i-m) oder unter Beachtung der schon oft erwähnten Besonderheit " Addition = Subtraktion" im Z2 a(i) + bm-1a(i-1) + bm-2a(i-2) + ....... + b1a(i-m+1) + b0a(i-m) + u(i-m) = 0. Ohne Eingangssignal u ist übrigens die zukünftige "Geschichte" des Registers ausschließlich durch den Zustand der Speicherzellen, d. h. durch deren Inhalt zu einem willkürlich gewählten Zeitpunkt t = iT bestimmt. Deshalb bezeichnet man diese In-
236
4.1 Eigenschaften halte auch als Zustandsgrößen (eine reale Bedeutung haben sie z. B. in mechanischen Systemen als Energiezustände: Die Geschwindigkeit eines Körpers ist ein Maß für seine kinetische Energie). In unserem Zusammenhang hat diese Tatsache sogar eine ganz ... endlich .... entscheidende Folge: Es gibt nur eine endliche Anzahl solcher Zustände, genau gesagt sind es 2m. Da der Null-Zustand 0,0,0,...,0 immer in sich selbst übergeht, bleiben 2m-1 verschiedene Zustände übrig, die höchstens durchlaufen werden können. Eine Folge verschiedener Zustände ist also bestenfalls 2m-1 lang, dann spätestens wiederholt sie sich. Allerdings gibt es auch kürzere Folgen, und wir werden bald sehen, wovon dies abhängt. Auf jeden Fall verbessert sich für unsere Zwecke die Brauchbarkeit einer Folge, je länger sie ohne Wiederholung ist. Die oben angegebenen diskreten Zeitfunktionen (wenn man sie Laufzeiten und Transformationen so deuten will) lassen sich übrigens in den Frequenzbereich transformieren und gestatten eine weitere nützliche Erkenntnis. Man erhält dabei so etwas wie eine diskrete Laplace-Transformation, hierauf soll aber nicht näher eingegangen, sondern gleich das Ergebnis betrachtet werden (wer mehr darüber wissen möchte, kann z. B. in das Buch “Diskrete Regelsysteme” von W. Leonhard sehen). Mit z-1 = e-Tp als Laufzeittransformierte (siehe auch Unterkapitel 6.2.4) wird die letzte der obigen Gleichungen in a z bm1
az az az az uz bm2 2 ....... b1 m1 b0 m m = 0 z z z z z
transformiert. Multiplikation mit zm ergibt a(z) zm + bm-1 a(z) zm-1 + bm-2 a(z) zm-2 + ...+ b1 a(z) z + b0 a(z) + u(z) = 0 oder a z =
uz zm bm1 zm1 bm2 zm 2 b2 t2 b1 z b0
Die Rückkopplungskoeffizienten b j erscheinen also als Koeffizienten des Rückkopplungspolynoms b(z) Schon wieder Ploynome
= zm + bm-1 zm-1 + ...... + b1 z + b0
zu dem wir bei der Behandlung der zyklischen Codes auch "Generatorpolynom" gesagt hatten. An dieser Darstellung erkennt man, dass das Polynom a(z) nichts anderes als das Divisionsergebnis des Polynoms u(z) durch das Polynom b(z) ist. Der jeweilige MOD-Rest steht in den m Speicherzellen. (Hinweis für Elektrotechniker: Genau genommen ist die diskrete FourierTransformation nur für abschnittsweise kontinuierliche Vorgänge definiert. Durch die Konstruktion des Schieberegisters können
237
4 Rückgekoppelte Schieberegister
Tot oder lebendig
von den "unendlich" vielen möglichen Signalfolgen aber nur solche auftreten, die die Werte "0" oder "1" haben. Die Gültigkeit der Voraussetzungen für die Laplace-Transformation ist dennoch nicht eingeschränkt, weil sie ja nur das System, nicht jedoch das Signal betrifft). Interessant ist an dieser Stelle weniger die Fähigkeit eines rückgekoppelten Schieberegisters als die eines Polynom- oder Binärzahlen-Dividierers. Was passiert eigentlich, wenn man das Eingangssignal u weglässt (=auf dem Wert 0 hält) und das Register sich selbst überlässt. Haben alle Zustandsgrößen (= Zelleninhalte) den Wert 0, so tut sich gar nichts, d. h., diesen Zustand muss man vermeiden. Anders sieht es aus, wenn eine oder mehrere Zellen mit dem Wert 1 besetzt sind. Am besten lässt man für das zu erwartende Ergebnis ein kleines Programm ablaufen, welches die obige Rekursionsgleichung abbildet. Da es hierfür verschiedene Varianten gibt, die sich bezüglich Leistungsfähigkeit und Übersichtlichkeit unterscheiden, einigen wir uns auf die (hoffentlich) gut nachvollziehbare Matrixform in Bild 4.2 mit den Zustandsvektoren s(i) und s(i-1) sowie der "Systemmatrix" C. Das Ganze ist nichts anderes als eine Darstellung der oben aufgebauten Zustandsgleichungen. Sehen wir uns ein paar Beispiele an, wobei zur Vereinfachung die Folge A der Registerausgangswerte a(i) mit A
= a(1),
a(2), a(3), a(4), ......
bezeichnet wird. ... für Programmierer
[ ] [ ][ ] [ ]
s0 i 0 0 0 .... 0 0 b0 s0 i1 ui1 s1 i s1 i1 1 0 0 .... 0 0 b1 0 0 s s i 1 0 0 .... 0 0 b i1 2 2 2 s i = = .............. ......... ............................ ............... 0 sm2 i 0 0 0 .... 1 0 bm2 sm 2i1 0 sm1 i 0 0 0 .... 1 0 bm1 s m1 i1
Bild 4.2: Zustandsgleichungen in Matrixform für ein rückgekoppeltes Schieberegister mit m Speichern Mit Hilfe des Vektors e (hier in transponierter Darstellung) eT = [ 1 0 0 0 ... 0 0 0 ]
und der „Übergangsmatrix“ C kann man dies in Kompaktform schreiben: s i = Csi1 eui1 ai = sm1 i
238
4.1 Eigenschaften Bei m = 5 ist mit einer maximalen Periodenlänge von n = 25 - 1 = 31 zu rechnen. Das Rückkopplungspolynom b(z)
= z5 + z4 + z3 + z2 + z + 1,
ergibt mit den Zelleninhalten (Achtung: bm = b5 erscheint in Bild 4.2 nicht!) s0(0) = 1, s1(0) = s2(0)
= s3(0)
= s4(0)
=0
die Folge Nicht ohne Folgen
A1 = 100001100001100001100001100001100001100001100001100001100001100001
(die Elemente 1, 32 und 63 sind zur besseren Orientierung unterstrichen), mit dem Polynom b'(z) = z5 + z3 + z2 + z + 1 erhält man bei sonst gleichem Anfangszustand A2 = 11001101111101000100101011000011100110111110100010010101100001110
oder mit dem geänderten Anfangszustand s0(0) = s1(0)
= s2(0)
= s3(0)
= s4(0)
=1
schließlich A2a = 011111010001001010110000111001101111101000100101011000011100110111
Überblick verloren Es ist nicht gerade einfach, aus diesen "Zahlenhaufen" irgendwelche Besonderheiten herauszulesen. Am einfachsten geht es noch mit der Folge A1, da sich hier immer zwei Einsen und vier Nullen ablösen. Die Folgenlänge beträgt also nur n1=6. Bei A2 scheint es sich um eine Folge maximaler Länge (n2=31) zu handeln, ebenfalls bei A2a, welche offensichtlich denselben Aufbau wie A2 besitzt, jedoch gegenüber dieser nach links verschoben ist (man vergleiche ab dem doppelt unterstrichenen Element in A2). Man muss aber schon sehr genau hinsehen, um ganz sicher sein zu können. Dabei hat das erzeugende Schieberegister mit m=5 sogar nur eine recht kleine Ordnung. Man stelle sich statt dessen Schieberegister der Ordnung 10 oder 20 vor. Eine Beurteilung der von diesen erzeugten Folgen durch "Betrachtung" ist dann nicht mehr zu machen. An dieser Stelle helfen uns die Werkzeuge der Statistik, deren Retter Statistik Aufgabe in der Bestimmung charakteristischer Kenngrößen von Zahlenmengen liegt. Bekannt sind z. B. Mittelwert und Streuung (= Standardabweichung) oder auch Verteilungsfunktionen. Für unsere Zwecke sind die so genannten Korrelationsfunktionen nützlich, welche die inneren Abhängigkeiten der einzelnen Zahlenwerte voneinander beschreiben. Betrachten wir zuerst die Autokorrelationsfunktion Maa(k) (abgekürzt AKF), die für endliche Zahlenmengen A = a(1), a(2), a(3), ....., a(n) als
239
4 Rückgekoppelte Schieberegister n
$aa k =
AKF: Ein starkes Tool
•
Die AKF ist eine symmetrische Funktion, also Maa(k) = Maa(k). Man braucht also zur Bestimmung ihres Verlaufs nur die Hälfte ihrer Werte aus zurechnen. A2 und A2a haben trotz der Verschiebung dieselbe AKF (Bilder 4.3c und 4.3d). Allgemein gilt, dass Verschiebungen sich nicht auf den Verlauf der AKF auswirken.
Bild 4.3a: Schieberegisterfolge A1 und AKF bei nicht minimalem Rückkopplungspolynom b(z), n=62
Bild 4.3b: wie 4.3a, aber n = 60
240
für k = 0, 1, 2,....., n1
definiert ist. Da a(i+n) = a(i) gilt (zyklische Verschiebung), wiederholt sich alles periodisch für k > n. Die Anwendung dieser Formel auf die genannten 3 Folgen ergibt die in den Bildern 4.3a bis 4.3d dargestellten Diagramme. Man erkennt hier unmittelbar die Folgenlänge aus den sich wiederholenden Verläufen. Bemerkenswert sind vor allem vier Beobachtungen:
•
AKF -Tomographie
1 aiai k, n i=1
4.1 Eigenschaften
Bild 4.3.c: Maximallängenfolge n= 25-1 = 31 und AKF
Bild 4.3.d verschobene Maximallängenfolge n= 25-1 = 31 und AKF Auf der Suche nach den Maximallängen
A2 und A2a weisen im Punkt k=0 den Wert (n-1)/n | 1 auf und haben in den restlichen n-1 Punkten immer den Wert (n1)/(2n) | 0.5. Ein solches Ergebnis ist charakteristisch für alle Binärfolgen maximaler Länge. Wahrscheinlich käme man durch bloßes Betrachten nicht so schnell darauf, dass sich hier ein so einfacher und vor allem gleichmäßiger Verlauf ergibt. Überhaupt ist es doch bemerkenswert, dass sich aus dem maximalen „Chaos“ der 31 regellosen Werte die einfachste AKF ergibt. • Die kleinere Länge n1 = 6 bei der AKF von Folge A1 erkennt man an den periodischen Maximalwerten in Bild 4.3a. Da die Gesamtfolgenlänge mit n = 62 aber kein Vielfaches von 6 darstellt, sind die einzelnen Teilmaxima der AKF im kleinen nicht symmetrisch aufgebaut. Wählt man dagegen n = 60, so erhält man die symmetrische Darstellung gemäß Bild 4.3b. Da es für jede beliebige Ordnung „m“ geeignete irreduzible Polynome b(z) gibt, kann auch jede Maximallängenfolge Am ge•
241
4 Rückgekoppelte Schieberegister bildet werden. Für m=6 und mit dem irreduziblen Polynom bz = z6 z5 1
sind die Folge A3 und ihre AKF in Bild 4.4 dargestellt. Aus Chaos entsteht Ordnung
Bild 4.4: Maximallängenfolge A3 und ihre AKF für m=6, n= 63
Kosmetische Operationen
Will man die beschriebenen Zahlenfolgen physikalisch übertragen, dann ist es oft günstiger (aber weder zwingend, noch in jedem Fall möglich), statt der "1"-Werte solche mit "-1" und statt der „0“-Werte solche mit „+1“ zu verwenden. Erstens wird die Folge dadurch (fast) mittelwertfrei. Zweitens kann der Empfänger bei jedem neuen Takt prüfen, ob der Sender überhaupt arbeitet, da immer entweder "1" oder "-1" zu erwarten ist, wohingegen bei "0"-Pegeln solche Schlüsse nicht gezogen werden können. Dieses Prinzip wurde im übrigen auch bei der Modulation binärer Signale verwendet. Die Folgen A1, A2 und A2a gehen bei dieser kleinen Änderung über in A1* = -1+1+1+1+1-1-1+1....,
A2* = -1-1-11-111-1...
A2a* = 1-111111-1-11....
Für die Folge A3 ist dies in Bild 4.5 dargestellt.
Bild 4.5: Maximallängenfolge A4 und AKF für m=6, wie A3, aber (fast) mittelwertfrei
242
4.1 Eigenschaften Die AKF der Binärfolge maximaler Länge hat für k > 0 hier den konstanten Wert Ma*a*(k) = 1/n =1/63. Mit wachsender Ordnung des erzeugenden Schieberegisters geht dieser Wert gegen 0, während der Wert für k = 0 bei Folgeamplituden von ± 0.5 immer Ma*a*(0) = 0.25 bleibt. Letzterer ist der Mittelwert der quadratischen Einzelwerte von A4, die Wurzel daraus kennt man in der Elektrotechnik als Effektivwert A4eff. Der gesamte Verlauf drückt aus, dass die einzelnen Werte der Folge untereinander statistisch wenig abhängig sind. Man kann also aus der Kenntnis eines Wertes oder mehrerer Werte nur schwer auf die folgenden schließen – und das umso weniger, je höher die Ordnung ist. (Eine solche Folge eignet sich gut, um das zufällige Ergebnis nachzubilden, welches beim Werfen einer Münze bezüglich Kopf oder Zahl zu erwarten wäre). KKF: Starker Part- Kommen wir zur Kreuzkorrelationsfunktion Maa'(k) (abgekürzt KKF), bei der nicht eine Folge A mit sich selbst sondern mit ner der AKF einer anderen Folge A' korreliert wird: n
$aa' k =
1 aia 'i k , n i=1
für k = 0, 1, 2,....., n1
Bild 4.6 zeigt die KKF der Folgen A1 und A2, also einer Nichtmaximallängen- und einer Maximallängenfolge. Außer der Folgenlänge von A1 (zu sehen über die Maxima) sind hier keine Besonderheiten zu erkennen.
Bild 4.6: Kreuzkorrelationsfunktion von A1 und A2 Verborgene Zusammenhänge: aufgedeckt
Korreliert man zwei stark verwandte Folgen, wie etwa A2 und die hiergegen verschobenen A2a, so erhält man ein ähnliches Ergebnis, wie bei den zugehörigen AKF's der Einzelfolgen. Lediglich der „Nullpunkt“ liegt anders, wie Bild 4.7 zeigt.
Bild 4.7: Kreuzkorrelationsfunktion von A2 und A2a
243
4 Rückgekoppelte Schieberegister
Elite der Polynome
Die praktische Bedeutung der KKF wird bisher sicher noch nicht klar, jedoch erkennt man bereits, dass die KKF im Gegensatz zur AKF eine ungerade Funktion darstellt. Die wichtigste Erkenntnis der bisherigen Untersuchungen ist aber, dass die geringste statistische Abhängigkeit und die aussagekräftigsten Korrelationsergebnisse bei gegebener Ordnung m offenbar dann erzielt werden, wenn das Rückkopplungspolynom b(z) irreduzibel ist. Zum Abschluß dieser Betrachtungen sehen wir uns daher an, wieviele irreduziblen Polynome eines bestimmten Grades m es gibt, wie man sie berechnet und warum die damit erzeugten Folgen eine maximale Länge n = 2m - 1 aufweisen. Die Antwort auf die erste Frage findet man z. B. im Buch von Lüneburg, der eine Aussage von Galois benutzt. Wir kennen schon das Fermat'sche Theorem aus Kapitel 3.2, Seite 46, welches besagt, dass jedes Polynom xn - 1 mit n = 2m - 1 sich als Produkt irreduzibler Polynome kleineren Grades darstellen lässt. Das entspricht der Primfaktorenzerlegung bei den natürlichen Zahlen. Für m=3 erhälg man wir z. B. x7 – 1 = (x+1)(x3+x+1)(x3+x2+1).
Irreduzible Polynome: Wieviele gibt’s denn?
Kein Mangelprodukt
Galois hat nun gezeigt, dass die irreduziblen Teilpolynome im Fermat'schen Ausdruck nur solche Grade haben können, die m ohne Rest teilen. Bei m = 3 sind das also 1 und 3, bei m= 4 haben wir 1, 2 und 4, bei m=5 gibt es nur 1 und 5 usw. Daraus lässt sich eine Formel aufbauen. Für den Körper Z2 und mit der Bezeichnung Ni als Anzahl aller irreduziblen Polynome vom Grad i ist diese Formel in Bild 4.7 angegeben. Man kann sich das Ergebnis aus der Fermat'schen Beziehung auch selbst ableiten. Für m=1 gibt es demnach genau das eine irreduzible Polynom (x +1), für m=2 ebenfalls ein einziges, nämlich (x2+x+1), für m=3 liegen mit den beiden Polynomen (x3+x+1) und (x3+x2+1) deren N3 = 2 vor usw. In den Tabellen 3-22, 3-23 und 3-24 auf den Seiten 129 ff. findet man das bestätigt. Auf jeden Fall werden es mit wachsender Ordnung immer mehr (übrigens gilt diese Formel mit einer kleinen Ergänzung auch für alle anderen endlichen Primkörper wie Z3, Z5 usw.). Nm =
1 m
2
m
1
im ,aber i#m
iNi
Der Ausdruck i|m bedeutet hier, dass i die Zahl m ohne Rest teilt. Bild 4.8 zeigt einige Werte. Die Berechnung der irreduziblen Polynome ist zwar einfach, wird aber mit wachsendem Grad immer aufwendiger. Das einfachste Verfahren hat Eratosthenes bereits vor mehr als 2000
244
4.1 Eigenschaften Jahren als „Sieb für Primzahlen“ vorgeschlagen, für irreduzible Polynome ist es äquivalent, siehe Seite 113. Für viele Zwecke wird das Nachschlagen in einer Tabelle ausreichen, z. B. im Buch von Peterson.
m=1: N1=1 1 m=2 : N2= 411N1 =1 2 1 m=3: N3= 811N1 =2 3 1 m=4 : N4= 1611N12N2 =3 4 1 m=5 : N5= 3211N1=6 5 1 m=6: N6= 6411N12N23N3=9 6 Bild 4.8: Anzahl der irreduziblen Polynome im Z2 Polynome und maximale Folgen
Viele sind berufen, aber nicht alle sind geeignet
Nun muss man sich noch vergewissern, dass die gewünschten Folgen maximaler Länge tatsächlich von Schieberegistern mit speziellen irreduziblen Rückkopplungspolynomen b(z) erzeugt werden. Die völlige Sicherheit hierüber ist äußerst wichtig, da sich z. B. nur mit solchen Maximallängenfolgen leistungsfähige Fehlerkorrekturverfahren ganz anderer Art als die bisher betrachteten aufbauen lassen, wie im nächsten Unterkapitel dargestellt wird. Der Grund liegt darin, dass die KKF zweier gegeneinander verschobener Maximallängenfolgen den in Bild 4.3c gezeigten markanten und einfachen Verlauf aufweist, wohingegen das für Nicht-Maximallängenfolgen gemäß Bild 4.5a nicht zutrifft. Bei geringen Ordnungen des Schieberegisters (zum heutigen Zeitpunkt – Juni 2006 – liegt eine solche "geringe" Ordnung bei ca. m=30, jedoch verschiebt sich diese Grenze mit wachsender Rechnerleistung dauernd nach oben) könnte man durch systematisches Ausprobieren zwar noch die gewünschten Folgen ermitteln, darüber hinaus wird es aber wegen der exponentiell mit m wachsenden Länge immer aussichtsloser, in angemessener Zeit zum Ziel zu kommen. Untersuchungen zum BerechnungsAufwand bei großen Variablen in einem Algorithmus werden im übrigen in der Komplexitäts-Theorie angestellt. Adamek erklärt im Kapitel 15.2 seines Buches ausführlich, warum spezielle irreduzible Rückkopplungspolynome b(z) Maximallängenfolgen erzeugen. Einen Hinweis findet man aber bereits in den bisher gewonnenen Ergebnissen: Die Tabellen 3-22, 3-23 und 3-24 auf den Seiten 129 ff. zeigen u. a. diejenigen Polynome vom Grad m, die ein primitives Element des GF(2m), also
245
4 Rückgekoppelte Schieberegister eines maximaler Ordnung definieren. Nur diese erzeugen als Generatorpolynome zyklischer Codes zur 1-Bitfehlerkorrektur die maximale Anzahl unterschiedlicher Syndrome. Da rückgekoppelte Schieberegister als MOD-Dividierer aufgefasst werden können, besteht hier ein direkter Zusammenhang mit den Maximallängenfolgen. Der Grundgedanke lässt sich an einem linearen Schieberegister der Ordnung m zeigen. Eine davon erzeugte, unendlich lange Folge kann nur aus sich wiederholenden Teilfolgen bestehen, die höchstens die Länge q <= n = 2 m-1 aufweisen. Zur Erinnerung: Der Grund hierfür liegt in der eindeutigen Festlegung der m Speicherzustände ausschließlich durch den vorangegangenen Zustand – aber natürlich gilt diese Aussage nur dann, wenn kein Eingangssignal u einwirkt. Aus einer anderen Sicht heraus folgt dagegen, dass diese TeilWeder größer m noch kleiner als .. folgen eine Länge q von wenigstens q >= n = 2 -1 haben müssen. Wenn einerseits q nur kleiner oder höchstens gleich n sein kann, andererseits aber mindestens so groß wie n sein muss, gibt es natürlich nur die Lösung q = n. Man geht von einer unendlichen Folge A mit der beliebigen Teilfolgenlänge q <= n aus, wie sie von dem in Bild 4.1 dargestellten Schieberegister (ohne Eingangssignal u(i)) erzeugt werden könnte, und bezeichnet sie mit A
=
a(0) a(1) a(2) ...... a(q-1) a(q) a(q+1) ......,
oder in abkürzender Schreibweise A
=
a0
a1
a2
.....
aq-1
aq
aq+1 ....
Diese Folge lässt sich auch als Polynom in z darstellen, so wie es bei den zyklischen Codes gemacht wurde. Die Potenzen von z dienen dabei nur der anderen Darstellung der FolgenelementPositionen: A(z) Jetzt wird’s ganz schön formal ...
=
a0 z0 + a1 z1 + a2 z2 + ... + aq-1 zq-1 + aq zq + aq+1 zq+1 ...
Man nennt eine solche Darstellung "formale Potenzreihe" (die Bezeichnung "formal" ist deshalb gewählt, weil der Zahlenwert dieser Reihe keinen Sinn ergibt, man aber dennoch formal damit rechnen darf) und kürzt sie mit der Summenschreibweise A z =
a izi i=0
ab. Man kann noch einen Schritt weitergehen und das Teilfolgen-Polynom d(z)
= a0 z0 + a1 z1 + a2 z2 + ..... + aq-1 zq-1,
Grad d(z) < q
vor die Summe ziehen, da es sich unendlich oft wiederholt:
246
4.1 Eigenschaften = d(z)(1 + zq + z2q + z3q + .....).
A(z)
Das Polynom in der Klammer ist wiederum eine formale Potenzreihe. Für solche Potenzreihen gilt der (formale) Grenzwert q
2q
1 z z ............. =
ziq i=0
=
1 1zq
Diese Formel ist vom Rechnen mit reellen Zahlen her bekannt, wo sie für z < 1 zum Bestimmen der Grenzwerte unendlicher geometrischer Reihen dient, z. B. in 2
4
1 0.5 0.5 ........ =
Verkehrte Welten
1 = 1.3333333 10.5 2
Man multipliziert nun das Folgen-Polynom A(z) mit dem so genannten reziproken Rückkopplungspolynom b*(z). Es entsteht aus b(z) durch Inversion der unabhängigen Variablen z und Multiplikation mit zm. Da das bereits schon vorher benutzte Rückkopplungspolynom b(z) den Aufbau b(z) = bm zm + bm-1 zm-1 + ...... + b1 z + b0,
bm = 1,
hat, erhält b*(z) die Gestalt
b *z = zmb z1 = zm bm zm bm1 zm 1 ......... b1 z1 b0 , 1
= bm bm1 z .......... b1 z
m1
b0 z
bm =1
m
Ein reziprokes Polynom hat im Vergleich zu seinem nicht reziproken Partner denselben Grad und dessen reziproke Nullstellen (z. B. ist x3 + x2 + 1 reziprok zu x3 + x + 1). Für Polynom-Produkte gilt außerdem (b(z)c(z))* = b*(z)c*(z). Potenzmittel
Das Produkt von b*(z) mit der Potenzreihe A(z) ergibt
f z = b*zAz = a0 bm +a0 bm1 a1 bm z +a0 bm2 a1 bm1 a2 bm z2 +................... +a0 b1 a1 b2 ......am1 bm zm1 +a0 b0 a1 b1 ...... am bm zm +................. Die Klammerausdrücke bei den z-Potenzen ab zm und größer sind alle 0, da in den Klammern ab dieser Stelle nichts anderes steht als die Rekursionsbeziehung, die bereits auf Seite 236 er-
247
4 Rückgekoppelte Schieberegister mittelt wurden (hier fehlt das Eingangssignal u). Daher hat das Produktpolynom f(z) einen kleineren Grad als m, also Grad f(z) < m. Aus all diesen Überlegungen heraus gilt nun A z = d z1 zq z2q z3q ....... f z = b * z d z = 1zq oder f z1zq = d zb * z
Die erwähnte Produktregel für reziproke Polynome gestattet es, daraus die Darstellung f * zzq1 = d*zbz
entweder oder ...
Fahrbahnteiler
abzuleiten. Das Polynom b(z) ist nach Voraussetzung irreduzibel und muss daher entweder ein Faktor von f*(z) oder einer von (zq - 1) sein. Da f*(z) als reziproker Partner von f(z) einen kleineren Grad als m hat, kann b(z) das Polynom f*(z) nicht ohne Rest teilen, denn der Grad von b(z) ist nach unserer Festlegung m. Also muss b(z) das Polynom zq - 1 teilen. Im Bereich der Zahlen gilt dieser Zerlegungssatz für Primfaktoren ganz genauso: Im Produktausdruck 614 = 127 teilt die Primzahl 7 den Faktor 6 nicht und muss dafür zwangsweise Bestandteil des Faktors 14 sein. Aus den Eigenschaften endlicher Körper ist bekannt, dass ein irreduzibles Polynom b(z) das Polynom zq - 1 nur dann teilt, wenn zq - 1 mindestens auch alle Nullstellen von b(z) besitzt (natürlich kann xq - 1 beliebig viele weitere Nullstellen haben). Für m = 3 etwa hat das irreduzible Polynom b(z) = z3 + z + 1 nach Tabelle 3-22, Seite 129, die Nullstellen D, D2 und D4. Das Polynom zq - 1 kleinsten Grades mit diesen Nullstellen ist das mit q = 23-1 = 7 oder – allgemein – das mit q = 2m – 1 = n. Da q wegen der ersten Forderung an die Teilfolgenlänge höchstens gleich groß wie n werden kann, interessieren Werte q > n nicht, und man weiß damit, dass Maximallängenfolgen von linearen Schieberegistern mit speziellen irreduziblen Rückkopplungspolynomen erzeugt werden.
248
4.2 Fehlerbeseitigung durch Kreuzkorrelation
4.2
Und ewig rauschen die Kanäle
Regellos – und doch effektiv!
Fehlerbeseitigung durch Kreuzkorrelation Nach diesen recht trockenen Überlegungen zu den Eigenschaften von Schieberegisterfolgen sehen wir uns an, welcher Nutzen sich daraus ziehen lässt. Mit Maximallängenfolgen können in Verbindung mit der Kreuzkorrelationstechnik sehr leistungsfähige Verfahren zur Fehlerkorrektur "verrauschter" Empfangssignale aufgebaut werden. Ein einfacher Fall wäre etwa gegeben, wenn man zur Entfernungsmessung einen Ultraschalloder Radar-Impuls aussendet und aus der Laufzeit nach Reflexion durch das Zielobjekt die zurückgelegte Strecke bestimmt. Der Haken liegt hierbei darin, dass einerseits das Empfangssignal am Sendeort geschwächt eintrifft und andererseits noch mit Störanteilen aus der Umgebung oder aus dem Eingangskanal des Empfängers überlagert ist. Will man mit einfachen Impulsen arbeiten, so müssen diese für eine sichere Erkennung entsprechend stark sein, jedoch ist damit z. B. in der astrophysikalischen Entfernungsmessung bald eine technische Grenzen erreicht. Hier hilft dann der Einsatz leistungsfähigerer Verfahren weiter. Man sendet nicht nur einen Impuls, sondern eine Impulsreihe, die als Maximallängenfolge aufgebaut ist. Die vom Zielobjekt reflektierte und am Sendeort wieder empfangene Folge ist erstens der Laufzeit entsprechend verschoben und zweitens wegen des überlagerten Rauschens direkt nicht mehr zu erkennen. Das Rauschsignal kann man als eine Folge regelloser Einzelimpulse mit einem bestimmten Effektivwert auffassen. Der Effektivwert ist die Wurzel aus der mittleren Quadratsumme aller Folgenelemente und entspricht damit der Wurzel der AKF an der Stelle k=0. Ein so geformtes elektrisches Stromsignal erzeugt z. B. an einem ohmschen Widerstand die gleiche Wärmeenergie wie ein Gleichstrom von der Stärke des Effektivwertes.
Bild 4.9: Folge r normal verteilter Rauschsignale und ihre AKF
249
4 Rückgekoppelte Schieberegister
(Ver-) Fälschung gelungen ...
Die Werte aus dem Zufallszahlengenerator eines Rechners als ein solches – mittelwertfreies – Rauschsignal r mit dem Effektivwert reff = 1 und seine AKF sind in Bild 4.9 dargestellt. Man beachte auch hier die Symmetrie der linken und rechten Äste, sowie deren kleine Absolutbeträge, die auf eine geringe statistische Bindung verweisen, auch, wenn die AKF hier nicht den glatten Verlauf zeigt wie diejenige der Maximallängenfolgen. Dafür bildet dieses Signal ein wirklich auftretendes Rauschen schon recht brauchbar ab und wiederholt sich praktisch auch nicht (genau genommen wiederholt es sich erst nach einer sehr großen Anzahl von Einzelschritten). Das Sendesignal, hier die Maximallängenfolge A2, wird auf dem Übertragungskanal mit dem Rauschen r überlagert: w = A2 + r Der Empfänger erhält die Folge w, siehe Bild 4.10, aus der das – noch um die Laufzeit verschobene – Sendesignal A2 praktisch nicht mehr wieder zu erkennen ist. Der Störabstand SNR hat hier übrigens den ungünstigen Wert von 0.25/1 =1/4:
Bilf 4.10: verrauschte Empfangsfolge w ... doch Hilfe naht Der zunächst nahe liegende Gedanke, die AKF von w zur weiteren Analyse zu verwenden, siehe Bild 4.11,
Bild 4.11: AKF von w. Der Anteil A2 im Empfangssignal hat hier durch die Laufzeit eine Verschiebung erfahren, der beim Empfänger den Eindruck erzeugt, das A2a gesendet wurde, was in der AKF aber nicht sichtbar ist hilft nicht wirklich weiter, da die Ausprägung der Maximalimpulse von der Summe der quadratischen Effektivwerte von A2 und r bestimmt ist. Der Anteil von r könnte also durchaus den Beitrag von A2 überdecken und damit Rückschlüsse verhindern. Zuverlässiger ist die Kreuzkorrelation zwischen A2
250
4.2 Fehlerbeseitigung durch Kreuzkorrelation und w, siehe Bild 4.12:
Bild 4.12: KKF von A2 und w, der Maximalwert bei k = 6 lässt auf die Laufzeit der Impulsfolge schließen Respekt, KKF: sau- Man kann zwei Maximalwerte bei k=6 und k= -25 erahnen, was einer Differenz von 31 entspricht. Daraus lässt sich auf eine Laufbere Arbeit zeit von 6 Zeiteinheiten schließen. Für eine Entfernungsmessung mit Ultraschall-, Infrarot- oder elektromagnetischen RadarImpulsen scheint das Verfahren also grundsätzlich geeignet zu sein. Eine weitere Verbesserung kann man mit einer Erhöhung der Maximallängen-Ordnung erzielen. Verwendet man für die Sendefolge das Signal A3 mit m=6, so ist die KKF gemäß Bild 4.13:
Bild 4.13: KKF von A3 und w, der Maximalwert bei k = 6 ist hier deutlicher zu erkennen als in Bild 4.12 Einfach: Mit mehr Die Werte größter Korrelation treten hier bereits sehr deutlich hervor, so dass die Sicherheit über eine richtig ermittelte Laufzeit Aufwand mehr von k= 6 Zeiteinheiten sehr hoch ist. Eine weitere Steigerung erErgebnis scheint bei diesem Störabstand von SNR = 0.25 nicht weiter erforderlich. Sie wäre auch ungünstig, da sich der Rechenaufwand zur Ermittlung der KKF mit jeder Ordnung verdoppeln würde.
4.3
Zufallserzeugung von Schlüsselwörtern Schieberegisterfolgen maximaler Länge bieten wegen des geringen inneren Zusammenhangs ihrer einzelnen Elemente auch für den Einsatz in der Informationssicherung gute Voraussetzungen. Sie lassen sich nämlich zur Erzeugung von zufälligen Schlüsselwörtern (also von Wörtern für die Verschlüsselung von Klartexten in Geheimtexte) verwenden, die so gut wie nicht vorhersagbar sind. Verschlüsselungsverfahren werden im nächsten Kapitel noch ausführlich untersucht, aber auch ohne tieferen Einstieg ist vermutlich
251
4 Rückgekoppelte Schieberegister
Dauerthema Passwort
Schwachstelle Mensch
Chipkarten: Dumm, schnell, gut
252
schon jetzt klar, dass die Geheimhaltung von Schlüsseln eine wesentliche Aufgabe darstellt. "Geheimhaltung" heißt dabei nicht nur, einen gerade benutzten Schlüssel (z. B. ein Passwort) vor Unberechtigten zu verbergen, sondern genauso, bei der Wahl weiterer Schlüssel – etwa wenn deren Gültigkeit nach einer Frist abgelaufen ist – möglichst keinen Zusammenhang zu den vorangegangenen erkennen zu lassen. Letzteres würde das Erraten unerwünscht vereinfachen. Machen wir uns die Lage zunächst anhand des Beispiels "Passwortgeschützter Zugang zu einem Rechner" klar. Für ein sechsstelliges Passwort aus Alphazeichen gibt es im Deutschen ohne Umlaute 266 oder etwa 300 Millionen Kombinationen. Bei dieser ungeheuer großen Anzahl ist die Wahrscheinlichkeit, das richtige Passwort durch systematisches Probieren zu finden, äußerst gering, zumal bei vielen Rechnersystemen bereits nach wenigen Fehlversuchen eine Sperrung aktiviert wird, so dass man ohnehin nicht beliebig oft versuchen kann. Dieser theoretisch erreichbare hohe Grad von Sicherheit wird aber in der Wirklichkeit erheblich vermindert. Da die vom Menschen gewählten Passwörter vermutlich häufig aus dem Bereich verständlicher Begriffe stammen, um sie sich besser merken zu können, schrumpft die Menge der tatsächlich gebrauchten Passwörter auf wenige Tausend. Wenn man dazu weitere Anhaltspunkte findet, die es wahrscheinlich werden lassen, dass ein Rechnerbenutzer bevorzugt Passwörter aus einem ganz bestimmten, ihm nahestehenden Begriffsbereich wählt, kann sich das Erraten nochmals entscheidend vereinfachen und die Sicherheit praktisch verlorengehen. Beispiele wie "Passwort = Geburtsort des Passwortbesitzers" oder "Passwort = Vorname des Freundes der Passwortbesitzerin" sind zwar reichlich abgenutzt, treffen den Kern aber trotzdem recht gut. In dieser direkten Form eignet sich also das Passwortverfahren offensichtlich nicht besonders für die Anwendung durch den Menschen. Beutelsbacher beschreibt im Kapitel 4.3 seines Buches Verbesserungen, die sich etwa durch den Einsatz von Chipkarten erreichen lassen. Solche Instrumente, die eigentlich winzige Spezialrechner darstellen, sind bereits seit längerem im Einsatz und können den gesamten Zugangsdialog und dabei auch die Handhabung wirklich zufälliger Passwörter sehr viel vollkommener erledigen. Die immer heikle Rolle des Benutzers "Mensch" beschränkt sich dann auf dessen Berechtigungsnachweis gegenüber der Karte. Zwar bleibt auch das noch ein wunder Punkt, dieser lässt sich aber besser beherrschen, als es beim direkten Dialog zwischen Mensch und Anwendungsrechner der Fall ist. Beim Einsatz von Passwortverfahren kommt es also neben der selbstverständlichen Geheimhaltung der Passwörter darauf an,
4.3 Zufallserzeugung von Schlüsselwörtern diese aus einer möglichst großen Menge zufällig und mit gleicher Wahrscheinlichkeit auszuwählen, um das Erraten für Unberechtigte möglichst schwer zu machen. Das gilt natürlich auch für jeden Passwortwechsel. Ähnliche Verhältnisse liegen vor, wenn Klartexte in Geheimtexte verschlüsselt werden sollen. Als Beispiel dient der folgende Text: diese nachricht ist sofort nach kenntnisnahme zu vernichten! sensation: soeben wurde ueber streng geheime kanaele bekannt, dass eine enge verwandschaft der nierensteinlaus und der blasen-steinlaus mit der erst vor wenigen jahren entdeckten grzimek-loriot-steinlaus besteht Einfach und schlecht
Ein sehr einfaches Verfahren ist das der zyklischen Verschiebung aller Zeichen um einen festen Wert. Man erreicht dies unter anderem durch die Modulo-Addition eines willkürlich gewählten ASCII-Bytes als Schlüssel auf jedes Textzeichen. Der entstehende Geheimtext kann vom Adressaten in den Klartext zurückverwandelt werden, wenn er den Schlüssel Modulo-subtrahiert. Mit dem Schlüssel “C” = 67dez entstehen aus den n Klartextzeichen Ki über Gi = K i32MOD 25612832 32 mit i = 1, 2, ... n
die Geheimtextzeichen Gi GLHVHcQDFKULFKWcLVWcVRIRUWcQDFKcNHQQWQLVQDKPHc]XcYHUQLFKWHQdcVHQVDWLRQ}cVRHEHQcZXUGHcXHEHUcVWUHQJcJHKHLPHcNDQDHOHcEHNDQQWocGDVVcHLQHcHQJHcYHUZDQGVFKDIWcGHUcQLHUHQVWHLQODXVcXQGcGHUcEODVHQpVWHLQODXVcPLWcGHUcHUVWcYRUcZHQLJHQcMDKUHQcHQWGHFNWHQcJU]LPHNpORULRWpVWHLQODXVcEHVWHKW
Verräter: das statistische Profil
Die verwendete Formel stellt sicher, dass von den 256 möglichen ASCII-Zeichen nur die druckbaren im ASCII-Bereich 32dez – 127dez entstehen. Dies dient hier aber ausschließlich der besseren Übersicht beim Verfolgen des Beispiels. Obwohl mit diesem Geheimtext unmittelbar sicher nichts anzufangen ist, kann man ihn durch systematisches Ausnutzen der Häufigkeitsverteilung der Zeichen in natürlichen Sprachen doch einfach entschlüsseln. Eine Tabelle mit solchen Verteilungen ist z. B. im Buch von Heider, Kraus und Welschenbach (Anhang H) oder bei Steinbuch/Rupprecht (Tabelle 9.4) angegeben. Für die Kleinbuchstaben ist dies im oberen Diagramm von Bild 4.14 gezeigt. Wie erwartet, zeigt der Geheimtext gemäß Bild 4.15 die zum Klartext identische Verteilung, da sich diese invariant zu einer zyklischen Verschiebung verhält. Ist man nicht im Besitz des Schlüssels “C”, könnte man alle möglichen Schlüssel durchprobieren, um an den Klartext zu kommen. Ist der Schlüssel ein ASCII-Byte, wäre man in der Tat schnell am Ziel. Bei längeren Schlüsseln steigt aber der Aufwand erheblich, so dass andere Vorgehensweisen gefragt sind. Machbar wäre es, in einem ersten Schritt der Verteilung der
253
4 Rückgekoppelte Schieberegister Geheimtextzeichen diejenige der vermuteten Sprache zuzuordnen.
Sprach-DNA
Bild 4.14: Häufigkeitsverteilung der Buchstaben der deutschen Sprache (oben) und des Beispieltextes (unten). Das Zeichen ] steht dabei für den Zwischenraum oder Leerschritt.
Bild 4.15: Häufigkeitsverteilung des mit der MOD(256-128-32) = MOD(96)-Addition durch das ASCII-Zeichen „C“ (=67) verschlüsselten Textes Leichtes Spiel
Vermutet man einen deutschen Text, kommt die Verteilung aus Bild 4.14 zum Zuge und man erhält: diese nachricht ist sozort nach kenntnisnahme fu vernichten, sensation! soeben wurde ueber streng geheime kanaele bekanntj dass eine enge verwandschazt der nierensteinlaus und der blasen-steinlaus mit der erst vor wenigen :ahren entdeckten grfimek-loriot-steinlaus besteht
254
4.3 Zufallserzeugung von Schlüsselwörtern Redundanz: Der Helfershelfer
Bereits jetzt sind schon große Textteile zu erkennen, die Redundanz der Sprache hilft weiter. So sind offenbar die Zeichen “z” und “f” vertauscht. Macht man das rückgängig, so erscheint: diese nachricht ist sofort nach kenntnisnahme zu vernichten, sensation! soeben wurde ueber streng geheime kanaele bekanntj dass eine enge verwandschaft der nierensteinlaus und der blasen-steinlaus mit der erst vor wenigen :ahren entdeckten grzimek-loriot-steinlaus besteht
Das Weitere ist Feinarbeit. So muss z. B. der Doppelpunkt “:” gegen das “J” getauscht werden: diese nachricht ist sofort nach kenntnisnahme zu vernichten, sensation! soeben wurde ueber streng geheime kanaele bekanntj dass eine enge verwandschaft der nierensteinlaus und der blasen-steinlaus mit der erst vor wenigen Jahren entdeckten grzimek-loriot-steinlaus besteht
Wasserdicht machen
Die Krönung: Einmal-Schlüssel
und so weiter. Mit Rechnerunterstützung laufen die notwendigen Schritte sehr schnell ab, so dass die zyklische Verschlüsselung kurzer Klartextblöcke für Geheimhaltungszwecke unbrauchbar ist. Der Schwachpunkt liegt, wie wir uns überzeugen konnten, im charakteristischen Verteilungsprofil der Klartextzeichen. Dies lässt sich auf zwei verschiedenen Wegen entschärfen: • Man fasst Klartextzeichen zu längeren Blöcken zusammen, “verwirbelt” die Bits ähnlich wie die Kugeln in einer Lottomaschine, – nur umkehrbar – und verschlüsselt diese vorbehandelten Blöcke zum Geheimtext. Da dieses Verfahren, wie zuvor, zyklisch arbeitet, ist das Verwirbeln unbedingt erforderlich. Sonst könnte man nach Unterteilung der Geheimtextblöcke leicht wieder das Verteilungsprofil der Einzelzeichen ermitteln. Die Verbesserung liegt nun darin, dass der “Angreifer” auf eine wesentlich flachere Verteilung der Geheimtextblöcke trifft als bei Einzelzeichen. Bei genügend langen Klartextblöcken macht das die richtige Zuordnung der Geheimtextblöcke praktisch unmöglich. Das DES-Verfahren verwendet diesen Weg und arbeitet mit wenigsten 8 Byte langen Blöcken. • Man verwendet für jedes Klartextzeichen einen anderen, zufällig gewählten Schlüssel. Dieses Verfahren geht auf den amerikanischen Ingenieur Gilbert S. Vernam zurück und wird auch one time pad genannt. Obwohl es sich für den praktischen Gebrauch wegen des aufwändigen Schlüsseltausches nicht besonders gut eignet, gilt es in der Verschlüsselungstheorie als perfektes Verfahren. Der uns bereits aus dem Gebiet der Leistungsbeurteilung von Fehlerkorrekturcodes bekannte geniale C.E. Shannon hat dieses in “Communication Theory of Secrecy Systems”, Bull. Sys. Tech. J. 28 (1949) , Seiten 656 – 715, bewiesen. Für die 272 Zeichen des Beispieltextes benötigt man zur one time pad-Verschlüsselung also 272 zufällig gewählte Schlüsselzeichen.
255
4 Rückgekoppelte Schieberegister Diese erzeugt man auf einfache Weise über Schieberegisterfolgen. Das hat den zusätzlichen Vorteil, dass man gar nicht die Folge selbst, sondern nur deren Startzustand als “Basisschlüssel” an den Adressaten übergeben muss. Auch hierbei sind einige Punkte besonders zu beachten. Sehen wir uns aber zunächst in Bild 4.16 das Ergebnis an, wenn 96 verschiedene mögliche Schlüssel-Bytes im Wertebereich zwischen 1 und 96 eingesetzt werden: Profil kaputt
Bild 4.16: Häufigkeitsverteilung eines Geheimtextes bei one time pad-Verschlüsselung
Aufwandsfragen
256
Die Zahl verschiedener Geheimtextzeichen ist von 27 auf 89 gestiegen, das Verteilungsprofil hat sich stark abgeflacht. Selbst aus der verbliebenen Struktur lässt sich keine brauchbare Schlussfolgerung auf die Klartextzeichen mehr ziehen, da wegen der zufälligen Verschlüsselung hinter jedem Geheimtextzeichen mehrere unterschiedliche Klartextzeichen stehen. Vielleicht kann man ahnen, dass ein solches Verfahren tatsächlich zur perfekten Verschlüsselung führt. Das nicht vollkommen flache Verteilungsprofil hat seinen Grund in dem verhältnismäßig kurzen Klartext, bei dem sich die statistischen “Unebenheiten” noch nicht ganz glätten lassen. Im übrigen wird hier eine Eigenheit deutlich, die in der Verschlüsselungstheorie eine besondere Rolle spielt: Zwar kennt man bei praktisch allen Verfahren systematische Wege, um einen Geheimtext auch ohne Schlüsselkenntnis zu entschlüsseln. Bei brauchbaren Verfahren ist dafür aber der Aufwand so hoch, dass keine Chance besteht, in angemessener Zeit ein Ergebnis zu erhalten. Die Mathematiker kennzeichnen dies durch Angabe der bereits zuvor erwähnten Komplexität des Verfahrens. Sie liefert eine Abschätzung der benötigten Rechenoperationen, wenn die dafür entscheidenden Parameter eingesetzt werden. Beispiele: • Bei der zyklischen Verschlüsselung mit einem einzigen Schlüs-
4.3 Zufallserzeugung von Schlüsselwörtern
Der ultimative Grund
Starker Wächter: Komplexität
sel wächst die Anzahl der maximal benötigten Versuche – auch als “Brute Force” bezeichnet – linear mit der Anzahl der möglichen Schlüssel. Sind die Schlüssel ASCII-Bytes, benötigt man also maximal 256 Versuche, für eine rechnerunterstützte Aktion keine wirkliche Herausforderung. • Beim one time pad-Verfahren müsste man zu n Klartextblöcken und m Schlüsseln maximal mn Operationen investieren. Der Aufwand steigt bei festem n mit wachsendem m polynomial (Exponent bleibt konstant), bei festem m mit wachsendem n aber exponentiell (Exponent verändert sich). Im Beispiel ist n = 272 und m = 96, so dass man auf 96272 | 10540 käme. Allerdings müsste man nicht den gesamten Geheimtext auf einmal ansetzen, sondern würde sich diesen in kleinere Einheiten zerlegen. Bei z. B. 10 Zeichen wären in diesem Beispiel “nur” 9610 | 1020 Versuche durchzuführen. Der Aufwand läge dann in Größenordnungen, für die im Jahr 2001 eine “Brute Force”-Attacke auf einen mit einem 56 Bit-Schlüssel behandelten DESGeheimtext in etwa 22 Stunden erfolgreich war (2 56 | 1020), siehe Unterkapitel 5.2. Das ändert jedoch nichts an den astronomisch hohen Unterschieden zu einem zyklischen Verfahren. Aber aufgepasst: Diese rein numerische Sicht verdeckt eine nochmals tiefere Wirkung des one time pad-Ergebnisses, die es wirklich perfekt macht. Man sucht bei einer “Brute Force”-Attacke ja nach etwas, was eine inhaltlich sinnvolle oder erwartete Information sein könnte. Beim Durchlaufen der Schlüsselmenge entsteht aber jede mögliche Kombination aller Klartextzeichen. Die 272 Zeichen des Beispiels würden also eine große Menge sinnvoller, teilweise äußerst unterschiedlicher, aber ebenso auch ähnlicher Klartexte ergeben. Groteskerweise stünde man dann vor der Aufgabe, hieraus die gesuchte Information auswählen zu müssen, ohne einen Anhalt zur eindeutigen Zuordnung zu haben, ein wirklich unlösbares Problem. Da die Entwicklungen der Informationstechnologie wie etwa Prozessorleistungen am ehesten linear oder bestenfalls polynomial voran schreiten, sind Verschlüsselungs-Algorihmen mit exponentieller Komplexität gegen Aufbrechversuche sicher. Technischen Leistungssteigerungen kann man hier leicht durch Vergrößerung der Komplexitätsparameter begegnen. Die Bezeichnung one time pad kommt aus der vereinfachenden Sicht, dass der Sender die Schlüssel auf zwei Zettelblöcke schreibt, und einen davon an den Empfänger übergibt. Zur Ver- und Entschlüsselung wird nun den beiden Blöcken ein Schlüssel nach dem anderen entnommen – und anschließend vernichtet. Beutelsbacher weist darauf hin, dass dieses Verfahren zur Zeit des kalten Krieges wahrscheinlich für die Nachrichtenübermittlung zwischen
257
4 Rückgekoppelte Schieberegister dem Kreml und dem Weißen Haus über das berühmte Rote Telefon vorgesehen war. Die Rolle der Zettelblöcke wurde hier vielleicht von Magnetbändern übernommen. Wie zuvor angedeutet, geht es aber auch einfacher, wenn man die besonderen Eigenschaften rückgekoppelter Schieberegister zu Hilfe nimmt. Meister der Viel- Wie in den Unterkapiteln 4.1 und 4.2 zu sehen war, lassen sich mit seitigkeit: Schiebe- geeigneten Rückkopplungsstrukturen Maximallängenfolgen erzeugen, deren Elemente kaum einen inneren Zusammenhang beregister sitzen. Unterteilt man diese Folgen in Abschnitte, die der Länge der Klartextblöcke von z. B. 8 Bit entsprechen, so kann man diese als Zufallszahlen interpretieren. Geeignete Rückkopplungsstrukturen sind dann gegeben, wenn die Rückführungen im Schieberegister an denjenigen Stellen gesetzt werden, wo das Rückkopplungspolynom “1”-Koeffizienten aufweist. Als Beispiel wird ein Schieberegister der Ordnung m = 12 betrachtet, welches mit dem irreduziblen Rückkopplungspolynom bz = z12 z6 z4 z 1
arbeitet. Es wurde der Tabelle über irreduzible Polynome im Buch von Peterson entnommen. Die damit realisierbare Maximallängenfolge ist 2m -1 = 4095 Bits lang. Mit einem Startwert s 0 = [s 0, s2, ....., s11 ] = [1 0 0 0 0 1 0 0 0 0 0 1]
der Speicher von links nach rechts ergibt sich die Ausgangsfolge A1 = 000101101010001110111110010011000010110101000111011111001001100001...
.... (fast ) reiner Zufall ....
Achtung: Schlaglöcher
und je 8 Bit stellen eine zufällige, gleichverteilte Binärzahl im Wertebereich zwischen 0 und 255 dar. Um eine größere Menge von 8Bit Zufallszahlen zu erzeugen, müssen also nur die beiden Parameter m und s(0) bekannt sein. Nur diese beiden Werte sind auch dem Adressaten zur Entschlüsselung zu übermitteln. Leider besitzt dieses Verfahren immer noch einen Pferdefuß. Wenn ein unberechtigter Interessent des Klartextes irgendwie einige Schlüsselwörter zu fassen bekommt, so kann er sich eventuell alle anderen daraus bestimmen. Warum? Der Grund liegt in der linearen Verknüpfung der Folgenelemente über das Rückkopplungspolynom. In Kapitel 4.1 wurde festgestellt, dass die Folgenelemente sich aus der Beziehung ai = bm1ai1 bm2ai2 ..... b0aim
berechnen lassen. Dies besagt, dass bei Kenntnis des Rückkopplungspolynoms b(z) und m aufeinanderfolgender Elemente a(im), ....., a(i-1) das nächste Element a(i) bekannt ist. Damit gilt diese Aussage allgemein auch für alle weiteren Elemente a(i+1), ..., a(i+2), ... . Nun dreht man den Spieß um und nimmt an, dass man
258
4.3 Zufallserzeugung von Schlüsselwörtern zwar 2m Folgenelemente kennt, nicht aber das Rückkopplungspolynom b(z). Mit (aufeinander folgenden!) 2m Elementen lassen sich m verschiedene – bei Vorliegen einer Maximallängenfolge sogar unabhängige – Gleichungen aufstellen: a(i)
= bm-1a(i-1)
+ bm-2a(i-2) + ....
+ b1a(i-m+1) + b0a(i-m)
a(i+1)
= bm-1a(i)
+ bm-2a(i-1) + ....
+ b1a(i-m+2) + b0a(i-m+1)
.
.
+ bm-2a(i+m-3) + ..
+ b1a(i)
. a(i+m-1)
... und geknackt!
= bm-1a(i+m-2)
. + b0a(i-1)
Das ist nichts anderes als ein lineares Gleichungssystem zum Bestimmen der m unbekannten Rückkopplungskoeffizienten in b(z). Als Beispiel wird die in Unterkapitel 4.1 erzeugte Folge A2 = 000101101010001110111110010011000010110101000111011111001001100001...
verwendet, aus der die 10 Folgenelemente ab dem doppelt unterstrichenen bekannt seien, also die Teilfolge 1011111001. Wir nehmen versuchsweise an, dass die Ordnung des erzeugenden Schieberegisters m=5 ist und beachten, dass links das älteste, rechts das jüngste erzeugte Element steht. Mit der willkürlichen Annahme i=6 ergäbe sich die Folge a(1)=1,
a(2)=0,
a(3)=1,
a(4)=1,
a(5)=1,
a(6)=1
usw. Mit den in einem Vektor zusammengefassten unbekannten Rückkopplungskoeffizienten lassen sich die 5 Gleichungen in Matrixform als
[ ] [ ][ ] 1 1 0 0 1
Enttarnung der Unbekannten
=
1 1 1 0 11 1 1 11 1 1 0 11 1 0 0 11
b4 1 b3 0 1 b2 1 b1 1 b0
schreiben. Die Auflösung nach dem Koeffizientenvektor erfolgt wie üblich, indem man das System durch lineare Zeilen- und Spaltenoperationen so umformt, dass die Matrix eine rechte obere Dreiecksform annimmt:
[ ] [ ][ ] 1 0 1 0 1
b4 1 1 1 0 1 b3 0 1 1 1 1 = 0 0 1 1 1 b 2 0 0 0 1 1 b1 0 0 0 0 1 b0
259
4 Rückgekoppelte Schieberegister Damit sind die 5 gesuchten Koeffizienten, das Rückkopplungspolynom b(z) und die Schlüsselfolgen vollständig bekannt: b0 b(z)
=1, 5
b1=1, 3
b2=1,
b3=1,
b4=0
2
= z + z + z + z +1.
Man muss also unter allen Umständen vermeiden, dass ein Unberechtigter in den Besitz zusammenhängender Teilfolgen gelangt. Das wäre möglich, wenn ihm zu einem entsprechend langen – oder kurzen – Stück Geheimtext auch der zugehörige Klartext vorläge. Wird immer nach der Verwendung von 2Ym-1 Schlüsselbits auf einen neuen Speicherzustand oder sogar auf ein anderes Rückkopplungspolynom umgeschaltet, so ist dieser Weg zwar blockiert, wegen der zusätzlich an den Adressaten zu übermittelnden Angaben aber kaum praktikabel. Gefragt: (Dienst-) Im übrigen hat es ein Angreifer zunächst insofern schwerer, als er Grad-Kenntnisse den Grad m des verwendeten Schieberegisters nicht, wie oben angenommen, bereits kennt. Allerdings kann er versuchen, diesen aus seinem vorhandenen Datenmaterial zu ermitteln, wenn er zwei Eigenschaften berücksichtigt: • Bei Annahme eines zu hohen Polynomgrades für b(z) enthält das lineare Gleichungssystem abhängige Zeilen, die seine Auflösung verhindern; dann muss der angenommene Grad verkleinert werden. • Bei Annahme eines zu niedrigen Polynomgrades entstehen ebenfalls linear abhängige Zeilen, die man im Gegensatz zum vorherigen Fall sogar direkt erkennt. Im Beispiel enthält die Teilfolge A2 rechts neben der doppelt unterstrichenen "1" die 5 kursiv dargestellten, hintereinander stehenden "1"-Elemente:
Hilft: HSW = Häufiger Schlüsselwechsel
....10111110010........
Panzersperren
260
Für m=4 würde die Systemmatrix 2 gleiche Zeilen aufweisen, da sie ja aus aufeinanderfolgenden Abschnitten von A2 zusammengestellt wurde. Allgemein gilt, dass in einer Maximallängenfolge der Ordnung m nicht mehr als m "1"- oder m "0"-Elemente zusammen auftreten können, wovon man sich mit einem Blick auf die möglichen Verknüpfungen in Bild 4.1 überzeugen kann. In einem solchen Fall muss also der Polynomgrad so lange erhöht werden, bis dieses Übel beseitigt ist. Ein anderer Weg besteht in der Benutzung nichtlinear rückgekoppelter Schieberegister, bei denen sich die Rückkopplungskoeffizienten nicht mehr aus einem linearen Gleichungssystem bestimmen lassen. Beutelsbacher gibt im Kapitel 3.5 seines Buches zu dieser Technik einige Hinweise.
4.4 Was blieb?
4.4
Was blieb? 1.
Bleibt das one time pad-Verfahren perfekt, wenn die Anzahl verschiedener Schlüssel gegenüber der Anzahl verschiedener Klartextzeichen verringert wird? 2. Besteht eine reale Möglichkeit, die Parameter eines linearen Schieberegisters zur pseudo-zufälligen Schlüsselerzeugung für das one time pad-Verfahren über die ausschließliche Auswertung eines Geheimtextes G zu ermitteln? 3. Welche Antwort zu Frage 2 ist zu geben, wenn zum Geheimtext G auch kurze Stücke des zugehörigen Klartextes K verfügbar sind? 4. Erzeugt ein lineares, mit den Koeffizienten eines über Z2 irreduziblen Polynoms vom Grad m rückgekoppelten Schieberegisters immer eine maximale Pseudo-Zufallsfolge der Länge 2m -1? Begründung? 5. Die mittlere Entropie Hmd eines Zeichens (ASCII-Darstellung) der deutschen Sprache betrage k. Ist die mittlere Entropie HmG gleich, kleiner oder größer als k? 6. Mit welchem Verfahren kann die Laufzeit eines Radarsignals auch bei stark gestörtem (verrauschten) Empfangssignal noch sicher erkannt werden? 7. Wenn f(x) ein über Z2 irreduzibles Polynom ist: Welche Eigenschaften zeichnet das hierzu reziproke Polynom aus´? 8. Wie heißt der Entdecker der Steinlaus? 9. Welche Maßnahmen kann der Angreifer auf einen mit dem one time pad-Verfahren pseudo-zufallsverschlüsselten Geheimtext G, der ein Stück zugehörigen Klartextes K kennt, treffen, um den Grad m des Schieberegisters zu ermitteln? 10. Warum eignet sich die Autokorrelationsfunktion AKF eines verrauschten Empfangssignals nicht zur Fehlerbeseitigung, sondern nur die Kreuzkorrelationsfunktion KKF?
261
5
Objekte gleich, Aufgaben anders
Werkzeugkästen reich bestückt
Datenverschlüsselung Nachdem im Unterkapitel 4.3 bereits Gesichtspunkte zur Verschlüsselung von Klartexten in Geheimtexte unter dem Blickwinkel der Erzeugung zufälliger Passwörter erörtert wurden, geht es nun darum, einige heute aktuelle Verfahren aus dem Gebiet der Kryptologie (Lehre von der Geheimhaltung und Verschlüsselung) anhand von Beispielen darzustellen und ein "Gefühl" für deren Leistungen zu ermöglichen. Nebenbei wird damit auch eine Grundlage geschaffen, um schneller in weiterführende Literatur einsteigen zu können, falls dies erforderlich ist. An sich sind die Verfahren zur Datenverschlüsselung wie diejenigen zur Datenfehlerbeseitigung ebenfalls Codierungsverfahren, wobei die Aufgabenstellung aber anders lautet. Während das Ziel für die Datenfehlerbeseitigung darin liegt, Informationen wiederherzustellen, die durch unerwünschte technische Fehler verfälscht wurden, will man bei der Datenverschlüsselung gerade umgekehrt die Informationen systematisch so verfälschen, dass sie nicht rekonstruiert werden können, es sei denn, durch ausdrücklich hierzu Berechtigte. Aus diesem Grunde unterscheiden sich die Verfahren zur Datenverschlüsselung erheblich von denen zur Datenfehlerbeseitigung, jedoch verwenden sie zum Teil die gleichen mathematischen Hilfsmittel. Viele, vor allem die moderneren, benutzen die hochinteressanten Eigenschaften von Primzahlen und endlichen Zahlenkörpern, wobei sich dieses aber nicht mehr auf den Z2 beschränkt. Wie für die Fehlererkennungs- und Korrekturverfahren gibt es auch für die Verschlüsselung heute fertige Hard- und Softwarelösungen. Pakete mit mathematischen Hilfsmitteln stehen auch als Ergebnisse von öffentlich geförderten Verbundprojekten zur Verfügung, wie es z. B. im Aufsatz "Eine Krypto-Toolbox für Smartcards" in der Zeitschrift für Datenschutz und Datensicherung, 7/92, S. 353 ff. von H.J. Knobloch und P. Horster beschrieben ist. Als zentrale Einrichtung behandelt das Bundesamt für Sicherheit in der Informatiostechnik BSI Fragen von öffentlichem Interesse aus diesem Gebiet und bietet Rahmenrichtlinien, an denen man sich orientieren kann. Trotz dieser Hilfsmöglichkeiten bleibt es für den Ingenieur und Informatiker weiterhin nützlich und vorteilhaft, Verschlüsselungsverfahren nicht nur zur Kenntnis zu nehmen, sondern deren
263
5 Datenverschlüsselung Wirkungsweisen verstehen sowie die Leistungen vergleichen und bewerten zu lernen. Zur Einordnung in die dabei vorliegende Begriffsumgebung mögen die folgenden sehr groben, pragmatischen Definitionen dienen: Begriffsklärungen • Ein Informatiksystem ist der technische Verbund von Hardware- und Betriebssoftware-Komponenten, auf dem Anwendungssysteme ablaufen können. Es besteht im wesentlichen aus den Recheneinheiten, den Speichern, den Ein/Ausgabeeinrichtungen sowie den Verbindungskanälen und Netzwerken. Die Arbeitsfähigkeit eines Informatiksystems wird durch eine Reihe flankierender Maßnahmen gestützt, z. B. durch Datensicherungsverfahren gegen technisch bedingten Datenverlust oder durch Maßnahmen zur Informationssicherung gegen illegale Zugriffe. • Informationssicherheit durch Gewährleistung der VertraulichDas Dreigestirn: keit, Verfügbarkeit und Integrität aller in und mit Informatik-Verfügbarkeit systemen verarbeiteten Daten ist eines der wesentlichen Ziele -Vertraulichkeit für den Betreiber. Es besteht darin, Programme und Daten in -Integrität einem mit dem Kunden (= Auftraggeber und Anwender) abgestimmten Umfang gegen unberechtigten Zugriff, Verlust und Verfälschung zu sichern. Der zu erreichende Grad ist daher vereinbarungsabhängig und ergibt sich aus dem Gleichgewicht zwischen unverzichtbaren Forderungen und bezahlbarem Aufwand. Um diesen Grad der Informationssicherheit zu erreichen, bedient sich der Betreiber eines Informatiksystems der Werkzeuge der Informationssicherung. Um den Kunden eine geeignete vertrauenswürdige Basis und stetige Fortentwicklung bieten zu können, ist die Orientierung an Information Security Management Systemen ( ISMS) hilfreich, wie sie etwa mit Hilfe des BS7799-Standards angeboten wird. Sicherung bringt • Die Informationssicherung umfaßt alle die Maßnahmen, welche zum Erreichen einer gewünschten Informationssicherheit Sicherheit notwendig sind.
5.1
Datenverschlüsselung zur Informationssicherung Wer heute ein Informatiksystem plant und betreibt, muss dazu Antworten für eine ganze Reihe verschiedenster Fragen finden, um seinen Kunden etwas anbieten zu können, was den Ansprüchen der Informationssicherung genügt. Wie zuvor festgelegt wurde, heißt das vor allem, dass Programme und Daten gegen unberechtigten Zugriff, Verfälschung und Verlust ausreichend gesichert sein müssen. So trivial dies auch klingt, so ist zum Erreichen dieses Ziels doch ein äußerst methodisches, systematisches und sorgfältiges Vorgehen mit dauernden Überprüfungen
264
5.1 Datenverschlüsselung zur Informationssicherung
Gesetz und Warenkörbe
Verschlüsseln: nur Teil eines Ganzen
Kandidatenliste
der Wirksamkeit erforderlich. Da Informatiksysteme mittlerweile in beinahe allen mittleren und großen Unternehmen die Geschäftsprozesse unterstützen, birgt ihr unverzichtbarer Einsatz auch erhebliche Risiken bis zur Verhinderung der ordentlichen Geschäftstätigkeit. Die Gesetzgeber haben daher ihrerseits bereits tiefgreifende Auflagen geschaffen. Neben diesen gesetzlichen Gesichtspunkten wird eine der ersten Fragen sein, welchen Sicherheitsgrad der Benutzer eigentlich fordert und was er dafür zu zahlen bereit ist. Einige Ansprüche, wie z. B. der Schutz vor physischer Zerstörung von Daten und Programmen, sind wohl immer unverzichtbar, andere können nach Wunsch hinzukommen, wie etwa die "Rund um die Uhr"-Verfügbarkeit, die man nicht in jedem Fall benötigt. Die technische, organisatorische und personelle Ausstattung des Informatiksystems hängt stark von diesen gesetzlichen und gewünschten Anforderungen ab. Ob man die darauf geführten Daten verschlüsselt, ist nur einer von vielen weiteren Aspekten und nimmt keineswegs eine besondere Stellung ein. Statt dessen wird eine ausreichende und vor allem noch bezahlbare Informationssicherheit nur gewährleistet, wenn alle Teilmaßnahmen in einem ausgewogenen Verhältnis zueinander stehen. Um diesen selbstverständlich erscheinenden Zustand erreichen zu können, müssen viele Überlegungen angestellt w