Grundkurs Codierung, 3. Auflage

Stimmen zu vorangegangenen Auflagen: „Beim Thema Codierung /. . ./ ist das Dankmeier-Buch immer noch eins der besten“ P...

Author: Wilfried Dankmeier

108 downloads 2053 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

DOWNLOAD PDF

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 werden. Eine Checkliste, die weder Vollständigkeit noch Ausgewogenheit beansprucht, und in der mit dem "V" markiert ist, wo Verschlüsselungsverfahren helfen würden, könnte sein: • Zugangsschutz am Aufstellungsort (kontrollierter Gebäudeund Raumzugang zum Rechnersystem und zu den Endgeräten) [V] • Ausfallgesicherte Stromversorgung für Rechner, Speicher und Netzwerke • Ausfallgesicherte Kühlung der Temperatur-empfindlichen Komponenten • Brandschutz • • •

•

Fachliche und sicherheitstechnische Schulung des Personals und der Anwender [V] Einsatz genügend leistungsfähiger und zuverlässiger Rechenanlagen und Hilfssysteme [V] Einhaltung gesetzlicher Bestimmungen (z. B. Bundesdatenschutzgesetz, Telekommunikations-Gesetz, Sabarnes-Oxly Act usw.) [V] Bereithaltung von Ersatzsystemen und Wiederherstellungsverfahren bei Ausfällen (Backup) [V]

265

5 Datenverschlüsselung • • • •

Organisation und Personaltraining für den Fall des Übergangs auf Ersatzsysteme (Notfallpläne, Disaster Recovery) Sichere und verteilte Aufbewahrung von Datensicherungsmedien [V] Kontrolliertes Einspielen von Daten, Programmen und Updates [V] Virenschutz [V bedingt]

•

Das Quartett der Kernaufgaben

5.2

Kontrollierter Zugriff auf die Rechnersysteme, Daten und Programme, auch über externe Netze [V] • Organisierte Programmentwicklung und Überführung in den Produktivbetrieb mit Funktionstrennung. [V] Man erkennt, dass Verschlüsselungsverfahren nur bei einem Teil dieser Überlegungen eine Rolle spielen. Dort sind sie dann allerdings in einem größeren Rahmen zu sehen, als man vielleicht annimmt. Das klassische, mit seinen Ursprüngen weit in die Vergangenheit vieler tausend Jahre zurückreichende Gebiet der Verschlüsselung von Daten hat sich erst in den letzten Jahrzehnten bedeutend erweitert. Es sind wenigstens folgende Aufgabengebiete dazu zu zählen: • Benutzer-Authentikation: Sicherstellung, dass nur Berechtigte ganz bestimmte Handlungen vornehmen dürfen, wie z. B. Informationen lesen, erzeugen, kopieren oder weiterleiten, Gebäude oder Räume betreten usw. Letztlich kann man in dieser Aufgabe eine Erweiterung des Passwortverfahrens sehen. • Nachrichten-Verschlüsselung: Ursprünglich nur die Verschlüsselung von Klar- zu Geheimtext, umfasst heute auch die Aufgabe der sicheren Übertragung von Schlüsseln. • Nachrichten-Integrität: Sicherstellung, dass eine Nachricht nicht unerkannt verfälscht werden kann. Diese Aufgabe ähnelt derjenigen der Fehlererkennung und ist heute in vielen Fällen sogar wichtiger als die Geheimhaltung der Nachricht selbst. • Nachrichten-Authentikation: Sicherstellung, dass die Nachricht vom angegebenen Autor gesendet wurde. Dazu gehört z. B. das Gebiet der elektronischen Unterschrift.

Verschlüsselung nach dem Data-Encryption-Standard (DES) Die Verschlüsselung mit dem DES-Algorithmus gehört heute – noch – zu den am meisten gebrauchten Verfahren für diese Zwecke. Obwohl seine Sicherheit immer wieder angezweifelt wurde, gibt es bisher keinen bekanntgewordenen erfolgreichen Versuch, ihn mit anderen Mitteln als durch „Brute Force“ zu bre-

266

5.2 Verschlüsselung nach dem Data-Encryption-Standard (DES) chen. Letzteres ist in der hier beschriebenen Urversion mit 56Bit-Schlüsseln inzwischen allerdings mehrfach gelungen. Obwohl der damit verbundene Rechenaufwand immens ist und bei weitem nicht von jedermann geleistet werden kann, gilt er damit in dieser Form nicht mehr als wirklich sicher. Da er andererseits in einer leicht erweiterten Variante als Triple DES wieder sicher gemacht werden konnte, eignet er sich zu Anschauungszwecken dennoch gut als erprobtes Grundmodell für symmetrische Verschlüsselungs-Verfahren. Der DES wurde von IBM in den 70er Jahren entwickelt und späKampferprobt: ter vom amerikanischen National Bureau of Standards (NBS) für Der Klassiker die Vereinigten Staaten von Amerika standardisiert (Dokument: Federal Information Processing Standards Publication 46 vom 15.01.1977). Der DES wird vermutlich noch einige Zeit in Gebrauch bleiben. Ende 2001 wurde vom National Institut of Standards and Technology (NIST) sein Nachfolger AES (= Advanced Encryption Standard) frei gegeben, der nun bei neueren Entwicklungen zum Einsatz kommt. Er baut auf Ergebnissen von Joan Daemen und Vincent Rijmen auf. Vom mathematischen Standpunkt aus betrachtet ist der DES ein Tugendhaft: Anspruchslos und äußerst einfaches Verfahren, das symmetrisch arbeitet. Letzteres bedeutet, dass sowohl Verschlüsselung als auch Entschlüsselung schnell mit demselben Algorithmus und mit demselben Schlüssel erfolgen. Diese Aussage wird manchem wegen ihrer scheinbaren Selbstverständlichkeit überflüssig vorkommen, wir werden aber in den nächsten Unterkapiteln noch einige hochwirksame Lösungen kennenlernen, die erstaunlicherweise völlig anders arbeiten. Was passiert nun beim Ver- und Entschlüsseln mit dem DES-Algorithmus? Charakteristisch ist dabei das Durchlaufen von insgesamt 16 Teilschritten, in denen der Klartext K mit Hilfe des Algorithmus A und des Schlüssels S in den Geheimtext G verschlüsselt wird und umgekehrt. Anfangs wählt daher der Absender einen Schlüssel, der aus 56 Bits bestehen muss. Nach den Überlegungen von Unterkapitel 4.3 ist es dringend zu empfehlen, das volle Spektrum der 256 = 72 1015 Bitmuster als Schlüssel gleichmäßig zu nutzen, aber es spricht natürlich nichts dagegen, diese Bitmuster als 7 Zeichen eines 8-Bit-ASCII-Codes aufzufassen. Das in Bild 5.6, Seite 275, gezeigte Beispiel etwa verwendet das Schlüsselwort "Holleri". Vorbild Lottokugel Der DES-Algorithmus erwartet allerdings kein 56 Bit- sondern ein 64 Bit langes Schlüsselwort S, bei dem je 7 Bit des 56-Bit-Wortes durch ein Bit ungerader Parität ergänzt wurde. Diese 7 zusätzlichen Bits haben keine sicherheitserhöhende Wirkung auf die Verschlüsselung und dienen nur dazu, Fehler bei der Übertragung des Schlüssels erkennbar zu machen, siehe auch Unterkapitel 3.6.2. Aus dem 64 Bit langen Schlüsselwort S wird nun für jeden der 16

267

5 Datenverschlüsselung

Schlüsseldienst

... da wird geschoben und getauscht...

erwähnten Teilschritte je ein 48 Bit langer Teilschlüssel S1, S2, ..., S16 erzeugt. Der Ablauf ist im Diagramm des Bildes 5.1a angedeutet und lässt sich vielleicht am übersichtlichsten im oberen Block des Bildes 5.5, Seite 274 verfolgen, da hier ein besonders einfacher Schlüssel (10000000 00000000 00000000 .....) verwendet wurde. Am Anfang steht die Entfernung der Paritätsbits und die Vertauschung aller restlichen Bits gemäß der Permutations-Liste MPC1 in Bild 5.1b. Diese Liste besagt, dass Bit 57 des 64-Bit-Schlüssels S den Platz 1 einnimmt, Bit 49 auf Platz 2 kommt usw. Da in MPC1 die Zahlen 8, 16, 24 usw. nicht auftreten, enthält das Ergebniswort die Paritätsbits nicht mehr und besteht nur noch aus 56 Bits. Diese werden in ein linkes und rechtes, je 28 Bit langes Wort LS0 und RS0 aufgeteilt. Nachdem die beiden Hälften jede für sich mit Z1 zyklisch um ein Bit nach links geschoben und wieder zusammengesetzt wurden (LS1 und RS1), durchläuft das Ergebnis eine zweite Vertauschung gemäß der Permutations-Liste MPC2, die ebenfalls 8 Bits entfernt. Am Ende steht der 48 Bit lange Teilschlüssel S1. Im oberen Block von Bild 5.5, Seite 274 lässt sich das am Beispiel nachvollziehen. LS1 und RS1 bilden nun die Startwerte für die Erzeugung des Teilschlüssels S2, die genauso abläuft. Bei der Berechnung von S3 ist es ebenso, allerdings wird hier zyklisch um 2 Bitpositionen nach links geschoben. Diese zyklischen Verschiebungen geschehen nach folgender Liste: Schritt-Nr.

1

2

3

4

5

6

7

8

9 10 11 12 13 14 15 16

Verschiebung

1

1

2

2

2

2

2

2

1

2

2

2

2

2

2

1

Die Verschiebung um eine weitere Bitposition würde wegen der insgesamt 28 Verschiebungen wieder den Anfangszustand erzeugen.

Bild 5.1a: Schema der DES-Teilschlüsselerzeugung

268

5.2 Verschlüsselung nach dem Data-Encryption-Standard (DES)

Bild 5.1b: Permutationslisten für die DES-Schlüsselerzeugung

Klartext-Bits im Super-Wirbel

Im Beispiel von Bild 5.5, Seite 274, erkennt man auch, dass durch MPC2 immer einige Bits entfernt werden: Die Teilschlüssel 8 und 15 enthalten keine "1" mehr. Nun steht die eigentliche Verschlüsselung im Blickfeld. Bild 5.2 zeigt den Startablauf, der zum ersten Teilergebnis führt. Der 64-BitKlartext durchläuft zu Anfang eine Vertauschung gemäß der Permutations-Liste MIP in Bild 5.3 und wird in zwei 32-Bit-Hälften L0 bzw. R0 aufgeteilt. Das Wort R0 erfährt über ME (Bild 5.3) sowohl eine Permutation als auch eine Verdoppelung bestimmter Bits (nämlich der Bits 4 und 5, 8 und 9 usw.). Als Zwischenergebnis erhält man ein 48-Bit-Wort, welches nun mit dem 48-Bit-Teilschlüssel S1 über die Funktion XOR verknüpft wird.

Bild 5.2: Startphase und Teilschritt 1 der DES-Verschlüsselung mit dem Teilschlüssel S1, den Permutationen MIP, ME und MP, den Substitutionen MS1 bis MS8 und den beiden XOR-Verknüpfungen

269

5 Datenverschlüsselung

Der Fluch des Hütchenspiels: Überblick weg

Das 48-Bit-Zwischenergebnis macht eine besondere Behandlung mit: Den je 6 aufeinander folgenden Bits werden über die Substitutionstabellen MS1, MS2, ...., MS8 gemäß Bild 5.4 je 4 Bits zugewiesen, so dass nach Zusammenfassung wieder ein 32-BitWort entsteht. Ein Beispiel: • Angenommen, der zweite 6-Bit-Block aus dem 48-Bit-Zwischenergebnis sei 101010. Das erste und das sechste Bit wird als Binärzahl aufgefasst, hier also 102 = 210, ebenso das zweite, dritte, vierte und fünfte Bit, hier 01012 = 510. Für den zweiten 6Bit-Block ist die Substitutionstabelle MS2 "zuständig". Die 4 Zeilen aller dieser Tabellen sind jeweils von 0 bis 3, die 16 Spalten von 0 bis 15 durchnummeriert. In unserem Beispiel sieht man bei MS2 in der Zeile mit der Nummer 2 (dritte Zeile) und in der Spalte mit der Nummer 5 (sechste Spalte) nach. Die dort stehende Zahl 4 wird als 4-Bit-Binärzahl genommen, hier 410 = 01002, und bildet den zweiten 4-Bit-Block des 8-Block-Zwischenergebnisses.

Bild 5.3: Die Permutationslisten MIP, MIPI, ME und MP Erfolgsrezept: ... permutieren ...

270

•

Dieses 32-Bit-Wort durchläuft wiederum eine Permutation, diesmal gemäß der Liste MP, und wird schließlich mit L0 über die XOR-Funktion verknüpft. Damit liegt R1 fest, L1 ist einfach der rechte Block aus dem vorangegangenen Schritt, hier also L1 = R0. Dieser Ablauf wiederholt sich 16 Mal, wobei die Verschlüsselung – jeweils mit dem zugehörigen Teilschlüssel Si (i= 1,2,..,16) -immer stärker voranschreitet. Im Beispiel von Bild 5.5, Seite 274, lässt sich das gut beobachten. Wie man an R1 erkennt, macht der aus 64 "0"-Elementen bestehende Klartext K bereits im ersten Teilschritt eine ziemliche Veränderung mit. L1

5.2 Verschlüsselung nach dem Data-Encryption-Standard (DES) besteht hier wegen L1 = R0 zwar immer noch aus 32 "0"-Elementen, aber im zweiten Teilschritt ist wegen L2 = R1 natürlich auch dieses Bild zerstört. ... und substituieren ... - ein teuflisches Gespann

.

...

. Bild 5.4: Die 8 Substitutionstabellen MS1 bis MS8 • Zum Schluss werden die beiden 32-Bit-Hälften L16 und R16 miteinander vertauscht und noch gemäß der Liste MIPI permutiert (mit der Liste MIPI erzielt man eine gegenüber MIP inverse Vertauschung eines 64-Bit-Wortes. Würde man beide Permutationen hintereinander schalten, so erhielte man wieder das

271

5 Datenverschlüsselung

Entschlüsselung im Rückwärtsgang

ursprüngliche 64-Bit-Wort). Das Ergebnis ist der 64-Bit-Geheimtext G. Der DES-Algorithmus bewirkt, dass die 64 Bits des Klartextes sehr kräftig und gleichmäßig – wie die Kugeln in einer Lottomaschine, nur eben rekonstruierbar – "durcheinander gewirbelt" werden, was die Wiederherstellung von K aus G ohne Kenntnis des Schlüssels S praktisch unmöglich macht Die Entschlüsselung des Geheimtextes G läuft ganz genauso ab, wie die Verschlüsselung des Klartextes K, der Empfänger muss nur die Reihenfolge der von ihm aus dem Schlüssel S berechneten 16 Teilschlüssel umkehren. Dass dies funktioniert, erkennt man wieder am Beispiel in den Bildern 5.5 oder 5.6, Seiten 274 und 275. Das Ganze lässt sich aber auch etwas formaler erklären. Wenn der Geheimtext G gemäß Bild 5.2 statt des Klartextes K in den Algorithmus eintritt und die erste Permutation mit der Liste MIP durchlaufen hat, so sind die beiden neuen Startblöcke L0 und R0 wieder identisch mit den alten Blöcken R16 und L16 (man beachte die zuvor erwähnte gegenseitige Vertauschung von L16 und R16 nach dem letzten Teilschritt!). Es gilt also L0neu = R16alt

und

R0neu = L16alt.

Das Bildungsgesetz für die Teilschritte lässt sich folgendermaßen schreiben: R1

= L0 XOR f(R0, S1)

und

L1

= R0,

wobei die Funktion f abkürzend die wesentlichen Teile der Rechenoperationen nach Bild 5.2 bezeichnet. Allgemein gilt für jeden Schritt i Ri Geordneter Rückzug

= Li-1 XOR f(Ri-1, Si)

und

Li

= Ri-1.

Bezogen auf den Geheimtext G ist also auch R1neu = R16alt XOR f(L16alt, S16)

und

L1neu = R16alt

oder R1neu = [L15alt XOR f(R15alt, S16)] XOR f(R15alt, S16) = L15alt

und

L1neu = R16alt.

R2neu = L1neu XOR f(R1neu, S15)

und

L2neu = R1neu

R2neu = R15alt XOR f(L15alt, S15)

und

L2neu = L15alt

Es geht weiter mit

R2neu = [L14alt XOR f(R14alt, S15)] XOR f(R14alt, S15) = L14alt

und

L2neu = R14alt.

An dieser Stelle ahnt man vielleicht, dass bei vollständiger Durchführung im 16.Teilschritt R16neu = L0alt

272

und

L16neu = R0alt

5.2 Verschlüsselung nach dem Data-Encryption-Standard (DES)

Vertrauensbildung

„Die Renten sind sicher... “, DES aber nur als „Triple“

Hetzjagd

herauskommen wird. Jetzt ist auch der Grund für die nach dem 16.Teilschritt durchzuführende Vertauschung des linken und des rechten 32-Bit Blockes klar: Nur so erhält man überhaupt dieses einfache Ergebnis (man probiere einmal, was entsteht, wenn man auf die Vertauschung verzichtet). Man kann diesen Teilschritt auch so betrachten, dass der in Bild 5.2 skizzierte Weg rückwärts (also von unten nach oben) durchlaufen wurde und man wieder auf der Ebene von L0 und R0 ankommt. Da jedoch der linke mit dem rechten Block noch vertauscht ist, muss dies rückgängig gemacht und anschließend die Wirkung der Permutation MIP beseitigt werden. Das aber erledigt gerade die inverse Permutation MIPI am Ende des Durchlaufs. Damit liegt auch der Klartext wieder vor. Im Beispiel von Bild 5.5 lassen sich diese letzten Entschlüsselungsschritte im Vergleich zur Anfangsphase der Verschlüsselung genau verfolgen. Damit nicht der Verdacht aufkommt, das Beispiel in Bild 5.5 funktioniere vielleicht nur deshalb, weil das einfache Schlüsselwort S und der Klartext K einen Sonderfall darstellen, ist in Bild 5.6 noch ein allgemeiner erscheinender Fall gezeigt, der die gleichen Ergebnisse bringt. Der Klartext "Didudljö" wird hier mit dem Wort "Holleri" verschlüsselt und wieder entschlüsselt. Wir hatten bereits festgestellt, dass sich die "Sicherheit" in jedem Teilschritt erhöht. Führt man z. B. abweichend vom Standard nur wenige Schritte – etwa deren 4 – durch, so kann der Geheimtext bereits bei Einsatz eines PCs in wenigen Minuten entschlüsselt werden. Bei weiterer Erhöhung der Teilschrittzahl wächst die Zeitdauer für unberechtigte Entschlüsselungsversuche auf einem einzigen Rechner aber dramatisch an. Nach dem derzeitigen Stand der Technik (Anfang 2006) werden allerdings bei Einsatz vieler gekoppelter Rechner im Sinne verteilter Strukturen nur noch wenige Stunden (ca. 10 -20) benötigt, wie bereits am Anfang diese Unterkapitels erwähnt. Der mit 3 verschiedenen Schlüsseln a 56 Bit verschachtelt arbeitende Triple DES-Algorithmus bringt bei erhöhter Rechenzeit vorläufig wieder die „alte“ hohe Sicherheit zurück. Nicht ausgeschlossen bleibt weiterhin, dass irgendwer einmal einen ganz neuen Entschlüsselungsweg findet, der zu bedeutenden Zeiteinsparungen führt. Das wäre das – nicht tragische – Ende des DES, da mit AES ja bereits ein leistungsstarker Nachfolger bereit steht.. Allgemein gilt folgende Aussage: Sind Zeitverkürzungen bei Entschlüsselungsversuchen ohne Kenntnis des Schlüssels nur durch höhere Rechnerleistungen bedingt, so lassen sie sich durch quantitative Maßnahmen wie Verlängerung des Schlüssels, Erhöhung der Anzahl von Teilschritten usw. rückgängig machen. Außer dem Probieren aller möglichen Schlüssel (|721015) gibt es auch andere Versuche, den DES zu "knacken".

273

5 Datenverschlüsselung

Bild 5.5: DES-Ver- und Entschlüsselung mit dem Nullstring als Klartext K; das obere Diagramm zeigt die Teilschlüsselerzeugung

274

5.2 Verschlüsselung nach dem Data-Encryption-Standard (DES)

Bild 5.6: DES-Verschlüsselung und Entschlüsselung wie in Bild 5.5, aber hier Schlüssel S "Holleri" und Klartext K "Didudljö"

275

5 Datenverschlüsselung Erwünscht gnadenlos: Die Analytiker

Verdachtsmomente

Vorsicht : Schlaglöcher

Einer ist die so genannte differentielle Kryptoanalyse nach Shamir. In keinem Fall konnte bisher jedoch ein Erfolg in einer Form erzielt werden, dass nur wenige Wochen oder Monate benötigt gewesen wären. Ingrid Schaumüller-Bichl macht in ihrem Buch weitere ausführliche Bemerkungen zur Sicherheitsanalyse des DES. Hier findet man auch Beschreibungen der DES-Varianten FEAL und C80, bei Schneier die Beschreibung von Blowfish. Am DES lässt sich übrigens sehr deutlich eine Grundaussage zur Verschlüsselung erkennen, die der Niederländer Kerckhoff erstmals zum Ausdruck gebracht hat: Ein Verschlüsselungsverfahren muss so aufgebaut sein, dass seine Sicherheit ausschließlich von der Geheimhaltung des Schlüssels und nie von derjenigen des Algorithmus abhängt. Das DES-Verfahren liegt wahrscheinlich vollkommen offen, restlos sicher ist man sich nicht, da immer wieder geargwöhnt wurde, dass die Experten von NSA die Substitutionsboxen so gestaltet haben, dass für Eingeweihte hierüber eine Hintertür besteht. Das allerdings hat sich bisher nicht bestätigt. Jedenfalls muss man allen Anbietern von Verschlüsselungsprodukten mißtrauen, die behaupten, ein "totsicheres" Verfahren entwickelt zu haben, jedoch nicht bereit sind, es offen zulegen! Zum Abschluß ist noch zu erwähnen, dass auch der DES eine kleine, systematische Schwachstelle aufweist, die sich aber leicht umgehen lässt. Es gibt insgesamt 4 Schlüssel, die nur gleiche Teilschlüssel, so genannte schwache Schlüssel, erzeugen. Wählt man als Schlüsselwort z. B. das Nullwort, so sind alle Teilschlüssel ebenfalls Nullwörter, wie mit Hilfe von Bild 5.1 nachvollziehbar ist. Aufgrund der Wirkung der Substitutionen mit den Listen MS1 bis MS8 entsteht zwar auch bei Benutzung solcher Schlüssel ein "richtiger" Geheimtext, wird dieser aber nochmals mit demselben Schlüsselwort verschlüsselt (also nicht entschlüsselt), so erhält man als Ergebnis wieder den Klartext. Das ist zu erwarten, da sich der Ver- und der Entschlüsselungsvorgang nur durch die Vertauschung der Teilschlüssel-Reihenfolge unterscheiden, die in diesen Fällen aber gar keine Unterschiede aufweist. Es könnte im praktischen Gebrauch durchaus vorkommen, dass ein zum Geheimtext G verschlüsselter Klartext K nochmals verschlüsselt wird und man in diesen Fällen wieder K erhielte. Bild 5.7 zeigt in verkürzter Darstellung das Ergebnis der zweimaligen Verschlüsselung des Klartextes "Dödudldö" mit dem schwachen Schlüssel 000111 000111 000111 ...., (Hinweis außerhalb der "Geschäftsordnung": Bei diesem Klartext handelt es sich um das zweite Futur bei Sonnenaufgang im berühmten Erzherzog-Johann-Jodler, siehe auch im Schnupperkurs, Unterkapitel 1.2.1). Die ersten beiden schwachen Schlüssel sind (ohne Paritätsbits und deshalb nur als 7-Bit-Blöcke dargestellt): 0000000 0000000 0000000 0000000 0000000 0000000 0000000 0000000

276

5.2 Verschlüsselung nach dem Data-Encryption-Standard (DES) 0001111 0001111 0001111 0001111 0001111 0001111 0001111 0001111

Die zweiten beiden stellen das Komplement (= logisches NOT) der ersten beiden dar.

Bild 5.7: Zweimalige Verschlüsselung mit einem "schwachen Schlüssel" in verkürzter Darstellung Halbes und ganzes Schwächeln

Außerdem gibt es noch 6 so genannte halb schwache Schlüssel und deren Komplement. Diese Schlüssel erzeugen nur zwei verschiedene Teilschlüssel, die zwar bei zweimaliger Verschlüsselung nicht wieder zum Klartext führen, aber wegen der geringen "Verwirbelung" des Klartextes dennoch bedenklich sind. Es handelt sich dabei um: 1110000 1111111 1110000 1111111 1111000 1111111 1111000 1111111 0000000 1111111 0000000 1111111 0000000 1111111 0000000 1111111 0000000 1110000 0000000 1110000 0000000 1111000 0000000 1111000 1111111 1110000 1111111 1110000 1111111 1111000 1111111 1110000 1111111 0000000 1111111 0000000 1111111 0000000 1111111 0000000 1110000 0000000 1110000 0000000 1111000 0000000 1111000 0000000.

277

5 Datenverschlüsselung

AES: Nachrücker und Perfektionist

5.3

Kaum zu fassen, einfach genial ...

278

Auch hier haben die 6 komplementären Schlüssel dieselben Eigenschaften, so dass insgesamt 4+12=16 Schlüssel existieren, die man vermeiden muss. Die Betrachtungen zum DES-Verfahren sind damit abgeschlossen, und es folgt noch ein kurzer Blick auf den anfangs schon erwähnten Nachfolge-Standard AES. Dieser arbeitet mit Klartext-Blocklängen zwischen 128 und 256 Bit sowie mit Schlüssellängen von 128, 196 oder 256 Bit. Er gilt nach dem Stand der Technik als kryptologisch sicher, ist „schnell“ und unterliegt keinen Freigabe- oder Nutzungsbeschränkungen. Damit stellt er für neue Anwendungen inzwischen das bevorzugte Mittel dar. Der DES wird aber, wie erwähnt, als Variante Triple DES noch einige Zeit weiter bestehen. Die Verwendung ist denkbar einfach: Statt des 56-Bit-Schlüssels wird ein solcher mit 168-Bit Länge gewählt, der wiederum drei 56-Bit lange Teilschlüssel liefert. Mit dem ersten erfolgt eine „normale“ DES-Verschlüsselung, das Ergebnis wird mit dem zweiten Teilschlüssel „entschlüsselt“ (dabei entsteht natürlich nicht der Klartext) und dieses mit dem dritten Teilschlüssel wieder verschlüsselt. Für eine „Brute Force“-Attacke müssten nun statt 256 Entschlüsselungsversuche bereits 2168 durchgeführt werden. Deshalb betrachtet man den Triple DES als vergleichbar sicher wie konkurrierende Verfahren mit 128 Bit, also auch wie der AES im 128 Bit-Modus. Nachteilig für den praktischen Gebrauch wirkt sich allerdings aus, dass der Zeitbedarf für die Anwendung des Triple DES gegenüber dem DES auf Seiten beider Partner um das 3-fache ansteigt.

Verschlüsselung mit dem RSA-Algorithmus Rivest, Shamir und Adelmann haben in ihrem Aufsatz "A Method for Obtaining Digital Signatures and Public-Key Cryptosystems", erschienen in Communications of the ACM 21, S. 120-126, Februar 1978, ein im Vergleich zum DES vollkommen anderes Verfahren zur Codierung vorgeschlagen. Es fasziniert wegen einer kaum zu überbietenden Einfachheit bei gleichzeitiger, bis heute unangetasteter Sicherheit. Das RSA-Verfahren arbeitet asymmetrisch, d. h. der Absender verschlüsselt mit einem anderen Schlüssel, als mit dem, den der Empfänger zum Entschlüsseln benutzt. Manch einer wird sich kaum vorstellen können, dass so etwas überhaupt möglich ist. Wie funktioniert es? Eine vertrauenswürdige Schlüsselvergabestelle oder auch der Teilnehmer selbst erzeugt zunächst zwei geheime Primzahlen p und q und bildet ihr Produkt n=pYq, den Modul. Für das Prinzip des Verfahrens ist die Größe dieser Primzahlen zwar unerheblich, die Sicherheit gegen Aufbrechen wächst aber mit deren Größe, so dass

5.3 Verschlüsselung mit dem RSA-Algorithmus man heute mit wenigstens 100- bis 350-stelligen Primzahlen arbeitet (Eine Zahl mit 1024 Binärstellen entspricht etwa einer 350-stelligen Dezimalzahl). Wie man sich diese auf einfache Weise beschafft, beschreibt Unterkapitel 5.5. Kennt man nur den Modul n, so lassen sich p und q zum heutigen Primzahlen: Zeitpunkt bei den verwendeten großen Primzahlen in angezähe Burschen messener Zeit nicht berechnen. Dahinter steht das bisher ungelöste Problem der schnellen Zerlegung großer Zahlen in ihre Primfaktoren, die Aufgabe hat eine exponentielle Komplexität. Schlüsselindustrie Die Schlüsselvergabestelle bildet außerdem zur Zahl n noch die Eulerfunktion (n). Bei Primzahlen ist sie das Produkt %n = % pq = p1q1

Des weiteren wählt sie eine zu (n) teilerfremd e Zufallszahl e und berechnet hierzu die modulare inverse Zahl d bezüglich (n). Für d gilt: de MOD% n = 1

... leicht wie ein Kinderspiel ...

Auf Seite 44 findet man einen Algorithmus zum Berechnen solcher modularer inverser Zahlen. Die Zahlen n, e und d werden z. B. der Teilnehmerin Annette zugeordnet. Ihr Name kommt zusammen mit dem Modul n und dem Schlüssel e in ein öffentliches Teilnehmerverzeichnis (ähnlich einem elektronischen Telefonbuch). Den Schlüssel d hingegen erhält als Geheimsache nur Annette selbst. Die Schlüsselvergabestelle sollte zur Vermeidung von Mißbrauch nun die Zahlen p und q und die Eulerfunktion (n) löschen (natürlich unwiderruflich und ohne vorher Kopien anzufertigen!). Will Ulrich für Annette eine Nachricht verschlüsseln, so verwandelt er die ASCII-Zeichen zunächst in deren Dezimal- oder Binär-Äquivalent und bildet mit der entstandenen Klartextzahl K die Geheimtextzahl G

= Ke MOD n.

Annette ihrerseits kann diesen Geheimtext mit K

= Gd MOD n

wieder entschlüsseln. Das ist eigentlich schon alles. Warum aber funktioniert dies und wie werden die angekündigten sehr großen Zahlen rechentechnisch verarbeitet? An einem Beispiel lässt sich der Ablauf erläutern, zur besseren Übersicht verwendet es bei Verzicht auf Sicherheit allerdings nur kleine Zahlen. Als Klartext K dient der vierstellige Wert K

= 1223.

Vor seiner Verschlüsselung sind noch einige vorbereitende

279

5 Datenverschlüsselung Schritte erforderlich. Primzahlen: woher nehmen und nicht stehlen?

Eulerzahlen: unscheinbar, doch mächtig

EA, der geniale Helfer

Schritt 1: Wahl der Primzahlen p und q = 577 und 419. Diese Primzahlen kann man sich für solche kleinen Beispiele aus einer Primzahlentabelle holen, wie sie in vielen mathematischen Formelsammlungen zu finden ist. Die für eine sichere Verschlüsselung notwendigen großen Primzahlen mit etwa 100 - 200 Dezimalstellen findet man allerdings nirgendwo, da Primzahlen sich nicht unmittelbar über einen einfachen Algorithmus gezielt bestimmen lassen. In Kapitel 5.5 werden wir aber einen ziemlich guten Weg kennenlernen, um große Zahlen herzustellen, die mit einer beliebig hoch vorgebbaren (jedoch nie 100-prozentigen) Wahrscheinlichkeit Primzahlen sind. Für praktische Zwecke reicht das dann vollkommen aus. Schritt 2: Bildung des Moduls n = pYq = 241763. Eine kleine Bedingung besteht zwischen K und n: Die Zahl K muss kleiner als n bleiben. Im Fall von K = n funktioniert nämlich die Verschlüsselung im Schritt 6 nicht mehr. Diese Bedingung ist allerdings durch entsprechende Blockung des Klartextes immer erfüllbar. Schritt 3: Berechnung der Eulerzahl (n) = (p-1)(q-1)

= 240768.

Zur Erinnerung (siehe auch Kapitel 2.2): Die Eulerzahl einer Zahl n ist diejenige Anzahl von Zahlen kleiner als n, die mit der Zahl n nur den gemeinsamen Teiler 1 haben oder, anders ausgedrückt, teilerfremd zu n sind. Diese Definition gilt ganz allgemein für natürliche Zahlen. Beispiele: (3)

= 2,

da 1 und 2 teilerfremd zu 3 sind,

(8)

= 4,

da 1, 3, 5, 7 teilerfremd zu 8 sind,

(11)

= 10,

da 1,2,3,4,5,6,7,8,9,10 teilerfremd zu 11 sind.

Mit dem Euklidischen Algorithmus, den wir bereits in Kapitel 2.2 auf Seite 43 erwähnt und bei der Decodierung des Goppa-Codes intensiv benutzt hatten, lässt sich für ganze Zahlen mit geringem Aufwand feststellen, welchen größten gemeinsamen Teiler (=ggT) sie haben. Da Primzahlen p wegen ihrer Definition nur durch sich selbst und durch 1 geteilt werden können, ist in diesem Sonderfall die Anzahl (p-1) aller kleineren Zahlen gerade die Eulerzahl. Schritt 4: Wahl einer zu (n) teilerfremden Zufallszahl e = 1264763. Die Zahl e hat also mit (n) den ggT = 1. Auch hier hilft der Eu klidische Algorithmus. Falls nämlich der ggT größer als 1 ist, teilt man die Zahl e hierdurch und verwendet statt e das Ergebnis e' = e/ggT, das nun auf jeden Fall eine teilerfremde Zahl ist. Sollte e

280

5.3 Verschlüsselung mit dem RSA-Algorithmus dabei zu klein geworden sein, was aus Gründen der Sicherheit unerwünscht wäre, sucht man erneut. Der Aufwand ist gering und man kommt immer schnell zum Ergebnis. Beispiel: p = 5, q = 7, n = 35, (n) = 4Y6 = 24. Teilerfremd zu 24 ist etwa 11, was leicht über den Euklidischen Algorithmus nach geprüft werden kann: 24

= 211 + 2

(2 ist der Rest)

11

= 52 + 1

(1 ist der ggT von 24 und 11)

2

= 21 + 0

Der Rest in der zweiten Zeile ist der ggT(24,11) = 1, da sich in der dritten Zeile als Rest der Wert 0 ergibt. Das allgemeine Berechnungsschema wurde auf Seite 43 beschrieben. Schritt 5: Berechnung von „d“ so, dass ed MOD (n) =1 Diese Beziehung wird durch die Zahl d =221747 erfüllt. Sie ist die modulare Inverse zu e bezüglich (n) und kann Fast pervers: Die Bedeutung der In- nach der auf Seite 44 beschriebenen Rückwärtsrechnung im Euklidischen Algorithmus sehr einfach bestimmt werden, wenn man versen sich bei der Vorwärtsrechnung die Faktoren q1, q2, ..., qn-1 gemerkt hat. Aus der Rekursionsbeziehung zi

= - qn-izi-1+ zi-2

mit und

i z0 z1

= 2, 3, 4, ..., n-1 = 1, = -qn-1

lässt sich für das Beispiel wegen n = 3, qn-1 = q2 = 5, q1 = 2 das zu 11 modulare Inverse bezüglich 24 als die Zahl 11 berechnen. Im vorliegenden Fall wird dieses Ergebnis bereits im ersten Schritt erzielt. Überhaupt haben sowohl der Euklidische Algorithmus selbst als auch die oben genannte Rekursionsgleichung für die Rückwärtsrechnung die angenehme Eigenschaft, dass sie nur wenige Schritte benötigen. Probe: Große Zahlen? Wo, bitte, liegt das Problem?

1111 MOD 24

= 121 MOD 24

= 1.

Schritt 6: Verschlüsselung G

= Ke MOD n,

G

= 12231264763 MOD 241763

= 96883. Obwohl n und e öffentlich bekannt sind, kann man bei Kenntnis von G dennoch in angemessener Zeit den Klartext K nicht bestimmen, wenn man den Schlüssel d nicht hat. Man müsste für K

281

5 Datenverschlüsselung

Viagra? Nee, Potenz auch ohne berechenbar

Her und Hin

nämlich alle Zahlen von 1 bis n durchprobieren, um zu sehen, welches K zu welchem G "passt", das schon bekannte „Brute Force“-Verfahren. Spätestens an dieser Stelle taucht vermutlich die Frage auf, wie man eigentlich die hier auftretenden Potenzen berechnet. Es handelt sich ja um Zahlen, die jenseits jeglicher normaler Größenordnungen liegen. Hier kommen die Eigenschaften der Modulofunktion zu Hilfe, die es gestatten, die Grundrechenarten mit der Modulo-Bildung zu vertauschen. So wurde etwa das vorliegende Verschlüsselungsbeispiel mit einem Taschenrechner-Programm aufgestellt, bei dem systembedingt exakte Ganzzahloperationen nur mit Ergebnissen bis zu 16 Dezimalstellen möglich sind. Da ähnliche Aufgaben noch bei anderen Verfahren auftauchen, werden sie gesondert in Kapitel 5.4 behandelt. Schritt 7: Entschlüsselung K

= Gd MOD n,

K

= 96883221747 MOD 24176

= 1223. Warum funktioniert diese? Zunächst gilt nach den Rechenregeln für die MOD-Funktion: Gd MOD n

= (Ke MOD n)d MOD = Ked MOD n

Der Exponent „eYd“ lässt sich mit dem ganzzahligen Faktor i, der gar nicht als Wert bekannt sein muss, auch als ed

= i (n) + 1

schreiben, da die Zahl d als modulare Inverse so bestimmt wurde, dass ed MOD (n)

=1

gilt. Damit wird Gd MOD n

= K ed MOD n

= K i (n)+1 MOD n = KK i (n) MOD n.

Wenn die Entschlüsselung richtig arbeitet, müsste also ? KK „Hee, Teiler K, was bist Du mir so fremd ... „

282

i (n)

MOD n

= K i (n)+1 MOD n

=K

gelten. Um das zu überprüfen, betrachten wir zwei Fälle. Fall a: K und n sind teilerfremd, haben also den ggT(K,n) = 1. Hier hilft der Satz von Euler, der besagt, dass bei Teilerfremdheit zwischen K und n der zweite Faktor

5.3 Verschlüsselung mit dem RSA-Algorithmus K (n) MOD n

=1

immer den Wert 1 hat. Wegen K i (n) MOD n

= (K (n)) i MOD n = (K (n) MOD n) i MOD n

= 1i MOD n = 1

funktioniert also auch die Entschlüsselung. ... und bei gemeinsamen Teilern? .....Funktioniert es auch!

Fall b: K und n sind nicht teilerfremd, d. h. ggT(K,n) z 1: Wegen K < n und n=pYq kann in diesen Fällen der Klartext nur Potenzen einer der beiden Faktoren p oder q enthalten. Nehmen wir an, es wäre p r. Mit K

= tpr,

t,r: natürliche Zahlen t 1

und t i (n) MOD n

= (t (n) MOD n) i

= 1i

= 1 (wegen ggT(t,n)=1)

gilt zunächst K i (n)+1 MOD n

= [(t i (n)+1 MOD n)(pr( i (n)+1) MOD n)] MOD n = [(tt i (n) MOD n)(pi (n)+1 MOD n)r ] MOD n = t(p i (n)+1 MOD n)r MOD n.

Der unterstrichene Ausdruck ist der Rest der ungekürzten Division

pi%n 1 n Mit einer geeigneten ganzen Zahl s lässt sich dieser Sachverhalt als erster Schritt des Euklidischen Algorithmus so ausdrücken: p i (n)+1

= sn

+ pi (n)+1 MOD n.

Man kann aber auch aus pi (n)+1und n zunächst den gemeinsamen Faktor p heraus kürzen und den Rest der Division bezüglich des dann verbleibenden Faktors q berechnen. Mit einer geeigneten ganzen Zahl s' ergibt sich hier: p i (n)

= s'q

+ p i (n) MOD q.

Nach Multiplikation beider Seiten mit p wird daraus: pi (n)p

= pi (n)+1

= s'qp

+ (p i (n) MOD q)p.

Die Anwendung der MOD n-Funktion führt wegen n=qYp, p,q
= (p i (n) MOD q)p MOD n = (p (q) MOD q) i (p)p

= p.

Also arbeitet die Entschlüsselung auch in diesem Fall richtig:

283

5 Datenverschlüsselung ... alles paletti ...

K i (n)+1 MOD n

= tpr MOD n

= K.

Falls der Klartext K Faktoren q enthält, läuft der Nachweis genauso ab. Es besteht also Gewissheit, dass die Entschlüsselung beim RSAVerfahren aus dem Geheimtext G wieder den Klartext K herstellt, wenn K < n ist. Leider noch Für die Sicherheit reicht der bisher beschriebene Ablauf aber trotzmangelhaft: dem noch nicht aus. Warum? Geheimtexte lassen sich hier grundWho is Who? sätzlich von jedem beliebigen Absender erzeugen, da Modul n und öffentlicher Schlüssel e des Empfängers im Teilnehmerverzeichnis stehen. Zwar ist nur derjenige Empfänger zum Entschlüsseln dieses Geheimtextes in der Lage, der sich im Besitz des Geheimschlüssels d befindet, wie im Beispiel Annette. Woher soll Annette aber wissen, dass der richtige Absender (Ulrich) ihr diese Nachricht geschickt hat? Hier sind beliebige Täuschungsversuche möglich. Sabine, die auf Annette eifersüchtig ist, könnte diese z. B. unter der Angabe "Dein Ulrich" leicht betrügen. (Aber auch Ulrich könnte Sabine auf diesem Wege bei Annette "eins auswischen"). Die Beseitigung dieser – sehr großen – Schwachstelle wird dann ... der Täter wurde zweifelsfrei einfach, wenn der Absender Ulrich ebenfalls Teilnehmer ist und ihm deshalb der Modul nU, der öffentliche Schlüssel eU sowie der identifiziert ... geheime Schlüssel dU zugeordnet wurde. Dann kann er durch eine kleine zusätzliche Maßnahme dafür sorgen, dass die Empfängerin Annette sicher sein darf, nur vom ihm selbst die Nachricht erhalten zu haben. Ulrich ergänzt diese Nachricht zunächst mit seiner Adresse und fügt dem ganzen eine Prüfsumme an, die etwa aus den CRC-Bytes des Fehlererkennungs-Codes gemäß Kapitel 3.7.10 bestehen könnte. Dort wurde fest gestellt, dass bei Einsatz geeigneter Generatorpolynome g(x) Verfälschungen (= Veränderungen) der Nachricht bis zu einer vorgebbaren Länge eines Fehlerbündels sicher entdecken werden. Stoppt den Betrug! Natürlich wären alle Betrüger auch in der Lage, zu irgendeinem Klartext die passende Prüfsumme zu erzeugen, so dass Ulrich allein damit noch nichts gewonnen hätte. Er verschlüsselt daher zusätzlich eine Kopie dieser CRC-Bytes mit seinem eigenen geheimen Schlüssel dU. Die Reihenfolge im RSA-Algorithmus ist wegen der Vertauschbarkeit der Exponenten e und d ja grundsätzlich egal. Diese so verschlüsselten CRC-Bytes fügt er ebenfalls der Nachricht an und verschlüsselt nun den aus den vier Teilen Nachricht Absenderadresse CRC-Bytes mit dU verschlüsselte CRC-Bytes bestehenden Klartext mit Annettes öffentlichem Schlüssel eA zum Geheimtext G. Annette ihrerseits entschlüsselt G mit ihrem Geheimschlüssel dA und erhält

284

5.3 Verschlüsselung mit dem RSA-Algorithmus

... jetzt aber ...

.... ohne Vertrauen geht’s trotzdem nie!

Doppelt wertvoll

die Nachricht die Absenderadresse von Ulrich die CRC-Bytes die mit dU verschlüsselten CRC-Bytes. Man beachte dabei, dass ausschließlich sie selbst dazu in der Lage ist! Über die Absenderadresse holt sie sich aus dem Teilnehmerverzeichnis Ulrichs Modul nU mit seinem öffentlichen Schlüssel eU und entschlüsselt damit die von Ulrich mit dU verschlüsselten CRC-Bytes. Stimmen sie überein, so darf Annette annehmen, dass tatsächlich kein anderer als Ulrich diese Nachricht geschickt hat. Keiner außer ihm wäre imstande gewesen, die richtigen CRC-Bytes mit dU zu verschlüsseln – es sei denn, er hätte seinen Geheimschlüssel nicht genügend geschützt. So überzeugend das alles ist – ein Schönheitsfehler bleibt bestehen: Annette muss zu Ulrich Vertrauen haben. Zwar darf sie sicher sein, dass die Nachricht von ihm stammt (wenn er mit seinem Geheimschlüssel sorgsam umgegangen ist und auch die Schlüsselvergabestelle "sauber" arbeitet). Ulrich könnte Annette aber mit dem Inhalt der Nachricht betrügen. Ganz lässt sich dieser Mangel vielleicht nie beseitigen, man könnte aber die Lage verbessern, wenn man nach dem Vier-Augen-Prinzip eine weitere (Vertrauens-) Person in das Verfahren einbezieht, die eine Inhaltsprüfung durchführt. Die Verschlüsselungsexperten versuchen, auch dafür praktikable Lösungen zu entwickeln, wir begnügen uns mit diesen Hinweisen, siehe auch die kompakte Darstellung von G.Lepschies (Vieweg-Verlag). Das RSA-Verfahren hat schnell große Anerkennung gefunden und wird heute bereits vielfach eingesetzt. Durch die asymmetrische Schlüsselstruktur eignet es sich sowohl zum Übermitteln geheimer Nachrichten, nämlich wenn man den Ablauf Verschlüsseln mit dem öffentlichen Schlüssel e Entschlüsseln mit dem geheimen Schlüssel d benutzt, als auch zum Nachweis der Identität eines Absenders, wenn der Weg Verschlüsseln mit dem geheimen Schlüssel d Entschlüsseln mit dem öffentlichen Schlüssel e gegangen wird. Allerdings gibt es zur Zeit für den RSA-Algorithmus noch keine so schnellen und kostengünstigen Prozessoren wie für den DES, die Rechenzeit beträgt ein Vielfaches (ca. 5 – 10). Andererseits ist die Schlüsselverteilung wesentlich weniger aufwändig. Ein neuer Teilnehmer am DES erfordert im allgemeinen für jeden alten Teilnehmer, mit dem er in Beziehung treten will, einen weiteren Schlüssel, der als Geheimsache übergeben werden muss.

285

5 Datenverschlüsselung

Warnendes Beispiel

Beim RSA-Verfahren dagegen veröffentlicht die Schlüsselvergabestelle einmal den Modul n und den Schlüssel e im Teilnehmerverzeichnis und übergibt einmal dem neuen Teilnehmer seinen Geheimschlüssel d. Bei Annette beträfe das also die 3 Zahlen nA, eA und dA. Als angenehme Beigabe kommt hinzu, dass nur sie und kein anderer diesen Geheimschlüssel kennt, während beim DES (oder bei allen symmetrische Verfahren) wenigstens ein weiterer Partner beteiligt werden muss. Zum Abschluß noch ein Hinweis: Kurz nach Veröffentlichung des RSA-Algorithmus im Jahre 1978 haben die Autoren Merkle und Hellmann das ebenfalls für Verschlüsselungszwecke gedachte Untersummen-Verfahren bekannt gegeben (manchmal als TornisterVerfahren bezeichnet), welches auch asymmetrisch arbeitet und durch faszinierende Ideen besticht. Man kann es im Aufsatz "Hiding information and signatures in trapdoor knapsacks" nachlesen, der 1978 in der Zeitschrift IEEE Transactions on Information Theory, IT-24, auf den Seiten 525 – 530 abgedruckt wurde. Unabhängig von aller gebührenden Bewunderung stellt dieses Verfahren jedoch ein eindrucksvolles Beispiel dafür dar, dass man einer oberflächlichen Überzeugtheit niemals trauen darf: Shamir, einer der drei Erfinder des RSA-Algorithmus, hat 1982 in seinem Aufsatz "A polynomial time algorithm for breaking the basic Merkle-Hellmann cryptosystem“, 1982, Proceedings 23rdn IEEE Symposium Foundations of Computer Science", Seiten 142-152), gezeigt, wie man die mit diesem Algorithmus erzeugten Geheimtexte auch ohne „Brute Force“ doch in vertretbarer Zeit aufbrechen kann. Eine sehr empfehlenswerte, gut verständliche Darstellung des RSAund des Untersummen-Verfahrens bringt übrigens Hellmann selbst in dem im Kapitel 7 genannten Artikel aus der Zeitschrift "Spektrum der Wissenschaften".

5.4

Das Rechnen mit großen Ganzzahlen

Große Zahlen? Her damit, solange sie noch warm sind!!

Das Arbeiten mit langstelligen Ganzzahlen setzt voraus, dass entsprechende Prozeduren für die benötigten Langzahl-Arithmetik zur Verfügung stehen. Dazu gibt es wenigsten 2 Wege. Besonders schnelle Ergebnisse erzielt man, wenn die Operationen als Unterprogramme mit Hilfe Maschinensprache-naher Befehle aufgebaut werden, ohne auf die in den Compilern bereits vorhandene Normal-Arithmetik zurück greifen zu müssen Dies ist unter anderem mit den Sprachen C oder C++ möglich. Mit weniger Programmieraufwand verbunden, aber langsamer werden Abläufe sein, die auf der "Normal"-Arithmetik aufbauen. Sehen wir uns als Beispiele für diesen zweiten Weg einige Operationen an, wobei Langzahl-Additionen und -Subtraktionen bereits mit dem in der Grundschule erlernten Rechenwissen erledigt werden können und hier nicht extra behandelt sind.

286

5.4 Das Rechnen mit großen Ganzzahlen Multiplikation: Diese lässt sich aus den "eingebauten" Elementar-Multiplikationen mit Langzahl-Additionen aufbauen (siehe auch den Aufsatz von Comba mit dem Titel "Exponentiation cryptosystems on the IBM PC", IBM Systems Journal, Volume 29, Nr.4, 1990). So kann z. B. eine aus zwei n-ziffrigen Blöcken x2 und x1 zusammengesetzte Zahl x zur Basis p als x

= x2pn + x1

dargestellt werden. Mit der Zahl y

= y2pn + y1

ist das 2n-ziffrige Produkt z

= xy = (x2pn + x1)(y2pn + y1) = x2y2p2n 2n

= z4p

+ x2y1pn n

+ z3p

+ x1y2pn + z2p

n

+ x1y1 + z1.

Als Beispiel nehmen wir – etwa weil wir einen Rechner mit Auch Taschenrechner können's voller 10-Stellen-Dezimalarithmetik haben – die beiden im Dezimalsystem 10-ziffrigen Zahlen x

= 99999 66666

y

= 88888 77777.

Damit wird x1y1 = z1

= 51850 81482

x1y2 = z2

= 59258 07408

x2y1 = z3

= 77776 22223

x2y2 = z4

= 88887 11112.

Diese 4 Zahlen müssen nun gemäß der oben angegebenen Formel noch stellengenau addiert werden: z

= z4 + z3 + z2 + z1 = 88887 11112 00000 00000 + 00000 77776 22223 00000 + 00000 59258 07408 00000 + 00000 00000 51850 81482 _______________________ = 88888 48146 81481 81482

Wenn eine Unterteilung der Zahlen x und y in mehr als 2 Blöcke

287

5 Datenverschlüsselung

Anspruchsvoll, doch willig

notwendig ist, funktioniert das Verfahren ganz ähnlich. Wie immer geht es am einfachsten im Zweiersystem, da dann alle Zwischenmultiplikationen praktisch wegfallen – entweder haben wir den Faktor 0 oder den Faktor 1. Division: z:y

= (z4p2n + z3pn + z2pn + z1) : (y2pn + y1).

Diese lässt sich zwar nicht mit Elementar-Divisionen bearbeiten, weil hier der Nenner nicht wie der Zähler bei der Multiplikation zerlegt werden kann, doch erreicht man sein Ziel, wenn man das aus der Schule bekannte Verfahren programmtechnisch umsetzt (also den Divisor (y2pn + y1) mit einem passenden Faktor multipliziert, das Ergebnis vom Dividenden abzieht usw.). MOD n: Die Berechnung der MOD n-Funktion erfordert die Ausführung einer Division durch die Zahl n, wobei man nur am Rest interessiert ist. Die MOD n-Funktion lässt sich also ebenfalls leicht bearbeiten. Üble Tricks ....

Potenzen MOD n, wie in G = Ke MOD n: Auch diese Funktion ist weniger schwierig zu bearbeiten, als es zunächst aussieht. Man kann jede Hochzahl in eine Summe von Zweier-Potenzen zerlegen. z. B. ist 19

= 16 + 2 + 1 = 24 + 21 + 20

= 2222 + 2 + 1.

... mit Quadraten In Verbindung mit einer Rechenregel für Modulo-Funktionen, nämlich x2 MOD n

= (x MOD n)2 MOD n,

bedeutet das für die Potenzierung G

= [(((K2)2)2)2 K2 K] MOD n = [(((K2)2)2)2 MOD n K2 MOD n K MOD n ] MOD n,

wobei (K2)2 MOD n

= (K2 MOD n)2 MOD n

ist usw. Die Berechnung lässt sich also in Teile zerlegen, bei denen als Ergebnis nur Zahlen kleiner als n auftreten. Beispiel: 511 MOD 7

= (58 52 5) MOD 7 = ( ((52)2)2 MOD 7 52 Mod 7 5 MOD 7 ) MOD 7 = ( ((52 MOD 7)2 MOD 7)2 MOD 7 52 MOD 7 .... .... 5 MOD 7) MOD 7.

Man beachte hierbei die Klammerebenen. Da

288

5.4 Das Rechnen mit großen Ganzzahlen 52 MOD 7

= 25 MOD 7

=4

= (52 MOD 7)2 MOD 7

= 42 MOD 7 = 2

ist und sich hieraus (52)2 MOD 7

ergibt, kann dieser Ausdruck schrittweise vereinfacht werden: 511 MOD 7

= ( (42 MOD 7)2 MOD 7 (4 5) MOD 7 ) MOD 7 = ( 22 MOD 7 6 ) MOD 7 = ( 4 6) MOD 7 = 24 MOD 7 = 3.

Ganz genaue Ist z. B. die Ganzzahl-Genauigkeit eines Rechners mit 12 Stellen Ganzahlpotenzen festgelegt, so lassen sich exakte Potenzrechnungen der Art G

= Ke MOD n

ohne Einschränkung durchführen, solange K und n Zahlen von höchsten 6 Stellen Länge sind, da dann die Ergebnisse einer MOD n-Rechnung ihrerseits nicht länger werden und die größte auftretende Zahl bei allen Zwischenrechnungen, nämlich K2, ebenfalls höchstens 12 Stellen hat. Gleichermaßen darf in diesem Fall der Exponent „e“ 12 Stellen haben. Man sieht, dass die beim RSA-Algorithmus erforderlichen Langzahlrechnungen ohne Schwierigkeiten abgearbeitet werden können und Aufmerksamkeit nur wegen der benötigten Rechenzeiten beanspruchen (alle angeführten Beispiele wurden übrigens mit Programmen auf einem Taschenrechner HP48SX berechnet). ... alles schon da! Die eigene Programmierung solcher Rechenoperationen ist aber an sich nur für Übungszwecke zu verantworten. Für den praktischen Einsatz gibt es die bereits zu Anfang des Kapitels 5 erwähnten Softwarepakete, z. B. das von Knobloch und Horster. Doch auch das Standardwerk für numerische Mathematik von Knuth, "The Art of Computer Programming" (erschienen bei Addison-Wesley Publishing Corporation, Reading, Massachussets, Auflage 1981), ist sehr empfehlenswert. Außerdem muss man immer prüfen, ob sich vielleicht der Einsatz einer der speziellen Ver- und Entschlüsselungsprozessoren lohnt, die auf dem Markt verfügbar sind.

5.5

Erzeugung großer Pseudoprimzahlen "Kleine" Primzahlen kann man einer Tabelle entnehmen, von denen die größten zur Zeit etwa den Bereich bis 109 umfassen. Das Urverfahren zum Aufbau einer solchen Tabelle ist das schon

289

5 Datenverschlüsselung mehrfach erwähnte Sieb des Eratosthenes (ca. 200 vor Christus), siehe z. B. Kapitel XIV des in Kapitel 7 erwähnten Buches von Kiyek und Schwarz. Für "große", etwa 200-stellige Primzahlen gibt es aber keinen schnellen Berechnungsweg, so dass das Anlegen größerer Tabellen schon aus diesen Gründen scheitert. Außerdem wäre der astronomisch große Speicherplatz jenseits aller z. Z. realisierbaren Größenordnungen. Nach einer Näherungsformel von Hadamard und de la Valle-Poussin ist die Anzahl (k) aller Primzahlen zwischen 2 und k für große k ungefähr

k=

k lnk

wobei ln(k) den natürlichen Logarithmus von k bezeichnet. Danach enthalten die 1]10200 – 1]10199 = 0.9]10200 200-stelligen Zahlen, die es überhaupt gibt, etwa 1.95] Y10197 Primzahlen, immerhin also einen Anteil von 0.02 Prozent. Das Massenspeichervolumen mit den Platten- und Bandsystemen größerer kommerzieller Rechnersysteme liegt heute aber erst bei einigen 100 TeraByte (1 TeraByte= 1012 Byte). Man sieht, dass z. Z. nicht die geringste Aussicht besteht, eine nennenswerte Teilmenge von Primzahlen dieser Länge zu speichern, selbst dann nicht, wenn man sie überhaupt erzeugen könnte. Einfach ist dagegen die Berechnung so genannter Pseudoprimzahlen. ... dann eben nur Das sind Zufallszahlen, die bestimmte Tests auf Primzahl-Eigenschaften bestehen, wobei man aber auch bei positivem Ergebnis „Pseudo“ .... nicht sicher sein kann, eine Primzahl gefunden zu haben. Immerhin gestattet etwa das Verfahren von Miller-Rabin bei jedem Testdurchlauf die Verringerung der Wahrscheinlichkeit, dass keine Primzahl vorliegt, um den Faktor 1/4. Nach „i“ Schritten ist also die Wahrscheinlichkeit, keine Primzahl erhalten zu haben, auf 1/4i abgesunken. Eine Schrittzahl von i=10 ergibt bereits den sehr kleinen Wert 9]Y10-7. Zum Vergleich: Die Chance, 6 "Richtige" im Lotto zu erzielen, liegt bei ungefähr 1.6]Y10-7. Mit einem Verfahren zur Herstellung von Pseudoprimzahlen Fließband-Prokann man also bei sehr geringem Aufwand Zahlen erzeugen, die duktion mit einer beliebig hohen (aber keiner 100 %-gen) Wahrscheinlichkeit Primzahlen sind. Für praktische Zwecke reicht das zur Zeit aus. Die Gewissheit, mit p und q wirklich Primzahlen zu haben, ist im übrigen eine absolute Voraussetzung für das korrekte Funktionieren des RSA-Algorithmus. Würde man – unbewusst – nicht mit wirklichen Primzahlen arbeiten, so wäre die Bestimmung der Eulerfunktion (n) = (p-1)·(q-1) praktisch immer falsch spröde, aber mächtig

290

5.5 Erzeugung großer Pseudoprimzahlen und die Entschlüsselung funktionierte nicht. Die schon erwähnten Algorithmen zur Berechnung von Pseudoprimzahlen werden in mehreren Literaturstellen beschrieben. Viele bauen auf Vorschlägen der schon genannten Autoren M. O. Rabin und Gary L. Miller auf, wie sie im Buch von Kiyek/Schwarz im Kapitel XIV beschrieben sind. Auch bei Heider, Kraus und Welschenbach, Kapitel VII.3, findet man interessante Hinweise. Ausgangspunkt ist, dass sich jede ungerade Zahl w in der Form w

= 2m + 1

mit m als ungerader Zahl darstellen lässt. Beispiele:

Zahlentheorie hilft

3

= 211 + 1

5

= 221 + 1

7

= 213 + 1

9

= 231 + 1 usw.

Ein Satz aus der Primzahlentheorie (siehe Kiyek/Schwarz, Kapitel XIV, Satz 2.9) besagt nun für den Fall, dass w eine Primzahl ist: Für jede natürliche Zahl b, die die Eigenschaft 1
Jagd-Ordnung

Auswahl ohne Gnade

•

Entweder ist

bm MOD w = 1

•

oder es gibt eine Zahl c mit

c = 2, {0, 1, 2, ..., -1},

für die

bcm MOD w = w - 1

ist. Dieser Satz lässt sich folgendermaßen interpretieren: • Punkt 1: Für Primzahlen w stimmt die Aussage immer. • Punkt 2: Wenn keine der beiden Aussagen erfüllt wird, ist w keine Primzahl. • Punkt 3: Es kann Nicht-Primzahlen w geben, für die die Aussage trotzdem erfüllt ist. Punkt 1 kann man nicht benutzen, da man ja gerade nicht weiß, ob w eine Primzahl ist. Dagegen sind die Punkte 2 und 3 hilfreich. Punkt 2 gibt immerhin die Sicherheit, dass es sich wirklich nicht um eine Primzahl handelt. Vorsicht ist aber bei Punkt 3 geboten. Es lässt sich nämlich nachweisen (siehe Kiyek/Schwarz, Kapitel XIV, Satz 2.12), dass für Nicht-Primzahlen w bestimmte teilerfremde Zahlen b existieren, bei denen die Aussage des Satzes auch erfüllt ist. Leider kennt man für diese Zahlen b keine einfache Formel (sonst wäre die einfache Bestimmung von Primzahlen keine Schwierigkeit), aber wenigstens erlaubt eine Abschätzung die Angabe, dass sie von der teilerfremden Menge der

291

5 Datenverschlüsselung

Kein Entrinnen: Nullchance für Flüchtige

b's höchstens ein Viertel (= (w)/4) ausmachen. Beispiele: •

w = 25 = 23 3+ 1 (keine Primzahl). Hier erhält man für b = 7 und = 1 die Aussage 67 MOD 25 = 24 = w - 1 und deuten w als Primzahl. Dies ergibt sich auch für b = 18 und = 1 sowie für b = 24 und = 0, so dass die Fehlerwahrscheinlichkeit wegen der insgesamt 16 teilerfremden "b's" (b>1) in diesem Beispiel 3/16 = 18,7% beträgt. • Insgesamt sogar 17 "faule" b's treten bei w = 91 auf, die Fehlerwahrscheinlichkeit ist damit 17/71 = 24%. Hinweis: Mit dem in Kapitel 5.4 beschriebenen Verfahren zur "Potenz- MOD n"-Berechnung lassen sich die erforderlichen Rechnungen zu Übungszwecken leicht durchführen. Die erwähnte Abschätzung für die Fehlerwahrscheinlichkeit wird übrigens unter Zuhilfenahme der Eulerfunktion und des primitiven Elements des durch w definierten endlichen Ganzzahlkörpers Zw gemacht, für uns alles schon "gute Bekannte". Man braucht also keine Hemmungen zu haben, wenn man hier etwas tiefer einsteigen will. Da verschiedene Zahlen b zu Aussagen führen, die bezüglich w unabhängig voneinander sind, kann man eine Zahl w, die die Satzaussage erfüllt und damit zu 75% eine Primzahl darstellt, mit einem anderen b erneut "testen" und somit die Fehlerwahrscheinlichkeit bereits auf (0.25)2 = 0.0625 drücken, wenn die Satzaussage wiederum erfüllt ist usw. Das sind die Grundgedanken des Miller-Rabin-Verfahrens, welches für unsere Beipiele in einer Version benutzt wird, die in einem im Juli 1992 vom USamerikanischen National Institute of Standards and Technology (=NIST) veröffentlichten Vorschlag für digitale Unterschriften enthalten ist ("The Digital Signature Standard", Communications of the ACM, Volume 35, Nr.7, Seite 39). Der Abschnitt mit der Primzahlenerzeugung umfasst nur wenige Zeilen, die Lektüre des gesamten Vorschlags ist in Verbindung mit den Antworten ver•

Die Grenzen werden enger

292

w = 15 = 217 + 1 (keine Primzahl). Die Aussage des Satzes ist für b = 14 erfüllt, da 147 MOD 15 = 14 = w - 1 ist und veranlasst deshalb die falsche Schlußfolgerung "w ist eine Primzahl". Für alle anderen möglichen b's ergibt sich jedoch "w ist keine Primzahl", so dass bereits im nächsten Durchlauf Klarheit herrschen wird. In diesem Beispiel liegt die Fehlerwahrscheinlichkeit wegen der 7 teilerfremden "b's" (b>1!) bei nur 1/7 = 14,3%, was aber keinen Widerspruch darstellt, da die genannte Abschätzung ja von "höchstens" 25% spricht.

5.5 Erzeugung großer Pseudoprimzahlen

Schritt für Schritt kommt man ihm näher

schiedener Autoren auch darüber hinaus sehr empfehlenswert, weil viele Gebiete der modernen Verschlüsselungstheorie angesprochen werden. Der Algorithmus lässt sich in 7 Schritte unterteilen, die man sich in ihrer Wirkung aus den vorangegangenen Überlegungen heraus erklären kann. Wohl aus Gründen der Vereinfachung wurde in dieser Version der bei Miller-Rabin vorgesehene Test auf Teilerfremdheit zwischen w und b eingespart, was aber keinen Einfluß auf das Ergebnis nach sich zieht. Schritt 1: Wahl einer ungeraden, natürlichen Zufallszahl w. Diese lässt sich immer so zerlegen: w = 1 + 2D m

m o ungerade

Schritt 2:

2D ohöchste 2-er Potenz, die w-1 teilt Erzeugung einer Zufallszahl b mit

Schritt 3:

1
Schritt 4:

Falls oder

j=0

und

z=1

0 d j d -1 und z = w-1 dann Ende mit Schritt 7, andernfalls folgt Schritt 5. Aussage bombenfest

Schritt 5:

Falls j>0 und z=1 dann liegt mit w keine Primzahl vor (wenn z=1 erreicht ist, ändert sich wegen z = z2 MOD w = 1 in Schritt 6 nichts mehr) und man beginnt wieder bei Schritt 1, andernfalls folgt Schritt 6.

Schritt 6:

Erhöhen von j = j + 1 Falls

Schritt 7:

j<

dann z = z2 MOD w weiter mit Schritt 4 Falls j= dann liegt mit w keine Primzahl vor und man beginnt erneut mit Schritt 1. Nach dem Primzahlensatz auf Seite 291 ist die Zahl w jetzt im Vergleich zum Kenntnisstand von Schritt 1 mit der Wahrscheinlichkeit 75% eine Primzahl bzw. mit der Wahrscheinlichkeit 25% keine Primzahl. Man kann diese Fehlerwahrscheinlichkeit um

293

5 Datenverschlüsselung

Starke und schwache Kandidaten

5.6

den Faktor 0.25 auf 0.0625 drücken, wenn man w noch einmal hernimmt und die Prozedur ab Schritt 2 erneut durchläuft. Dabei könnte sich w dann auch als Nicht-Primzahl herausstellen, so dass man wieder bei Schritt 1 beginnen müsste. Man sieht, dass sich die Unsicherheit darüber, ob w vielleicht doch keine Primzahl ist, nach i erfolgreichen Durchläufen von Schritt 2 bis Schritt 7 auf den Wert 4-i gesenkt hat. Bei 10 Durchläufen liegt man bereits bei 910-7, der NIST-Vorschlag geht sogar von 50 Durchläufen aus. Die Primzahlen des RSA-Beispiels in Unterkapitel 5.3 wurden übrigens mit diesem Algorithmus berechnet (und vorsichtshalber anhand einer Primzahlentabelle überprüft). Zu dem beschriebenen Verfahren gibt es Erweiterungen, die z. B. darauf abzielen, Primzahlen zu finden, die sich mehr als andere der Entdeckung durch Zerlegungsalgorithmen entziehen. Die Erzeugung dieser so genannten starken (Pseudo-) Primzahlen wird bei Gordon in "Strong Primes are Easy to Find" beschrieben (erschienen in EUROCRYPT 1984, Springer Lecture Notes in Computer Science 209 (1985), Seiten 216 – 223).

Was blieb? 1.

2. 3.

4.

5.

6.

7.

294

In einem „Verschlüsselungsnetzwerk“ mit DES-Verfahren befinden sich n Teilnehmer. Wieviele Schlüssel müssen erzeugt und ausgetauscht werden, wenn ein weiterer Teilnehmer hinzukommt? Wie ist die Antwort auf Frage 1, wenn das Netzwerk mit dem RSA-Verfahren arbeitet? Auf welchem bisher ungelösten Problem der Zahlentheorie beruht die – derzeitige – Sicherheit des RSAVerfahrens? Kann ein „sicheres“ Verschlüsselungs-Verfahren allein die Sicherheit eines technischen Informatiksystems gewährleisten? Falls die Antwort auf Frage 4 „nein“ wäre, welche weiteren Merkmale müsste ein sicheres Informatiksystem erfüllen? Die großen 3 Anforderungen an ein Informatiksystem sind Verfügbarkeit, Vertraulichkeit und Datenintegrität. Welche dieser Anforderungen können primär durch Verschlüsselungsverfahren unterstützt werden? Warum ist der Rechenaufwand beim DES-Verfahren prinzipiell geringer als bei RSA?

5.6 Was blieb? 8.

Für welche beiden unterschiedlichen Zwecke lässt sich der RSA-Algorithmus verwenden? 9. Mit welcher Wahrscheinlichkeit ist eine durch das MillerRabin-Verfahren nach dem von NIST vorgeschlagenen 50-fachen Durchlaufen des Algorithmus erzeugte Pseudo-Primzahl eine tatsächliche Primzahl? 10. Welche Genauigkeit für die Ganzzahlrechnung muss ein Algorithmus aufweisen, mit dem Grundrechenoperationen MOD 1015 durchgeführt werden sollen?

5.7

Verschlüsselung mit Hilfe des Goppa-Codes

Vielseitig: Korrektur oder Verschlüsselung

McEliece hat in "A public-key cryptosystem based on algebraic coding theory" (erschienen im Februar 1978 im JPL DSN Progress Report 42-44, Seiten 114-116) ein weiteres asymmetrisches Verschlüsselungssystem vorgeschlagen, was in diesem Fall auf dem Goppa-Code aufbaut. Obwohl es sich anscheinend in der Praxis bisher nicht durchsetzen konnte – im Vergleich zum RSAVerfahren vermutlich wegen des höheren Aufwandes bei der Schlüsselerzeugung und -verteilung – , ist es lohnenswert, sich einmal mit den Grundgedanken auseinanderzusetzen. Da der Goppa-Code bereits im Unterkapitel 3.8 behandelt wurde, gehen wir gleich von dem dort erworbenen Wissen aus. Der Goppa-Code baut auf den 2m Elementen eines Galoisfeldes GF(2m) auf und benutzt zur Korrekturfähigkeit von „t“ EinbitFehlern ein erzeugendes Polynom c(z) mit dem Grade t. Der Mangel, dass dieses Polynom darüber hinaus nur der Forderung genügen muss, keine Nullstellen im GF(2m) zu besitzen und dadurch keine eindeutige Auswahl möglich ist, erweist sich für den Zweck der Verschlüsselung geradezu als Vorteil. Sehen wir uns das einmal genauer an. Im Beispiel von Unterkapitel 3.8 wurde der GF(24) zu Grunde gelegt und als c(z) ein Polynom 3.Grades genommen, um einen 3-Bitfehler-korrigierbaren Code zu erhalten: c(z)

= z3 + z + 1.

Des einen Leid, Diese Wahl war willkürlich und eigentlich mehr von der Tatsades andern Freud che bestimmt, dass wir es bereits bei den zyklischen Codes kennengelernt hatten. Dass es keine Nullstellen im GF(24) aufweist, kam uns damals gerade recht. Dennoch hätte es jede Menge weiterer Kandidaten gegeben. Überlegt man sich, wieviele Polynome 3.Grades es mit einem Koeffizienten "1" bei z3 im GF(24) gibt, so kommt man auf immerhin schon (2 4)3 = 163 = 4096, wobei als Koeffizienten nicht nur 0 und 1, sondern jedes der 16 Elemente einzubeziehen ist. Allgemein sieht ein solches Polynom so aus:

295

5 Datenverschlüsselung f(z)

= z3 + c2z2 + c1z + c0.

Im nächsten Schritt wird diejenige Anzahl von Polynomen f(z) gesucht, die Nullstellen im GF(24) besitzen. Dafür gibt es zwei unterschiedliche Fälle, nämlich einmal den, bei welchem 3 Nullstellen vorhanden sind, und zum anderen denjenigen mit nur einer Nullstelle in Verbindung mit allen irreduziblen Polynomen 2.Grades im GF(24). Drei Nullstellen z1, z2 und z3, welche zu verschieNordische Kombi- Fall a: denen Polynomen f(z) führen, können im Polynom nation f(z) = (z - z1)(z - z2)(z - z3) in (16 über 3) = 560 Kombinationen auftreten (z. B. unterscheidet sich das Ergebnis bei z1 = 1, z2 = 0 nicht von dem bei z1 = 0, z2 =1, wenn jeweils dasselbe z3 verwendet wird). Für eine Nullstelle z1 gibt es im Polynom

Fall b:

Mengenlehre

f(z) = (z - z1)(z2 + c1z + c0) genau 16 Möglichkeiten, allerdings immer in Verbindung mit der Anzahl irreduzibler Polynome 2.Grades. Die Bestimmung dieser Anzahl geschieht ähnlich: Es gibt 162 = 256 verschiedene Polynome z2 + c1z + c0. Davon haben (16 über 2) = 120 Nullstellen im GF(24). Es bleiben also 256 - 120 = 136 Irreduzible. Der Fall b wartet demnach mit 16] 136 = 2176 Polynomen auf, die eine Nullstelle im GF(24) besitzen. Damit liegt auch die Gesamtzahl aller Polynome mit Nullstellen im GF(24) vor: 560 + 2176 = 2736. Diese Zahl zieht man von der Anzahl aller Polynome 3.Grades ab und erhält 4096 - 2736 = 1360 Kandidaten für das erzeugende Polynom c(z), schon eine ganze Menge. Die Auswahl kann man bei der Trefferwahrscheinlichkeit von 1360/4096 = 33% getrost durch Zufallswahl und Austesten vornehmen: Man wählt aus den 16 Elementen des GF(24) irgendeine 3-er-Kombination als Koeffizienten c2, c1 und c0 aus und prüft durch Einsetzen aller 16 Elemente, ob sich der Polynomwert 0 ergibt. Diese Kombination ist dann zu verwerfen. Beispiel (mit Tabelle 3-20 auf Seite 124): die Kombination c2 = 0 = 1,

Goppa sucht den Superstar

c1 = 12,

c0 = 8

ergibt bei f(z) für kein Element des GF(24) den Wert 0. Das Polynom c(z)

= z3 + z2 + 12z + 8

ist also für die Erzeugung eines Goppa-Codes zur Korrektur von 3 Fehlern geeignet.

296

5.7 Verschlüsselung mit Hilfe des Goppa-Codes Generatormatrizen satt

Was haben wir damit aber für die Verschlüsselung gewonnen?Wir können uns mit c(z) eine von 1360 verschiedenen (4]16)-Generatormatrizen G erzeugen und mit den 4elementigen Klartextvektoren k Goppa-Codewörter v gemäß v

= kG

berechnen. Als Geheimtexte sind diese jedoch nur bedingt geeignet, da der Goppa-Code systematisch ist und jeder unerwünschte Interessent durch Ausprobieren versuchen könnte, die Klartextstellen (=Informationsstellen) herauszubekommen. Mit der Länge 2m des Codewortvektors v weiß er immerhin schon, in welchem Galoisfeld gearbeitet wird und kann hier aufsetzen. Allerdings steigt die Anzahl möglicher Kandidaten für c(z) gewaltig an, wenn man Galoisfelder mit höherer Ordnung m wählt, und außerdem lässt sich noch der Grad t des erzeugenden Polynoms c(z) in bestimmten Grenzen frei festlegen. Ob das bisher angedeutete Verschlüsselungsverfahren nun genügend sicher ist oder nicht, auf jeden Fall müsste man seinen Partnern das Polynom c(z) oder die daraus erzeugte Generatormatrix G als Schlüssel mitteilen. Was lässt sich noch tun? Man könnte den Klartext u "verschleiern", indem man den Klartextvektor k mit einer invertierbaren 44-Matrix S multipliziert: k' S-Matrizen als Hilfssheriffs

= kS.

Versuchen wir einmal abzuschätzen, wieviele solcher Matrizen S es wenigstens gibt. Dazu geht man davon aus, dass S in oberer Dreiecksform vorliegt, da S dann auf jeden Fall invertiert werden kann (S hat in diesem Fall nur linear unabhängige Zeilen) und sich andere Matrizen daraus durch Transformationen bilden lassen. Bezeichnet man mit c die Anzahl der Informationselemente im Klartextvektor k, so kann man die Matrix S aus 2 (c-1)! - 1, hier also aus 23! – 1 = 26 - 1

= 63

Möglichkeiten auswählen (warum?), wobei der Fall S ist die Einheitsmatrix Verschleierungstänze

bereits ausgeklammert wurde. Bild 5.8 zeigt ein Beispiel. Das Ausrufezeichen "!" beim Exponenten (c-1)! steht hier für die mathematische Funktion "Fakultät". Bildet man nun den neuen Codewortvektor v'

= (kS)G,

so haben es unerwünschte Interessenten schwerer, an den Infoteil u heranzukommen. Dafür muss man dem Partner allerdings

297

5 Datenverschlüsselung auch noch S als Geheimsache mitteilen. Er könnte dann zunächst k' bestimmen und = k'S-1

k berechnen.

S=

[ ] 1001 0111 0010 0001

,

P=

[ ] 0010000 1000000 0000001 0001000 0100000 0000010 0000100

Bild 5.8: Beispiele für binäre invertierbare Verschlüsselungsmatrizen S und Permutationsmatrizen P P-Matrizen: DES lässt grüßen

Doch lassen sich noch weitere Maßnahmen treffen: Mit einer Permutationsmatrix P (die gemäß Bild 5.8 in jeder Zeile an einer anderen, zufällig gewählten Stelle eine "1" aufweist und damit zugleich stets invertierbar ist), wirbelt man die Elemente des Codewortvektors v' kräftig durcheinander, so dass es wiederum schwerer wird, k zu erkennen. Für die Wahl von P gibt es (2m)!, hier also 16! = 201012 Möglichkeiten. Aus v' wird jetzt v''

Fehler: Willkommen!

= v'P

= (kS)GP.

Das endgültige Sendewort, also der Geheimtext g, entsteht daraus durch Addition eines zufällig aus (16 über 3) = 560 Möglichkeiten gewählten 3-Bit-Fehlers (dieser ist hier natürlich nicht durch technische Einflüsse bedingt): g

= v' + e

= (kS)GP + e.

Was wurde bis zu diesem Punkt erreicht? Der Klartext k konnte mit einer ziemlich großen Anzahl von Schlüsseln in den Geheimtext g umgesetzt werden, dazu waren aber auch c(z), S und P als Schlüssel an den Partner zu übertragen. Gegenüber dem DESVerfahren ist das wegen des wesentlich größeren Umfangs nachteilig. Das ändert sich entscheidend, wenn man den Weg etwas umgestaltet. Wir fassen dazu die drei Schlüsselmatrizen G, S und P zu einer einzigen (416)-Matrix S* zusammen, g ... und schon ist es asymmetrisch!

298

= k(SGP) + e

= kS* + e,

und drucken diese als öffentlichen Schlüssel – z. B. für den Teilnehmer Poldi – in einem Teilnehmerverzeichnis ab. Die 3 einzelnen Matrizen S, G und P erhält nur Poldi als geheime Schlüssel. Andere können diese aus der Kenntnis von S* heraus praktisch

5.7 Verschlüsselung mit Hilfe des Goppa-Codes

RSA: die liebe Verwandtschaft

nicht bestimmen, da es eine riesige Anzahl von Möglichkeiten gibt, S* zu bilden. Will nun der Teilnehmer Moritz an Poldi eine geheime Nachricht schicken, so verschlüsselt er den Klartext k mit S*, addiert zur nochmaligen Verschleierung einen zufälligen 3-Bit-Fehler darauf und schickt den Geheimtext g

= kS* + e

an Poldi. Der multipliziert g zunächst von rechts mit der zu P inversen Matrix P-1, erhält damit gP-1 = kSGPP-1

+ eP-1

= kSG

+ eP-1

Ein vollwertiges Mitglied der ehrenwerten Gesellschaft

und wendet auf gYP-1 das Decodierverfahren für den GoppaCode an. Der Fehler e]YP-1 wird dadurch beseitigt, und nach Rechts-Multiplikation mit G-1 liegt Poldi der Vektor k' = kY]S vor, aus welchem er über k = k'Y]S-1 den Klartext k berechnet. Man sieht, dass dieser Weg alle grundsätzlichen Vorteile eines asymmetrischen Verfahrens mit öffentlichen und geheimen Schlüsseln bietet. Im Vergleich zum RSA-Algorithmus gibt es darüberhinaus den Nachteil einer wesentlich aufwendigeren Schlüsselerzeugung, (längere Rechenzeiten) den Vorteil, keine Langzahl-Rechnungen durchführen zu müssen (kürzere Rechenzeiten)

5.8

Ansätze zur Suche nach Schwachstellen

An den Beispielen im Unterkapitel 4.3 war bereits deutlich geworden, dass es bei den einzelnen Verschlüsselungsverfahren offensichtlich erhebliche Unterschiede bezüglich der Sicherheit gegen unberechtigte Entschlüsselungsversuche gibt. Ohne in das anspruchsvolle Gebiet der so genannten Kryptoanalyse, also der Lehre von der Entschlüsselung, tiefer einzusteigen, kann man seinen Blick auf mögliche Schwachstellen doch etwas schärfen, wenn man sich an folgenden drei Fragen orientiert: 1. Lässt sich ein möglichst langes Stück Geheimtext beschafDie 3 Kernfragen fen? Diese Frage wird am ehesten mit "Ja" zu beantworten sein. (Wenn nicht, müsste man zu unfeinen Mitteln greifen, um an die begehrten Informationen heranzukommen. Skrupellosen Zeitgenossen würden dann Maßnahmen wie Bestechung oder Erpressung in den Sinn kommen). Liegt also ein Stück Geheimtext vor, dann lässt sich mit den Hilfsmitteln der Statistik über die Un-

299

5 Datenverschlüsselung

Die Allmacht der Statistik

Die Angst der Sclüssel vor Friedmann und Kasiski

Klartext + Geheimtext = Schlüssel

300

tersuchung von Häufigkeitsverteilungen vielleicht der zugehörige Klartext sowie – ebenfalls nur vielleicht – der verwendete Schlüssel ermitteln. Nach dem englischen Sprachgebrauch macht man damit einen " known ciphertext"-Angriff auf das Verschlüsselungsverfahren. Die beiden Beispiele im Unterkapitel 4.3, Bilder 4.14 und 4.15 zeigen, dass bei zeichenweiser Verschlüsselung der natürlichen Sprache mit immer demselben Schlüssel eine Entschlüsselung durch statistische Auswertung sehr aussichtsreich ist. Bei zufällig wechselnden Schlüsseln wird das schon bedeutend schwieriger, wie aus Bild 4.16 zu erkennen war. Nach erfolgter Entschlüsselung lässt sich wegen der einfachen MOD 256- Addition oder XOR-Bildung auch noch der Schlüssel selbst bestimmen. Ein gutes Verfahren ist aber zumindest so aufgebaut, dass sich der Schlüssel nur durch systematisches Durchprobieren („ Brute Force“) aller möglichen Varianten ermitteln lässt und damit bei langen Schlüsseln in einer tragbaren Zeit unmöglich wird. Das DES-Verfahren erfüllt z. B. diese Forderung. Zur Schlüsselbestimmung gibt es übrigens sehr leistungsfähige Verfahren, wie den Friedmann- und den KasiskiTest, über die man im Buch von Beutelsbacher genaueres erfahren kann. Noch eine Bemerkung: Obwohl die DES-, RSA- und McEliece-Verfahren zu Recht als sehr geeignet und sicher erscheinen, muss man sich doch klar machen, dass hier theoretische Grenzen bestehen. Wenn man nämlich immer mit demselben Schlüssel verschlüsselt, gibt es eine – wenn auch abhängig von der Länge der Klartextblöcke – sehr kleine Wahrscheinlichkeit, den Klartext über statistische Analysen ermitteln zu können. Allerdings besteht selbst dann kaum eine Chance, den Schlüssel zu berechnen. Immerhin hat diese Tatsache die Autoren des DES veranlasst, das häufige Wechseln der Schlüssel dringend zu empfehlen. Die Auswirkung haben wir bei der Betrachtung des one-time-pad-Verfahrens auf Seite 255 ff. wohl deutlich gesehen. 2. Lassen sich zusammengehörige Stücke von Geheim- und Klartext beschaffen? Sollte das möglich sein, z. B., weil man den Aufbau eines Klartextes als Brief oder Aktennotiz erahnt, lässt sich versuchen, den oder die Schlüssel herauszubekommen. Nach englischem Sprachgebrauch macht man in

5.8 Ansätze zur Suche nach Schwachstellen

Angreifers Trickkiste

5.9

(Schlüssel-) Partnertausch

diesem Fall einen "known plaintext"-Angriff Im Beispiel "XOR-Verschlüsselung und zufällig wechselnde Schlüssel" erhielten wir auf diese Weise eine Folge verschiedener Schlüssel und würden sehen, ob sich daraus die Parameter "Ordnung und Rückkopplungspolynom" eines Schieberegisters berechnen ließen. 3. Lässt sich der Verschlüsselungsstelle gezielt ein Stück Klartext unterschieben und kann daraufhin der zugehörige Geheimtext beschafft werden? Dann wäre eventuell die Bestimmung der Schlüssel noch einfacher als bei der Aufgabenstellung gemäß Punkt 2, weil man ganz unmittelbar Ursache und Wirkung beobachten könnte. Im Englischen heißt das "chosen plaintext"-Angriff. Shamir hat – allerdings bisher ohne durchschlagenden praktischen Erfolg – die theoretischen Möglichkeiten, die dann zur Analyse zur Verfügung stünden, am Beispiel eines Aufbrechversuchs des DES diskutiert. Es handelt sich um das schon erwähnte Verfahren der differentiellen Kryptoanalyse.

Verfahren zum Austausch von Schlüsseln (Diffie-Hellmann) Der im Vergleich zum DES-Verfahren aufwendigere Gebrauch des RSA-Algorithmus hat vorläufig erst einmal dazu geführt, dass die eigentliche Klartextverschlüsselung mit dem DES gemacht wird, während man sich zum Austausch des Schlüssels des RSAVerfahrens bedienen kann, da die Schlüssel im allgemeinen verhältnismäßig kurz sind (siehe Unterkapitel. 5.14, PGP und GnuPP) Diffie und Hellmann haben ein noch einfacheres, nach ihnen benanntes Verfahren gefunden, das als Diffie-HellmannSchlüsseltausch bezeichnet wird ("New Directions in Cryptography", IEEE Transactions on Information Theory IT-22, Seiten 644-654, November 1976). Dazu ein Beispiel: Schritt 1: Die beiden Teilnehmer Dieter und Hildegard wählen eine Primzahl n und eine beliebige Zahl s < n. Sie ist dann "automatisch" teilerfremd zu n. Beide Zahlen können öffentlich bekannt sein. Schritt 2: Dieter bestimmt für sich eine Geheimzahl d < n-1 und Hildegard eine Geheimzahl h < n-1. Dieter bildet e = s d MOD n und schickt e an Teilnehmerin Hildegard.

301

5 Datenverschlüsselung Hildegard berechnet

Schritt 3:

k

= e h MOD n = (s d MOD n)h MOD n

Schritt 4:

= s dh MOD n. Hildegard bestimmt

Schritt 5:

f = s h MOD n und schickt f an Dieter. Dieter berechnet f d MOD n = (s h MOD n) d MOD n

ganz ohne Geheimnistuerei

= k. = s hd MOD n Durch dieses Verfahren haben beide Teilnehmer also die gleiche, nur ihnen bekannte Zahl k ermittelt, die sie nun als Schlüssel für das DES-Verfahren verwenden können. Die Zahlen e und f brauchen nicht geheimgehalten zu werden, da es praktisch unmöglich ist, nur aus der Kenntnis von e, f, s und n die geheimen Zahlen d und h zu ermitteln. Daher wird auch die Berechnung von k für einen Außenstehenden unmöglich. Die Aufgabe, aus gegebenen Werten e, f, s und n die Exponenten d und h in e

= s d MOD n

oder

f = s h MOD n

zu berechnen, heißt "Bestimmung des diskreten Logarithmus. Sie harte Nüsse: Diskrete Logarith- ist mit den heute bekannten Hilfsmitteln praktisch genau so men schwierig wie die Zerlegung ganzer Zahlen in Primfaktoren. Ein Beispiel: Dieter und Hildegard vereinbaren öffentlich: n = 13, s = 11. Dieter

wählt geheim:

d = 5.

Hildegard

wählt geheim:

h = 7.

Dieter

berechnet:

e = 115 MOD 13 = 161051 MOD 13 =7

und schickt e öffentlich an Hildegard Hildegard:

berechnet mit e: k = 77 MOD 13 = 823543 MOD 13 = 6. Außerdem berechnet sie : f = 117 MOD 13

302

5.9 Verfahren zum Austausch von Schlüsseln (Diffie-Hellmann) = 19487171 MOD 13 =2 und schickt f öffentlich an Dieter berechnet mit f: k = 25 MOD 13 = 6. Man sieht, dass dies ein äußerst einfaches und unaufwändiges Verfahren ist, Schlüssel auszutauschen. Es wird heute für sichere Internet-Verbindungen im hypertext transfer protocol secure (= https) verwendet.

Dieter

5.10

(Kein diplomatisches) Protokoll

„Ich weiß was, sag's Dir aber nicht, ätsch!“

Nachweis der Berechtigung (Benutzer-Authentikation) Ein besonderer Mangel des üblichen Passwort-Verfahrens ist es, dass es den an einem Verschlüsselungsprozess beteiligten Partnern bekannt sein muss, z. B. dem Kunden und dem Bankrechner. Der Kunde als Eigentümer stellt nicht das Problem dar. Unangenehm ist vielmehr, dass es auch außerhalb seines Einflussbereiches in der Bank aufbewahrt wird. Bei allem gebotenen Vertrauen bleibt dies letztlich doch eine Schwachstelle. Eine grundlegende Verbesserung biete hier ein so genanntes Authentikationsprotokoll, welches Fiat und Shamir im Jahre 1987 erstmals im Rahmen weiterer Verfahren vorgeschlagen haben (Fiat und Shamir: How to Prove Yourself: Practical Solutions to Identification and Signature Problems, Advances in Cryptology, CRYPTO 1986, Springer-Verlag, Berlin 1987). Es wird auch ZeroKnowledge-Protokoll genannt und beruht auf einer verblüffenden Überlegung, von der man zunächst gar nicht glauben kann, dass sie funktioniert. Die Idee ist, dass jeder Benutzer eine geheime Information erhält und der Partner (z. B. der Bankrechner) prüfen kann, ob der Benutzer diese Information wirklich kennt, ohne – und hier liegt der entscheidende Punkt – die Information selbst preisgeben zu müssen. Die beiden Autoren stellen diese Idee in einem breiteren Zusammenhang dar: Sie behandeln drei verwandte Aufgaben, die mit folgenden Begriffen in Verbindung stehen: • Authentikation (= wie kann ich meinem Partner beweisen, dass ich der richtige bin?) • Identifikation (= wie kann ich meinem Partner beweisen, dass ich der richtige bin, und zugleich ausschließen, dass sich dieser Partner einem dritten gegenüber für mich ausgibt?) • Unterschriften-Echtheit (= wie kann ich meinem Partner beweisen, das ich der richtige bin, aber dieser Partner sich weder dritten noch sich selbst gegenüber für mich ausgeben kann).

303

5 Datenverschlüsselung „Stop! – Kannst Du Dich ausweisen?“

Aus diesen drei Aufgaben wird im folgenden die der Authentikation behandelt. Eine Schlüsselvergabestelle, der man ausreichendes Vertrauen entgegenbringen kann, wählt zwei sehr große Primzahlen p und q mit je etwa 200 Dezimalstellen, die geheim gehalten werden. Nur das Produkt n

= pq

wird veröffentlicht. Außerdem bestimmt sie für jeden Benutzer eine beliebige Zahl s, die zu n teilerfremd sein muss, also keine gemeinsamen Primfaktoren haben darf, ggT(n,s)=1. Die Schlüsselvergabestelle berechnet mit s die so genannte modulare Quadratzahl v mit v Modul ..., modulo ..., modular ....

= s2 MOD n.

Die Zahl s wird dem Benutzer geheim übermittelt, während v öffentlich bekannt sein kann und muss. Eine bemerkenswerte Eigenschaft liegt darin, dass man ohne Kenntnis von p und q aus v die modulare Wurzel s praktisch nicht bestimmen kann, insbesondere dann nicht, wenn p und q sehr große Primzahlen sind. Warum das so ist, wird zum Beispiel im Buch von I. Stewart/D. Tall, oder als Kurzdarstellung bei W. Dankmeier in „Modulare Quadratwurzeln beim Fiat-Shamir-Verfahren zur Authentikation“, 1996, Manuskript zur Vorlesung „Codierungsverfahren“, Fachhochschule Frankfurt am Main, erläutert. Betrachten wir ein Beispiel: Graf Dracula befindet sich häufig auf mehrjährigen Geschäftsreisen und möchte während dieser Zeit den Zugang zu seinem Schloß in Transsylvanien gegen Unbefugte "dichtmachen". Nach ausgiebigem Studium der modernen Fachliteratur über Kryptologie erscheint ihm der Lösungsvorschlag von Fiat und Shamir sehr überzeugend. Auf seinen Antrag hin berechnet die Schlüsselvergabestelle des Verbandes gemeinnütziger Vampire e. V. aus den beiden Primzahlen p

= 281

und

q

= 509

die den Modul n

= 143029,

wählt eine zu n teilerfremde Zufallszahl s

= 8133,

übergibt diese als Geheimsache an Graf Dracula, berechnet v

= 81332 MOD 143029

= 66291

und nimmt n und v in das Mitgliederverzeichnis des Verbandes auf. Mit seinem Sicherheitschef Oberst Werwolf, dem er nicht völlig vertraut, da dieser bei Vollmond meistens ein merkwürdiges

304

5.10 Nachweis der Berechtigung (Benutzer-Authentikation)

„ . behalte r, gib r2 .....

Verhalten zeigt, und er ihm deshalb auch keine geheimen Schlüsselzahlen bekannt machen möchte, vereinbart er (genau genommen: droht ihm bei Nichtbefolgung ein 777-jähriges BissVerbot an) folgendes Verfahren (=Protokoll): 1.Schritt: Wenn jemand Einlaß in das Schloß begehrt, wählt dieser jemand eine Zufallszahl r, die zu n teilerfremd sein muss, also z. B. r = 7567, und berechnet x

Der Würfel ist gefallen

= r2 MOD n = 47889.

Das Ergebnis x teilt er Oberst Werwolf mit. Dieser "würfelt" mit einem zweiwertigen Würfel (kann aus einer Schieberegisterfolge gemäß Kapitel 5.1 stammen) und fordert von dem unbekannten Besucher (er sieht sehr schlecht) weitere Informationen an. 2.Schritt, Fall a: Hat Oberst Werwolf eine "1" gewürfelt, so verlangt er vom Besucher die Zahl y

= rs MOD n = 75678133 MOD 143029

= 39941

(die Zahl r kann sich natürlich jeder bestimmen, s hingegen ist nur dem Grafen bekannt) und berechnet daraus y2 MOD n

= 81044,

was mit dem von ihm ebenfalls berechneten Wert xv MOD n = 4788966291 MOD 143029

= 81044

übereinstimmt und darauf hinweist, dass es sich tatsächlich um seinen Herrn handelt. Warum? Nach den Rechenregeln mit der Modulo-Funktion gilt für Produkte MOD n xv MOD n = ((r2 MOD n)(s2 MOD n)) MOD n

= r2s2 MOD n.

Andererseits ist y2 MOD n

= (rs MOD n)2 MOD n = ((r MOD n)2(s MOD n)2) MOD n

= r2s2 MOD n.

Die Ergebnisse sind also identisch, so dass y2 MOD n

= xv MOD n

sein wird. Schritt 2, Fall b: Der Oberst würfelt eine "0", verlangt vom Besucher die Zahl y = r MOD n und berechnet sich daraus das modulare Quadrat y2 MOD n

= r2 MOD n = 75672 MOD 143029

= 47889.

305

5 Datenverschlüsselung

Anstiftung zum Betrug

Spiel mit dem Feuer

Der Vergleich mit der Zahl x (= y2 MOD n = r2 MOD n) aus Schritt 1 bestätigt ihm auch hier die Identität des Grafen Dracula. An dieser Stelle seiner Unterweisung schärft ihm Dracula aber ein, diese Schritte noch einige Male mit jeweils einer neuen Zahl r durchlaufen zu lassen (wenigstens 20 Mal). Warum? Ein Betrüger könnte versuchen, sich als Graf Dracula auszugeben. Der Graf hat zur Zeit hierfür seinen ärgsten Rivalen Professor Frankenstein im Visier, von dem er weiß, dass dieser zur Unterstützung verschiedener Experimente größere Mengen Jahrgangsblut aus seinem Eiskeller benötigt. Es wäre nicht auszuschließen, das er sich während seiner Abwesenheit an den Oberst heranmacht und sich als Graf Dracula ausgibt. Er ginge dann so vor: Schritt 1, Fall a': Professor Frankenstein nimmt an, dass der Oberst eine "1" würfeln wird, gibt sich ohne Bestimmung von r irgendein y vor, z. B. y = 2345, und berechnet mit v (das ja öffentlich bekannt ist) eine passende Zahl x. Dazu muss er nur das so genannte modulare Inverse v-1 zur Zahl v ermitteln (s. Kapitel 3.2, Seite 44). Für ein modulares inverses Element gilt vv-1 MOD n

= 1,

hier also 66291v-1 MOD 143029

=1

für v-1

= 71891.

Er multipliziert die Gleichung y2 MOD n beidseitig mit v 2

= xv MOD n -1

und kann nun nach x MOD n auflösen:

-1

y v MOD n

= xvv-1 MOD n = x MOD n = 2345271891 MOD 143029 = 109652.

Wer wagt, gewinnt – vielleicht

Wenn der Professor also davon ausgeht, dass Oberst Werwolf eine 1 würfelt, dann braucht er die Zahl r nicht zu bestimmen (r selbst wird nach außen zunächst gar nicht verlangt), sondern kann über die Vorgabe von y bzw. y2 MOD n die Zahl x MOD n

= 109652

melden. Schritt 2, Fall a': Würfelt der Oberst tatsächlich eine "1" und fordert y

= rs MOD n

so teilt Frankenstein direkt y mit und überzeugt ihn wegen

306

= 2345

5.10 Nachweis der Berechtigung (Benutzer-Authentikation) y2 MOD n

= 63923

xv MOD n

= ((x MOD n)(v MOD n)) MOD n = 10965266291 MOD n = 63923,

dass er den Grafen vor sich hat. Der Täuschungsversuch wäre also gelungen. Anders sieht es dagegen aus, wenn Oberst Werwolf beim Werfen eine "0" erzielt. Dann will er ja y Fehlschuss

= r MOD n =r

wissen, was ihm aber der Professor nicht geben kann, da er die Zahl r gar nicht bestimmt hatte. Es nützt ihm auch nichts, wenn er das "schnell" noch nachziehen möchte, da man die modulare Wurzel r aus dem vorgegeben Wert für x praktisch nicht bestimmen kann. Bei den für den Einsatz vorgesehenen großen Zahlen scheitert die z. Z. einzige bekannte Lösungsmethode des systematischen Durchprobierens aller möglichen Zahlen r am Zeitaufwand. Der Pferdefuß liegt für Frankenstein also darin, dass er sich schon vor dem ersten Schritt für sein Vorgehen entscheiden musste und deshalb im zweiten Schritt festgelegt ist, ohne zurück zu können. Im anderen Fall steht er aber auch nicht besser da. Schritt 1, Fall b': Frankenstein nimmt hier an, dass der Oberst wahrscheinlich eine "0" würfeln wird. Für den ersten Schritt wählt er dann eine zu n teilerfremde Zahl r, z. B. r = 3659, und meldet x

= r2 MOD n

= 36592 MOD 143029

= 86584.

Schritt 2, Fall b': Wenn tatsächlich die "0" fällt, schiebt er y

= r MOD n

= 3659 MOD 143029

= 86584

nach und hat damit den Oberst, der sich daraus y MOD n berechnet, genauso von seiner Identität als Graf überzeugt. Kommt dagegen die "1", läuft der Professor voll gegen die Mauer, denn jetzt fehlt ihm die Kenntnis der Zahl s, damit er das richtige 2

y Doof: Annahmen sind keine Tatsachen

= rs MOD n

berechnen kann. Auch hier ist ein Zurückdrehen wegen der bereits bekanntgegebenen Festlegung auf die Zahl r im ersten Schritt unmöglich. Der Graf hat also nur allzu recht, wenn er seinem Sicherheitschef einbläut, auf jeden Fall viele solcher Tests hintereinander durchzuführen, da in einem Test offensichtlich immer eine 50%-Wahr-

307

5 Datenverschlüsselung

Ehrlichkeit siegt – fast immer

5.11

Manipulieren schwer gemacht

308

scheinlichkeit für die Entdeckung eines Betrugsmanövers besteht. Bei Hintereinanderschaltung mehrerer dieser unabhängigen Tests wächst die Entdeckungschance exponentiell an, bei 10 Schritten wäre die Erfolgsquote nur noch etwa 0.5-10 = 1024-1 = 0.001, also schon sehr klein. Oberst Werwolf ist nach dieser Unterweisung auch überzeugt, dass ein derartiges Protokoll nur derjenige unbeschadet durchläuft, der die Zahl s kennt – und dass er, Werwolf, sie gar nicht zu wissen braucht (daher die Bezeichnung "Zero-Knowledge-Protokoll"). Der Protokollablauf kann in der Praxis natürlich nur zwischen zwei Rechnern abgearbeitet werden. Einer davon wäre als Chipkarte an den Benutzer gebunden. Der Benutzer braucht sich dann nur über ein Passwort gegenüber seiner Chipkarte auszuweisen. Hier ist die Geheimhaltung wesentlich weniger kritisch, zumal er das Passwort auch selbständig ändern könnte.

Nachweis der Unversehrtheit einer Nachricht Bei der Betrachtung des RSA-Algorithmus kristallisierte sich unter anderem die Aufgabe heraus, der Nachrichtenempfängerin Annette glaubhaft zu machen, dass ihr die Nachricht wirklich von Ulrich geschickt wurde und nicht etwa von einem Betrüger, der sich als Ulrich ausgibt. Der Weg war einfach: Ulrich bildete aus der Nachricht ein Codewort mit Fehlererkennungs-Eigenschaften, d. h., er berechnete die CRC-Bytes zur Nachricht und fügte sie dieser an. Dann verschlüsselte er diese CRC-Bytes zusätzlich noch einmal mit seinem geheimen Schlüssel. Das ganze Paket verschlüsselte er darauf mit Annettes öffentlichem Schlüssel und schickte es ihr. Annette konnte sich nach dem Entschlüsseln überzeugen, ob die beiden CRC-Byte-Blöcke übereinstimmten. Wenn ja, konnte sie sich über den Absender sicher sein. Die Unversehrtheit der Nachricht wurde durch das Verschlüsseln mit ihrem öffentlichen Schlüssel garantiert. Der Schwerpunkt des Interesses lag hier neben der Geheimhaltung der Nachricht also auch darauf, den Nachweis zu führen, dass Ulrich der Absender war (er hätte dazu übrigens genausogut auf die Berechnung der CRC-Bytes verzichten und statt dessen ein kleines Anfangsstück der Nachricht mit seinem geheimen Schlüssel verschlüsseln können). Wenn wir die Nachricht dagegen nicht geheimhalten wollen oder dürfen – etwa weil wir eine Botschaft allgemein bekannt machen müssen – so sind andere Maßnahmen erforderlich, um deren Unversehrtheit zu garantieren (denken wir z. B. an die Anwendungsvorschriften für ein kritisches Medikament). Es gibt mehrere Lösungen hierfür: a) Der Autor verschlüsselt den Klartext mit seinem geheimen

5.11 Nachweis der Unversehrtheit einer Nachricht Schlüssel d und stellt den Geheimtext öffentlich zu Verfügung. Jeder Interessent kann sich den Klartext über den öffentlichen Schlüssel e des Autors beschaffen (s. Unterkapitel 5.3). Da es praktisch keinen zweiten Autor gibt, mit dessen öffentlichem Schlüssel die Entschlüsselung funktionieren würde, darf dieser Interessent sicher sein, die originale, unversehrte Nachricht in Händen zu halten. Voraussetzung ist natürlich, dass er dem Autor trauen kann. ... und immer Im Teilnehmerverzeichnis könnte sich ja auch ein Betrüger wieder: Vertrauen muss sein einschmuggeln, der dann inhaltlich bedenkliche, in kryptologischer Hinsicht aber einwandfreie Nachrichten veröffentlicht. Man müsste sich dann noch davon überzeugen, ob der Autor wirklich auch diejenige Vertrauensperson ist, die man mit dem Inhalt der Nachricht in Verbindung sieht. Wahrscheinlich ahnt man, dass solche Überlegungen leicht in eine endlose Kette einmünden. An irgendeiner Stelle muss man einfach einmal Vertrauen haben. Trotzdem ist es der richtige Weg, sich diese Stelle sehr genau auszusuchen und alles daran zusetzen, lückenlos sicher bis zu ihr zu gelangen. Damit die Interessenten überhaupt einen Hinweis auf den Inhalt erhalten, müssen dem Geheimtext Kurzinformationen über diesen Inhalt und über den Autor in Klartextform hinzugefügt sein. Nachteilig bleibt trotzdem, dass man auf jeden Fall entschlüsseln muss, selbst dann, wenn man an einem Unversehrtheitsnachweis gar nicht interessiert ist. b) Der Autor veröffentlicht den Klartext und zusätzlich den mit seinem geheimen Schlüssel erzeugten Geheimtext. Jeder Interessent kann hierbei selbst entscheiden, ob er die Unversehrtheit prüfen will oder nicht und den Aufwand seinen Vorstellungen anpassen. Nachteilig ist jedoch, dass die Nachricht gleich zweimal bereitgestellt werden muss. Dafür wird aber auch eine sehr große Sicherheit erreicht. c) Der Autor bildet aus der Nachricht eine Prüfsumme, die Sparen durch wesentlich kürzer als die Nachricht ist, verschlüsselt nur diese Prüfsummen Prüfsumme mit seinem geheimen Schlüssel und fügt sie dem Klartext an. Der Gesamtumfang von Klar- und Geheimtext ist dann ebenfalls wesentlich geringer. Interessenten, welche die Unversehrtheit prüfen wollen, entschlüsseln die vom Autor berechnete Prüfsumme, bilden diese aus der Nachricht noch einmal und dürfen sich bei Übereinstimmung sicher fühlen – wenn bestimmte Voraussetzungen bezüglich der Prüfsumme erfüllt sind. Welche das sein müssen und welche Verfahren sich hierfür eignen, wird nun genauer betrachtet. Anforderungen an die Prüfsumme können sein: Kandidatenprofil c1)Möglichst jedes Bit im Klartext muss Einfluss auf die Prüfsumme haben, oder anders ausgedrückt, Änderungen

309

5 Datenverschlüsselung

Einer wird gewinnen – oder ein paar mehr

reizende Herausforderungen

310

eines Bits im Klartext sollen möglichst viele Änderungen in der Prüfsumme hervorrufen. c2)Verschiedene Klartexte sollen möglichst viele verschiedene Prüfsummen erzeugen, oder anders ausgedrückt, möglichst wenige verschiedene Klartexte dürfen die gleichen Prüfsummen erzeugen. Der Idealfall "genau je eine eindeutige Prüfsumme für jeden möglichen Klartext" ist natürlich nicht erreichbar. Für einen Text mit 128 ASCIIZeichen zu je 8 Bit gibt es z. B. theoretisch 2128]8 = 21024 Kombinationen, während eine aus 4 Byte bestehende Prüfsumme nur 232 Kombinationen gestattet. c3)Es soll praktisch unmöglich sein, zu einer gegebenen Prüfsumme schnell einen passenden Klartext zu bestimmen. Die Prüfsumme muss also über eine so genannte Einwegfunktion bestimmt werden, bei der es für die Umkehrung keinen Weg außer dem des systematischen Probierens aller möglichen Klartexte („Brute Force“) gibt. Dieses Probieren scheitert im praktischen Einsatz immer an der ungeheuren Anzahl verschiedener Möglichkeiten. c4)Die Berechnung der Prüfsumme soll nicht aufwändiger sein als die Verschlüsselung des Klartextes. Andernfalls müsste man abwägen, ob der Weg b nicht günstiger wäre, da die Punkte c1, c2 und c3 dann ja auf jeden Fall in idealer Weise erfüllt wären. Welche Funktionen erfüllen diese Anforderungen an eine Prüfsumme? Nehmen wir uns einmal den schon gut bekannten Kandidaten "Fehlererkennungscode" vor. Mit diesem wird zu erreichen versucht, möglichst jede Änderung eines Bits so auf das Ergebnis der MOD-Division mit dem Generatorpolynom g(x) durchschlagen zu lassen, dass sich ein von 0 verschiedener Rest ergibt, um Übertragungsfehler oder Veränderungen zu erkennen. Die Anforderungen c1 und c4 (sowie vielleicht noch c3) lassen sich damit einigermaßen erfüllen, bei c2 sieht es aber schon bedeutend schlechter aus. Man kann die Untersuchung nämlich auch daraufhin ausrichten, nach denjenigen Klartextveränderungen zu suchen, welche dieselbe Prüfsumme ergeben. Die Antwort ist mit den Kenntnissen über zyklische Codes ziemlich einfach: Alle Fehler (oder Veränderungen), die dasselbe Bitmuster wie gültige Codewörter haben, werden nicht erkannt, da sie Vielfache des Generatorpolynoms sind. Wenn ein Betrüger das Verfahren zur Bildung der Prüfsumme kennt, kann er also mit Hilfe des Klartextes leicht ausprobieren, welche Änderung hieran zur selben Prüfsumme führt. Obwohl die Anzahl durch die Vielfachen des Generatorpolynoms beschränkt ist, werden seine Chancen nicht unrealistisch gering sein, eine geeignete Kombination für eine glaubwürdige Ver-

5.11 Nachweis der Unversehrtheit einer Nachricht änderung des Klartextes zu finden. Die Benutzung eines Fehlererkennungs-Verfahrens zur Bildung von Prüfsummen erscheint in diesem Zusammenhang deshalb als weniger gut geeignet. Besser aufgehoben für diesen Zweck ist man bei den Verfahren der so genannten Hash-Summen. Diese Bezeichnung trifft den Ablauf recht gut: Man zerlegt die Nachricht in Blöcke, vermischt sie, "presst" alles z. B. durch Addition auf die Größe eines einzigen Blockes zusammen und verwendet diesen als Prüfblock H(K) für den Klartext. Eine Variante kennen wir bereits, ohne es zu wissen: Das DESKandidatenliste Verfahren gestattet die, an den Anforderungen c1 bis c3 gemessen, recht brauchbare Bildung von Prüfsummen: Schritt 1: Wahl eines Schlüssels S, Schritt 2: Zerlegung des Klartextes in n 64-Bit-Blöcke, Schritt 3: Bildung des Geheimtextblocks g(1) durch Verschlüsselung des ersten Klartextblocks k(1) mit dem Schlüssel S, Schritt 4: Bildung des Geheimtextblocks g(2) durch Verschlüsselung des Ergebnisses k(2) XOR g(1) unter Verwendung des Schlüssels S (zur Erinnerung: XOR entspricht der stellenweisen MOD 2-Addition), Schritt 5: wie Schritt 4, aber Bildung des Geheimtextblocks g(3) durch Verschlüsselung von k(3) XOR g(2) mit dem Schlüssel S. Dies wird in den folgenden Schritten mit g(4), k(4), g(5), k(5) usw. solange fortgeführt, bis der letzte Geheimtextblock g(n) vorliegt Verschachtelungs- Als Ergebnis dieses Cipher-Block-Chaining-Verfahrens erhält man Taktik nach n Schritten am Ende eine 64-Bit-Prüfsumme, allgemein als Message-Authentication-Code (=MAC) bezeichnet. Dieser Weg ist schon deshalb besonders gut geeignet, weil der Versuch eines Betrügers, einen anderen Klartext mit derselben Prüfsumme zu finden, wegen des ihm – hoffentlich – unbekannten Passwortes außerordentlich erschwert wird. Bezüglich der Anforderung c4 liegt man dabei aber noch nicht besonders günstig. Das verbessert sich erst, wenn man speziell auf dieses Vorhaben zu geschneiderte Hash-Funktionen verwendet, wie sie z. B. von Pearson in "Fast Hashing of Variable-Length Text-Strings" (Communications of the ACM, Volume 33, Nr.6, Juni 1990) beschrieben werden: Man nummeriert zunächst alle Zeichen c eines Klartextes K von 0 ausgehend durch. Mit dem Binäräquivalent des ASCII-Zeichens c(i) bildet man gemäß dem folgenden Pseudo-Programmcode mit Hilfe einer Permutationstabelle T in einer Schleife die Hash-Zwischensummen h, wobei n die Zeichenanzahl im Klartext K bedeutet und die Länge eines "Klartextblocks" 8 Bit beträgt:

311

5 Datenverschlüsselung

BEGIN h = 0; FOR i = 1 TO n DO h = T(h) XOR c(i) NEXT; H(K) = h; END Hilfe, alles vertauscht!

Das Endergebnis h bei i = n ist die gesuchte Hash-Summe H(K). Wenn die Permutationstabelle T für eine gute statistische Verteilung sorgt, sind die Anforderungen c1, c2 und c3 gut erfüllt. Ein Beispiel ist als Tabelle 5-1 dargestellt. Diese Tabelle enthält 256 von 0 bis 255 durchnummerierte Elemente. Die Permutationsfunktion T(i) erhält danach z. B. die Werte T(0)=1, T(1)=87, T(2)=49 usw. Als Beispiel dient der Klartext K = "Heute, 20.00 Uhr, Tanz der Vampire im KARPATOS. Mitbringen von Eigenblut unerwünscht!" Die Hash-Summe ist bei diesem Verfahren immer eine Zahl zwischen 0 und 255 und hat hier den Wert H(K) = 130. Wenn jemand die Leser dieses Klartextes ärgern will, könnte er bei der Uhrzeitangabe zwei Ziffern in "02.00 Uhr" vertauschen. Das Ergebnis wäre bei gleicher Zeichen-Anzahl K'= "Heute, 02.00 Uhr, Tanz der Vampire im KARPATOS. Mitbringen von Eigenblut unerwünscht!"

Original und Fälschung: ertappt!

312

Die Hash-Summe verändert sich dabei zu H(K') = 166. Die (verschlüsselt) beigefügte Hash-Summe H(K) = 130 würde den Unterschied erkennen lassen (könnte aber natürlich nichts zur Korrektur beitragen). Man sieht, dass bereits die Änderung der Reihenfolge im Text zu einer anderen Hash-Summe führt, was bei fehlender Permutation übrigens nicht der Fall wäre. Zu diesem Verfahren gibt es eine ganze Reihe von Varianten. Es versteht sich von selbst, dass die Hash-Summe H(K) noch verschlüsselt werden muss, sonst ließe sich auch für alle anderen Klartexte immer die richtige Hash-Summe bestimmen. Außerdem

5.11 Nachweis der Unversehrtheit einer Nachricht ist allen Interessenten das Verfahren zur Bildung der Hash-Summe bekannt zu machen, da sich sonst H(K) nicht aus dem Klartext berechnen ließe. T =

1

87

49

12 176 178 102 166 121 193

84 249 230

44 163

85 218

80

64 239

24 226 236 142

38 200

110 177 104 103 141 253 255

50

77 101

81

31 222

34

72 242

20 214 244 227 149 235

14 197 213 181 161 25 107 190

70

86 237 240

97 234

18

45

57

22

60 250

58

66 154 106 195 245 171

132

56 148

75 128 133 158 100 130 126

91

13 153 246 216 219

119

68 223

78

138

30

170

73

27 188

15 238 2 157

79

99 122

11

92

32 136 114

52

26 143

74 251

94 129 162

63 152

95

67 124 168 252

61

3 150

53

23 131 37 123

9 145 134 228 207 212 202 215

69 229

42

40 186 147 198 192 155

140

36 210 172 65

54 159

28 144 254 221

4

55

59 151 220

29 108

33 164 191

21 247

90

10

16 105 137 225 224 217 160

89

233 51

0 243

35

46 116

41

62 135 248

17 187 182 179

88 201

7 115 167 241 206

125 173 118

83

5 127 199 111

96

174 169 211

48 183 156

82 175 208

6

19 205

39 203

98 204 165 180 117

8 185 232 113 196 231

93 189 194 139 112

43

76

47 146 120

71 109 184 209

Tabelle 5-1: Permutationen T Geringe Kosten, starke Wirkung

Standards setzen

Der Vorteil des soeben beschriebenen Verfahrens mit Permutationstabellen liegt im Vergleich zum Hash-Summen-Verfahren unter Verwendung des DES im wesentlich geringeren Rechenaufwand. Wir haben nun gesehen, welche Anforderungen an Verfahren zur Prüfung der Unversehrtheit einer Nachricht zu stellen sind und welche Verfahren mit welchen Vor- und Nachteilen es hierfür gibt. Auf jeden Fall stehen für den Einsatz in der Praxis geeignete Lösungen zur Verfügung. Diese beschränken sich keineswegs auf die Prüfung normaler Klartexte. Für die Informationssicherung an Daten und Programmen kann es z. B. sehr vorteilhaft sein, deren Unversehrtheit im Sinne des NichtVeränderten nachzuweisen. Man denke etwa an die Wirkung der lästigen oder sogar gefährlichen Computerviren vor allem im PCBereich, die ohne besondere Maßnahmen nicht sofort erkennbar sind, auf jeden Fall aber Veränderungen an Dateien nach sich ziehen. Diese Veränderungen ließen sich über Hash-SummenVergleiche erkennen. Aber Vorsicht: Das funktioniert nur dann, wenn das Virenprogramm nicht seinerseits in der Lage ist, die richtige Hash-Summe zu bilden und an der richtigen Stelle abzulegen. Die aktuellen Verfahren zur digitalen Signatur verwenden anerkannte Standard-Algorithmen zur Bildung von Hash-Summen. Zwei gängige sind zur Zeit (Anfang 2006) ¡ RIPEMD (Reseaux IP Europeens Message Digest). Er baut auf dem Algorithmus MD4 auf und verwendet 160 Bit-Schlüssel ¡ SHA-1 (Secure Hash Algorithm 1). Er ähnelt dem Algorithmus

313

5 Datenverschlüsselung MD5 von Rivest, wurde von NIST als Hash-Komponente im DSS (=Digital Signature Standard) entworfen, zu dem auch das im nächsten Unterkapitel besprochene DSA-Verfahren gehört und arbeitet ebenfalls mit 160 Bit-Schlüsseln. Mittlerweile steht er unter Beobachtung und soll mittelfristig von einem anderen, noch sichereren Algorithmus abgelöst werden. Über den aktuellen Stand kann man sich z. B. beim Bundesamt für Sicherheit in der Informationstechnik BSI (www.bsi.de), oder beim Informatikzentrum Niedersachen (www.izn.niedersachsen.de) informieren.

5.12

Nachweis der Absenderidentität (digitale Unterschrift, DSA)

Auch diese Aufgabenstellung, nämlich wie ein Autor beweisen kann, dass ein Dokument wirklich von ihm selbst angefertigt wurde, ist bei der Betrachtung des RSA-Verfahrens in Kapitel 5.3 schon aufgetaucht. Es scheint so, als ob die Sicherstellung der Nachrichten-Integrität sehr eng mit derjenigen der NachrichtenAuthentikation verbunden ist: Wer die Hash-Summe H(K) zum Klartext entschlüsseln kann, darf auch von der Identität des Autors überzeugt sein. Die Schönheit der Auf jeden Fall sind für solche Aufgaben asymmetrische Verfahren mit öffentlichen und geheimen Schlüsseln besonders geeignet. Asymmetrie Zwingend wären sie andererseits nicht. Man kann jeden Klartext K zusätzlich auch DES verschlüsseln oder mit einer DESverschlüsselten Hash-Summe ergänzen. Die Überprüfung ist hier aber nur denjenigen Teilnehmern möglich, die sich ebenfalls im Besitz des einen, gemeinsamen Schlüssels S befinden. „Dieser Logarith- Aus den verschiedenen Lösungen und Spielarten sehen wir uns mus ist absolut diejenige an, die in dem bereits in Unterkapitel 5.4 erwähnten diskret ....“ Standardisierungsvorschlag der US-Behörde NIST vorgestellt wurde. Sie benutzt die Eigenschaften des diskreten Logarithmus, wird auch DSA (= Digital Signature Algorithm) genannt und beruht auf Gedanken von ElGamal ("A public key cryptosystem and a signature scheme based on discrete logarithms", IEEE Transactions Information Theory 31 Seiten 469-473, 1985) und Schnorr ( "Efficient identification and signatures for smart cards", in Brassard, Proceedings CRYPTO 89, Springer, 1990, Lecture Notes in Computer Science Nr. 435, Seiten 239-252). Das Verfahren ist in den DSS (Digital Signature Standard) eingebettet, und es lohnt sich, einen Blick darauf zu werfen. Ziel ist es, den Klartext K = m (=message) eines Autors so zu veröffentlichen, dass sich alle Interessenten von seiner Unversehrtheit und Originalität überzeugen können. Dazu bestimmt die Schlüsselvergabestelle zunächst eine große Primzahl p (zwischen 2511 und 2512) sowie eine kleinere Primzahl q (zwischen 2159 und 2160), die

314

5.12 Nachweis der Absenderidentität (digitale Unterschrift, DSA) ein Teiler von p-1 sein muss (in der Praxis sucht man mit dem in Kapitel 5.5 beschriebenen Verfahren zunächst eine Primzahl q und dazu ein passendes p). Dann berechnet die Schlüsselvergabestelle mit einer Zufallszahl h zwischen 1 und p-1 die Zahl g

= h(p-1)/q MOD p

und mit einer Zufallszahl x zwischen 1 und q-1 die Zahl y Vorbereitende Maßnahmen

= g x MOD p.

Die Zahlen p, q, g und y werden einem Teilnehmer im Schlüsselverzeichnis öffentlich zugeordnet, während er die Zahl x als Geheimsache erhält. Will dieser nun den mit seiner "digitalen Unterschrift“ versehenen Klartext m veröffentlichen, so bildet er zunächst die HashSumme H(m) und wählt eine nur ihm bekannte geheime Zahl k zwischen 1 und q-1. Damit berechnet er die beiden Werte r

= (g k MOD p) MOD q

s

= (k-1(H(m) + xr)) MOD q

und gibt diese zusammen mit dem Klartext m heraus. Der Faktor k-1 ist die uns schon gut bekannte modulare Inverse zu k bezüglich q, für die also k-1k MOD q = 1 gilt. Jeder Interessent, der sich von der Unversehrtheit und Originalität des ihm vorliegenden Klartextes m überzeugen will, berechnet

Check positiv

w

= s-1 MOD q

u1

= ((H(m)w) MOD q

u2

= ((rw) MOD q

v

= ((g u1y u2) MOD p) MOD q.

Falls v = r ist, darf er sicher sein, das richtige Dokument in Händen zu halten. Ein gut nachvollziehbarer Nachweis für die Richtigkeit dieses Algorithmus steht im NIST-Vorschlag Anhang 1. Ein Beispiel: James Bond will an Goldfinger, dessen Aufenthaltsort er zur Zeit nicht kennt, folgende Nachricht absetzen: m=

"An Goldfinger: Übergabe des Zünders Freitag 09.32 Uhr im CARIBIC. (gez. 007) $"

Als Teilnehmer an dem oben beschriebenen Verfahren hat ihm die Schlüsselvergabestelle, nachdem sie sich vom Personalbüro des Secret Service seine Identität und Vertrauenswürdigkeit bestätigen ließ, folgende Zahlen zugeordnet:

315

5 Datenverschlüsselung Öffentlichkeit zugelassen

Öffentlich: p

= 643

q

= 107

g y

= (643-1)/6

6

= 52 MOD 643

= 600,

mit h = 52 als geheimer Zufallszahl

= 600 MOD 643 = 595,

mit x = 73 als geheimer Zufallszahl.

73

Unter Ausschluss Nur für James Bond als Geheimsache: der Öffentlichkeit x = 73. Bond berechnet, z. B. mit dem im vorangegangenen Kapitel beschriebenen Verfahren, die Hash-Summe von m und erhält H(m) = 7 Dann wählt er eine Zufallszahl k

= 23,

die er für sich behält, und bestimmt r

= (60023 MOD 634) MOD 107

= 52

s

= (14(7 + 7352)) MOD 107

= 63.

Diese beiden Zahlen fügt er der Nachricht m an und lässt alles über die Tagesschau ausstrahlen. Goldfinger sieht diese – oder lässt sich von seinen „Lakeien“ informieren – , berechnet H(m)

=7

w

= 17

u1

= 717 MOD 107

u2

= 5217 MOD 107

v

12

= 12 = 28

28

= ((600 595 ) MOD 643) MOD 107 = ((6598) MOD 643) MOD 107 = 373 MOD 107

Schlüsselwechsel leicht gemacht

316

= 52,

vergleicht v mit r und schließt aus der Übereinstimmung, dass hinter der Nachricht m tatsächlich sein alter Widersacher steckt. Im Gegensatz zum RSA-Verfahren kann James Bond bei Verwendung des DSA für jeden neuen Klartext m eine eigene Zufallszahl k wählen. Dadurch wird das Aufbrechen der so genannten Signatur s nochmals erschwert. Beim RSA-Verfahren muss für den Schlüsselwechsel immer die Vergabestelle eingeschaltet werden, wodurch sich der Aufwand erhöht. Zur Erinneung: Ein häufiger Schlüsselwechsel trägt wesentlich zur Sicherheit bei. Beim one-time-pad-Verfahren stellt er sogar die Voraussetzung an sich dar.

5.13 Hinweise zu PGP und GnuPG

5.13

Alltagstauglich

Das hübsche Märchen von der vollkommenen Sicherheit

Hinweise zu PGP und GnuPG Um die Verfahren zur Verschlüsselung und zur elektronischen Unterschrift im täglichen Leben nutzen zu können, muss es handhabbare Standards geben, die mit einem möglichst geringen Aufwand an Organisation auskommen. Das System PGP (Pretty Good Privacy) wurde von Philip Zimmermann zunächst als freie Software eingeführt und 1996 über das Unternehmen PGP Inc kommerziell vermarktet. Der Grundgedanke beruht darauf, sichere Lösungen bereit zu stellen, die auch ohne die bereits mehrfach erwähnten Schlüsselvergabestellen als dritter Instanz auskommen. Wenn zwei Partner, z. B. Käpt'n Blaubär und Hein Blöd, geheime Informationen austauschen wollen (etwa E-Mails, Vertragsdokumente und ähnliches), so erzeugt Blaubär zunächst ein RSA-Schlüsselpaar und sendet Hein Blöd seinen eigenen öffentlichen Schlüssel. Dieser wählt einen geheimen Schlüssel für ein schnelles symmetrisches Verfahren (DES, IDEA, AES ...) – wenn seine Intelligenz das überhaupt zulässt – und schickt ihn mit diesem öffentlichen Schlüssel verschlüsselt an Blaubär zurück. Ab jetzt können beide die vorgesehenen geheimen Nachrichten oder Informationen (z. B. über den Börsenkurs von Fischstäbchen) austauschen. Bemerkenswert ist an diesem Prozess, dass der geheime RSA-Schlüssel den Erzeuger Käpt'n Blaubär überhaupt nicht verlässt und daher auch keine Schwachstelle für die Schlüsselübergabe besteht. Außerdem kann dieses Verfahren auf einen beliebigen Teilnehmerkreis (die Bärchen-Neffen oder der Wolpertinger Rumo oder Professor Nachtigaller oder die Blutschinken oder... ) ausgedehnt werden. Dennoch gibt es wenigstens 2 Fragen, auf die Antworten zu finden sind: 1. Was passiert, wenn sich ein Dritter, etwa Volzotan Smeik, die Haifischmade, unerkannt in die Übertragung einschaltet („man in the middle“), die Nachrichten abfängt, in seinem Sinne manipuliert und weiterleitet? Er könnte sich dann als Hein Blöd ausgeben und Käpt'n Blaubär einigen Schaden zufügen. Diese Situation besteht allerdings bei jedem Datenaustausch und hat selbst bei dem als so sicher angesehenen TAN-Verfahren im Bankenverkehr schon für mächtigen Ärger gesorgt. Neben den inzwischen installierten technischen Hürden könnte Blaubär sich aber zur Authentifizierung von Hein Blöd über ein Zero Knowledge-Protokoll absichern, das selbst der verschlagene Onkel von Volzotan, Phistomefel Smeik, nicht erfolgreich zu bedienen imstande wäre. 2. Noch grundlegender ist es, ob Blaubär seinem Partner Hein Blöd überhaupt vertrauen kann. Bei so einer trotteligen Per-

317

5 Datenverschlüsselung

Der wahre Wert der Zertifikate

5.14

son „ohne Arg“ wäre das zwar vertretbar, gegenüber dem ausgebufften Schlitzohr Phistomefel Smeik aber keineswegs, wie die Fans der „Stadt der träumenden Bücher“ (Walter Moers), leidvoll erfahren mussten. Hierzu gibt es wenigstens 2 Wege, um die Lage zu verbessern. Der zentrale Weg stützt sich auf eine öffentliche Zertifizierungsinstanz, die auf Anfrage die Vertrauenswürdigkeit des potenziellen Partners bestätigen kann, da sie sich durch diverse Prüfungen selbst davon überzeugt hat. Der dezentrale Weg fordert alle Partner mit bereits erfolgreichem Kontakt auf, diesen zu vermerken. z. B. könnte Hein Blöd für Rumo, den Wolpertinger, in dessen Dokument mit dem öffentlichen Schlüssel ein Vertrauens-Statement verankern, das wiederum Blaubär beruhigt, wenn dieser mit Rumo in Kontakt tritt. Wenn sich zusätzlich noch weitere Gefährten wie Professor Nachtigaller, Hildegunst von Mythenmetz, die Zwergpiraten usw. beteiligen, wird die Vertrauensbasis durch das anwachsende Netzwerk für Rumo immer tragfähiger. Problematisch bleibt weiterhin das Management dieser Zertifkate, insbesondere der Rückruf ungültig gewordener, da es keinen zwingenden Prozess hierfür gibt. Trotz der bestehenden potenziellen Schwächen ist es sehr empfehlenswert, die genannten Verfahren zu untersuchen und auch einzusetzen. Für den kommerziellen Gebrauch mag eine der aktuellen Versionen des Urvaters PGP die geeignete Lösung sein. Für Privatpersonen kann das vom Bundesministerium für Wirtschaft und Technologie geförderte Projekt GnuPP sehr empfohlen werden. Die freie Software, die u. a. auch das Verfahren GnuPG (kompatibel zu PGP) enthält, ist zusammen mit einer sehr verständlichen und ausführlichen Benutzerdokumentation über www.gnupp.de abrufbar.

Weitere Entwicklungen, Quantenkryptographie In der Datenverschlüsselung werden ständig neue Techniken und Verfahren gefunden und weiterentwickelt. So gibt es Schwerpunkte zur immer schnelleren Zerlegung von Zahlen in ihre Primfaktoren wie etwa die Methode der elliptischen Kurven (elliptic curve primality prove). Darauf aufbauende Techniken eignen sich auch zur Verschlüsselung, siehe etwa A. J. Menzes, „Elliptic curve public key cryptosystem“, Kluwer Academic Publications 1993“. Die Theorie der Graphen oder die Quantenkryptographie bieten wiederum andere neue, hoch interessante Wege. Aber auch die Entwicklung weiterer Protokolle als Ablauf bestimmter Schritte zur Gewährleistung eines garantierten Si-

318

5.14 Weitere Entwicklungen, Quantenkryptographie

Neue Ideen braucht die (Krypto-) Welt

Schlüssel „Schlüsselerzeugung“

cherheitsniveaus bringt beeindruckende Ergebnisse (Mit dem Fiat-Shamir-Verfahren als Zero-Knowledge-Protokoll haben wir eines davon in Unterkapitel 5.10 kennen gelernt). Einen hervorragenden, kompakten Überblick zu vielen dieser Neuerungen findet man zum Beispiel in Beutelsbacher, Schwenk, Wolfenstetter, „Moderne Verfahren der Kryptographie“, 1995, ISBN 3528-06590-7, Vieweg-Verlag. Speziell zu Protokollen und aktuellen Fragen der Sicherheit im Internet-Handel findet man bei Gunter Lepschies in „E-Commerce und Hackerschutz“ 2000, Vieweg, ISBN 3-528-15702 X einen umfangreichen Überblick. Obwohl die Quantenkryptographie bisher (noch) nicht für einen praktischen Einsatz geeignet ist, lohnt es sich, wegen des damit verbundenen neuen Grundgedankens einen Blick darauf zu werfen. Der Kernpunkt ist weniger die Verschlüsselung selbst, als vielmehr die – immer kritische – Schlüsselübergabe. Bei der Quantenkryptographie wird dieses elementare Problem mit Hilfe spezieller Zustandseigenschaften von Photonen gelöst. Die Schwingungsebenen dieser Lichtteilchen können für ihre Abstrahlung, z. B. in Lichtwellenleitern, polarisiert werden. Für kryptographische Zwecke eignen sich besonders zwei orthogonale Richtungspaare: horizontal/vertikal und schräg + 45 Grad/schräg – 45 Grad. Ein Empfänger kann jedes Photon nur ein einziges Mal registrieren, es ist damit „verbraucht“, eine nicht zu umgehende quantenphysikalische Eigenheit. Ein „man in the middle“, der unerkannt abhören möchte, ist in der gleichen Lage. Wenn er die Polarisation eines Photons gemessen hat, kennt er diese zwar vermeintlich, muss nun aber ein neues Photon mit der selben Polarisation erzeugen (das empfangene Photon wurde durch die Messung „verbraucht“), über die er sich jedoch nicht sicher ist, und an den berechtigten Empfänger schicken. Darin steckt die Lösung. Sender und Empfänger vereinbaren zunächst öffentlich, welche Polarisation einem „0“- bzw. „1“-Bit zugeordnet sein soll. z. B. Bit

horizontal

0

ja

1

vertikal

+45 Grad

-45 Grad

ja ja

ja

Der Sender erzeugt jetzt gleich verteilte zufällige Bits und entscheidet gleich verteilt zufällig, ob er das dem Bit zuzuordnende Photon horizontal/vertikal oder schräg +45/-45 Grad polarisiert abschickt. Der Empfänger hat je eine Messeinrichtung für horizontal/ vertikal und schräg polarisierte Photonen. Vor jedem Empfangsakt wählt er gleich verteilt zufällig den Detektor für horizontal/ vertikal oder schräg +45/-45 Grad polarisiert aus. Im Mittel

319

5 Datenverschlüsselung

Öffentlliche Gespräche

Der Fluch des Quantenverhaltens: no chance für den Angreifer

werden also 50% seiner Messungen ein korrektes Ergebnis bringen. Nach Abschluss der Sendefolge gibt der Sender dem Empfänger öffentlich bekannt, zu welchem Sendetakt er horizontal/vertikal oder schräg polarisiert hatte, ohne das gesendete Bit zu nennen. Der Empfänger vergleicht diese Angaben mit seinen eigenen Aufzeichnungen. Bei Übereinstimmung der Polarisationsrichtung kann er von einem korrekten Empfangsergebnis ausgehen. Stimmt sie nicht überein, ist das Ergebnis zu 50% unsicher und wird verworfen. Die Positionen der sicheren Bits teilt er dem Sender mit. Die Folge der sicheren Bits dient jetzt als Schlüssel für die eigentliche Bildung des Geheimtextes. Ohne Abhörung ist diese Folge ausschließlich den beiden Partner bekannt. Ein Angreifer könnte sich dazwischen hängen und die Photonen abfangen. Er würde die gleiche Messeinrichtung verwenden, wie der berechtigte Empfänger. Da er den Wert des Photons an den Empfänger weiterleiten muss, er aber die beim Sender verwendete Richtung nicht kennt, sendet er das Photon z. B. immer als horizontal/vertikal polarisiert weiter. Damit ist dieser Vorgang nur in 50% der Fälle richtig. Wenn er allerdings zum Schluss die Sendeliste über die Richtungen mit liest (sie ist öffentlich), kennt er den Schlüssel genauso wie der Empfänger. Der Empfänger stellt wegen des „man in the middle“-Eingriffs beim Vergleich mit der Sendeliste nun aber nur 25% Treffer fest, was ihm einen deutlichen Hinweis entweder auf einen technischen Fehler oder auf eine Manipulation gibt. Daraufhin bricht er den Vorgang ab und probiert zusammen mit dem Sender einen neuen Übertragungskanal. Zunächst wird in Bild 5.8 ein Beispiel für den ungestörten Übertragungsvorgang betrachtet. Sendebits

1

0

0

1

0

1

1

1

0

0

1

0

Sende-Polarisa- + tion

+

x

+

x

x

x

+

+

+

x

x

x

x

x

+

x

+

x

x

+

x

x

0

0

0

0

1

0

1

0

0

1

0

0

1

0

Kanal Empfangs-Pola- + risation Empfangsbits

1

sichere Bits nach Vergleich

1

0

1

Bild 5.8: Ungestörter Übertragungsvorgang der potenziellen Schlüsselbits ohne Abfangen und Weiterleiten durch einen „man in the middel“-Angreifer

320

5.14 Weitere Entwicklungen, Quantenkryptographie Der Empfänger stellt fest, dass im Mittel die erwartete 50%-Übereinstimmung bei den Polarisationsrichtungen gegeben ist (6 Positionen) und die Verteilung der sicheren Bits auf „0“ und „1“ ebenfalls 50% beträgt. Die sicheren Bits werden jetzt zum Verschlüsseln des Klartextes verwendet. Sitzt ein Abhörer im Übertragungsweg, verändert sich dieser Vorgang gemäß Bild 5.9. Sendebits

1

0

0

1

0

1

1

1

0

0

1

0

Sende-Polarisa- + tion

+

x

+

x

x

x

+

+

+

x

x

Kanal Abhör-Polarisation

+

+

+

+

+

+

+

+

+

+

+

+

abgehörtes Bit

1

0

0

1

1

0

1

1

0

0

0

1

Sende-polarisation

+

+

+

+

+

+

+

+

+

+

+

+

Empfangs-Pola- + risation

x

x

x

+

x

+

x

x

+

x

x

1

1

0

0

0

0

0

0

0

0

1

0

0

Kanal

Empfangsbits

1

vermeintlich sichere Bits nach Vergleich

1

1

0

0

Bild 5.9: Der Empfänger stellt nach Veröffentlichung der Polarisationsfolge fest, dass mehr als 50% der gesendeten Bits von ihm falsch zugeordnet wurden. Sender und Empfänger verwerfen deshalb diese Folge Erdrückende Beweislasten so ....

... oder so!

Auch hier stellt der Empfänger fest, dass die Hälfte der Polarisationsrichtungen übereinstimmt. Die erwartete 50%-Verteilung von „0“und „1“ bei den vermeintlich sicheren Bits ist aber wegen des Verhältnisses 1/3 nicht mehr gegeben. Der Vorgang wird abgebrochen und auf einem neuen Kanal nochmals durchlaufen. Ein anderer Weg bestünde darin, dass Sender und Empfänger eine zufällige Auswahl der als sicher angenommener Bits heraus greifen und diese öffentlich vergleichen. Stimmen sie überein, so ist die Wahrscheinlichkeit sehr hoch, dass dies auch für den Rest gilt, weshalb dieser Rest als Schlüssel verwendet wird. Andernfalls wird der Vorgang ebenso abgebrochen. Das Bestechende an diesem Ablauf ist die völlige Unabhängigkeit vom drohenden „Damokles-Schwert“ der vielleicht doch

321

5 Datenverschlüsselung noch gelingenden schnellen Primfaktoren-Zerlegung, die alle damit zusammen hängenden Verfahren sofort wertlos machen Primzahlenprowürde. Selbst wenn eine schnelle Zerlegung nicht gelänge, droht blem: Für die Zeit Gefahr von superschnellen Quanten-Computern, mit denen „danach“ ..... „Brute Force“-Attacken in kurzer Zeit möglich wären. Die Verbindung der sicheren Schlüsselübertragung und des one time pad-Verfahrens würde dann trotzdem weiterhin eine sichere Verschlüsselung gewährleisten. Der beschriebene Weg wurde bereits 1984 von Charles Bennet und Gilles Brassard in „Proceedings of IEEE International Conference on Computers, Systems and Signal Processing“, Bangalore, Seite 175 ff, vorgeschlagen. Mittlerweile gibt es bereits Laborstrecken für diese Photonenübertragung von einigen zig-Kilometern Länge. Darüber hinaus existieren auch weitere, auf Quanteneffekten basierende Lösungsansätze. z. B. unter der Bezeichnung „Phasenkodierung“.

5.15

Was blieb? 1.

2.

3.

4. 5.

6.

7. 8.

322

Warum ist beim asymmetrischen Verschlüsselungsverfahren nach McEliece der Schlüssel umfangreicher als beim RSA-Verfahren? Welche Eigenschaft der Zahlentheorie gewährleistet (z. Z. noch) die Sicherheit des Diffie-HellmannSchlüsseltauschs? Welche prinzipielle Schwachstelle weist das herkömmliche Passwort-Verfahren auf? Warum wird diese beim Fiat-Shamir-Protokoll beseitigt? Warum ist es zweckmäßig, die Schritte des Fiat-ShamirProtokolls möglichst oft zu durchlaufen? Warum eignet sich ein CRC-Verfahren zwar gut zur Fehlererkennung, aber kaum zur sicheren Entdeckung willkürlicher Veränderungen? Warum ist im allgemeinen eine eineindeutige Zuordnung eines Klartextes zu einer Hash-Summe nicht möglich? Wie könnte man die eineindeutige Zuordnung erzwingen? Welche Nachteile hätte das für den praktischen Einsatz? Welche beiden Verschlüsselungsverfahren verwenden PGP und GnuPP und warum? Was läuft beim Verfahren der Quantenkryptograhie prinzipiell anders ab als bei allen sonstigen Verschlüsselungs-Verfahren? Ist es weiterhin sicher, wenn Wege zur schnellen Primzahlen-Zerlegung gefunden würden?

6

Datenkompression Wir stehen nun vor dem dritten Teilgebiet der Codierung, der Datenkompression, und werden hier die Frage beantworten, ob man beliebig geartete Datenmengen mit vertretbarem Aufwand so verkleinern kann, dass die verdichtete Datenmenge (der Code) ¡ aentweder den ursprünglichen Inhalt noch vollständig enthält (verlustfreie oder „lossless“ Kompression, wie sie für Textoder Programmdateien unumgänglich ist), oder ¡ aden „gestauchten“ Inhalt in einer Form beherbergt, dass seine wesentlichen Teile erkennbar bleiben (verlustbehaftete oder „lossy“ Kompression, wie sie für Bild- oder Audiodaten in vielen, wenn auch nicht allen Fällen, hingenommen werden kann). Für beide Fälle gibt es eine Reihe unterschiedlicher Lösungen.

6.1

Verlustfreie Kompression Für diese Form der Datenverdichtung können 4 wesentliche Grundtypen eingesetzt werden. Jeder davon nutzt eine spezielle Sicht auf die Häufigkeit des Auftretens von Zeichen. Alle unterscheiden sich im Aufwand, im Ergebnis und in der Wirkungsweise. Man findet sie unter anderem in den „zip“-Programmen bei PC-Systemen. Dort werden auch Kombinationen verschiedener Verfahren eingesetzt, um zum Beispiel durch Nachkomprimierung weitere Verbesserungen zu erzielen und noch mehr Redundanzen zu beseitigen. Auch die verlustbehafteten Verdichtungsmethoden wie JPEG und MPEG sind dort enthalten.

6.1.1

Lauflängen-Codierung (Run Length Encoding = RLE) Die Lauflängen-Codierung ist ein äußerst einfaches und damit unaufwendiges Verfahren. Es nutzt das mehrfache Aufeinanderfolgen einzelner Wörter oder Zeichen im Originaltext, in dem es im Ausgabecode nur einmal das Zeichen selbst und dann in einem Zähler die Anzahl seines Auftretens angibt. Um den Zähler zu kennzeichnen, stellt man ein Zeichen voraus, welches im Originaltext selten vorkommt (es kann aber selbst durchaus auftreten!). Dies ist hier das (hexadezimal dargestellte) Byte 90h. Besteht der Originaltext zum Beispiel aus

323

6 Datenkompression A b c d d d d d x x T s s s s u q 90h f m .... so erscheint als codierte Folge A b c d 90h 5 x x T s 90h 4 u q 90h 0 f m ... „Wir fordern absolute Transparenz“

Spezialist für große Flächen

Da der Text vollkommen transparent, das heißt ohne Sonderdarstellung spezieller Zeichen im Originaltext behandelt werden soll, muss für den Empfänger klar sein, wann ein Zählerzeichen auftritt. Dies wird durch das Zeichen 90h markiert und zeigt an, dass das folgende Zeichen „5“ die Anzahl des vor 90h stehenden Zeichens „d“ ist. Da auch das Zeichen 90h im Originaltext enthalten sein kann, würde man in diesem Fall das Zeichen 0 folgen lassen. Dies ist eindeutig, da ein Zähler mit dem Wert 0 prinzipiell nicht auftreten kann. Die 20 Zeichen zu je 8 Bit im Originaltext wurden im Sendetext also auf 18 Zeichen reduziert, lassen sich aber am Empfangsort wieder vollständig in den Originaltext zurück verwandeln. Da mehrfach hintereinander auftretende Zeichen, sofern ihre Anzahl nicht größer als 255 ist, im Ausgangstext immer als 3 Zeichen (Bytes) abgebildet werden, lohnt sich dieses Ersetzen erst, wenn die Wiederholung wenigstens 4 Zeichen beträgt. Aus diesem Grund ist dieses Verfahren für Dateien mit Texten einer natürlichen Sprache auch nicht geeignet, da solche Wiederholungen hier praktisch nicht vorkommen. Bei Grafikdateien aber, wo z. B. große Flächenelemente gleicher Farbe codiert wurden, kann das Kompressionsergebnis beachtlich sein. Als kleines Beispiel betrachten wir die 64 Pixel des folgenden Bildelementes, bei dem die Grauwerte als Hex-Zahlen eingetragen sind (selber aber nicht zum Pixelinhalt gehören): 65

65

FF

FF

FF

FF

65

65

65

65

FF

FF

FF

FF

65

65

90

FF

FF

FF

FF

FF

FF

90

FF

FF

FF

FF

FF

FF

FF

FF

FF

FF

FF

FF

FF

FF

FF

FF

90

FF

FF

FF

FF

FF

FF

90

65

65

FF

FF

FF

FF

65

65

65

65

FF

FF

FF

FF

65

65

Die Codierungsfolge ist mit den 43 Bytes (alles HEX-Zeichen) 65 65 FF 90 04 65 90 04 FF 90 04 65 65 90 00 FF 90 06 90 00 FF 90 10 90 00 FF 90 06 90 00 65 65 FF 90 04 65 90 04 FF 90 04 65 65

um 33% kompakter als ohne Codierung.

324

6.1 Verlustfreie Kompression

Willkommener Helfer

6.1.2

Redundanz-Abbau: oft = kurz selten = lang

Für RLE existieren weitere Varianten. Eine hiervon nutzt z. B. die Tatsache, dass ASCII-Daten überwiegend als 7-Bit-Zeichen auftreten. Die führende 1 als achtes Bit dient oft nur zur Kennung von Sonderzeichen, die selten dargestellt werden müssen. Wenn ein Zeichen mehrfach hintereinander folgt und als achtes Bit eine führende 0 hat und somit keines von diesen Sonderzeichen ist, fügt das Verfahren statt dessen eine führende 1 ein und signalisiert damit das mehrfache Auftreten. Das folgende Zeichen ist dann der Zähler. Falls das Zeichen aber bereits eine 1 aufweist, wird als Folgezeichen wieder die 0 gewählt, die als Zähler-inhalt nicht auftritt. Damit ist auch hier völlige Transparenz sichergestellt, und man kann auf die Verwendung eines speziellen Bytes (90h) zur Kennzeichnung des Zählers verzichten. RLE wird auch zur Nachkomprimierung bei den verlustbehafteten Kompressionsverfahren eingesetzt. Die einoder zweidimensionale DCT (=Diskrete Cosinus Transformation) zum Beispiel ergibt für Bilddaten häufig Folgen gleicher Frequenzanteile und eignet sich daher für eine solche Nachbehandlung. Dieser Schritt bleibt für sich betrachtet dann verlustfrei.

Huffman- und Fano-Codierung Während RLE nach Zeichen sucht, welche mehrfach hintereinander auftreten, hat D. A. Huffman 1952 ein Verfahren vorgeschlagen (A method for the construction of minimum redundancy codes, Proceedings IRE 40, 1952), welches die statistische Verteilung der einzelnen Zeichen unmittelbar nutzt. Es ist damit für Daten aus beliebigen Quellen geeignet, erfordert aber auch einen höheren Verarbeitungsaufwand. R. M. Fano hatte 3 Jahre vorher über einen ähnlichen Weg berichtet (The Transmission of Information. MIT-Report 65, 1949), wird aber heute in diesem Zusammenhang weniger genannt. Die Idee ist, häufiger auftretende Zeichen in kürzere Codes abzubilden und dadurch im Mittel Übertragungsvolumen einzusparen. Der einfachste Fall liegt vor, wenn die Häufigkeitsverteilung der Zeichen bereits bekannt ist, was man bei der Übertragung von Zeichen einer natürlichen Sprache annehmen kann. Die optimale Codierung wird in diesem Fall erzielt, wenn die einzelnen Zeichen als Endknoten (= Blätter) eines binären Baumes erscheinen. Machen wir uns das Vorgehen am Beispiel des Erzherzog Johann-Jodlers aus Unterkapitel 1.2, Seite5, klar: holleri di dudl jö, diridi di dudl dö, hollera di dadl do, holleri du dödl di, di-ri diri dudl dö Diese 100 Zeichen treten mit folgenden Häufigkeiten auf:

325

6 Datenkompression

Baumschule

ZWR

d

i

l

r

u

ö

o

,

h

e

a

j

23

22

13

11

6

4

4

4

4

3

3

2

1

Im ersten Schritt nimmt man die beiden Zeichen mit der kleinsten Häufigkeit, hier j und a, und ordnet sie dem Summenknoten mit 1+2 = 3 zu. Im zweiten Schritt schaut man, ob ein Zeichen mit der gleichen oder einer größeren Häufigkeit vorhanden ist, als der soeben gebildete Summenknoten ausweist. Dies ist beim e der Fall. daher wird es mit dem benachbarten Knoten zum nächsthöheren Summenknoten zusammen gefasst und dieser hat nun die Summe 3+3 = 6. Wäre die Häufigkeit von e geringer gewesen, so würde man es zunächst mit dem nächsten Zeichen zusammenfassen. 100 1 0

55 1 0

45 0

1

ZWR

d

„auf Reihe“ gebracht

Redundanz ade

326

31 1

0

18

24 0

1

i

l

13

0

8

10

1

0

1

6

7

0

1

0

1

0

1

0

r

u

ö

o

,

h

e

1

3 0

1

a

j

Der dritte Schritt nimmt „h“ und „,“ (Komma) ins Visier, beide ergeben eine Häufigkeit von 7 und ergänzen den letzten Knoten zum neuen Knoten mit 7 + 6 =13. Die Zeichen o und ü weisen die Summe 8 auf und bilden, da diese kleiner ist, zunächst einen Unterbaum. „r“ und „u“ ergeben 10, werden daher mit diesem zusammengefasst und nun mit dem Knoten 13 zum übergeordneten Knoten 31 geführt. Dieser Prozess endet im oberen Knoten mit der Häufigkeit 100 (alle Zeichen). Man kann statt der Häufigkeiten auch die Wahrscheinlichkeiten verwenden, der oberste Knoten enthält dann die Summe 1.0, da jedes Zeichen in der Gesamtmenge in jedem Fall auftritt. Aus diesem Baum lässt sich nun die Entropie-optimierte Codierung eines jeden Zeichens ablesen. Die rechten Zweige stehen für eine „1“, die linken für eine „0“. Dies führt auf folgende Tabelle:

6.1 Verlustfreie Kompression i a e h , o ö u r l i d ZWR

„nicht getrennt lebend“

111111 111110 11110 11101 11100 11011 11010 11001 11000 101 100 01 00

Trennzeichen sind nicht erforderlich, da sich für ein empfangenes Zeichen immer ein eindeutiges Ende ergibt, wie der Baum zeigt. In unserem Beispiel werden für den Text 320 Bits benötigt, bei Codierung der 13 verschiedenen Zeichen mit je 4 Bits braucht man 400 Bits. Dies bringt eine Einsparung von 20%, der Kompressionsfaktor ist 0.8. Theoretisch können die 13 Zeichen im Mittel mit Log2(13) =3.7 Bits dargestellt werden, so dass die Einsparung nur 7.5% ausmachen würde. Praktisch ist der Gewinn höher, da man Texte im allgemeinen mit 8 Bit ASCII-Zeichen codiert, was eine Einsparung von 40% ergibt. Da der gewählte Text etwas künstlich aussieht, betrachten wir noch einen allgemeineren (aus „Rotkäppchen auf Juristendeutsch“): Als in unserer Stadt wohnhaft ist eine Minderjährige aktenkundig, welche infolge ihrer hierorts üblichen Kopfbedeckung gewohnheitsrechtlich Rotkäppchen genannt zu werden pflegt. Vor ihrer Inmarschsetzung wurde die R. seitens ihrer Mutter über das Verbot betreffs Verlassens der Waldwege auf Kreisebene belehrt. Sie machte sich infolge Nichtbeachtung dieser Vorschrift straffällig und begegnete beim Überschreiten des diesbezüglichen Blumenpflückverbotes einen polizeilich nicht gemeldeten Wolf ohne festen Wohnsitz. Dieser verlangte in unberechtigter Amtsanmaßung Einsichtnahme in den zum Transport von Konsumgütern dienenden Korb und traf zwecks Tötungsabsicht die Feststellung, daß die R. zu ihrer verwandten und verschwägerten Großmutter eilends war. Da bei dem Wolfe Verknappungen auf dem Ernährungssektor vorherrschend waren, beschloß er, bei der Großmutter der R. unter Vorlage falscher Papiere vorsprachig zu werden.

Die Häufigkeitsverteilung für diese 923 Zeichen zeigt 47 verschiedene Zeichen. Der Binärbaum lässt sich hieraus wie zuvor aufbauen.

327

6 Datenkompression e 127

ZWR r 117 69

n 68

t 50

i 50

s 43

h 39

d 31

a 30

u 27

o 27

l 27

g 27

c 26

b 19

f 18

m 14

w 12

p 11

z 9

k 8

. 8

v 7

V 6

ü 5

ß 5

ä 5

W 4

R 4

K 4

, 4

T 2

S 2

M 2

G 2

Wermutstropfen „Tabellenpflicht“

... nicht nur für Singles ....

328

E 2

D 2

A 2

Ü 1

P 1

ö 1

N 1

j 1

I 1

F 1

B 1

Die Einsparung gegenüber 8 Bit ASCII-Zeichen beträgt 43%. Allerdings weist der beschriebene Weg noch einen Schönheitsfehler auf. Die Häufigkeitstabelle ist zunächst nur beim Sender bekannt und ohne diese kann der Empfänger den Binärbaum zum Decodieren gar nicht aufbauen. Wenn der Sender die Tabelle als Klartext vorausschickt, wird der Kompressionsvorteil geschmälert oder zunichte gemacht. Es gibt verschiedene Lösungen, um dieses zu entschärfen. Ein Weg besteht darin, anfangs einen genügend langen Klartextblock (zum Beispiel 300 Zeichen) zu schicken, aus dem Sender und Empfänger die gleiche Häufigkeitstabelle aufbauen können, die dann zum Codieren der Folgezeichen dient. Dabei wird vorausgesetzt, dass die Folgezeichen ähnliche statistische Eigenschaften besitzen. Ist das nicht der Fall, funktioniert die Decodierung trotzdem, aber mit geringerem oder gar keinem Kompressionsgewinn. Ein anderer Weg wird bei der Kompression von grafischen Daten beschritten, siehe Unterkapitel 6.2.3. Die zugehörigen Dateien enthalten häufig große Datenmengen. Hier fällt dann die zusätzliche Übertragung einer nur für die gesendete komprimierte Datei gültigen Häufigkeitstabelle – oder der Codetabelle selbst – nicht ins Gewicht. Wie bereits in Unterkapitel 4.3 bemerkt wurde, haben – zumindest in Texten natürlicher Sprachen – auch Zeichenpaare, Dreiergruppen und so weiter unterschiedliche Häufigkeiten. So kommen die Gruppen „ei“, „ie“, „en“, „sch“, oder „ung“ öfter vor als zum Beispiel „qn“ oder „stv“. Bei der Kryptoanalyse erweist sich dies als hilfreich und ließe sich prinzipiell auch bei der Kompression nutzen. Das exponentielle Anwachsen des Gruppenvolumens erschwert allerdings den praktischen Einsatz. Statt einer Häufigkeitstabelle der Länge 256 für alle möglichen Bytes oder ASCII-Zeichen müsste theoretisch eine solche mit (256)2 = 65536 Einträgen für alle Zweiergruppen verwendet werden. Praktisch ist das nicht erforderlich, da nur wenige hiervon eine nennenswerte Häufigkeit aufweisen und man sich auf diese beschränken könnte. Die Häufigkeitstabelle enthält dann die getroffene Auswahl der meist häufig auftretenden Zweiergruppen.

6.1 Verlustfreie Kompression

6.1.3

Lempel-Ziv-Welch-Codierung (= LZW-Codierung)

A. Lempel und J. Ziv haben im Mai 1977 in „A Universal Algorithm for Sequential Data Compression“, IEEE Transactions on Information Theory, 23:3, Seiten 337-343 ein pfiffiges Verfahren zur Datenkompression vorgeschlagen, welches ganz ohne Vereinbarungen über Häufigkeitsverteilungen auskommt. Sender MTM: Meisterliund Empfänger müssen nur über die gleiche ASCII-Tabelle ches Tabellen-Ma- verfügen. T.A. Welch beschrieb im Juni 1984 in „A Technique for nagement High-Performance Data Compression“, IEEE Computer, Volume 17, Nr. 6, Seiten 8 –19, weitere Ausbaumöglichkeiten. Versuchen wir, uns den Ablauf wieder an einem Beispiel klar zu machen (hier mit der Fortsetzung von „Rotkäppchen auf Juristendeutsch“ von Seite 327): Da dieselbe wegen Augenleidens krank geschrieben war, gelang dem Wolf die diesfällige Täuschungsabsicht, worauf er unter Verschlingung der Bettlägerigen einen strafbaren Mundraub ausführte. Bei der später eintreffenden R. täuschte er seine Identität mit der Großmutter vor, stellte der R. nach und durch Zweitverschlingung derselben seinen Tötungsvorsatz unter Beweis. Der sich auf einem Dienstgang befindliche Förster B. vernahm verdächtige Schnarchgeräusche und stellte die Urheberschschaft seitens des Wolfsmaules fest. Er reichte bei seiner vorgesetzten Dienststelle ein Tötungsgesuch ein, welches zuschlägig beschieden wurde. Daraufhin gab er einen Schuß auf den Wolf ab. Dieser wurde nach Infangnahme der Kugel ablebig. Die Beinhaltung des Getöteten weckte in dem Schußabgeber die Vermutung, daß der Leichnam Personen beinhalte. Zwecks diesbezüglicher Feststellung öffnete er unter Zuhilfenahme eines Messers den Kadaver zur Einsichtnahme und stieß hierbei auf die noch lebende R. nebst Großmutter. Durch die unverhoffte Wiederbelebung bemächtigte sich der beiden Personen ein gesteigertes, amtlich nicht erfaßbares Lebensgefühl. Der Vorfall wurde von den Gebrüdern Grimm zu Protokoll gegeben.

Der Sender schickt dem Empfänger anstelle dieser 1199 uncodierten ASCII-Zeichen die codierte Zeichenfolge 68, 97, 100, 105, 101, 115, 101, 108, 98, 101, 32, 119, 101, 103, 101, 110, 32, 65, 117, 270, 110, 108, 101, 105, 100, 271, 115, 32, 107, 114, 97, 110, 107, 32, 270, 115, 99, 104, 114, 260, 265, 272, 119,........... Satte Gewinne trotz gestiegener Kosten

Vielleicht fällt hier auf, dass auch Werte über 255 auftreten und somit mehr als 8 Bit für jedes codierte Zeichen zu investieren sind. Allerdings muss der Sender insgesamt nur 643 codierte Zeichen mit je 10 Bit schicken. Dies ergibt 6430 Bits gegenüber 1199]8=9592 Bits uncodiert oder einen Gewinn von 33%. Wie wird dieser erzielt? Als erstes bauen Sender und Empfänger identische Tabellen mit allen 256 ASCII-Zeichen auf (oder – neutral – mit allen mögli-

329

6 Datenkompression chen 256 Bitmustern, da keine Voraussetzungen über die Art der Datenquelle vorliegen müssen). Diese enthalten in Spalte 1 eine fortlaufende Nummerierung beginnend bei 0, in Spalte 2 das ASCII-Zeichen, in Spalte 3 den Bytewert des ASCII-Zeichens und in Spalte 4 den Wert –1. Zuzüglich einer für unsere Zwecke angehängten Kommentarspalte 5 sieht das in Ausschnitten so aus (im praktischen Einsatz benötigt man nur die Spalten 3 und 4): Nummer 0 1

Dez. Byte-Wert 0 1

Vorgänger -1 -1

65 66 67 68

A B C D

65 66 67 68

-1 -1 -1 -1

255 256 257 258 259 260 261

ÿ a ZWR d i e s

255 97 32 100 105 101 115

-1 68 97 32 100 105 101

Vorgänger und Nachfolger

Einfach- (ein) Algorithmus

330

ASCII-Zeichen & i

Bemerkungen Erstes Zeichen

Ende der Starttabelle Erster Neueintrag

Der Sender nimmt nun das erste Zeichen „D“ des Textes, sucht dessen Tabellenplatz, findet ihn bei 68 und sieht an der Vorgängerkennung „–1“, dass es (noch) keinen Vorgänger hierzu gibt. Damit ist 68 zugleich der Code, der an den Empfänger geschickt wird. Außerdem trägt der Sender in der noch leeren Zeile 256 in Spalte 4 den Wert 68 ein. Damit ist dokumentiert, dass das Folgezeichen den Vorgänger „D“ mit der Zeilennummer 68 hat. Das Folgezeichen selbst ist das „a“ mit dem Wert 97. Da es in diesem Anfangsstadium noch keine frühere Kombination „Da“ gegeben haben kann, wird der Wert 97 in Spalte 3 eingetragen, der Code 97 an den Empfänger geschickt und in der Folgezeile 257 in Spalte 4 ebenfalls der Wert 97 eingeschrieben. Wieder ist damit festgelegt, dass das nächste Zeichen den Vorgänger „a“ mit der Zeilennummer 97 in der Tabelle besitzt. Da wir soeben die Zeile 256 behandelt haben, erhält der Zeilenzähler „zz“ den Inhalt zz = 256, auf den sich die folgenden Angaben beziehen. Der nun ablaufende Algorithmus wiederholt sich für alle weiteren Zeichen des Textes, in Klammern stehen als Beispiel die aktuellen Werte für das nächste Zeichen (ZWR=Zwischenraum): Schritt 1: Prüfung, ob alle Zeichen des Textes abgearbeitet sind. Wenn ja: Ende. Wenn nein: Einlesen des nächste Zeichens (hier „ZWR“).

6.1 Verlustfreie Kompression Eintrag des Byte-Wertes dieses Zeichens (hier 32) in Spalte 3 der Folgezeile mit zz+1 (hier also 257) und dessen Zeilennummer 32 in Spalte 4 der übernächsten Folgezeile mit zz+2 (hier 258). Schritt 3: Durchsuchen aller vor der Zeile mit zz+1 (hier 257) liegenden Zeilen bis hinunter zu 256, ob die Kombination in den Spalten 3 und 4 (hier „aZWR“ beziehungsweise 97,32) von zz+1 bereits vorher schon einmal aufgetreten ist. Wenn ja: Überschreiben des Wertes in Zeile zz+1, Spalte 4, mit der Nummer dieser gefundenen Zeile. Weiter mit Schritt 1. Wenn nein: Aussenden des Wertes in Spalte 4 (hier 32) an den Empfänger, Eintragen der Zeilennummer des Zeichens (hier 32) in Spalte 4 der übernächsten Zeile mit zz+2 (hier 258), Erhöhen des Zeilenzählers auf zz =zz+1. Weiter mit Schritt 1. Damit ist sichergestellt, dass alle Zweier-, Dreier-, Viergruppen, ....., berücksichtigt werden. Schauen wir, was im Beispiel geschieht. Der Sender holt das nächste Zeichen „ZWR“ (Schritt 1), trägt dessen Wert (32) in Zeile 257, Spalte 3 ein (Schritt 2) und durchsucht anschließend alle vorherigen Zeilen bis 256 daraufhin, ob in den Spalten 3 und 4 die Kombination 32,97 vorhanden ist (Schritt 3). Dies trifft nicht zu, also wird der Code 32 an den Empfänger geschickt, der Zeilenzähler auf zz=257 gesetzt und mit Schritt 1 fortgefahren. Jetzt wird das „d“ behandelt und so fort, wie es der folgende Tabellenauschnitt zeigt. Dabei stößt der Sender irgendwann auf ein Zeichen, das zusammen mit seinem Vorgänger bereits aufgetreten war. Dadurch erfüllt sich in Schritt 3 die „Ja“-Bedingung. Im Beispiel tritt dieser Fall ein, wenn im Text die Folge „ge“ zum zweiten mal erscheint: „Da dieselbe wegen Augenleidens....“. Schritt 2:

Gesucht und gefunden

Singles und Paare: Alle werden rasiert

262 263 264 265 266 267 268 269 270 271 272 273 274 275 276

e l b e ZWR w e g e n ZWR A u g n

101 108 98 101 32 119 101 103 101 110 32 65 117 103 110

115 101 108 98 101 32 119 101 103 101 110 32 65 117 270

„ge“ tritt erstmalig auf

„ge“ wird erstmalig genutzt

331

6 Datenkompression 277 278 279 280 281 282 283

l e i d e s ZWR

108 101 105 100 101 115 32

110 108 101 105 100 271 115

Der Zeilenzähler zeigt zz=275, es wurde also gerade das „g“ in „Augenleiden“ behandelt. Spalte 4 von Zeile 276 enthält zur Zeit den Wert 103, Spalte 3 ist leer: 275 276 leer

g leer leer

103 leer leer

117 103 leer

Schritt 1 holt jetzt das „e“. Bei Schritt 2 wird dessen Wert 101 in Zeile 276, Spalte 3 eingetragen. Die Suche nach der Kombination „ge“ (=101, 103) ergibt, dass diese bereits in Zeile 270 vorliegt. Der Code für „e“ wird diesmal nicht gesendet, Spalte 4 in Zeile 276 erhält den Wert 270, der Zeilenzähler zz wird nicht erhöht und steht weiter auf zz=275. 275 276 leer

g e leer

103 101 leer

117 270 leer

Schritt 1 bringt das nächste Zeichen „n“. Bei Schritt 2 überschreibt dessen Wert die Spalte 3 in Zeile 276 mit 110. Die Suche nach der Kombination 110, 270 gemäß Schritt 3 bleibt diesmal erfolglos, der Sender schickt den Code 270 an den Empfänger, der Wert 110 wird in Spalte 4 von 277 eingetragen, der Zeilenzähler wird auf zz=276 erhöht und mit Schritt 1 fortgefahren. 275 276 leer

g n leer

103 110 leer

117 270 110

Endzustand

Statt der 16-Bit-Folge für „ge“ enthält der Code nun den 10-BitWert von 270 und trägt damit erstmalig zur Einsparung bei. Das Verfahren stellt auch bereits vorgekommene Dreier-, Vierer-, und weitere Gruppen fest, wobei die Einsparungen immer größer werden. Eine solche Dreiergruppe liegt erstmalig bei „ZWRdi“ in „die diesfällige...“ vor. Sie erhält den Code 315, die Tabellenzeile 315 enthält das „i“, sowie als Vorgänger die Zeile 258, also das d und den ZWR: 314 315 316 317

332

ZWR i ZWR e

32 105 32 101

102 258 260 315

Beginn einer

6.1 Verlustfreie Kompression Mehrfachverkettung 318 319

Nichts überstürzen, immer schön der Reihe nach

f ä

102 228

261 102

Man sieht außerdem, dass die Treffer auf bereits registrierte Gruppierungen immer mehr werden. Wer genauer hinschaut, wird fragen, warum die Folge „ZWRdi“ nicht bereits bei ihrem zweiten Auftreten in „ die diesfällige...“ als Code berücksichtigt wurde, da sie bereits am Anfang in „Da dieselbe wegen...“ vorkam. Dies liegt daran, dass das Verfahren zunächst die Zweiergruppe „ZWRd“ registrieren muss, ehe es auf dieser Grundlage nach der nächst längeren Gruppe suchen kann. Was macht der Empfänger? Er kann sich mit der empfangenen Codefolge 68, 97, 100, 105, 101, 115, 101, 108, 98, 101, 32, 119, 101, 103, 101, 110, 32, 65, 117, 270, 110, 108, 101, 105, 100, 271, 115, 32, 107, 114, 97, 110, 107, 32, 270, 115, 99, 104, 114, 260, 265, 272, 119,...........

Hilfstruppen

6.1.4

die gleiche Tabelle wie der Sender aufbauen. Die ersten 19 Code-Zeichen sind ASCII-Codes, beim 20-ten Code mit dem Wert 270 sieht er das „e“ und stößt auf dessen Vorgänger „g“. Das „g“ selbst findet er in der Zeile 103, einen Vorgänger gibt es seinerseits dazu nicht. Damit liegen alle Informationen vor, um auf seiner Seite die Tabelle fortführen und die empfangenen Zeichen decodieren zu können. Für die schnelle Verarbeitung der LZW-Kompression gibt es heute Codecs, zum Beispiel den Typ AHA3580 von comtech aha corporation, der Byteströme mit 80 Megabyte/s liefert. Es wird das ALDC-Verfahren (Adaptive Lossless Data Compression) verwendet, dessen Kern der LZW-Algorithmus bildet. Je nach Art der Datenquelle sind Einsparungen von 50% bei Texten und bis 85% bei Grafikdaten möglich. Aktualisierte Informationen zu diesem sehr praktikablen Verfahren findet man auch über die Suchmaschinen im Internet. Zum Beispiel unter den Begriffen „LZW“ oder „Lempel Ziv Welch“.

Arithmetische Codierung Wie bei der Huffman- oder Fano-Kompression benötigen Sender und Empfänger für die Anwendung des arithmetischen Codes eine Tabelle mit der Häufigkeitsverteilung der zu codierenden Zeichen, die entweder von Anfang an vorliegt oder dynamisch aufgebaut werden kann. Der kurze Beispieltext aus Unterkapitelkapitel 6.1.2

333

6 Datenkompression holleri di dudl jö, diridi di dudl dö, hollera di dadl do, holleri du dödl di, diri diri dudl dö wies mit seinen 100 Zeichen folgende Häufigkeiten auf: ZWR

d

i

l

r

u

ö

o

,

h

e

a

j

23

22

13

11

6

4

4

4

4

3

3

2

1

Bei der arithmetischen Codierung werden diese 14 verschiedenen 100 Zeichen zwischen 0 und 100 entsprechend ihrer Häufigkeiten in Teilintervalle eingeordnet (in der Literatur sind diese Teilintervalle meistens auf die Gesamtzahl der Zeichen normiert dargestellt, haben also Werte zwischen 0 und 1): 1 2 3 4 5 6 7 8 9 10 11 12 13 ZWR d i l r u ö o , h e a j 23 22 13 11 6 4 4 4 4 3 3 2 1 0-23 23-45 45-58 58-69 69-75 75-79 79-83 83-87 87-91 91-94 94-97 97-99 99-100

Perfekt durch Intervallschachtelung

Üppiger Stellenmarkt

334

Der Text beginnt mit „h“ im Intervall Nummer 10, dies hat die untere Grenze iu (h) = 91 und die obere Grenze i0(h)= 94. Der Code für „h“ besteht hier zunächst aus diesen beiden Angaben. Man kann sie mit cu (1)=91 und co (1)=94 bezeichnen. Erhält der Empfänger eine Zahl zwischen 91 und 94, so schließt er daraus, dass das erste Zeichen das „h“ ist. Das nächste Zeichen “o“ wird mit seiner Intervallposition 8 in das Intervall von „h“ proportional eingepasst. Seine Untergrenze beträgt dann, bezogen auf die Untergrenze des Intervalls für „h“, iu(o) = 91+83](94-91)/100 = 93.49, die Obergrenze io(o)= 91+87](94-91)/100=93.61. Jetzt ist cu (2)=93.49 und co(2)=93.61. Erhält der Empfänger eine Zahl zwischen 93.49 und 93.61, so kann er aus dieser Codezahl eindeutig die Zeichenfolge „ho“ decodieren. Jedes neu hinzugefügte Zeichen vergrößert also die Anzahl der Nachkommastellen. Hat man eine Rechenmethode zur Verfügung, mit der für die Grundrechenarten eine beliebig große Stellengenauigkeit gewählt werden kann, was nach Unterkapitel 5.4 grundsätzlich möglich ist, so lassen sich mit dem Verfahren der arithmetischen Codierung beliebig lange Codefolgen erzeugen. Da alle Ausgangswerte rationale Zahlen sind und wir mit den Rechenschritten im Körper der rationalen Zahlen bleiben, sind alle Ergebnisse wiederum rationale Zahlen. Als übertragene Zahl c genügt diejenige, welche mit der geringsten Stellenzahl in das letzte Intervall passt, da hierdurch die Eindeutigkeit gewährleistet bleibt. Im Beispiel reicht also die Angabe 93.5. Ist n die Gesamtzahl der Textzeichen und i die laufende Zeichennummer innerhalb des Textes, dann lässt sich die Entwicklung des Codewortes code bezüglich seiner unteren und oberen Intervallgrenzen cu, co rekursiv auch so schreiben:

6.1 Verlustfreie Kompression

c u i 1

c o i cu i = cu i iu i 1 n

c o i 1

c o i cu i = cu i io i 1 n

mit cu 0 = 0, c o 0 = 100, i = 0, 1, 2, ..., n1 Nimmt man die ersten 21 Textzeichen („holleri di dudl jö, “), so erhält man cu(7)= 93.56865213843493653982903522765611212800 c0(7)= 93.56865213843493653992169215021531189248 Sparsame Stellenbesetzung erwünscht

Da Binärfolgen gesendet werden sollen, wandelt man diese Zahlen noch in Dualzahlen. Eine geeignete Codezahl ist diejenige mit der geringsten Stellenzahl in diesem Intervall. Das wäre hier zum Beispiel: code= 101 1101.1001 0001 1001 0011 0010 1111 1100 0001.... ........0110 0000 1110 0110 0111 1110 1000 01

... auch hier: oft = viel selten = lang

Mit diesen 69 Bits wird bereits eine kleine Einsparung von 18% erzielt, wenn man davon ausgeht, dass die 13 unterschiedlichen Zeichen mit je 4 Bits dargestellt werden können und dann 4 21=84 Bits benötigen. Bei dem praxisnäheren Vergleich mit 8Bit-Zeichen sind es sogar 36%. Das Ergebnis würde sich weiter verbessern, wenn wir alle 100 Zeichen einbezogen hätten, was wegen der Stellenzahl aber die ohnehin schon wenig übersichtliche Darstellung noch mehr beeinträchtigte. Die Bestimmung der langstelligen Zahlen erfolgte mit dem Mathematik-Programmsystem Mathematica, bei dem Rechengenauigkeit und Stellenzahl praktisch beliebig gewählt werden können. Wie entsteht der Kompressionseffekt? Zeichen mit geringer Häufigkeit ergeben kleinere Beiträge in den oben genannten Rekursionsbeziehungen, für deren Darstellung mehr Stellen erforderlich sind. Eine Häufigkeit von 25 geht bei 100 Zeichen insgesamt mit 0.25 ein, eine solche von 3.125 aber nur mit 0.03125, also der doppelten Stellenzahl. In der Binärdarstellung ist dies ähnlich: 0.2510

=0.012

0.0312510

=0.000012

Im Mittel tragen also die häufigeren Zeichen zu einer geringeren Gesamtstellenzahl bei.

335

6 Datenkompression Jetzt ist noch zu klären, wie die Decodierung erfolgt. Die Codezahl c (die aus der Binärdarstellung zunächst wieder in eine Dezimalzahl umgewandelt werden kann, aber keineswegs umgewandelt werden muss) liegt im Intervall 10 und zeigt somit, dass es sich beim ersten Zeichen um ein „h“ handelt: z 1 = Zeichenintervall c = z h

... und rückwärts geht’s auch ...

Zieht man von der Zahl code die untere Intervallgrenze für „h“ ab und spreizt das „h“-Intervall durch Division der Gesamtintervallbreite n und der Breite des „h“-Intervalls, so lässt sich auch das zweite Zeichen „o“ ermitteln: n

i z hi zh

code : = codeiu zh

o

= code91

u

100 = 85 . 62173794783121 .. . 9491

z 2 = Zeichenintervall code = z o

Im nächsten Schritt identifiziert dieser Algorithmus das Zeichen „l“

n

i z oi z o

code : = codeiu z 0

o

u

= code83

100 = 65 . 543448695 .. . 8783

z 3 = Zeichenintervall code = z l

Keine Tabelle = keine Kompression

und so fort, bis man das letzte Zeichen erreicht hat. Um gar zu lange Zahlen für code zu vermeiden, unterteilt man den zu komprimierenden Text und hängt ein Endekennzeichen an jeden Block. Dies kann ein „Byte“ mit dem Zahlenäquivalent 257 sein, welches man der ASCII-Tabelle hinzufügt. Dass es mit 9 Bit dargestellt werden müsste, stört hier nicht, da es im wesentlichen nur bei der Bestimmung der Häufigkeiten eingeht. Wie beim Huffman-Code gibt es auch für den arithmetischen Code einige Varianten, um die Anforderung nach einer im vorhinein bekannten Häufigkeitstabelle bei Sender und Empfänger zu entschärfen. Theoretisch kann man mit dem arithmetischen Code größere Einsparungen als mit dem Huffman-Code erzielen. Da dieser auf den Eigenschaften eines binären Baums aufbaut, arbeitet er nur optimal, wenn die Häufigkeiten der Zeichen Potenzen von ½ sind. Diese Einschränkung fällt beim arithmetischen Code weg, er ist also besser an allgemeinere Voraussetzungen angepasst, erfordert allerdings auch mehr Rechenaufwand.

6.1.5

Was blieb? 1.

336

Bei welchen Datentypen bringt das einfache RLE-Verfahren gute Ergebnisse, bei welchen nicht?

6.1 Verlustfreie Kompression 2.

3.

4.

5.

6.

7.

8.

6.2

Für welche besonderen Zeichen- oder Bitmuster-Verteilungen bringt das Huffman-Verfahren optimale Kompressionsergebnisse und warum? Warum ist für beliebige Bitmuster-Verteilungen die arithmetische Kompression besser geeignet als der HuffmanCode? Welche von C. E. Shannon definierte fundamentale Größe der Informationstechnik wird durch die Kompression einer Bitmuster-Menge beeinflusst und was ist das Ergebnis? Wie sieht der Huffman-Code für folgende Zeichenverteilungen aus: p(a) =0.01, p(b) = 0.03, p(c) = 0.005, p(d) =0.008, p(e) = 0.09, p(f) = 0.002, p(g) = 0.12, p(h) = 0.3, p(i) = 0.07, p(j) = 0.4, p(k) = 0.046? Welche der möglichen Varianten erzielt das beste Ergebnis? Ermitteln Sie mit Hilfe eines Programms zu einem Text aus einer Tageszeitung oder einer anderen Quelle die Häufigkeiten der einzelnen Zeichen sowie die Häufigkeiten aller Zeichenpaare und lassen Sie sich daraus die Huffman-Binärbäume aufbauen. Welche mittleren Entropien haben die Zeichen des Originaltextes, die Zeichen nach erfolgter Huffman-Codierung sowie die Zeichenpaare? Welche Typen von sich wiederholenden Zeichen- oder Bitmustern kann das LZW-Verfahren prinzipiell finden?

Verlustbehaftete Kompression In einigen Fällen ist es vertretbar, bei der Verdichtung von Daten auf bestimmte Anteile in der Information zu verzichten. Hier kommen uns die Eigenschaften des Gehör- und Gesichtssinnes entgegen, der aus den angebotenen „Rohdaten“, also den physikalischen Signalen in Form von Licht- und Schallwellen, in komplexen Prozessen das wahrnehmbare Ereignis erstellt. Er ist hierbei oft schon mit „weniger“ zufrieden.

6.2.1

Wesentliche Einspar-Potenziale Fragen wir uns zunächst, was denn gezielt aus der Rohdatenmenge weggelassen werden kann, und zwar ohne, dass man dieses im Endergebnis als störend empfindet. Zunächst liegen die Rohdaten als diskrete Signalfolge s(Q 'T) in den Abtastzeitpunkten Q 'T (Q = 1, 2, 3, 4.. ) vor, bei einer Musikaufnahme z. B. als Ausgangssignal s( 'T) = s(Q) = u(Q 'T) = u(Q) eines AnalogDigitalwandlers für die Ausgangsspannung u(t) eines Mikrofons,

337

6 Datenkompression bei einem Bild als zweidimensionale Wertefelder sxy(P'x,] Q 'y) = l(P'x,] Q 'y) = sxy(P],Q) für die Helligkeit (Luminanz) der von einer Digitalkamera aufgenommenen Bildpunkte (Pixel). Das Ziel ist dann, das für die Darstellung der Wertefolgen s(Q) bzw. sxy(P],Q) benötigte Bit-Volumen so abzuspecken, dass sich ohne störenden Qualitätsverlust eine nennenswerte Einsparung ergibt. Für Audiosignale sind dabei Kompressionsraten von 1:10, für Bilddaten solche von 1:20 bis „einige“ 1:100 (Juni 2006) erreichbar. Der Preis der Voll- Für eine Musik-CD zum Beispiel werden pro linkem und rechtem Kanal 16-Bit tiefe Abtastwerte verwendet, die Abtastfrequenz kommenheit beträgt 44,1 Khz (diese kann man bei einer Soundkarte einstellen). Dabei entsteht pro Sekunde ein Datenvolumen von 2 44.100]16 Bit = 1.411.200 Bits = 176 KByte, was auf die CD unverändert übernommen wird (in Wirklichkeit ist es mehr, da für die Fehlerkorrektur mit dem Reed-Solomon-Code noch die Paritätsbits hinzukommen). Der Aufbau der „wav“-Dateien etwa orientiert sich an diesem Vorgehen, weshalb diese auch beachtliche Längen erreichen. Es gibt prinzipiell schon hier zwei Wege, um dieses Datenvolumen zu verkleinern. ¡

Zum anderen könnte man Abtastwerte einfach weglassen. Bei Verzicht auf jeden zweiten verringert sich das Datenvolumen um 50%. Der Effekt ist eine Halbierung der höchsten darstellbaren Frequenzkomponente und damit ein entsprechend dumpferes Klangbild. Diese einfachsten Verfahren arbeiten nach dem „Rasenmäherprinzip“ und nützen damit nicht die sehr viel feineren Eigenschaften anderer gezielter Eingriffe. Solche lassen sich weniger am zeitlichen oder räumlichen Verlauf der Signalfolge s(Q) bzw. sxy(P,Q), als vielmehr an deren einzelnen Frequenzkomponenten vornehmen. Dazu wendet man die Fourier-Transformation auf s(Q]) bzw. sxy(P,Q) an und erhält die Amplituden- und Phasenspektren als Funktionen der Frequenzanteile. Aus den Forschungsergebnissen über das spezifische Verhalten des Gehör- und Gesichtsinnes lässt sich nun entscheiden, welche ¡

Operation gelungen, Patient (halb-) tot

338

Einmal kann man die Auflösung verringern. Statt der 16-BitAnalog-Digitalwandler nimmt man solche für nur 12 oder 8 Bit und verkleinert so das Datenvolumen um 25% oder sogar 50%. Der Nachteil sind größere Quantisierungsfehler, die sich in einem stärkeren Rauschen bei leisen Passagen und einer weiteren Einengung der Dynamik, also der Darstellbarkeit zwischen sehr leisen und sehr lauten Passagen, bemerkbar machen.

6.2 Verlustbehaftete Kompression Verzichtserklärung

Gewinn- und Verlustrechnung

6.2.2

Frequenzkomponenten unter welchen Bedingungen weiterverwendet werden müssen und auf welche man verzichten kann. Bei Audiosignalen nimmt man hier ein so genanntes psychoakustisches Modell zu Hilfe. Nach dieser Auswahl wird aus dem übriggebliebenen Rest über die inverse Fourier-Transformation wieder ein synthetisches Audio- oder Bildsignal s*(Q) bzw. sxy(P,Q) berechnet. Dies entspricht physikalisch zwar nicht mehr dem Originalsignal, wenn aber die oben genannte Auswahl der Frequenzkomponenten geschickt genug gemacht wurde, ist der Unterschied praktisch so gut wie nicht zu bemerken, und das alles bei den schon genannten Kompressionsraten von 1:10 für Audiosignale, bzw. 1:20 für Bildsignale. Audiodaten im MP3Format z. B. benötigen damit statt 176 KByte nur ca. 18 KByte pro Sekunde. Der Preis, den man für ein solches Ergebnis zahlt, besteht einmal in der Erforschung geeigneter psychoakustischer oder psychovisueller Modelle, zum anderen in der Notwendigkeit, genügend schnelle, für die Echtzeitbearbeitung einsetzbare Algorithmen und Prozessoren einsetzen zu müssen.

Fourier-Transformationen Der Grundgedanke der im vorhergehenden Unterkapitel genannten Fourier-Transformation ist der Folgende: Jedes über der Zeit t oder dem Ort (x,y) veränderliche Signal, z. B. die Ausgangsspannung s(t) eines Mikrofons oder die Pixelwerte sxy(x,y) der Bildebene einer Digitalkamera, kann als Summe von sinusförmigen Teilsignalen verschiedener Frequenzen, Amplituden und Phasenwinkeln dargestellt werden.

TransformatorStationen

Wie diese Teilsignale berechnet werden und unter welchen Bedingungen das überhaupt funktioniert, beschreibt die Theorie der Fourier-Transformationen, die man in vielen Lehrbüchern der Elektro- und Nachrichtentechnik findet, zum Beispiel in denen von Steinbuch oder Leonhard gemäß Literaturverzeichnis, Kapitel 7. Es gibt hiervon verschiedene Varianten, die sich jeweils für bestimmte Aufgaben besonders gut eignen. Zur Abkürzung werden in der folgenden Aufzählung nur zeitabhängige Signale betrachtet, die Aussagen gelten aber genauso für räumliche Signale: a) Fourier-Reihe FR für periodisch sich im Abstand T wiederholende Signale s(t) = s(t+T). Als Ergebnis erhält man ein zwar diskretes, aber im allgemeinen unendlich breites Amplituden- und Phasenspektrum über der Grundfrequenz f = 1/T und allen Vielfachen, auch Linienspektrum genannt. b) Fourier-Transformation FT für nicht periodische Signale

339

6 Datenkompression

Variantenreichtum

s(t). Das Ergebnis ist hier ein kontinuierliches Amplitudenund Phasenspektrum. Man kann es sich aus der Fourier-Reihe für periodische Signale hervorgegangen denken, wenn die Periodendauer T über alle Grenzen wächst. c) Diskrete Fourier-Transformation DFT für nicht periodische Signale s(t), die als höchste Frequenzkomponente fmax enthalten. Nach dem Abtasttheorem von Shannon reicht es aus, wenn statt des Signals s(t) eine Folge von äquidistanten Abtastwerten s(Q'T) im Abstand T =

1 2f max

=

2 = 2 2 fmax max

vorliegt, um die sinusförmigen Teilsignale höchster Frequenz sicher zu erfassen. Hierbei genügen theoretisch bereits zwei solcher Abtastwerte s(QT) und s((Q+1)T), da bei bekannter Frequenz Zmax die zwei unbekannten Parameter Amplitude und Phasenwinkel M einer Sinusschwingung durch diese zwei Abtastwerte bestimmt sind: st

= s'sin max t $ ,

s T

= s'sin max T $

= 'ssin $

= s'cos sin$

= ± s'sin$

s 1 T = 'ssin max 1 T $ = s'sin 1 $ = 'scos 1 sin$ 2 mal Eingang 2 mal Ausgang

=(s'sin$

Wie man sieht, ist bei Wahl der „Grenz“-Abtastzeit 'T allerdings nur das Verhältnis von Amplitude und Sinus des Phasenwinkels bestimmt. Für eine genaue Festlegung macht man 'T noch etwas kürzer, 'T*=a]T, mit a<1, aber a | 1 und stellt damit die gewünschte Eindeutigkeit sicher: s T*

= s'sin max a T $= s'sin a $

= s' sina cos $ cos a sin$ s 1 T * = 'ssin max 1 aT $ = 's sin 1 a $ = 's sin 1 acos $ cos 1 a sin$

340

6.2 Verlustbehaftete Kompression Das Teilsignal niedrigster Frequenz fmin ist durch die Anzahl der Abtastwerte bestimmt. Falls 2N solcher Werte vorliegen, wobei dann Q = 0, 1, 2, 3, ... , 2N-1 ist, hat das langsamste Teilsignal die Periodendauer T = 2N 'T oder die Frequenz fmin = 1/T. ... wie am Airport: Abtasten ja, aber bitte ganz diskret!

Die Möglichkeit, für die Berechnung der Amplituden- und Phasenspektren Folgen von Abtastwerten des Signals s(t) verwenden zu können, kommt den technischen Gegebenheiten nahe, da sich die Abtastwertefolge oft leicht mithilfe von Analog-Digitalwandlern aus einem gemessenen Spannungsverlauf u(t) für das Signal s(t) ermitteln lässt. d) Fast Fourier-Transformation FFT als schnelle Variante der DFT, wenn N-1 eine Potenz von 2 ist. e) Diskrete Cosinus-Transformation DCT als Spezialfall der DFT. Hier verdoppelt sich – bei gleicher Auflösung mit 'T und 2N Abtastwerten – die Periodendauer der Grundschwingung auf 2T, da man die gemessene Folge willkürlich als die eine Hälfte einer geraden Funktion betrachtet, womit die andere Hälfte bereits bekannt ist:

s t =s t bzw. s Tt =s t .... für jeden etwas im Angebot

Im Gegensatz zu ungeraden Funktionen sind gerade Funktionen bezüglich t=0 bzw. t=T/2 spiegelsymmetrisch. Die zugehörigen Fouriersummen enthalten dann ausschließlich Cosinus-Anteile, da Beiträge mit den ungeraden Sinusfunktionen diese Symmetrie stören würden (ungerade Funktionen sind punktsymmetrisch).

Kleine Tricks, große Wirkung

Die Abtastwerte s(Q) weisen die beabsichtigte Symmetrie allerdings erst auf, wenn man einen kleinen Trick anwendet und die Argumente der Abtastwerte (oder der Cosinusfunktionen) um den Betrag T 2

verschiebt. Dann ist s

2 1 T 2

= s

2N

2 1 T , =0, 1, 2, .., 2N1 2

oder cos

2 1 T 2

= cos

2N

2 1 T , =0, 1, 2, .., 2N1 2

Die Abtastwerte können jetzt doppelt genutzt werden, und außerdem sind nur Cosinus-Schwingungen in der Fouriersumme enthalten, siehe Unterkapitel 6.2.2.4 (dort wird von

341

6 Datenkompression 4N statt wie hier von 2N Abtastwerten ausgegangen, was aber für das Ergebnis belanglos ist). Als Besonderheit fällt sogar noch der Koeffizient für die höchste Frequenz weg und den N Abtastwerten stehen genau N Fourierkoeffizienten gegenüber. f) Zweidimensionale DFT, FFT oder DCT für Bilddaten oder Pixelfelder sxy(x,y) Da die Transformationen b) bis f) auf dem „Urvater“ a) aufbauen, folgt jetzt eine genauere Betrachtung dieses Typs.

6.2.2.1 Fourier-Reihe für periodische Signale Wiederholt sich ein Signal s(t) nach der Zeit T periodisch, ist also s(t+T) = s(t), so wird die Darstellung besonders einfach. Als Ergebnis der Fourier-Transformation, auch Fourier-Reihe genannt, erhält man die Amplituden aQ und bQ aller Sinus- und Cosinus-Schwingungen für die Grundfrequenz f = 1/T und für alle Vielfachen ]f = Q/T mit Q = 1, 2, 3, .... sowie für den arithmetischen Mittelwert a0, den so genannten „Gleichspannungsanteil“. Die Schwingungsanteile können im allgemeinen unendlich viele sein. T

2

s tcost dt T

a =

0

, b =

2

T

st sint dt , T 0

= 1, 2, 3, . ..

a0 =

1

T

s t dt T

b0 = 0

,

0

Signal und Koeffi- Das Signal s(t) lässt sich nun seinerseits aus den Amplituden a Q , bQ rückgewinnen: zienten: Zwei gleichwertige Partner s t = a cos t b sin t= s' sin t $ =0

=0

Hier bedeuten

s' =

a a 2 b 2 , $= arctg b

,

da nach den Gesetzen für trigonometrische Umformungen

[

s' sin t $ = s' sin $ cos t cos $ sin t

ist und sich hieraus a = s'sin $ ,

342

b = s'cos $

]

6.2 Verlustbehaftete Kompression für eine alternative Darstellung ergibt. Maskenparaden .. Noch kompakter ist die Variante in der komplexen Form, bei der die Beziehung e

j t

=cos t j sin t

verwendet wird:

s t =s t T=

= T

c e

1 j t c = s t e dt, T 0

j t

1 c= aj b , 2

c=c , konjugiert komplex ... und Kreuz(Korrelations) Züge

Wie die Integrale zeigen, ist die Berechnung der Koeffizienten aQ, bQ eigentlich eine Kreuzkorrelations- oder Mittelwert-Bildung über s(t) mit dem jeweiligen Partner cos(t) bzw. sin(t): Nur dann, wenn im Signal s(t) ein korrelierender Anteil aQ cos (_ t) bzw. bQ cos(_ t) gefunden wird, hat das Integral den Wert aQ bzw. bQ. Alle anderen Anteile mitteln sich heraus. Die Cosinusfunktion wirkt also wie eine „Maske“, die sich im Signal denjenigen Anteil heraussucht, der zu ihr passt. Der Fourierkoeffizient gibt das Maß an, wie stark die Übereinstimmung bezogen auf den Amplitudenwert 1 ist. Bild 6.1 zeigt das bereits im Unterkapitel 3.5.6 verwendete Beispiel Bild 3.6, Seite 85, das hier nun unter einem ganz anderen Blickwinkel betrachtet wird.

Bild 6.1: Signal s(t) unbekannter Zusammensetzung (identisch mit vs'(t) in Bild 3.6

343

6 Datenkompression ... wie in der Che- Dort wurde – alternativ zur rechteckförmigen Modulation des Sendesignals vs – den Bitwerten je eine Amplitude eines Simie: Synthesen gnalgenerators oder Frequenzsynthesizers zugeordnet, so dass und Analysen ein bandbegrenztes Sendesignal vs' entstand. Jetzt stellt sich die umgekehrte Aufgabe, nämlich die Frequenzanalyse oder die Bestimmung der unbekannten Frequenzkomponenten. Da es beliebig viele sein können, erfordert dies ungleich mehr Aufmerksamkeit, während ihre Zahl im anderen Fall eindeutig festgelegt ist. Um sich einen Überblick zu verschaffen, kann man z. B. aus einer Folge von 100 äqudistanten Messwerten einen Polygonzug bilden und diesen als Näherung für s(t) in die obigen Formeln einsetzen. Man erhält:

Vollständig erfasst?

Schnelltest

Koeffizient

Näherung

gerundet Koeffizient

Näherung

gerundet

a0

-0.999998

-1

-

-

-

a1

1.0

1

b1

0.999998

1

a2

-0.999995

-1

b2

-1.00001

-1

a3

-0.999994

-1

b3

0.999989

1

a4

1.0

1

b4

-0.000019

0

a5

-0.0000017

0

b5

-0.000030

0

Genau genommen müssten noch einige Koeffizienten höherer Ordnung berechnet werden, aber der verhältnismäßig „ruhige“ Verlauf des Signals legt nahe, dass keine über die Komponente mit f = 1/(4s) hinaus gehenden enthalten sind. Damit wäre in diesem Fall die Analyse abgeschlossen. Ein Vergleich mit den – in Wirklichkeit allerdings unbekannten – Komponenten des Ursprungssignals gemäß Bild 3.6 zeigt eine praktisch völlige Übereinstimmung (ASCII-Zeichen „e“ # 0110 0101, Achtung: a0 ist dem letzten Bit zugeordnet). Der Check auf genügend vertretene Frequenzkomponenten geht auch einfacher: Mit Hilfe der berechneten Koeffizienten setzt man ein synthetisches Signal zusammen und vergleicht es mit dem gemessenen Verlauf. Bei genügender Übereinstimmung bricht man die Berechnung höherer Komponenten ab. Die maskierende Wirkung der Sinus- und Cosinusfunktionen in den Integranden der Fourierkoeffizienten erkennt man vermutlich besser, wenn man als Beispiel ein Summensignal s(t) s t = c 0 c1 cos ) t c2 cos 2) t d1 sin) t d2 sin 2) t

betrachtet, dieses in die Formeln einsetzt und dann die Auswertung durchführt. Hier das Ergebnis für die ersten drei Koeffizienten:

344

6.2 Verlustbehaftete Kompression

a0 =

2

a1=

T 2

a2 =

=

T

1

T

s t dt = 1T T 0

[

]

T

c 0t c 1

T

s tcos tdt = 0 T

2 T

[

1 sin t . .. . = c 0 , 0

c0

]

T

1 1 1 sin t c1 t sin2t .. .. = c1 , 2 4 0

s t cos2 tdt 0

[

]

[

]

T

2 1 1 1 1 sin2)t c1 sin3)t c sin)t T 0 2) 2 ) 3)

+

2 1 1 sin4)t c2 t T 2 4)

0

T

= c2

0

Bei Multiplikation von s(t) mit den Maskenfunktionen cos(QZt) bzw sin(QZt) entstehen in den Integranden jeweils Produkte mit gemischten Faktoren c 0cos ) t c1 cos ) t cos ) t d1 sin ) t cos ) t

Das Sieb des Herrn Fourier

Nur Terme mit gleichen Faktoren ergeben bei der Integration über t in den Grenzen 0 d t d T wegen T

cos ) t2 dt 0

Immer senkrecht bleiben

c 2 cos 2) t cos ) t d2 sin 2 ) t cos ) t

=

[

]

1 1 t sin2 ) t 2 4 )

T 0

=

T 2

von Null verschiedenen Beiträge, alle anderen haben den Wert Null. Daher bleiben nur Terme ohne diese Funktionen übrig, und hiervon gibt es in jedem Integral jeweils nur einen einzigen. Etwas vereinfacht könnte man auch sagen, dass jede Cosinusund Sinus-Funktion aus dem Signal s(t) nur denjenigen Anteil „herausschneidet“, der ihr selbst bis auf einen Amplitudenfaktor gleich ist (Orthogonalitäts-Eigenschaft der harmonischen Funktionen). Die Voraussetzung, dass in s(t) neben dem Gleichspannungsanteil nur Grundschwingungen der Dauer T bzw. der Frequenz f = 1/T und ganzzahlige Oberwellen enthalten sein sollen, stellt allerdings eine Einschränkung dar, die bei realen physikalischen Signalen nur in Sonderfällen gegeben ist. Nur in diesen

345

6 Datenkompression funktioniert auch die Rücktransformation ohne Veränderung, ist also das aus der Summe berechnete synthetische Signal s*(t)

s* t =

a cos t

=0

b sin t = s t

identisch mit dem Originalsignal s(t), aus dem die Koeffizienten aQ und bQ ermittelt wurden.

6.2.2.2 Fourier-Transformation für nicht periodische Signale s(t) Wenn die Periodendauer T über alle Grenzen wächst, T o f, dann gehen die oben genannten Summen in Integrale über und die Linienspektren für Amplituden und Phasen werden „dicht“, verlaufen also kontinuierlich. Meist stellt man die Transformationen in komplexer Form dar, was wie bei der Fourier-Reihe nur eine kompakte Variante der reellen Schreibweise ist. Die Transformationsbeziehungen sind: t =+

s tej t dt

S j =

t= j

st Komplexe Verhältnisse

=

1 S j e j t d 2 j j

S(jZ) ist das komplexe Frequenzspektrum, dessen Betragsverlauf das Amplituden- und dessen Argumentenverlauf das Phasenspektrum beschreibt: S j

= ReS j jIm S j

S j =

$ j

ReS j 2 ImS j 2

= arctg

ImS j ReS j

Die Fourier-Transformation konvergiert nur unter bestimmten Bedingungen, die das Signal s(t) erfüllen muss. Sie ist in erster Linie als theoretische Ausgangsbasis für die technisch wesentlich interessantere diskrete Fourier-Transformation nützlich.

6.2.2.3

Diskrete Fourier-Transformation für bandbegrenzte Signale Diese Form eignet sich besonders für den praktischen Gebrauch, wie schon in Punkt c) festgestellt wurde. Aus den 2N Abtastwerten s(Q 'T) des Signals s(t) im Abstand

346

6.2 Verlustbehaftete Kompression T =

1 1 T = = 2f max 2Nfmin 2N

ergeben sich 2N Fourierkoeffizienten, siehe weiter unten. In der komplexen Schreibweise sind es mit 22N doppelt soviel, da die Koeffizienten aber konjugiert komplex auftreten, entsteht keine zusätzliche Information. 2N1

a =

2N1

1 1 s cos N , b = 2N s sin N 2N =0 =0

= 0, ±1, ±2, . .. , ±N

Paritätische Besetzung: Koeffizienten und Abtastwerte

Da O einen Wertebereich von 2N+2 umfasst, entsteht der Eindruck, dass mehr Koeffizienten vorhanden wären als Abtastwerte. Es ist aber immer b0 = 0 und nach den Überlegungen auf Seite 340 auch bO=N = 0, so dass die Anzahl der Koeffizienten auf 2N begrenzt bleibt. Durch Rücktransformation lassen sich wieder die Abtastwerte s(Q) ermitteln: N

s = s T =

= N

Möglichkeiten und Grenzen

j

c e

N

N

=

=N

aj be

j

N

= 0, 1, 2, .. ., 2N1 So nützlich diese Form auch ist, muss man bei der Interpretation der Ergebnisse doch vorsichtig sein. Die Transformation ist, wie die vorangegangenen, umkehrbar. D. h., wenn s(t) als schnellste Schwingungskomponente wirklich eine Sinusschwingung mit der höchsten Frequenz fmax enthält, dann werden sich aus den Koeffizienten aQ und bQ wieder die zu ihrer Berechnung verwendeten Abtastwerte s(Q) = s(Q 'T) ergeben – nicht weniger, aber auch nicht mehr. Die Periodendauer ist mit T = 2N T

durch die Summe der 2N Abtastintervalle gegeben. Damit wird der niedrigste Frequenzanteil in s(Q) eine Sinusschwingung mit der Frequenz f min =

Einfluss der Abweichler

1 2 = T 2N T

sein. Eine Komponente mit f=1.3fmin würde für sich im synthetischen Ausgangssignal nicht erscheinen, weil sie in der Rücktransformations-Beziehung nicht auftritt (erscheinen würde erst

347

6 Datenkompression

Wiederherstellung eingeschränkt

eine Komponente mit f= 2 fmin). Dagegen wird die in den Abtastzeitpunkten gemessene Summe der niedrigsten und zweit niedrigsten Schwingung richtig wiedergegeben. Das rücktransformierte Ausgangssignal gibt die physikalischen Gegebenheiten des Eingangssignals also nur richtig wieder, wenn dieses aus Vielfachen der Grundschwingung mit f min =

1 T

besteht. Anhand des Beispiels von Unterkapitel 6.2.2.1 lässt sich dies verdeutlichen. Der gestrichelte Verlauf in Bild 6.2a zeigt nochmals das Summensignal von Bild 6.1 im Zeitabschnitt t=0s bis t=1s, also für eine volle Periode T. Die gestrichelte Linie enthält zusätzlich auch einen Beitrag mit f=1.3·fmin , die Amplituden sind mit a1.3 =0.8, b1,3 =0.5 verhältnismäßig stark.

Bild 6.2a: Signalgemisch s'(t) mit Anteil 1.3 fmin, zum Vergleich gestrichelt das Signal s(t) aus Bild 6.1

Bild 6.2b: Das aus den Fourierkoeffizienten des Signals s'(t) gemäß Bild 6.2a ermittelte synthetische Summensignal ss'(t), zum Vergleich gestrichelt s'(t)

348

6.2 Verlustbehaftete Kompression Alle tragen der anderen Last

Macht man hier die Fourieranalyse unter der Annahme, dass diese Komponente nicht vorhanden ist, so erhalten die Fourierkoeffizienten andere Werte, sie übernehmen deren Anteil mit. Der tatsächlich Fehler im synthetischen Summensignal ss'(t) ist aber gerade dadurch wiederum gering, was der Vergleich in Bild 6.2b zeigt. Man muss also nicht von vornherein mit starken Abweichungen rechnen. Noch eine Frage ist zu beantworten: Was passiert, wenn man das Signalgemisch nicht durch ein Tiefpassfilter auf fmax bandbegrenzt und es dann möglicherweise höhere Komponenten gibt? Betrachten wir wiederum das Signal s(t) = vs(t) in Bild 6.1, welches Komponenten bis 4fmin enthält. Ist man nur an den Komponenten bis 3fmin interessiert, würde man aus s(t) 6 Abtastwerte im Abstand von 'T = 0.167 s messen. Die daraus berechneten 6 Koeffizienten sind: a0' = -1 ( a0 = -1) a1' = +1 ( a1 = +1) a2' = 0 ( a2 = -1) a3' = -1 ( a3 = -1) b1' = +1 (b1 = +1) b2' = -1 (b2 = -1)

Begrenzung ist die erste (Bürger-) Pflicht

b3' = 0 (b3 = +1)

a2' und b3' geben demnach die Verhältnisse falsch wieder, so dass ein daraus gewonnenes synthetisches Signal das Originalsignal ebenfalls verfälschen würde. Die Bedingung, vor der Abtastung eine Bandbegrenzung durchzuführen, ist also wesentlich! Bezüglich der Bandbegrenzung auf fmax wurde bisher der Fall betrachtet, dass die aktuellen Frequenzkomponenten nur im Bereich des „Basisbandes“ 0 f f max

liegen dürfen. Tatsächlich gilt die Bandbegrenzung aber für alle Bereiche innerhalb eines Spektrums mit der unteren Frequenzgrenze fu, was insbesondere für die Audiokompressionsverfahren von Bedeutung ist, da das Hörspektrum in einzelne Bänder aufgeteilt werden muss, siehe Unterkapitel 6.2.4.2: f u f fu fmax

6.2.2.4

Diskrete Cosinus-Transformation als Sonderfall der DFT Bei nicht periodischen, auf fmax bandbegrenzten Signalen kann man diese in Gedanken nach links und rechts periodisch fortsetzen, ohne dass sich in den Fourierkoeffizienten des erweiterten Signals eine Veränderung ergäbe: Die Frequenzkomponenten bleiben dabei gleich und das Signal sähe so aus, wie in Bild 3.6a dargestellt:

349

6 Datenkompression

Bild 6.3a: Signal s'(t) aus Bild 6.1 und gedachte periodische Wiederholung (unsymmetrisch) nach links und rechts Gleiche LandDies hat zunächst keinen weiteren Nutzen, was sich jedoch schaft – andere ändert, wenn der Signalausschnitt nach links und rechts spiegelSicht symmetrisch fortgesetzt wird, wie es Bild 6.3b zeigt. Damit wurde aus dem unsymmetrischen Verlauf von s'(t) derjenige einer geraden Funktion s''(t) mit der Eigenschaft s''(t)= s''(-t), was bei Anwendung der DFT aus Unterkapitel 6.2.2.3 einige Vereinfachungen für die weitere Verarbeitung mit sich bringt: ¡ Die Periodendauer verdoppelt sich zwar von T auf 2T, aber wegen der Symmetrie treten alle Abtastwerte ebenfalls doppelt auf, weshalb auch weiterhin wie bei der DFT nur 2N Werte im Bereich 0 d t < T im Abstand 'T =T/2N gemessen und verwendet werden müssen. Änderungskatalog ¡ Die Anzahl der Fourierkoeffizienten verdoppelt sich zunächst auf 4N+2. ¡ Es gibt keine ungeraden Anteile in s''(t), alle mit der ungeraden Sinusfunktion verknüpften Beiträge in der Fouriersumme entfallen. Diese würden sonst als ungerade Funktionen x(t) = - x(-t) die Symmetrie stören. Alle Koeffizienten bO sind Null, es bleiben nur die 2N+1 Koeffizienten aO übrig. ¡ Die Fouriersumme ist rein reell. ¡ Der Koeffizient a2N verschwindet, siehe weiter unten, a2N =0. Daher stehen den 2N unterschiedlichen Abtastwerten genau 2N Fourierkoeffizienten gegenüber. ¡

350

6.2 Verlustbehaftete Kompression

Bild 6.3b: s''(t) als spiegelsymmetrische Fortsetzung des Signals s'(t). Die auf dieses Signal angewendete DFT mit 'T = 0.125 s ergibt folgende 4N+2 = 18 Fourierkoeffizienten:

Neue Teilnehmer

Stunde des Cosinus

a0

-1

b0

0

a1

-0.65

b1

0

a2

1

b2

0

a3

1.04

b3

0

a4

-1

b4

0

a5

-1.04

b5

0

a6

-1

b6

0

a7

0.65

b7

0

a8

1

b8

0

Wegen der nicht differenzierbaren „Stossstellen“ bei t = -1s, t=0, t = +1s usw. sind jetzt trotz der gebliebenen Bandbegrenzung im ursprünglichen Signal s(t) weitere hinzu gekommen. Als Ergebnis der Rücktransformation mit diesen Koeffizienten erhält man die Darstellung in Bild 6.3c. In der Literatur findet sich diese spezielle Variante unter der Bezeichnung „Diskrete Cosinustransformation DCT“, da offensichtlich nur die Cosinusbeiträge von Null verschieden sind. Obwohl die hierfür wesentlichen Besonderheiten soeben beschrieben wurden, lässt sich durch einen kleinen, bereits unter Punkt e) genannten Trick eine spezielle Darstellung der DCT erreichen, die man in dieser Form häufig in der Literatur findet und bei der ein weiterer Koeffizient wegfällt.

351

6 Datenkompression

Bild 6.3c: Synthetisches Signal nach Rücktransformation der DFT-Koeffizienten für das auf eine gerade Funktion erweiterte Signal: Im Bereich 0 d t < 1 zeigt sich die enge Übereinstimmung mit dem ursprünglichen – gestrichelt dargestellten – Verlauf. Nur an den Bereichsgrenzen bei t = 0 und t = 1 sind kleine Abweichungen zu sehen, die Abtastwerte bleiben identisch Doppelnutzung durch Symmetrie

Trickreiche Schiebereien

Achtung: Die Periodendauer T* ist hier mit T* = 2T doppelt so lang, die Messwerte haben aber weiterhin den Abstand 'T, weshalb sich ihre Zahl verdoppelt (ohne dass wegen der Symmetrie mehr als 2N ermittelt werden mussten) Der Trick besteht darin, die Abtastwerte nicht bei t=0 beginnend zu messen, sondern um den Betrag *T 1 T* 1 2T T = = = 2 2 4N 2 4N 4N

verschoben, also s('T/2), s(2 'T/2), s(3 'T/2), ...... Auf das Endergebnis bleibt dies ohne Einfluss, da der Startpunkt über eine volle Periode T betrachtet ohnehin willkürlich gewählt wird. Von den 4N Abtastwerten entsprechen sich jeweils 2: *T *T = s 4N* T 2 2 *T *T s* T = s 4N1* T 2 2 *T *T s 2* T = s 4N2* T 2 2 usw. s

Mit

352

6.2 Verlustbehaftete Kompression

t = * T

Produkt-Design

*T 2 1 = * T 2 2

nehmen die Produktterme in den Transformationsbeziehungen für die DFT folgende Form an:

2 1 2 *T cos * T 2 2 T* 2 1 *T cos = s * T 2 4N 2 1 1 = s cos 2 4N

stcos)t= s * T

= 0, 1, 2, ......, 4N1 = 0, 1, 2, ......, 4N Die Koeffizienten für die Wechselkomponenten sind: 4N1

2 1 4 N =0 ¿ 2N1 4N1 2 1 2 1 1 1 1 s cos = s cos 4N =0 2 4N 2 4N = 2N

a =

1 4N

s 12 cos

[

=

1 2N

]

2N1

2 1

s 12 cos 4N

=0

für = 1, 2, ....., 2N1,

da a2N = 0 siehe unten

Der Gleichanteil ist der arithmetische Mittelwert: a=0 = a0 =

... einer fliegt ...

1 N

2N1

s 12 =0

Von diesen 2N+1 Koeffizienten ist der für die höchste Frequenzkomponente mit O = 2N wegen cos 2N

2 1 2 1 = cos = 0, = 0, 1, 2, .. , 4N1 4N 2

immer Null, weshalb 2N Koeffizienten aO übrig bleiben. Die Koeffizienten bO verschwinden wegen der geraden Funktion auch hier allesamt, bO = 0. Die Rücktransformation ergibt sich als

353

6 Datenkompression 1 s = 2

Leistungsvergleiche: kein Sieger, kein Verlierer

2N1

a cos =0

2 1 , = 0, 1, 2, ....., 2N1 4N

Was wurde gegenüber der DFT erreicht? ¡ ¡ ¡

¡

(Ver-) Lustlosigkeit

¡

Tote Winkel

¡

Sowohl DFT als auch DCT verwenden 2N Abtastwerte s(Q). Bei der DFT sind N+1 Koeffizienten a0, a1, ... aN und N-1 Koeffizienten b1, b2, ..., bN-1 zu berechnen, insgesamt also 2N Bei der DFT mit künstlich auf eine gerade Funktion s(t) = s(-t) und doppelten Zeitbereich -T d t d 7 erweitertem Signal müssen 2N+1 Koeffizienten a0, a1, ..., a2N bestimmt werden, die bO fallen weg. Die DFT geht in die DCT-Variante über, wenn die Abtastwerte um den Betrag 'T/2 verschoben werden. Dann sind nur 2N Koeffizienten a0, a1, .... a2N-1. zu berechnen. Beide Transformationen arbeiten verlustfrei: Aus den über die Abtastwerte s(Q) berechneten Fourierkoeffizienten werden bei der Rücktransformation genau wieder diese Abtastwerte ermittelt. Nur das ist im allgemeinen auch die Aufgabe. Möchte man aus den Fourierkoeffizienten über die Abtastwerte s(Q) hinaus auch das kontinuierliche Signal s(t) rekonstruieren, so eignet sich nur die DFT-Variante, da sie s(t) vollständig und ohne Abweichung liefert. Mit der DCT ist das nicht möglich, da ihre Cosinus-Koeffizienten nicht die in den Sinus-Koeffizienten enthaltenen Phasenwinkel-Informationen aufweist, siehe Bild 6.4

Bild 6.4: Aus den DCT-Koeffizienten rücktransformiertes Signal. Es stimmt in den Abtastzeitpunkten mit dem ursprünglichen – gestrichelt dargestellten – Signal s'(t) überein, ist wegen der fehlenden Phasenwinkel-Information darüber hinaus aber nicht identisch

354

6.2 Verlustbehaftete Kompression Als Vorteil bleibt also, dass bei der DCT ein Koeffizient weniger zu berechnen ist. Einen weiteren kleinen Bearbeitungsvorteil kann man erzielen, wenn die Fourierkoeffizienten aO nur relativ untereinander im richtigen Verhältnis zu stehen brauchen, aber nicht die absoluten Größen der zugehörigen Teilschwingungsamplituden wiedergeben müssen. Dies ist z. B. der Fall, wenn man sie lediglich als rechentechnische Zwischengrößen für die Rücktransformation in die Abtastwerte s'(Q) benötigt. DCT: Achtungserfolg beim Handling

Dann setzt man bei den Summen für die aO statt der Vorfaktoren 2 1 bzw . N N

die Wurzeln hieraus an, also

k=

1 2 für =0, k = für =1, 2, ,, N1, N N

und korrigiert diesen „Fehler“ durch nochmals die gleichen Faktoren in der Rücktransformation: 2N1

a *0

1 = k 0 s 2 =0 2N1

2 1 1 , = 1,2, .., 2N1 = k s cos 2 4 N =0 2N1 2 1 1 s = k a * cos , =0,1,2, .. , 2N1 2 4 N =0 a *

Damit kann für beide Transformationen ein einziger Algorithmus verwendet werden, wenn man die Größen s(Q) und aO vertauscht.

6.2.2.5 Raumgreifend

Zweidimensionale Diskrete Cosinus-Transformation Das Signal s kann auch eine räumliche Funktion s = s(x) sein und hängt dann in seinem Verlauf z. B. von der Ortskoordinate x ab. Man denke etwa an die Oberflächenrauhigkeit einer bearbeiteten Metallkante, das Relief eines Gebirgszuges oder die Grau- und Farbpunkte eines Bildes (Pixel). Alle zuvor genannten Transformationen lassen sich in gleicher Weise verwenden, wobei die Signalzerlegung jetzt in räumliche Teilschwingungen erfolgt. Wegen der meist flächenhaft vorliegenden Objekte liegt es nahe, die Teilschwingungen in den zwei Raumkoordinaten x,y zu betrachten. Häufig nutzt man für die Transformation des Signals s = sxy(x,y) oder seiner NN = N2 Abtastwerte s xy x , y = s , , =0, 1, 2, ..., N1 , =0, 1, 2, ... , N1

355

6 Datenkompression die DCT in ihrer zweidimensionalen Ausführung: a*- = k -

N1 N1

cos s , cos - 2 1 2 N

=0 =0

2 1 , 2 N

-, = 0, 1, 2,,, N1

Kosmetikstudio

1 1 1 2 k 00= , k 0 = , k - 0 = , k - = für -, = 1, 2,,, N1 N N N N Achtung: Zuvor hatten wir die Anzahl der Abtastwerte mit 2N bezeichnet. Da die Darstellung nun komplexer wird, ist es ohne jede Einschränkung in den Formeln etwas übersichtlicher, von 2N auf N Abtastwerte zu gehen, wobei sich nach außen nichts ändert. Wo vorher N = 4 angesetzt war und die Indexgrenzen bis 2N = 8 gingen, ist jetzt eben N = 8. Oder anders ausgedrückt: In den bisherigen Formeln ist nur N durch N/2 zu ersetzen, wobei nach wie vor von einer geraden Anzahl der Abtastwerte ausgegangen wird (was im übrigen nicht einmal zwingend ist). Hier stellt der Koeffizient a*00 den Gleichanteil oder arithmetischen Mittelwert der Abtastfolge dar. Die Rücktransformation in die NN Abtastwerte erfolgt mit N1 N1

s . , =

k - a*-cos -=0 .=0

2 1 2. 1 cos 2 N 2 N

- , = 0, 1, 2, .... , N1

Wir berechnen die Fourier-Koeffizienten aNO* auch hier als Kreuzkorrelation zwischen dem Signal und der „Maskenfunktion“, welche jetzt das Produkt aus den beiden Cosinusfunktionen cos

Flächendeckend verlustfrei

2 1 2 1 cos 2 N 2 N

darstellt. Als Beispiel wird die zweidimensionale DCT für die folgende 8Y8-Anordnung von 64 Zahlen bestimmt: 1 1 1 1 1 1 1 1

2 1 1 1 1 1 1 1

1 3 3 1 1 1 1 1

1 1 1 4 4 1 1 1

1 1 1 1 1 3 3 1

1 1 1 1 1 1 1 2

1 1 1 1 1 1 1 1

1 1 1 1 1 1 1 1

Man erhält die nachfolgend dargestellten 64 Koeffizienten. Die

356

6.2 Verlustbehaftete Kompression linke obere Zahl stellt als die durch N=8 geteilte Summe ein Maß für den arithmetischen Mittelwert aller „Kästchen“ dar. Die Rücktransformation der Koeffizienten führt wieder genau auf die obige Ausgangstabelle, die zweidimensionale DCT ist also ebenfalls eine verlustfreie Transformation. 10 0 -0.65 0 0 0 -0.27 0

6.2.3 Verlust = Gewinn

Operationsplan

0.51 0.86 -0.21 -0.15 0 -0.10 -0.09 0.17

-1.9 0.56 1.28 -0.16 -0.06 -0.11 0.53 0.11

-0.75 -1.35 0.95 0.66 -0.15 0.44 0.39 -0.27

0.50 -0.98 -1.31 0.83 0.50 0.56 -0.54 -0.20

0.22 0.52 -1.42 -0.77 1.12 -0.51 -0.59 0.10

-0.02 0.45 0.53 -1.15 -0.79 -0.77 0.22 0.09

0 -0.04 1.04 0.15 -2.57 0.10 0.43 -0.01

JPEG Die Joint Photographic Expert Group, ein Standardisierungsgremium der CCITT und Mitglied der ISO, hat 1992 das Kompressionsverfahren CCIR-601 für statische Bilder veröffentlicht. Das Ziel war, Dateien eines Farbbildes in ausreichend guter Qualität und angemessener Zeit über Telefonleitungen übertragen zu können. Es stehen 4 Verfahren bereit, die sich in Darstellungsqualität und Kompressionsgrad unterscheiden: ¡ Die verlustbehaftete Verdichtung mit Kompressionsraten von 1:10 bis 1:2 ¡ Die verlustfreie Verdichtung mit Kompressionsraten von etwa 1:2 (für Bilder, bei denen keine Veränderungen gegenüber dem Original zulässig sind, etwa aus dem Bereich der Medizin) ¡ Das progressive Verfahren, bei dem Bilder zuerst in einer groben Voransicht übertragen und in anschließenden Schichten verfeinert werden (dies sieht man bei manchen Bilddarstellungen im Internet), und schließlich ¡ Das hierarchische Verfahren, bei dem Bilder in verschiedenen Auflösungen dargestellt sind und jeweils nur die Unterschiede zum nächstkleineren behandelt werden (Foto-CD). Wir sehen uns jetzt den groben Ablauf des häufig verwendeten ersten Verfahrens an, welches aus mehreren Schritten besteht. Weitaus umfangreichere Detail-Informationen erhält man zum Beispiel über die Homepage www.jpeg.org der JPEG-Gruppe. Schritt 1: Falls das Bild in der RGB (=Rot/Grün/Blau)-Darstellung vorliegt, wird es zunächst Pixel für Pixel in die YUV-Form umgewandelt. Y steht dabei für den Helligkeitswert

357

6 Datenkompression (=Luminanz), U und V beschreiben die Farbwerte (=Chrominanz) der Pixel-Codierung. Der Grund für diese Umwandlung liegt darin, dass in der YUV-Form Helligkeitswert und Farbwerte getrennt sind. Da unser Gesichtssinn mehr Informationen aus dem Helligkeitsverlauf (Graustufen) bezieht als aus den Farben, kann die Auflösung der Farbinformationen halbiert werden, ohne dass subjektiv eine wesentliche Qualitätsverschlechterung empfunden wird. Das ergibt bereits eine Datenreduktion um 50% ohne nennenswerte Informationsverluste. Pixelreigen

Schritt 2: Nun wird das Bild in 88 große Pixelblöcke unterteilt, jeweils für Y, U und V. Ein 512 x 384 Punkte umfassendes Original aus einer einfachen Digitalkamera besteht also aus 64483 = 9216 solcher Blöcke. Jeder Bildpunkt ist mit 8 Bit codiert (auch tiefere Auflösungen wie 12 Bit sind üblich, heute bei Digitalkameras sogar 48 Bits) und kann 256 Werte annehmen. Für die Helligkeitswerte Y sieht ein solcher Block als Ausschnitt einer weißen Linie in einer dunklen Fläche so aus:

Diese Blöcke durchlaufen die zweidimensionale diskrete Cosinus-Transformation gemäß Kapitel 6.2.2.5, das Ergebnis sind 64 Fourierkoeffizienten a* pro Block, nämlich der arithmetische Mittelwert a00* über alle Pixelwerte sowie die 63 Frequenzkomponenten. Im Beispiel ergibt das bei Rundung auf ganze Zahlen: 1260 -14 -13 -12 -10 -8 -5 -3

Runde(nde) Sachen: Kaum Verluste zu beklagen

358

-142 -297 90 -33 18 14 -8 -29

-161 142 163 -62 48 -19 40 47

62 133 -158 -28 23 -63 -9 -11

-48 -40 -48 68 -10 23 9 -27

8 16 17 10 -4 10 3 6

-8 -2 2 4 -8 -8 15 -9

0 7 -1 -3 -18 0 -3 3

Die Rundung zieht bereits einen ersten Informationsverlust nach sich, der umso stärker ausfällt, je kleiner der Absolutwert in einem „Kästchen“ ist. Die linke obere Zahl, der Gleichanteil a00*, hat – wie oft bei Grafikdatenblöcken – auch hier einen hohen Wert, die restlichen fallen nach rechts und unten hin ab. Da in dieser Richtung aber

6.2 Verlustbehaftete Kompression die Koeffizienten für die höheren ebenen Frequenzanteile liegen, heißt das, dass diese immer schwächer werden. Je „flacher“ ein Bildblock oder ein Bild ist oder je weniger Kontrast und Konturen es besitzt, um so kleiner fallen die höheren Komponenten aus. Abgesehen davon liegt einfach eine zu den Pixeln gleichwertige Darstellung vor. Insbesondere ergeben sich diese bei Verwendung der nicht gerundeten Werte vollständig wieder aus der Rücktransformation, wovon wir uns bereits im Beispiel von Kapitel 6.2.2.4 überzeugt hatten. Worin liegt der Vorteil bei diesem Schritt? Unser optisches WahrWertmaßstäbe nehmungssystem bewertet höhere Frequenzanteile im allgemeinen geringer, so dass uns Veränderungen hieran weniger störend auffallen als bei tiefen ebenen Schwingungen. Wenn man gezielt eingreifen will, bieten sich daher die hohen Frequenzkomponenten als erstes an. Hinweis: Eine ausgeprägte ebene Schwingung bildet z. B. das Wellenfeld von Sanddünen in einer Wüste. Ungleich-Behand- Schritt 3: Diese Erkenntnis lässt sich gezielt zur Kompression nutzen, indem man die hohen Frequenzkomponenten gegenlung: relativ ... über den tiefen absenkt. Ein Weg besteht darin, den linken oberen Wert unverändert zu lassen und die anderen nach rechts unten stetig bis zum Faktor von z. B. 10 zu verkleinern. Die Ergebnisse werden anschließend gerundet, so dass Ausgangswerte kleiner als 5 den Wert Null annehmen. Die Zahl 0 erscheint daher im rechten unteren Bereich öfter als andere Werte. Zur weiteren Beseitigung weniger wichtiger Informationsinhalte .... und absolut kann man diesen Effekt noch steigern, indem man zusätzlich die Absolutbeträge jeder Zelle senkt. Eine Lösung wäre zum Beispiel, bereits die linke obere Zahl um den Faktor 10 zu verkleinern und die restlichen Werte im zuvor vorgeschlagenen ansteigenden Verhältnis zu „drücken“. Damit beträgt der Teilerfaktor für die rechte untere Zelle 100. Dieses Vorgehen ist willkürlich und bedarf der Erprobung. Da eine Festlegung durch JPEG nicht erfolgt, könnte eine geeignete Teilertabelle, auch Quantisierungstabelle genannt, so aussehen: 10 12 14 17 20 23 27 32

Willkür ohne Gefahr

12 14 17 20 23 27 32 38

14 17 20 23 27 32 38 44

17 20 23 27 32 38 44 52

20 23 27 32 38 44 52 62

23 27 32 38 44 52 62 73

27 32 38 44 52 62 73 86

32 38 44 52 62 73 86 100

Die Faktoren sind Potenzen von 1.18, da 1.1814 ungefähr die Zahl 10 ergibt. Der Exponent 14 ist dabei der „rechtwinklige Abstand“ der Zellen von links oben nach rechts unten. Mit diesen

359

6 Datenkompression Werten entstehen nach Rundung die erwünschten zusätzlichen Nullen: 126 -1 0 0 0 0 0 0

Optimale Wege

Sternstunde für RLE

-12 -21 5 -2 0 0 0 0

-12 8 8 -3 2 0 1 1

4 7 -7 -1 0 -2 0 0

-2 -2 -2 2 0 0 0 0

0 0 0 0 0 0 0 0

0 0 0 0 0 0 0 0

0 0 0 0 0 0 0 0

Schritt 4: Die so veränderten Fourierkoeffizienten werden nun in eine lineare Reihenfolge gebracht, indem man sie, beginnend links oben, dann nach rechts, darauf diagonal schräg nach links unten und so weiter im „Zick-Zack“-Kurs einsammelt, also Zelle11, Zelle12, Zelle21, Zelle31, Zelle22, Zelle13, Zelle14, Zelle32 .....: 126, -12, -1, 0, -21, -12, 4,8,5,0, 0,-2,8,7,-2, 0,-2,-7,-3,0,0, 0,0,2,-1,-2,0,0, 0,0,0,2,0,0,0,0, 0,1,-2,0,0,0,0, 0,0,0,0,0,1, 0,0,0,0,0, 0,0,0,0, 0,0,0, 0,0, 0

Schritt 5: Da in dieser Folge viele Nullen hintereinander liegen, lässt sich zunächst die RLE-Komprimierung nach Kapitel 6.1.1 anwenden. Die Zahl 144 = 90Hex stellt hierbei das Sonderzeichen für den Zähler dar: 126, -12, -1, 0, -21, -12, 4, 8, 5, 0, 0, -2, 8, 7, -2, 0, -2, -7, -3, 0, 144, 4, 2, -1, -2, 0, 144, 5 2, 0, 144, 5, 1, -2, 0, 144, 9, 1, 0, 144, 15

Schritt 6: Dieses Ergebnis mit einer Kompressionsrate von 0.64

360

6.2 Verlustbehaftete Kompression

Huffman ohne Tabellenproblem

Es geht noch besser

Alles zurück!

„ . unsere Verluste hielten sich in Grenzen“

(warum?) wird seinerseits der Huffman- oder arithmetischen Codierung unterzogen. Insgesamt entstehen bei diesem und dem vorigen Schritt keine weiteren Verluste. Für die Huffman- oder arithmetische Codierung bietet es sich an, die Zahlenverteilung über alle Pixelblöcke eines Bildes zugrunde zu legen. Es kommt ja nicht auf die beste Kompression der einzelnen Pixelblöcke sondern auf das günstigste Ergebnis für das vollständige Bild an. Im vorliegenden Beispiel erreichen wir mit der Huffman-Codierung dieser 17 Zeichen einen Kompressionsfaktor von immerhin 0.47, insgesamt also 0.64 x 0.47 = 0.3 oder einen Gewinn von 70%. Dieses Ergebnis ist beachtlich, weil wir uns mit der kontrastreichen Linie ein recht anspruchsvolles Beispiel heraus gesucht haben (scharfe Kanten). Bei gleichmäßigen Grauflächen können in den Pixelblöcken noch weit höhere Einsparungen erzielt werden, im Mittel bis zu 95%, was zwar von der Art des Datenmaterials, aber auch von der Wahl der Quantisierungstabelle abhängt. JPEG wendet ein speziell auf Bilddatenquellen optimiertes RLEund Huffman-Verfahren an, das noch höhere Kompressionsvorteile erschließt. Hierzu gibt es eine Vielzahl von Literaturstellen, zu denen man sich am einfachsten einen Überblick mithilfe der JPEG-Internetseiten www.jpeg.org verschafft. Zum Beispiel wird nur beim ersten Pixelblock der linke obere Wert vollständig übertragen. Bei den folgenden beschränkt man sich auf die Differenz zum vorhergehenden Block, weshalb der Stellenumfang für diese Zelle insgesamt geringer ausfällt. Schritt 7: Auf der Empfängerseite wird die Huffman- und RLEcodierte Bitfolge zunächst wieder in den „gestauchten“ Fourierkoeffizientenblock decodiert und dieser mit der Quantisierungstabelle multipliziert. Der bei der anschließenden DCT-Rücktransformation gemäß Kapitel 6.2.2.4 und nach Rundung entstehende Pixelblock

lässt das Original trotz einiger Veränderungen immer noch ausreichend erkennen. Die Zahlenwerte geben etwas feinere Differenzierungen wieder, die aber in den Unterschieden der hier darstellbaren Graustufen nicht im vollen Umfang zu sehen sind, siehe die folgende Tabelle. Das beschriebene Verfahren befindet sich weiter im Gebrauch, mittlerweile wurden aber neue, noch

361

6 Datenkompression bessere (und aufwendigere) Kompressionstechniken in der Version JPEG 2000 bereitgestellt. Bestandteil hierin ist die WaveletKompression, siehe Kurzbeschreibung in Unterkapitel 6.2.5. 91 94 117 86 118 91 103 181

113 98 110 87 80 107 182 245

111 89 89 109 98 173 256 259

92 104 100 169 193 253 251 184

118 185 180 239 268 260 176 106

193 263 258 255 245 186 107 91

254 243 236 193 162 113 92 104

272 169 161 118 99 87 108 107

JPEG on Chips

Auch hierzu findet man über die bereits erwähnte Homepage der JPEG-Gruppe oder über Suchmaschinen unter den Stichworten jpeg und wavelet eine Fülle von Dokumentenverweisen. Außerdem bietet zum Beispiel der Hersteller ZORAN verschiedene Bausteine für die JPEG-Verarbeitung, so den JPEG Image Compression Processor ZR36050, den Integrated JPEG Processor und weitere.

6.2.4

MPEG

„.... etwas mehr Bewegung bitte!“

6.2.4.1

(Fast) nur Differenzen

362

Die Moving Picture Expert Group MPEG der ISO hatte 1988 das Ziel, Bildfolgen aus Videosequenzen und zusätzlich akustische Signale so darzustellen, dass sie in angemessener Qualität mit 1.5 MegaByte/s von Speichermedien wie zum Beispiel der CD übertragen werden können. Dieser klassische Standard hat die Bezeichnung MPEG-1 (ISO/IEC 11172). Mittlerweile gibt es neue, an weitere unterschiedliche Anforderungen angepasste Varianten, wie MPEG-2 (ISO/IEC 13818) mit Blick auf die Möglichkeiten der DVD (=Digital Versatile Disc ) oder MPEG-4 (ISO/IEC 14496) für individuelle Videoformate. Wie im Unterkapitel über JPEG werden hier nur einige Gesichtspunkte zu MPEG erläutert, um einen (sehr) groben Blick auf die prinzipiellen Abläufe möglich zu machen. Auch hier empfiehlt es sich, für aktuelle Detailinformationen die Internetseiten www.mpeg.gov der MPEG-Gruppe anzuwählen.

MPEG-1 Video Video-Einzelbilder werden mit MPEG-1 etwa so behandelt, wie JPEG-codierte. Wie diese bauen sie auf dem in Unterkapitel 6.2.3 angedeuteten Verfahren nach CCIR-601 auf. Da sich die Bildfolgen aber oft nicht wesentlich von ihren Vorgängern unterscheiden, steckt hier noch einiges an zusätzlichem Verdichtungspotenzial. Betrachtet man nur die Differenzwerte der zugeordneten Pixel aufeinanderfolgender Bilder, so kommt man mit kleineren Zahlen aus, was schon einmal den Darstellungsbereich

6.2 Verlustbehaftete Kompression verkleinert. Die Verdichtungstechniken werden darüberhinaus auf die Differenzwerte angewendet, wodurch weitere und längere Nullfolgen entstehen, die bei RLE-Kompression zusätzliche Gewinne bringen. Differenz falsch – Allerdings ist ein solches, auf Differenzbildung aufbauendes Bild kaputt Verfahren empfindlich gegen Übertragungsfehler. Tritt ein solcher auf, so stimmt die Bezugsdatenmenge nicht mehr und die Bildqualität leidet sichtbar. Daher muss in regelmäßigen Abständen immer ein vollständiges Bild als neue Ausgangsbasis gesendet werden. RahmenhandBei MPEG-1 sind 3 verschiedene Formate definiert: Intra-Frames lung (I) werden als vollwertige Einzelbilder ähnlich wie bei JPEG codiert. Predicted Frames (P) beziehen sich auf den nächsten oder vorherigen Intra- oder Predicted-Frame. Zu jedem 8]8-Pixel-Block wird dort ein möglichst ähnlicher gesucht und die Differenz dargestellt. Findet man keinen, so erfolgt die vollständige Codierung wie bei einem Intra-Frame. Die Bidirectional-Frames (B) beziehen sich sowohl auf einen vorhergehenden als auch auf einen nachfolgenden Intra- oder Predicted-Frame. Aus beiden werden diejenigen Blöcke heraus gesucht, deren Differenz möglichst nahe am gerade betrachteten Block liegt. Bei Videofolgen, in denen sich temporär wenig ändert, erzielt man hier entsprechend viele Treffer, und die Nullfolgen der zugeordneten DCT werden angenehm lang. Die Frames folgen beim Empfänger gemäß der Anordnung I B B P B B P B B P B B I B B.... Der P-Frame wird aber direkt aus dem anfänglichen I-Frame berechnet, erst danach lassen sich die B-Frames bestimmen. Die rechentechnische Abfolge ist also 1, 4, 2, 3, 7, 5, 6, 10, 8, 9, 13, 11, 12, 16, 14, 15,..... was beim Empfänger eine Zwischenspeicherung erfordert. Diese Hinweise sollen für den Video-Part genügen.

6.2.4.2

Gut Hören statt Sehen

MPEG-1 Audio Layer III und MP3 Zur Kompression der Audiodaten muss ein anderer Weg als bei der Bildkompression eingeschlagen werden. Der dort vertretbare Verzicht auf höhere Frequenzanteile würde bei akustischen Aufzeichnungen ein dumpferes Klangbild und eine Klangverfälschung bewirken, weil im Ausgangssignal weniger Obertöne enthalten wären, diese bei Musiksignalen aber maßgeblich die charakteristischen Klangfarben der Instrumente beschreiben. Die volle Bandbreite von etwa 20 KHz bleibt also notwendig. Hier helfen zwei spezielle Eigenheiten unseres Gehörsinnes: ¡ Die eine besteht darin, dass Frequenzanteile in einem

363

6 Datenkompression Ohr und Hirn: Das SuperDreamteam

... und immer wieder Huffman

akustischen Signal die unmittelbar benachbarten Komponenten dann „verdecken“, wenn letztere deutlich schwächer sind. In diesem Fall müssen sie nicht übertragen werden, da der Hörer sie ohnehin nicht wahrnimmt. ¡ Die andere folgt aus der Beobachtung, dass sich das Gehör nach Beendigung eines lauten Tones noch eine kurze Zeit „erholen“ muss, um für weitere Klangereignisse wieder voll aufnahmefähig zu werden. Da man in dieser kurzen Zeitspanne (und innerhalb dieses Frequenzbereichs) weniger hört, braucht man die darin liegenden Folgetöne ebenfalls nicht zu übertragen. Durch die komplexen Eigenheiten des Gehörsinnes bedingt trifft das sogar auf leise Passagen vor einem lauten Ereignis zu. Die Verarbeitung der Klangereignisse erfolgt also, bevor das Ergebnis in unser Bewußtsein gelangt, ein erstaunliches Phänomen! Insgesamt bieten diese beiden Eigenheiten in Verbindung mit der Huffman-Codierung ein Verdichtungspotenzial von über 90%. Ein Prinzip-Ablauf ist in Bild 6.5 dargestellt

Filter1

MDCT

s(Q) Filter2

MDCT

Filter32

MDCT

DFT/FFT

Berechnung von: - Quantisierungsfaktoren - Bitraten - Quantisierungsrauschen - Masken - Huffman-Codes

MP3Code

psychoak. Modell

Bild 6.5: Erzeugung des MP3-Codes aus den Abtastwerten s(Q) des Eingangssignals. MDCT ist eine rechentechnische Variante der DCT. Intelligent Design

364

Was sich so einfach liest, erfordert aber einige sorgfältige Vorbereitungen. Zunächst ist zu ermitteln, ¡ wie die Schwellwertkurven um die einzelnen Frequenzkomponenten und Folgetöne herum verlaufen, ¡ welche Abstände zwischen den zu übertragenden Frequenzanteilen noch zulässig sind, die so genannten kritischen Bandbreiten (critical bands).

6.2 Verlustbehaftete Kompression Gebildete Models

Stufenplan

Ideen-Reichtum

Durch statistische Messungen mit geschulten Versuchspersonen hat man diese Informationen in psychoakustischen Modellen erfasst und diese Modelle dann so angepasst, dass die überwiegende Mehrheit keine Unterschiede zwischen den Originalsignalen und denen aus der Verdichtung hervorgegangenen bemerkt. Im nächsten Schritt war ein Weg zu finden, um die Signalverdichtung in Echtzeit vornehmen zu können. MPEG-1 sieht hier drei so genannte Layer oder Ebenen vor, die sich in Aufwand und Leistung unterscheiden. Layer 2 etwa wird beim Astra Digital Radio-Verfahren (ADR) angewendet, welches eine gute, CD-nahe Stereo-Qualität produziert. Die einzelnen Layer sind aufwärtskompatibel, das heißt, eine Layer 1-Sequenz kann auf einem Layer 2- oder Layer 3-Decoder abgehört werden (aber nicht umgekehrt). Eine zusammenfassende Darstellung hierzu bieten Davis Yen Pan in „Digital Audio Compression“, Digital Technical Journal Vol. 5 Nr. 2, Frühjahr 1993 oder Andre Kappes in „Die Audiokodierung mp3“. Auf diese Dokumente kann man über das Internet zugreifen. Große Aktualität hat MPEG-1 Layer 3 dadurch erfahren, dass Musiksequenzen in CD-ähnlicher Qualität über das Internet übertragen oder kompakt gespeichert werden können. Das Verfahren wird mit der Bezeichnung MP3 abgekürzt und liegt in ähnlicher Form auch der – sich inzwischen wohl schon wieder zurückziehenden – MiniDisc-Technik zugrunde. Es wurde maßgeblich von einer Forschergruppe des Fraunhofer-Instituts mitgestaltet, die im Herbst 2000 hierfür einen Preis erhielt. Originalinformationen findet man über www.iis.fraunhofer.de/amm/techinf/layer3/index.html. Was sind die Grundzüge? Zunächst durchläuft das von einem AD-Wandler gelieferte PCM-Eingangssignal (s. u.) eines Stereokanals die parallele Anordnung von 32 Bandfiltern, die so genannte Filterbank, siehe Bild 6.5, mit den Bändern Band-Nr. 1 2 3 ..... 32 Bereich (Hz) 0 625 1250 ...... 31375 von bis 625 1250 1875 ...... 32000 Eigentlich müsste die Verteilung aufgrund der experimentellen Ergebnisse anders erfolgen, da die kritischen Bänder unten mit 0-50 Hz, 50-95 Hz, 95-140 Hz,... sehr schmal beginnen und erst allmählich breiter werden. Der Fehler lässt sich aber durch geschickte Kompensationsmaßnahmen so klein halten, dass er nicht stört. PCM ist die Abkürzung für Pulscodemodulation und bedeutet in diesem Fall, dass die kontinuierliche, verstärkte Mikrofon-

365

6 Datenkompression

Filterwirkungen

spannung s(t) als Folge von 16-Bit Abtastwerten s(QT) vorliegt. T ist die Zeitspanne zwischen zwei Abtastungen und beträgt bei 48 KHz etwa 0.00002 Sekunden (20 Ps). Die Ausgangsfolgen si(Q T) der einzelnen Filter (i=1, 2, ....., 32) enthalten aus dem Frequenzgemisch des Eingangssignals im Idealfall nur diejenigen Schwingungsanteile, welche von diesen durchgelassen werden. Bild 6.6 zeigt die Durchlasskurven zweier einfacher Bandfilter 2. Ordnung und verhält sich bereits wie eine „Mini“-Filterbank. Die Resonanzfrequenzen betragen fres1 =1000 Hz und fres2 =2000 Hz.

Bild 6.6: Durchlasskurven zweier Bandfilter mit verschiedenen Resonanzfrequenzen

Fj 2f

=

Fj 2 f

=

1 2

f f j 2 D 1 f0 f0 1

2

2

2D arg [ Fj 2 f ] = arctg

fres

=

2

f f 1 2D f0 f0 f f0

f 2 1 f0

12D f 2

0

Die vertikale Achse stellt die Beträge der oben als Formel dargestellten komplexen Filter-Übertragungsfunktion F(j2Sf) für den

366

6.2 Verlustbehaftete Kompression

Einstellungssache

eingeschwungenen Zustand dar. D ist der Dämpfungsfaktor, f0 die Resonanzfrequenz des ungedämpften Filters bei D = 0, fres die Resonanzfrequenz für 0 < D < 1. Über die Dämpfung lässt sich die Bandbreite des Filters einstellen, wie Bild 6.7a zeigt. Bei geringerer Dämpfung verschmälert sich die Bandbreite. Allerdings entsteht auch eine Phasenverschiebung der Komponenten, siehe Bild 6.7b.

Bild 6.7a: Betragsverlauf des Filterfrequenzganges bei gleicher Resonanzfrequenz, aber unterschiedlichen Dämpfungen (gestrichelt D2=0.02)

Bild 6.7b: Phasenwinkelverschiebung des Filterfrequenzganges bei gleicher Resonanzfrequenz, aber unterschiedlichen Dämpfungen (gestrichelt D2 = 0.02) Wirkungsvoll

Die Wirkung solcher Bandfilter lässt sich an einem Signalgemisch s(t) aus 4 Sinusfunktionen gleicher Amplituden aber unterschiedlicher Periodendauern zeigen, Bild 6.8. Die Komponenten haben 500 Hz, 1000 Hz, 2000 Hz und 4000 Hz. Speist dieses Gemisch das Bandfilter mit der Resonanzfrequenz fres = 1000 Hz, so wird die Komponente mit 1000 Hz heraus gefiltert und zwar umso besser, je kleiner die Dämpfung ist, siehe Bild 6.9a.

367

6 Datenkompression

Bild 6.8: Signalgemisch aus 4 Sinuskomponenten .... elementar, doch oft Mauerblümchen: Die Winkelverschiebung

Entsprechend liefert das Filter mit fres = 2000 Hz im wesentlichen die Sinuskomponente mit 2000 Hz, wie es Bild 6.9b illustriert. In beiden Diagrammen zeigt sich im übrigen auch die Phasennacheilung.

Bild 6.9a: Filterwirkung eines Bandfilters mit der Resonanzfrequenz 1000 Hz auf ein Eingangssignal aus 4 Frequenzkomponenten (eingeschwungener Zustand)

Bild 6.9b: wie Bild 6.9a, aber Resonanzfrequenz 2000 Hz ... anpassungsfähig ...

368

Mit Filtern höherer Ordnung können größere Bandbreiten bereitgestellt werden, die mehrere Komponenten eines Bandkanals durchlassen, die übrigen aber sperren. Das Prinzip ist aber das

6.2 Verlustbehaftete Kompression gleiche. Die Berechnung der einzelnen FilterausgangsKomponenten erfolgt für den eingeschwungenen Zustand nach folgender Beziehung: si t = F1 2 500 sin2 500 t argF 1 2 500 F1 2 1000sin2 1000 t argF 1 2 1000 F1 2 2000sin 2 2000 t argF 1 2 2000 F1 2 4000sin 2 4000 t argF 1 2 4000

F1 ist dabei der Frequenzgang des Bandpassfilters für 1000 Hz nach Bild 6.6. Nur für die Frequenz 1000 Hz hat dieses Filter den maximalen Betrag, alle anderen Frequenzanteile werden abgesenkt. Während es vor Verfügbarkeit der Digitaltechnik notwendig war, solche Filter mit elektrischen Schwingkreisen zu realisieren, die Platz erfordern und aufwendig zu justieren sind, verwendet man heute dort, wo es sich anbietet, geeignete Rechenverfahren, welche sich mit schnellen digitalen Signalprozessoren (DSPs) in Echtzeit abarbeiten lassen und eine hohe Flexibilität bei der Gestaltung der Filterparameter garantieren. Wie diese Filter arbeiten, beschreiben viele Lehrbücher der Nachrichten- und Regelungstechnik, zum Beispiel das von W. Leonhard, „Diskrete Regelsysteme“, BI-Verlag. Für die Filterbank verwendet man Bandpässe mit jeweils benachbarten Resonanzfrequenzen. Willkommene Dif- Die prinzipielle Wirkung jedes einzelnen Bandfilters im vorliegenden Beispiel kann durch eine Differenzengleichung ferenzen folgender Form nachgebildet werden, bei der man die Abtastwerte s((Q1) 'W) = s(Q1) einspeist Bodyguards am Durchlass

si = c 1 si 1 c 2 si 2 r1 s 1

und die Abtastwerte si(Q) am Ausgang erhält. Dem komplexen Frequenzgang F(j2Sf) des Filters im Kontinuierlichen entspricht die Impulsübertragungsfunktion F(z) für abgetastete Signale: z *T p mit z = e , z2 c 1 z c 2 = komplexe Frequenz = j 2 f

Fz = r1 p

Lizenz für Echtzeit

In den Koeffizienten c1, c2 und r1 stecken die Filterparameter f0 und D. Da diese Koeffizienten nur einmal berechnet werden müssen und sich dann als Konstanten programmieren lassen, ist ersichtlich, dass die Differenzengleichungen mit geringem Aufwand in Echtzeit abgearbeitet werden können. Eine Alternative besteht in der Nutzung der diskreten Impulsantwort des Filters und die Berechnung des Ausgangssignals si(Q) über die Faltungs-

369

6 Datenkompression

Eine Mutter mit vielen Kindern

summe. Layer 3 verwendet einen rechentechnisch optimierten Weg mit so genannten Polyphase-Filtern, deren Aufbau z. B. bei Dieter Brückmann in „Höhere Integration mit niedrigerer Zwischenfrequenz“, Elektronik Wireless, Oktober 2004, beschrieben ist und über www.elektroniknet.de/topics/baulelemente/ abgerufen werden kann. Die Bandfilter sind dabei nicht gemäß Seite 367 individuell für ihre jeweilige Mittenfrequenz aufgebaut, sondern nutzen die Möglichkeit, den komplexen Frequenzgang eines Referenztiefpasses erforderlicher Bandbreite zu gleichartigen Bandpässen gewünschter Mittenfrequenzen zu verschieben. Man kann z. B. von einem Tiefpass 1. Ordnung der Bandbreite fB ausgehen und daraus durch Verschiebung um iYfres, i = 0, 1, 2, 3, .... 31, die benötigten 31 zusätzlichen komplexen Bandfilter-Frequenzgänge für die Filterbank herstellen: F Tiefpass j 2 f =

1 f fb 1 , fif res

1 j f Bandpass j 2 f = 1 j

i=0, 1, 2, .... ,31

fb

In der diskreten Version wird wegen z = e

Rechnen: Total ausgebufft

Daten-Tsunami

370

Tp

z' = e

Tp j 2 f res

T2 f res

= ze

in die zugeordneten Differenzengleichungen eingesetzt, was nach einigen Zwischenschritten und unter Verwendung der im MPEG-Standard veröffentlichen Filterkoeffizienten und weiterer Parameter schließlich die Aufwands-minimierten Filterbeziehungen für den MP3-Algorithmus ergibt, wie im oben genannten Dokument von Davis Pan beschrieben ist. Aus einem Übertragungsblock (=Frame) von 32Y36=1152 Abtastwerten (=Samples) des analogen Eingangssignals, der Zeitspanne 21 Ps1152 = 24 ms entsprechend, werden die ersten 32 Werte entnommen und daraus über die Filterdifferenzengleichungen für jedes der 32 Filter je ein gefilterter Ausgangswert s i berechnet, siehe Bild 6.5. Nach 36 verarbeiteten Sample-Blöcken a 32 Werte stehen also an jedem Filterausgang 36 Samples zur weiteren Verarbeitung bereit. Diese durchlaufen in Blöcken zu je 12 oder 36 eine Fourier-Transformation mit dem DCT-Verfahren, hier MDCT genannt (=modifizierte DCT, im Prinzip die eindimensionale DCT). Anhand der nun vorliegenden Frequenzspektren kann man entscheiden, welche Komponenten tatsächlich in diesem Zeitblock

6.2 Verlustbehaftete Kompression Maskenbälle

Gehörbildung

von ca. 24 Millisekunden Dauer enthalten sein müssen. Auf jedes der 32 Filter-Ergebnisse wird dazu die entsprechende Maskenfunktion gemäß Bild 6.10 angewendet. Welche der theoretisch unendlich vielen Masken im jeweils aktuellen Fall einzusetzen ist, wird mit Hilfe der parallel über den gesamten Frame berechneten FFT bestimmt.

Bild 6.10a: Maskenfunktion für benachbarte Frequenzkomponenten. Die starke Komponente bei 3 KHz maskiert die links daneben und die beiden rechts liegenden Komponenten, während die dritte von rechts noch „durchschlägt“. Alle Frequenzanteile, die sich zum aktuellen Zeitpunkt unter dem von einer starken Komponente aufgespannten „Maskenhügel“ befinden, siehe Bild 10a, werden vom Gehör nicht wahrgenommen und erhalten im Ergebnisspektrum für dieses Band den Wert 0. Ähnliches gilt für leise Signalanteile, die zeitlich nach dem lauten Signal erscheinen, siehe Bild 10b.

Bild 6.10b: Maskenfunktion für die temporale Wirkung: Ein starkes Signal zum Zeitpunkt t = 0 überdeckt für einige 50 ms leisere Ereignisse und überraschenderweise für einige Millisekunden auch kurz davor liegende. Wie dort auch zu sehen ist, wird wegen des komplexen Verarbeitungsprozesses akustischer Signale im System von Ohr und

371

6 Datenkompression (Konten-) Überde- Gehirn ein leises Signal für eine kurze Zeitspanne über etwa 5 ckung ms sogar von einem erst später eintretenden lauten Folgesignal überdeckt. Die nach diesen Maskierungen übrig gebliebenen Wertefolgen werden anschließend noch mit dem verlustfreien Huffman-Verfahren verdichtet. Das Ergebnis ist, zusammen mit den in jedem Frame verwendeten Huffman-Tabellen und weiteren Informationen der gewünschte MP3-Code. Das Datenvolumen wurde auf etwa 8 – 10 % gesenkt, ein erstaunlich niedriger Wert. Das Dekodieren des Codes im MP3-Player ist sehr viel weniger aufwändig, da nur die decodierten Frequenzanteile über die MDCT-Rücktransformation wieder in Abtastwerte des akustischen Zeitsignals umgesetzt werden müssen. Die komplexe Maskenverarbeitung fällt vollkommen weg Was hier insgesamt zum MP3-Verfahren sehr kurz zu schildern Lobeshymne versucht wurde, erfordert offensichtlich eine Vielzahl kluger Anpassungen und Optimierungen der theoretischen Verfahren an die Anforderungen für den praktischen Einsatz. Deshalb darf man ruhig etwas staunen, wenn man beim Hören eines MP3Files oder einer ADR-Sendung (Astra Digital Radio) die gebotene Klangqualität und Rauscharmut genießt – auch dann, wenn es vielleicht nicht immer ganz der CD gleichkommt, über die aber selbst die Supercracks nicht einer Meinung sind. Mittlerweile wurde die zu MP3 kompatible Variante MP3Pro entwickelt. Sie beansprucht bei gleicher Qualität nochmals weniger Speicherplatz. Ein normaler MP3-Datenstrom von 100 Kbit/s kommt hier bereits mit 64 Kbit/s aus. Allerdings ist der Rechenaufwand um den Faktor 3 höher. Z. Z. (Juni 2006) erscheint es nicht sicher, dass sich diese Variante durchsetzt. Mehr Chancen hat hier möglicherweise das zu MP3 – allerdings inkompatible – Verfahren MPEG-2 AAC (Advanced Audio Coding), welches ebenfalls höhere Kompressionsraten ergibt.

6.2.5

FT: Klasse, aber begrenzt

372

Konkurrenz: Fraktale und Wavelets Obwohl sich die Fourier-Transformation als vorbereitendes Werkzeug für die Kompression recht gut eignet, gibt es Grenzen für ihre Leistungsfähigkeit. Das liegt vor allem daran, weil in der zu verdichtenden Funktion s(t) oder s(x) durch die Mittelwertbildung mit den „maskierenden“ Sinus- und Cosinusfunktionen kontrastreiche Details, zum Beispiel steile Flanken, leicht untergehen. Dies lässt sich nur durch Berücksichtigung einer sehr viel größeren Zahl von Oberwellen verbessern. Um den damit verbundenen Rechenaufwand in Grenzen zu halten, muss man sich eventuell mit fehlerbehafteten Näherungen begnügen, oder man verkleinert die Zeitabschnitte, für die die Fourier-Transformation durchgeführt wird. Das hat aber eine nachteilige Folge. Das Ergebnis jeder Transformation gilt immer nur für den

6.2 Verlustbehaftete Kompression

Sinus/Cosinus: Harte Umwelt gegen weichen Charakter

Maskenwechsel

gerade bearbeiteten Abschnitt und „weiß“ nichts vom vorhergehenden. An den Abschnittsgrenzen ergeben sich daher Abweichungen, die sich im Ergebnis des rücktransformierten Signals störend bemerkbar machen. Dieser Effekt wird umso stärker, je kleiner die Abschnitte zu wählen sind, z. B. wegen höherer Auflösungen der Pixel oder geringerer Abtastzeiten bei akustischen Signalen. Den Mangel bei Erfassung und Wiedergabe steiler Verläufe lässt Bild 6.11 erkennen. Die Flanken in der Funktion s(t) oder s(x) gehen durch die Integration von s(t)Ycos(ZYt) unter und können auch bei Berücksichtigung sehr vieler Koeffizienten (=Oberwellen), nicht beliebig genau angenähert werden. Hier stört zusätzlich auch das Gibbs’sche Phänomen, nach dem der Fehler bei der Nachbildung von Unstetigkeitsstellen in s(t) selbst bei großer Auflösung prinzipiell nicht zurückgeht.

Bild 6.11: Steilflankiges Originalsignal s(t) und die Wiedergabe aus der inversen Fourier-Transformation bei verschiedenen Abtast-raten nab. Auch bei Inanspruchnahme sehr vieler Fourierkoeffizienten gelingt die Nachbildung an den Flanken nicht. Die mit diesen Besonderheiten verbundene Begrenzung für den Einsatz der Fourier-Transformation lässt sich entschärfen, wenn einerseits für die Zerlegung des Signals s(t) längere Abschnitte gewählt werden dürfen, da sich dann die Zahl der Differenzen an den Abschnittsgrenzen verkleinert und andererseits geeignetere Basis- oder Maskenfunktionen verwendet werden. Letztere

373

6 Datenkompression

Starke Familien

AnpassungsSpezis

sind in großer Vielfalt Bestandteile der Wavelet-Transformationen. Die Technik der Wavelets ist bereits bei JPEG 2000 im Einsatz, wenn sie auch wegen der oft noch fehlenden Darstellungsmöglichkeit über die gängigen Browser zur Zeit (Juni 2006) nur beschränkt genutzt werden kann. Während die Fourier-Transformation als Basisfunktionen die Sinus- und die Cosinus-Funktion verwendet, sind es bei der Wavelet-Technik so genannten Wavelet-Familien. Deren Namen leiten sich häufig von ihren Erfindern ab: Daubechies, Haar und weitere. Die beiden Grundeigenschaften jeder Wavelet-Funktion sind die Skalierbarkeit (vergleichbar der Amplitude der Cosinusfunktion) und die Verschiebbarkeit (die es in der Fourier-Transformation nicht gibt). Beide gestatten eine feinere Anpassung an ein gegebenes Signals und damit das bessere Herausarbeiten sowohl tiefer als auch hoher Frequenzanteile. In den Bildern 6.12a und 6.12b ist versucht worden, den Grundgedanken grob zu beschreiben.

Bild 6.12a: Zur Wavelet-Transformation: Oben: Signal s(t) oder s(x)

Wavelet-Transformation und FT: beide KKF's

374

•

Links Mitte: Mother-Wavelet (t), hier als Funktion nach Haar

•

Links unten: Produkt s(t)·(t), über das durch Integration wie bei der Fourier-Transformation der Mittelwert gebildet wird und einen der Wavelet-Koeffizienten ergibt

•

Mittlere und rechte Spalte: Baby-Wavelets der zweiten Skalierungsstufe und beide hiermit möglichen Translationen sowie die Produkte mit s(t)

Die Wavelet-Koeffizienten wv(W,l) errechnen sich wie bei der Fourier-Transformation als Integrale über Produkte des Signals s(t) mit den Wavelet-Funktionen <(t), von denen es allerdings sehr verschiedene Typen gibt.

6.2 Verlustbehaftete Kompression wv /,l =

1

s t 0 l

t/ dt l

Eine Übersicht findet sich bei Ingrid Daubechies, „Orthonormal bases of Compactly Supported Wavelets“, Comm. Pure Appl. Math., Vol 41, 1988, Seiten 906-966.

„ ... wir wollen senkrecht zu einander stehen“

„Onkel (FT) und Tante (WT), ja das sind Verwandte ...“

Bild 6.12b: Zur Wavelet-Transformation: wie zuvor, aber BabyWavelets der dritten Skalierungsstufe und die 4 Translationen Da Wavelet-Funktionen wie die Sinus- und Cosinusfunktion orthogonal (sowie möglichst auch stetig differenzierbar) sind, ergeben nur diejenigen Integranden einen von Null verschiedenen Integralwert, bei denen im Signal s(t) ein zum aktuellen Wavelet ähnlicher Anteil vorhanden ist. Das entsprechende Wavelet maskiert also das Signal wie die Cosinus- oder Sinusfunktion in der Fourier-Transformation, siehe auch Seite 344. Statt des Index für die Frequenz sind die Koeffizienten durch den Skalierungsfaktor l und den Translationsparameter W bestimmt, deren Wirkung sich besonders in Bild 6.12b erkennen lässt. Die Rücktransformation erfolgt wiederum ähnlich zu der inversen Fourier-Transformation aus den ermittelten Wavelet-Koeffizienten und den verwendeten Wavelets selbst. Sehr vereinfacht dargestellt hat die Rücktransformation in der diskreten Form die folgende Form: s t =

wv/ ,l0/ ,l t / ,l

Die Wavelet-Technik bietet gegenüber der Fourier-Transformation besonders bei hohen Kompressionsraten ab 0.02 bis 0.01 qualitative Vorteile, die allerdings durch einen höheren Berechnungsaufwand erkauft werden müssen. Im Internet findet man auch hierzu wieder eine Fülle von Dokumentenverweisen. Sehr informativ sind zum Beispiel „The Wavelet Tutorial“ von Robi Polikar mit vielen Grafiken oder „Amara‘s Wavelet Page“ von Amara Graps.

375

6 Datenkompression Auch die Technik der Fraktale hat zum Ziel, einen gegebenen Funktionsverlauf mit wenigen Parametern möglichst gut anzupassen. Statt Basisfunktionen wie Sinus- und CosinusSchwingungen oder Wavelets verwendet man hier aber Grundmuster, die in den Pixelblöcken eines Bildes bereits vorhanden sind und durch Drehen, Verschieben, Spiegeln und Zoomen andere Pixelblöcke angenähert mit nur geringen Fehlern wiederMusterknaben ge- geben. Die Idee erinnert entfernt an die Mustersuche beim LZWVerfahren und geht auf den Mathematiker Benoit B. Mandelbrot sucht! zurück, der diese 1977 in seinem Buch „The Fractal Geometry of Nature“ veröffentlichte. Fraktale sind merkwürdige mathematische Objekte und weisen gebrochenzahlige Dimensionen auf. Viele kennen die „Apfelmännchen“. Sie entstehen, wenn man die rekursive Folge mit der komplexen Konstanten c Das Heer der Gebrochenen

zk 1 = z2k c , k = 1, 2, 3, 4,. .. c=a bi, i= 1, z1 =0 berechnet und alle Werte für c in die komplexe Ebene als Punkte einträgt, für die diese Folge konvergiert. Das Ergebnis zeigt Bild 6.13a. Im übrigen gibt es eine Vielzahl „schönerer“ Bilder von Apfelmännchen, bei denen zusätzlich auch die Divergenzgeschwindigkeit einbezogen und alles über Farb- oder Grauwerte dargestellt wird

Verdichtungsquelle „Selbstähnlichkeit“

376

Bild .6.13a: Mandelbrotmenge in der komplexen Ebene Was nach Spielerei aussieht, erweist sich als für den praktischen Gebrauch sehr nützlich. Engt man nämlich durch Zoomen den Darstellungsbereich auf dem dunklen Rand ein, so zeigt auch der vergrößerte Rand ähnliche Strukturen, wie im Bild 6.13b im Bereich oberhalb von -0.82 < Re[c] < -0.7 zu sehen ist ( die erste große „Kerbe“ links) Für den Zoomfaktor gibt es keine Begrenzung, man kann also den Ausschnitt beliebig klein machen. Es ist ähnlich wie bei einem Blick aus dem Flugzeug: Ein Küstenstreifen kommt einem aus großer Höhe vielleicht recht „glatt“ vor, fliegt man tiefer, of-

6.2 Verlustbehaftete Kompression fenbaren sich auf einmal feinere Details. Und geht man dann am Strand spazieren, zeigt der Sand weitere, vorher unbeobachtbare Einzelheiten.

Bild 6.13b: Beim Zoomen auf den Rand trifft man immer neue selbst-ähnliche Punktmengen. Diese sich bei den Fraktalmengen besonders deutlich zeigende Einfache ZutaEigenschaft der Selbstähnlichkeit ist auch in „normalen“ Bildern ten... zu finden und kann folgendermaßen genutzt werden: ¡ Man zerlegt ein Bild (etwa die Funktion s(x,y)) in Teilbilder oder Pixelblöcke, die nicht notwendigerweise gleichgroß sein müssen. Die Größe hängt vielmehr davon ab, wie viele Details sich in einem Abschnitt befinden. ¡ Unter Drehen, Verschieben, Spiegeln und Zoomen vergleicht man das Muster mit denen weiterer Pixelblöcke. ¡ Ist das vorgegebene Ähnlichkeitsmaß, z. B. eine minimale Summe der quadrierten Pixelwertdifferenzen, erreicht, so speichert man statt des Pixelblockes nur die Ähnlichkeitsparameter wie Drehwinkel, Verschiebebetrag usw. ab, deren Umfang wesentlich unter dem für einzelne Pixel des Blockes selbst liegen (vergleichbar dem LZW). Mordsaufwand ... Der Aufwand für das Ergebnis steckt in der Zahl der Operationen, welche zur Feststellung der Ähnlichkeit erforderlich sind, die Qualität wird entscheidend vom Ähnlichkeitsmaß bestimmt. Hierfür gibt es daher auch unterschiedliche Ansätze. Der erzielbare Gewinn liegt allerdings im Mittel deutlich höher als bei Super-Ergebnis der JPEG-Technik und gestattet Kompressionsraten um 0.01 und besser. Insgesamt befindet sich diese Technik aber noch in der Entwicklung für den praktischen Einsatz. Diesen sehr groben Hinweisen auf ein weiteres hochinteressantes neues Gebiet der Datenkompressionstechniken steht eine Fülle von Literatur für die eingehende Beschäftigung gegenüber. Neben den Dokumentenverweisen im Internet ist unter anderem als Literatur das Buch „ Fractal Image Compression“, 1993, von Michael Barnsley und Lyman Hurd zu nennen.

377

6 Datenkompression

6.2.6

Was blieb? 1.

2.

3. 4.

5.

6. 7. 8.

378

Kann man aus einer DFT für ein Signal mit den Frequenzkomponenten f, 1.1 f, 1.2 f, 1.3 f, 2 f, 2.4 f, 3 f, 4 f wieder das vollständige Signal zurückgewinnen? Die DCT ist eine verlustfreie Transformation. Warum entstehen bei JPEG im DCT-Schritt dennoch bereits erste kleine Verluste? Warum nennt man die bei MPEG eingesetzte Filteranordnung Polyphase-Filterbank? Wie groß ist bei MP3 die Abtastrate für das Analogsignal? Welche Wirkung auf das Ergebnis hat eine Verlängerung der Abtastrate? Welche Wirkung auf das Ergebnis hat es, wenn für die DFT statt der Abtastwerte des bandbegrenzten Eingangssignals die des ungefilterten Signals verwendet werden? Welche Eigenschaft zur Datenreduktion von Videosequenzen macht man sich bei MPEG zunutze? Welche Transformationen verwendet JPEG2000? Welche Werkzeuge und Kriterien sind geeignet, bei Fraktalkompressionsverfahren Ähnlichkeiten zwischen Pixelblöcken zu finden und das Ergebnis festzustellen?

7

Literaturauswahl Zum Gebiet der Codierungsverfahren gibt es eine Fülle von Büchern und Artikeln, in denen Übersichten und Einzelheiten dargestellt sind. Die zugrunde liegende Mathematik gehört überwiegend zum Gebiet der Zahlentheorie. Vielen ist diese (Wunder-) Welt zunächst nicht geläufig, die Beschäftigung mit ihr – und wenn es nur in diesem ganz speziellen Rahmen ist – , belohnt aber mit reichhaltigen, vielseitigen Erkenntnissen. Auf Spezialaufsätze wird im Text verwiesen. Das vorliegende Buch unterstützt das Erreichen der im Unterkapitel 1.5 skizzierten Ziele. Zur Ergänzung kann die nachfolgend genannte Literatur hinzugezogen werden (auf jeden Fall sollte nach dem Durcharbeiten dieses Buches hier eine gute Grundlage zum tieferen Einstieg geschaffen sein, sofern dieser erforderlich ist): Jiri Adamek: Foundations of Coding, 1991, John Wiley, ISBN 0471-62187-0 (guter Überblick zur Datenfehlerbeseitigung, sehr ausführlich, mit kurzem Ausblick auf Verschlüsselungsverfahren) W. Wesley Peterson und E.J. Weldon: Error correcting methods, 1971, MIT Press, Cambridge (etwas älterer, aber sehr umfassender "Klassiker" zur Datenfehlerbeseitigung) Steinbuch, Rupprecht: Nachrichtentechnik Band 3, Nachrichtenverarbeitung, 1982, Springer-Verlag (zur Nachrichten- und Informationstheorie) Albrecht Beutelsbacher: Kryptologie, 1991, Vieweg, ISBN 3-52818990-8 (sehr gut und leicht zu lesender, sehr fundierter Überblick auf die Verschlüsselungsverfahren) Albrecht Beutelsbacher, Jörg Schwenk, Klaus-Dieter Wolfenstetter: Moderne Verfahren der Kryptographie (von RSA zu ZeroKnowledge), 1995, Vieweg, ISBN 3-528-06590-7 (eine vorzügliche Ergänzung zum vorgenannten Werk, was weitere neue Verfahren kompakt darstellt) Martin E. Hellmann: Die Mathematik neuer Verschlüsselungssysteme, Spektrum der Wissenschaften, Heft 10/1979 (mit Beispielen versehener, gut verständlicher Kurzbeitrag zur Verschlüsselung; von einem der bekanntesten Wissenschaftler dieses Fachgebiets) DTV-Atlas Mathematik, Band 1, ISBN 3-423-03007-0 (als Nachschlagewerk für Fragen der Mathematik), zum Einstieg in die – nicht minder – interessanten Nachbargebiete unter anderen geeignet. Hans Riesel: Prime Numbers and Computer Methods for Factor-

379

7 Literaturauswahl ization, 1985, Birkhäuser, ISBN 0-8176-3291-3 (Mathematische Grundlagen für die modernen Verschlüsselungsverfahren) Ian Stewart, David Hall: Algebraic Number Theory, 1986, Chapman and Hall (Grundlagen der Zahlentheorie) Jörg Sauerbrey: Langzahl-Modulo-Arithmetik für kryptographische Verfahren, 1993, Deutscher Universitäts Verlag, ISBN 3-8244-2048-1 Ingrid Schaumüller-Bichl: Sicherheitsmanagement, BI-Verlag, ISBN 3-411-15501-9 (Schwerpunkte sind hier zwar Fragen der Informationssicherung, das Buch enthält u. a. aber auch kurze Beschreibungen verschiedener aktueller Verschlüsselungsverfahren (z.B DES) und gibt dazu interessante Bewertungen zur Leistungsfähigkeit) Charles P. Pfleeger: Security in Computing, 1989, Prentice-Hall International Editions, ISBN 0-13-799016-2 (enthält im Abschnitt 3 einige kurzgefaßte Darstellungen zu Verschlüsselungstechniken, setzt sich aber hauptsächlich mit den interessanten Fragen der Informationssicherung auseinander) Heider, Kraus, Welschenbach: Mathematische Methoden der Kryptoanalyse, 1985, Vieweg, ISBN 3-528-03601-X (behandelt ausführlich die mathematischen Grundlagen der Verschlüsselungsverfahren, u. a. auch diejenigen der Primzahlenerzeugung; als Ergänzung zum Buch von Beutelsbacher zu empfehlen) Kiyek/Schwarz: Mathematik für Informatiker 2, 1991, Teubner, ISBN 3-519-02278-8 (als umfassendes Nachschlagewerk für Fragen der Informatik, allerdings für den Ingenieur nicht gerade leicht zu lesen; ein Schwerpunkt ist unter vielen anderen die Erzeugung großer Pseudoprimzahlen) W. Leonhard: Statistische Analyse linearer Regelsysteme, 1973, Teubner, ISBN 3-519-02046-7 (sehr praxisorientierte Ergänzung speziell zu den im Kapitel 5 verwendeten Korrelationsverfahren) Rafael C. Gonzalez, Richard E. Woods: Digital Image Processing, 1992, Addison-Wesley Publishing Company (Ein Überblick auf die Verfahren der Bildverarbeitung) Lüneburg: Galoisfelder, Kreisteilungskörper und Schieberegisterfolgen, 1979, ISBN 3-411-01566-7 (mathematisch sehr interessante Ergänzung speziell zu den im Kapitel 5.1 behandelten Schieberegistern). Gunter Lepschies: E-Commerce und Hackerschutz, 2.Auflage 2000, Vieweg-Verlag, DuD-Fachbeiträge, ISBN 3-528-15702-X (kompakter Überblick auf technische und organisatorische Lösungen bei der Abwicklung von Geschäften mit elektronischen Medien, zum Beispiel über das Internet, als wesesentliche Ergänzung und Erweiterung der in Kapitel 6 behandelten Themen)

380

8

Sachwortverzeichnis

A a posteriori-Ergebnisse 221 a posteriori-Werte 222 a priori-Werte 222 Absenderidentität 314 Absolutwert 358 Abstandstabellen 25 Abtastfrequenz 338 Abtastintervall 347 Abtasttheorem 16, 21, 85, 340 Abtastwert 20f., 338, 366 Abtastzeitpunkte 337 Abweichungssumme 64 AD-Wandler 365 Addition = Subtraktion 236 Additionsgruppe 38 ADR 365 Advanced Audio Coding 372 Advanced Encryption Standard AES 267, 278 ähnliche Struktur 20 Ähnlichkeitsmaß 377 Ähnlichkeitsparameter 377 AKF 240, 249f. algebraische Körpererweiterungen Amplituden- und Phasenspektrum Amplitudenfaktor 345 Amplitudenmodulation 21 Amplitudenspektren 338 Amplitudenwert 86 Analog-Digital-Wandler 20, 337, Apfelmännchen 20, 376 Argumentenverlauf 346 arithmetische Codierung 12, 333, ASCII-Code 2 ASCII-Zeichen 6

267

Assoziativgesetz 35 Astra Digital Radio 365 asymmetrische Schlüsselstruktur asymmetrische Verfahren 314 asymmetrische Verschlüsselung asymptotisch guter Code 78, 142, asymptotisch schlechter Code asymptotisches Verhalten 141 Audiosignale 12, 338 Aufbrechversuch 257 Auftrittswahrscheinlichkeit 14 aufwärtskompatibel 365 Ausgangsfolgen 226, 229 Ausgangsspannung 337 äußerer Code 207 Authentikation 303 Authentikationsprotokoll 303 Autokorrelationsfunktion 239 AWGN 47

285 278, 295 154 78, 154

B

40, 42 339

341

361

bandbegrenztes Sendesignal 344 Bandbegrenzung 349 Bandbreite 16, 21, 47, 67, 73, 82, 363 Bandfilter 365f. Bandkanal 368 Bandpassfilter 369 Basis 2 14 Basis-Folgen 232 Basisband-Modulation 21 Basiscodewörter 98, 119 Basisfunktion 373 Basisschlüssel 256 Basisvektoren 201f. Basiswörter 119, 166 Bayes'sche Beziehung 48, 216ff. BCH-Code 11, 54, 101

381

8 Sachwortverzeichnis Codealphabet 4 BCJR-Algorithmus 234 Codec 333 bedingte Entropie 14 Codelänge 115 bedingte Verteilungsdichte 217 Codewort 12 bedingte Wahrscheinlichkeitsdichte 219 Codewortbit 15, 60 Beispiele für Codes 1 Codewörter 8 Bellman'sches Optimalitätsprinzip 229 Codewortpolynom 103, 105 Benutzer-Authentikation 266 Codewortvektor 96 Betragsverlauf 346 Codierungsverfahren 4 Bidirectional-Frames 363 Coding Gain 80 Bilddaten 12, 338 constituent codes 224 Binär-Äquivalent 279 Convolutional Codes 212, 225 Binärbaum 327 Cosinusfunktion 356 Binärcode 22 Cosinusschwingung 20 Binärdarstellung 335 CRC 159 binäre Quelle 14 CRC-CCITT-Polynom 159 binärer Code 32 CRC-Codes 3 Binärfolgen 335 critical bands 364 Binärsignal 90 Cyclic Redundancy Check 159 Binärsystem 12, 32 bipolar 82 D bipolare Sendesignale 88, 90, 92 Dämpfungsfaktor 367 Bit-Volumen 338 Data-Encryption-Standard 266 Bitfehler 72 Datenkompression 19 Blockcodes 13 Datenreduktion 358 Brute Force 24, 54, 257, 266, 300 Datensicherungsverfahren 264 BS7799-Standard 264 Daubechies 374 BSI 263 dB 17 Bündelfehler 101 DCT 20, 341 Bundesamt für Sicherheit in der InformationsDecodieraufwand 229 technik 314 Decodierung 16, 133, 192 Bundesdatenschutzgesetz 265 Demodulator 14 Bundesministerium für Wirtschaft und Technologie DES 266 318 DES-Algorithmus 267 C DES-Schlüsselerzeugung 269 Charakteristik 42, 123, 172 DES-Verfahren 255 Chase 65 DES-Verschlüsselung 275 chosen plaintext- Angriff 301 deziBel 17 Chrominanz 358 DFT 20, 340 Cipher-Block-Chaining-Verfahren 311 differentielle Kryptoanalyse 276, 301 Code 12 Differenzengleichung 369 Code-Definition 4 Differenzwerte 362 Code: (n,k,dmin) 18 Diffie-Hellmann-Schlüsseltausch 301

382

Digital Signature Algorithm 314 Digital Signature Standard 314 digitale Signalprozessoren 369 digitale Signatur 313 digitale Unterschrift 315 Digitaltechnik 369 Disaster Recovery 266 Diskrete Cosinus-Transformation 20, 341, 349 Diskrete Fourier-Transformation 20, 340, 346 diskrete Störimpulse 50 diskrete Zeitfunktion 237 diskreter Logarithmus 302, 314 Divergenzgeschwindigkeit 376 Divisionsrest 101, 158 Divisionsrest-Verfahren 102 Drahtleiter 14 Drehen 376 Dreiecksform 163, 259 Dreiecksmatrix 164 Dreiergruppen 328 DSA 314 DSP 369 DSS 314 duale Codes 224 Dualzahlen 335 Durchlasskurven 366 dynamische RAMs 65

E EAN-Code 2 ebene Schwingungen 359 EBR 19 Effektivwert 14, 249f. Eindringtiefe 227 Einflusslänge 227 Eingangskanal 249 Einsbit 218 Einspar-Potenziale 337 Einswort 60 Einwegfunktion 310 Einzelwahrscheinlichkeit 219 Einzelwahrscheinlichkeitsdichte elektronische Unterschrift 7, 266

Elemente eines Codewortes 13 elliptic curve primality prove 318 elliptischen Kurven 318 Empfänger 50 Empfangsbit-Paar 230 Empfangsfeldstärke 1 Empfangspaket 158 Empfangssignal 16 Empfangssignalvektor 64 Empfangswort 173 Empfangswort-Polynom 111 Empfangswortbits 60 Empfangswortelemente 59 Empfangswortpolynom 105, 128, 235 Empfangswortvektor 170 Endekennzeichen 336 endliche Ausgangsfolgen 233 endliche Ganzzahlkörper Zn 32 endliche Ganzzahlmengen 12 endliche Informationsmenge 3 endliche Primkörper 244 Entropie 13f., 17 Entropie-optimiert 1 entschlüsseln 253 Entschlüsselung 272, 282 Entschlüsselungsversuch 273 Erkennbarkeit 23 Error Bit Rate 19 Ersatzsysteme 265 Erweiterungskörper 36, 122 Erzherzog-Johann-Jodler 4 Euklidischer Algorithmus 43, 167, 175f., 188, 190, 280 Eulerfunktion 43 exponentiell 257 exponentielle Komplexität 257, 279 extrinsisch 221

F

219

Faltungscode Faltungscodierer Faltungsintegral Fano, R. M.

11, 225, 228 226 84 11

383

8 Sachwortverzeichnis Frequenzbereich 237 Farbcode 2 Frequenzgemisch 366 Fast Fourier-Transformation 20, 341 Frequenzkomponenten 338, 344, 358 Fehler 49 Frequenzmodulation 21 fehlerarm 90 Frequenzspektrum 15, 68, 370 Fehlerarmut 91 Frequenzsynthesizer 344 Fehlerbeseitigung 21 Frequenzumsetzer 14 Fehlerbitrate EBR 69 Friedmann-Test 300 Fehlerbündel 156, 207 FT 339 Fehlerbündelbreite 204 Fundamentalsatz der Algebra 41 Fehlerbündelpolynom 158 Funkstrecke 14, 50 Fehlereinflüsse 47 Funktionstrennung 266 Fehlererkennung 8f., 155 fehlerfrei 90 G Fehlerhäufigkeit 69 Galois 120 Fehlerkorrektur 9, 155 Galoisfeld 42, 122 Fehlermuster 132 Galoiskörper 42, 122 Fehlerort 52 Ganzzahlkörper 32, 93f. Fehlerpolynom 105, 112 Ganzzahlmenge 32 Fehlerposition 8, 94, 143 Gauß-verteilt 19 Fehlerpositions-Polynom 171, 180 Gauß'sche Fehlerfunktion 70 Fehlerpositionsbestimmung 128 Gauß'sche Glocke 215 Fehlerrate 8, 19 Gauß'sche Normalverteilung 47 Fehlerspektrum 154 gebrochenzahlige Dimensionen 376 Fehlervektor 96 Geheimhaltung von Schlüsseln 252 Fehlerwert 52, 94, 143 Geheimschlüssel 170, 284 Fermat'scher Satz 106, 124 Geheimtext 7, 253, 272 Fermat'sches Theorem 46, 159 Geheimtextblock 255, 311 FFT 20, 341 Gehörsinn 363 Filterbank 365f., 369f. Generatormatrix 61, 96, 99 Filterdifferenzengleichung 370 Generatorpolynom 102, 118, 228, 235 formale Potenzreihe 246 Genetische Codes 2 Fourier-Reihe für periodische Signale 342 genetischer Code 2 Fourier-Transformation 12, 19, 86, 339 gerade Funktionen 341 Fourier-Transformation für nicht periodische SiGesamtintervallbreite 336 gnale 346 Gesamtstellenzahl 335 Fourierkoeffizienten 360 Gewicht 118 FR 339 ggT 280 Fraktal-Transformation 12, 20 Gibbs’sches Phänomen 373 Fraktale 20, 372, 376 Gitterdiagramm 229 Fraunhofer-Institut 365 Glasfaser 50 freier Abstand 232 gleich verteilt 88 Frequenzanalyse 344 Gleichanteil 356

384

Glockenkurve 47 GMS 225 GnuPG 318 GnuPP 301 Golay-Code 54 Goppa-Code 49, 161, 166, 170 Graustufen 358 Grenz-Abtastzeit 340 Grenzwertsatz der Statistik 70 Größter gemeinsamer Teiler (ggT) 280 Grundkörper 142 Grundmuster 376 Gruppen 36 Gruppenvolumen 328

H Haar 374 Hadamard und de la Valle-Poussin 290 Hagenauer, Joachim 212 halb schwache Schlüssel 277 Halbgruppe 35 Hamming-Code 9, 49, 58, 90, 206 Hamming, R. W. 56 Hammingabstand 9, 18, 230 Hard Decision 16, 127 Hard-Decision-Decodierung 52 harmonische Funktion 345 Hash-Funktion 311 Hash-Summe 311f., 314 Häufigkeiten 46, 334 Häufigkeitstabelle 328 Häufigkeitsverteilung 7, 11, 253, 327, 333 HD-Decodierung 111 HD-Demodulation 229 Helligkeitsverlauf 358 hierarchisches Verfahren 357 Hilfspolynom 177 hinreichende Bedingung 54, 113 Histogramm 214 horizontale Decodierung 223 Horizontalkomponente 207 Hörspektrum 349 https 303

Huffman-Codierung 361 Huffman-Tabellen 372 Huffman, D. A. 11 hypertext transfer protocol secure

303

I Ideal 38 Identifikation 303 IEC-Farbcode 3 imaginäre Zahl 40 Impulsantwort 226 Impulsreihe 249 Impulsübertragungsfunktion 369 Infobit 51 Infobitsignale 219 Infopolynom 102 Inforate 90 Informatiksystem 21, 264 Information Security Management Systeme 264 Informationsbit 15 Informationsbyte 8 Informationselement 16 Informationsgehalt 13 Informationspolynom 235 Informationsrate 18, 22, 90, 170, 197 Informationssicherheit 7, 264 Informationssicherung 264 Informationsstellen 13, 57 Informationstechnik 12 Informationsvektor 165, 193f. Informationswort 50 Infostelle 9 innerer Code 207 Integrand 344, 375 Integrität 264 Integritätsring 36 Interleaving 156, 203 Intervallgrenze 334, 336 Intervallposition 334 Intra-Frames 363 inverse Permutation MIPI 273 inverses Element 36, 38, 44 invertierbar 298

385

8 Sachwortverzeichnis irreduzibel 40 irreduzible Polynome ISBN-Code 2 ISMS 264 Iterationen 224

40, 42, 106, 112, 120

J Joint Photographic Expert Group JPEG 357 JPEG 2000 374

357

K Kanal 14, 50 Kanalbandbreite 154 Kanalkapazität 21, 82, 210 Kanalrauschen 229 Kanalstörung 221 Kapazität 87, 90 Kapazitätstheorem 17 Kasiski-Test 300 katastrophale Codes 233 Kerckhoff'sches Gesetz 276 KKF 244 Klartext 6, 253, 269, 272 Klartextblöcke 255, 311 Klartextverschlüsselung 301 Klartextzahl 279 Klartextzeichen 253 known ciphertext-Angriff 300 known plaintext-Angriff 301 Koeffizientenvektor 259 Koeffizientenvergleich 172 Kommutativgesetz 36 Komplement 277 komplementäre Schlüssel 278 komplexe Filter-Übertragungsfunktion komplexe Nullstellen 40 komplexer Frequenzgang 369 komplexes Frequenzspektrum 346 Komplexität 32 Komplexitäts-Theorie 245 Komplexitätsparameter 257 Kompressionscode 3 Kompressionsgewinn 328

386

Kompressionsrate 18, 377 Kompressionsvorteil 328 konjugiert komplex 40, 347 Konstruktionsverfahren 60 kontinuierliches Amplituden- und Phasenspektrum 340 Körper 38 Körper der rationalen Zahlen 334 Körperelement 42, 122 Körpererweiterungen 38, 40 Korrektur-Rate 154 Korrekturverfahren 8 Korrelationsfunktionen 239 korrelierender Anteil 343 korreliert 223 Kreisteilungspolynom 46, 123, 157 Kreuzkorrelation 250 Kreuzkorrelationsbildung 343 Kreuzkorrelationsfunktion 243 Kreuzkorrelationstechnik 249 kritische Bänder 365 Kryptoanalyse 299 kryptologisch sicher 278

L Langzahlrechnung 289 Laplace-Transformation 237 Lauflängen-Codierung 12, 323 Laufzeittransformierte 237 Lempel-Ziv-Welch-Codierung 329 Lichtleiter 14 Likelihood Ratio 219 lineare Algebra 60 lineare Operation 227 46 366 Linearfaktoren Linearkombination 60 Linienspektrum 339 LLR 219 Log Likelihood Ratio 219 logarithmisches Wahrscheinlichkeitsverhältnis 219 Logarithmus 14 logisches NOT 277

lossless Kompression Lösungsdeterminante Lösungsvektor 139 Lottomaschine 272 LR 219 Luminanz 358 LZW 12, 329 LZW-Algorithmus 333

323 139

M MAC 311 Mandelbrot, B. B. 376 Mandelbrotmenge 376 MAP-Verfahren 212, 223 Martinshorn 14 Maskenfunktion 356, 371, 373 Maskenhügel 371 maskierende Wirkung 344 Massenspeichervolumen 290 Matrixform 138 Matrixschreibweise 151 Matrizenrechnung 33 maximale Ordnung 122 maximale Periodenlänge 239 Maximallängenfolgen 241, 245, 249 Maximum a Posteriori-Prinzip 212 Maximum Likelihood 64 Maximum Likelihood-Prinzip 212 Maximum Likelihood-Typ 233 McEliece-Verschlüsselung 295 MD4 313 MD5 314 MDCT 364, 370 MDCT-Rücktransformation 372 Mehrbit-Fehler-Korrektur 127 Mehrfach-Nullstellen 125 Mehrheitsbetrachtung 55 Mehrheitswerte 197 Mengen 35 Message-Authentication-Code 311 Mikrofonspannung 365 Mindestabstand 8, 18 Mindesthammingdistanz 207

MiniDisc 365 Minimalfolge 232 Minimalpolynom 42 Mittelwert 239 Mittelwert-Bildung 343 mittelwertfrei 19 mittelwertfreie Normalverteilung 14 Mittenfrequenz 370 mittlere Rauschleistung 70 ML 212 ML-Prinzip 212 ML-Verfahren 64, 224 MOD-Dividierer 108 Modem 14 modifizierte DCT 370 Modul 278 modulare Inverse 315 modulare inverse Polynome 166f., 169, 178 modulare inverse Zahl 44, 279 Modulare Quadratwurzeln 304 modulare Quadratzahl 304 modulares Quadrat 305 Modulation 21, 50 Modulationsverfahren 21 Modulator 14 Modulo-Division 102, 104 Modulo-Funktion 32, 103, 282, 288, 305 Morsecode 1 Moving Picture Expert Group 362 MP3 365 MP3-Algorithmus 370 MP3-Player 372 MP3Pro 372 MPEG 362 MPEG-1 Layer 3 365 MPEG-1 Video 362 MPEG-2 AAC 372 MPEG-Standard 370 Mustersuche 376

N n-Tupel 12f., 161 Nachkomprimierung

323

387

8 Sachwortverzeichnis Nachrichten-Authentikation 266 Nachrichten-Integrität 266, 314 Nachrichten-Verschlüsselung 266 Nachrichtentechnik 12 Nachrichtentheorie 12 Näherungsformel 290 Näherungsverfahren 65 Netzwerke 264 neutrale Elemente 35 Nibble 80 nicht systematischer Code 110, 197 nicht zyklisch 182 Nicht-Maximallängenfolgen 245 Notfallpläne 266 notwendige Bedingung 54, 112 Nullbit 218 Nullfolgen 363 Nullstellen 120 Nullstellenbestimmung 180 nullteilerfrei 36ff. Nullwort 60, 276 Nutzinformation 8 Nutzsignalleistung 16 Nutzungsbeschränkung 278 Nyquist 21

O obere Dreiecksform 297 Obertöne 363 Oberwellen 372 öffentlicher Schlüssel 284 Offer, Elke 65 one time pad 7, 255 one time pad-Verfahren 322 Optimalitätsprinzip 230 Ordnung 122, 124, 145, 159, 239, 243 Ordnung eines Körperelements 42 Ordnungszahl 201 orthogonale Richtungspaare 319 Orthogonalitäts-Eigenschaft 345

P p-när 52 p-Zahlensystem

388

12, 94

Paritätsbeziehung 60 Paritätsbits 268, 338 Paritätsgleichung des Goppa-Codes 169 Paritätsgleichungen 17, 162, 206 Paritätsmatrix 192 Paritätsprüfbeziehung 96 Paritätsprüfmatrix 61, 96, 99 Passwort 5, 252, 263, 303, 308, 311 Passwortverfahren 252, 266 Passwortwechsel 253 PCM 365 PCM-Eingangssignal 365 perfekte Codes 54, 94f. perfekte Verschlüsselung 7, 255 Periodendauer 341, 367 Permutation 269f. Permutation MIP 273 Permutations-Liste 268f. Permutationsmatrix 298 Permutationstabelle 311 PGP 301, 317 Phasenkodierung 322 Phasennacheilung 368 Phasenspektren 338 Phasenverschiebung 367 Phasenwert 86 Pixelblöcke 377 Polarisationsrichtung 320 polarisieren 319 Polynom 12, 34, 39, 102 Polynom nullten Grades 167 Polynom, modulares inverses 168f., 184 Polynomdivision 44, 103, 108, 167 polynomial 257 Polynompaar 177 Polynomring 36, 144 Polyphase-Filter 370 Predicted Frames 363 Pretty Good Privacy 317 Primfaktor 108 Primfaktorenzerlegung 244 Primideale 39

60 primitives Element 41, 122, 124, 127, 159 Rechnersuche rechnerunterstützt 257 Primzahl 38, 94, 263, 278, 294, 301 rechnerunterstützte Suche 228 Primzahlenkörper 122 Rechteckanordnung 209 Primzahlensatz 293 Rechteckspannung 21, 67 Produktcodes 212, 222 redundant 22 Produktcodewort 210 Redundanz 3, 255, 323 Produktivbetrieb 266 Redundanzerhöhung 13 progressives Verfahren 357 Reed-Muller-Code 54, 192, 197 Protokoll 318 Reed-Solomon-Code 11, 94, 101, 142, 338 Prozess 52 Referenztiefpass 370 Prüfbit 8, 50 Regenerator 14 Prüfbitsignale 219 Registerausgangswerte 238 Prüfgleichungen 59 regulär 138 Prüfinformation 8 Rekursionsbeziehung 247, 335 Prüfstellen 13, 57 Rekursionsgleichung 236, 238 Prüfstellengleichung 66 rekursiv 222, 334 Prüfstellenwert 95 rekursive Beziehung 45 Prüfsumme 309f. rekursive Folge 376 Pseudoprimzahlen 289 Resonanzfrequenz 367 psychoakustisches Modell 339, 365 Restfehlerdiagramm 141 psychovisuelles Modell 339 Restklassenmengen 37 Pulscodemodulation 21, 365 Restklassenring 38 punktsymmetrisch 341 Restpolynom 40, 103, 167 Q reziprokes Rückkopplungspolynom 247 Q-Gruppen 2 RGB 357 Quanteneffekte 322 Ringe 36 Quantenkryptographie 318f. Ringeigenschaft 37 Quantisierungstabelle 359 RIPEMD 313 Quellenalphabet 4 RLE 323 R RLE-Komprimierung 360 Radar-Impuls 249 RS-Code 155 RAM 19 RSA-Schlüsselpaar 317 Rasenmäherprinzip 338 RSA-Verfahren 278 Rate 16 rückgekoppelte Schieberegister 235 Rauschen 1 Rückkopplungskoeffizienten 237, 260 Rauschleistungsdichte 16 Rückkopplungspolynom 237, 239 Rauschquelle 14 Run Length Encoding 323 Rauschsignal 250 Rundung 358 Rauschsignalleistung 16 Rauschsignalwert 69 Rechengenauigkeit Rechnersimulation

S

335 210

Sabarnes-Oxly Act Sample-Blöcke 370

265

389

8 Sachwortverzeichnis Sarrusregel 138 Satz von Euler 43 Schätzung 221 Schätzwert 16, 50, 217, 219, 222, 233 Schiebebefehle 197 Schieberegister 108, 158, 189 Schieberegister ohne Rückführung 233 Schieberegister-Anordnung 225, 228 Schieberegisterfolgen 256 Schlüssel 253 Schlüsselbestimmung mit Friedmann- und KasiskiTests 300 Schlüsselbit 260 Schlüsselfolge 260 Schlüssellänge 278 Schlüsselmatrizen 298 Schlüsselmenge 257 Schlüsseltausch 7, 255 Schlüsseltausch nach Diffie-Hellmann 301 Schlüsselübergabe 317 Schlüsselvergabestelle 278 Schlüsselverteilung 285 schnelle Primfaktoren-Zerlegung 322 Schnupperkurs 4 schwache Schlüssel 276f. Schwachstelle 284 Schwellwertkurven 364 Secure Hash Algorithm 1 313 Selbstähnlichkeit 377 Sendefolgen 233 Sendeleistung 16 Sender 50 Sendesignal 16, 50 Sendesignalvektor 64 SHA-1 313 Shannon-Grenze 91, 141, 224 Shannon-Limit 115 Shannon-Theorem 85, 87, 205 Shannon, C. E. 8, 14, 18, 21, 82, 340 Sicherheitsanalyse des DES 276 Sieb des Eratosthenes 113, 290 Signal-Definition 15

390

Signalelement 16 Signalgenerator 344 Signatur 316 Single Parity Check Codes 213 Sinnzusammenhang 22 Sinuskomponente 368 Sinusschwingung 20 Skalierbarkeit 374 SNR 16, 51 Soft Decision 213 Soft Decision-Decodierung 47, 233 Sonderfall der DFT 349 Spaltenelemente 193 Spaltenkorrektur 208 Spaltenoperationen 34 Spaltentausch 60 SPC-Codes 213 Speicherausgang 225, 228 Speichereingang 225 Speicherinhalt 225 Speicherplatten-Oberfläche 7 Speichertechnologie 65 Spektralanteil 21, 68 Spiegeln 376 spiegelsymmetrisch 341, 350 Standardabweichung 239 starke Primzahlen 294 Startzustand 256 Statistik 239 statistisch unabhängig 219 statistische Charakteristik 7 steile Flanken 372 Stellengenauigkeit 334 Stereokanal 365 stetig differenzierbar 375 Störabstand 16, 68, 82 Störimpuls 14 Störsignal 14, 67 Störspannung 7 Streuung 239 Strichcode 2 Substitutionsboxen 276

Substitutionstabelle 270 Summenknoten 326 Symbol 14 symmetrisch 267 symmetrische Verschlüsselungs-Verfahren 267 Syndrom 59, 96, 99f., 209 Syndrombits 60 Syndromgleichungen 59 Syndrompolynom 105, 111f., 115, 171 Syndromvektor 63 Syndromwert-Tabelle 97 Syndromwort 173 synthetisches Signal 346 systematische Suche 49 systematischer Code 13, 201 systematischer Fehler 203 Systemdeterminante 138 Systemmatrix 164, 238 Systemtheorie 226

T Täuschungsversuch 284 teilerfremd 167, 176, 279f., 291, 301, 304 teilerfremde Polynome 44 Teilerfremdheit 293 Teilerpolynom 167 Teilfolgen-Polynom 246 Teilfolgenlänge 246 Teilintervalle 334 Teilschlüssel beim DES 268 Teilschlüsselerzeugung 274 Teilsyndrome 116 Telekommunikations-Gesetz 265 TeraByte 290 ternärer Code 32 Textbit 8 Theorem von Burton und Weldon 207 Theorie der Graphen 318 thermisches Rauschen 50 Thermodynamik 13 Tiefpass 1. Ordnung 370 Tornister-Verfahren 286 totale Wahrscheinlichkeit 218

totale Wahrscheinlichkeitsdichte 217 TPC 212 transparent 324 transponierte Matrix 62 Transposition 207 Trellis 229 Trennzeichen 11 Triggerschwelle 69 Triple DES 278 Turbo-Produkt-Code 11, 101, 155, 212 Turboverfahren 224

U Übereinstimmung zu 50% 321 Übergangsmatrix 238 Übertragung von Schlüsseln 266 Übertragungsgeschwindigkeit 85 Übertragungskanal 16 Übertragungsleistung 11 Übertragungsrate 17, 87, 90 UND-Funktion 198 ungerade Funktionen 244, 341 Ungewissheit 14 Unstetigkeitsstellen 373 Unterbaum 326 Unterbestimmtheit 87 Unterschriften-Echtheit 303 Untersummen-Verfahren 286 Unveränderbarkeit 7 Unversehrtheit 308, 313 Unversehrtheitsnachweis 309 UTMS-Mobilfunk 225

V Vektor 12 Vektorprodukt 198 Vektorrechnung 33 verallgemeinerter Hammingcode Veränderungen an Dateien Verbundverteilungen 219 Verbundverteilungsdichten Verbundwahrscheinlichkeit Verbundwahrscheinlichkeitsdichte Verfügbarkeit 264

95 313 219 48 48, 214

391

8 Sachwortverzeichnis Verknüpfung 35 verlustbehaftete Kompression verlustbehaftete Verdichtung verlustfreie Kompression 12, 323 verlustfreie Verdichtung 357 Vernam, G. S. 7 Verschachteln 203 verschachtelte Codestrukturen Verschiebbarkeit 374 Verschieben 376 Verschlüsselung 6, 21 Verschlüsselungs-Algorihmen Verschlüsselungstheorie 255, 293 Verstärker 14 Vertauschungsmatrix 62 Verteilungsdichte 47 Verteilungsdichtefunktion 214 Verteilungsfunktionen 239 vertikale Anordnung 222 vertikale Codierung 207 vertikale Decodierung 223 Vertikalkomponente 207 Vertrauen 285 Vertraulichkeit 264 Verwirbeln 255 Videosequenzen 362 Virenprogramm 313 Virenschutz 266 vollständiger Code 22 Vorgängerkennung 330 Vorwärtsrechnung 281

323, 337 357

222

X

257

W Wahrscheinlichkeit 46 Wahrscheinlichkeitsdichte 47, 214 Wahrscheinlichkeitsmaß 213, 233 wav-Dateien 338 wavelet 20 Wavelet-Familien 374 Wavelet-Koeffizienten 374 Wavelet-Transformation 12, 20, 374 Wavelets 362, 372, 374 Wechseln der Schlüssel 300

392

weißes Rauschen 15 weißes Rauschsigna l 16 Wellenfeld 359 Wertefolge 16 Widerstandsrauschen 14 Wiederherstellungsverfahren 265 Wiederholungscode 10, 49, 55 Wortfehler 72 XOR 197, 269 XOR-Funktion 270 XOR-Verknüpfung

236

Y YUV

357

Z Zahlenäquivalent 336 Zahlenelement 32 Zahlenkörper 54, 94 Zeichenfolge 334 Zeichenpaare 328 Zeilenkorrektur 208 Zeilenoperationen 34, 163 Zeilensyndrome 208 Zeilentausch 60 Zeilenzähler 330 Zelleninhalt 238 Zentraler Grenzwertsatz 47 Zerlegungsalgorithmen 294 Zerlegungssatz für Primfaktoren 248 Zero-Knowledge-Protokoll 303, 308 Zertifizierungsinstanz 318 Zertifkat 318 Zick-Zack-Kurs 360 zip-Dateien 3 Zoomen 376 zufälliger Fehler 203 Zufallserzeugung 251 Zugang 252 Zugangsschutz 265 Zustandseigenschaften von Photonen 319 Zustandsgitter 229 Zustandsgleichungen 238

Zustandsgröße 237 Zustandspaar 232 Zustandsvektoren 238 Zustandsverlauf 229 Zwei-Bit-Fehlererkennung 93 Zweidimensionale DFT 342 Zweiergruppen 328 Zweifachfehler 97

Zweimalige Verschlüsselung 277 Zwischenspeicherung 363 zyklisch 107 zyklische Codes 39, 49, 201 zyklische Eigenschaften 46 zyklische Verschiebungen 108, 158, 268 zyklischer Hamming-Code 111 zyklotomische Polynome 123

393