Codierungstheorie - Diskrete Mathematik - Universität Tübingen

Codierungstheorie 

Skript zur Vorlesung im SS 2004 

Prof. Peter Hauck 

Arbeitsbereich Diskrete Mathematik 

Universität Tübingen 

L ATEX-Fassung von Anja Korsten

INHALTSVERZEICHNIS 1 

Inhaltsverzeichnis 

1 Codes - Grundbegriffe und Beispiele 4 

2 Hamming-Schranke und perfekte Codes 14 

3 Lineare Codes 18 

4 Allgemeine Konstruktionsprinzipien 34 

5 Reed-Muller-Codes und 

Majority-Logic-Decodierung 47 

6 Polynomcodierung und zyklische Codes 65


Einführung 

Codierung: Sicherung von Daten und Nachrichten gegen zufällige Fehler 

bei der Übertragung oder Speicherung. 

Situation: 

Quelle Kanalcodierer Kanal 

Decodierer 

Empfänger 

Nachricht codiert Nachricht 

Störungen! Nachricht wird 

(Folge von Symbolen in Wort über 

rekonstruiert 

aus Alphabet B) 

Alphabet A 

Ziele bei der Codierung: 

Abbildung 1: Schema der Kanalcodierung 

1. Möglichst viele bei der Übertragung (oder Speicherung) aufgetretene 

(zufällige) Fehler sollen bei der Decodierung erkannt werden und evtl. 

sogar korrigiert werden. 

2. Der Aufwand zur Codierung und Decodierung soll nicht zu groß sein. 

Verwandte Gebiete: Neben dieser sog. Kanalcodierung, die gegen zufällig 

auftretende Fehler schützen soll, gibt es noch zwei weitere Codierungsbzw. 

Verschlüsselungsbereiche: 

1. Quellencodierung: Nachricht wird so codiert, dass häufig auftretende 

Strings in kurzer Form codiert werden und seltenere in längerer Form; 

Datenkompression 

2. Kryptographie: Sicherung von Nachrichten/Daten gegen Abhören 

oder Änderungen durch unbefugte Dritte; Datenverschlüsselung 

In der Praxis kann eine Kombination aller drei Verfahren vorkommen: 

Zunächst wird eine Nachricht komprimiert (z.B. *.zip), dann verschlüsselt 

und an- schließend codiert. In dieser Vorlesung werden Datenkompression 

und Kryptographie nicht behandelt, sondern nur die Kanalcodierung. 

Grundprinzip der Kanalcodierung: Füge der zu übertragenen Nachricht 

Redundanz zu, so dass auftretende Fehler (häufig) erkannt werden 

können.


Drei Hauptaufgaben: 

1. Konstruktion geeigneter Codes zur Fehlererkennung und ggf. -korrektur 

2. Konstruktion von Codierern 

3. Konstruktion von Decodierern 

Anforderungen: 

1. Schnelle Codierer und Decodierer 

2. Große Fehlererkennungs- bzw. korrektursicherheit des Codes mit möglichst 

wenig zusätzlicher Redundanz.

1 CODES - GRUNDBEGRIFFE UND BEISPIELE 4 

1 Codes - Grundbegriffe und Beispiele 

Zunächst wird in einigen Beispielen beschrieben, wie die in der Einleitung 

beschriebene Kanalcodierung erfolgen kann. 

1.1 Beispiele. 

(a) Parity-Check Code 

Nachrichten und Codewörter sind aus demselben Alphabet A = B = 

{0,1}. Die Nachrichten sind 00, 01, 10, 11 und werden auf folgende 

Weise codiert: 

00 → 000 

01 → 011 

10 → 101 

11 → 110 

Es gibt acht 0-1-Wörter der Länge 3, von denen nur die mit einer 

geraden Anzahl von Einsen tatsächlich Codewörter sind. Entsteht bei 

der Übertragung eines Codewortes genau ein Fehler, so ist die Anzahl 

der Einsen ungerade und der Fehler wird entdeckt. Man hat jedoch 

keinen Anhaltspunkt, in welcher Koordinate der Fehler entstanden ist. 

Damit ist eine Decodierung nicht eindeutig möglich. Zwei Fehler in 

einem übertragenen Codewort werden nicht entdeckt. 

Der ASCII-Code ist von diesem Typ: 128 Zeichen werden mit 8 Bits 

codiert, wobei das achte Bit ein Parity-Check-Bit ist. 

(b) Wiederholungscode 

Nachrichten und Codewörter sind aus demselben Alphabet A = B = 



00 → 000000 

01 → 010101 

10 → 101010 

11 → 111111 

Dies ist ein Code mir relativ hoher Redundanz. Die Länge einer Nachricht 

wird bei der Codierung verdreifacht.


Je zwei Codewörter unterscheiden sich an mindestens 3 Stellen. Ein Decodierer 

könnte dasjenige Codewort suchen, zu welchem er die wenigsten 

Bits am empfangenen Wort ändern muss. Dann wird zum Beispiel 

das empfangene Wort 101011 zu 101010 decodiert. 

Wird nur ein Bit bei der Übertragung geändert, so wird der Fehler 

erkannt und (mit obiger Methode) richtig korrigiert. Treten zwei Fehler 

auf, so wird erkannt, dass Fehler aufgetreten sind, aber nicht korrekt 

decodiert. 

(c) Nachrichten und Codewörter sind aus demselben Alphabet A = B = 



00 → 00000 

01 → 01101 

10 → 10110 

11 → 11011 

Dies ist ein Code mir geringerer Redundanz als im vorigen Beispiel. Es 

unterscheiden sich auch je zwei Codewörter an mindestens drei Stellen. 

Und auch hier werden maximal zwei Fehler erkannt und ein Fehler 

korrekt decodiert. 

ÜA: Ist ein Codierung mit denselben Eigenschaften, wie in den beiden 

vorigen Beispielen, in Codewörter der Länge vier möglich? 

(d) Prüfziffern-Code (1): EAN-13 

Die Europäische Artikelnummer ist ein 13-stelliger Code, der sich auf 

vielen Produktverpackungen befindet. 

Nachrichten und Codewörter sind aus dem Alphabet A = B = {0, . . . , 

9}. Die gültigen Codewörter sind aus der folgenden Menge: 

C = {c1 . . . c13 ; ci ∈ A, c1 +3c2 +c3 +3c4 +. . .+3c12 +c13 ≡ 0 mod 10} 

Die eigentliche Information steckt in den zwölf Ziffern c1, . . . , c12, von 

denen die ersten beiden das Herstellungsland angeben (40-43 Deutschland). 

Die Ziffern c3 bis c12 sind für die Herstellungsfirma reserviert (in 

der Regel geben c3 bis c7 den Hersteller und c8 bis c12 das Produkt an). 

Zur Codierung wird eine 13te Ziffer angehängt. Diese wird eindeutig so 

gewählt, dass sich ein gültiges Codewort ergibt. 

Beim Lesen oder Abtippen einer Zahlenfolge ist mit 80% der am häufigsten 

auftretende Fehler eine veränderte Ziffer. EAN-13 erkennt einen


solchen Fehler, da x → 3x mod 10 eine Permutation auf A ist. Der 

Zahlendreher - die Vertauschung zweier benachbarter Ziffern - ist der 

am zweit häufigsten auftretende Fehler. Jedoch werden Vertauschungen 

von zwei Ziffern ci und cj in folgenden Fällen nicht erkannt: 

1. Der Abstand der Indizes i und j ist gerade. 

2. Ist i gerade und j ungerade, so wird eine Vertauschung nicht erkannt 

falls: | ci − cj |= 5 

Die Erkennung eines Zahlendrehers ist damit nur gesichert, falls je zwei 

benachbarte Zahlen einen Abstand ungleich 5 haben. So werden über 

90% aller Abtipp- oder Lesefehler erkannt. 

Der EAN-13 Code wird in einen Barcode/Strichcode übersetzt, der 

optisch-elektronisch mit einem Scanner gelesen werden kann. Jedes der 

c2, . . . , c13 wird zunächst in einen 7-Bit-String codiert. Dabei werden 

die vier Codes A, B, C und D aus Tabelle 1 verwendet. Die Ziffer c1 

gibt anhand von Code D an, in welcher Folge Code A und Code B 

angewendet werden müssen, um c2 bis c7 zu codieren. Da Code A und 

Code B disjunkt sind, wird beim Dekodieren erkannt, wie c2 bis c7 

codiert worden sind. So kann wieder auf c1 geschlossen werden. 

Ziffern Ziffern bestimmt 

c2 − c7 c8 − c13 durch c1 

Zeichen Code A Code B Code C Code D 

0 0001101 0100111 1110010 AAAAAA 

1 0011001 0110011 1100110 AABABB 

2 0010011 0011011 1101100 AABBAB 

3 0111101 0100001 1000010 AABBBA 

4 0100011 0011101 1011100 ABAABB 

5 0110001 0111001 1001110 ABBAAB 

6 0101111 0000101 1010000 ABBBAA 

7 0111011 0010001 1000100 ABABAB 

8 0110111 0001001 1001000 ABABBA 

9 0001011 0010111 1110100 ABBABA 

Tabelle 1: Die vier Codes des EAN-13 

Die entstandene Bitfolge wird nun in einen Strichcode übersetzt. Dabei 

wird jede 1 in einen schwarzen Balken und jede 0 in einen weißen Balken 

codiert. Die ersten drei Codes sind so gewählt, dass das gleiche Bit


höchstens viermal nacheinander auftaucht. So treten nur Balken der 

Breite 1 bis 4 auf. 

Abbildung 2: Beispiel eines EAN-13 Codewortes 

Bemerkungen: 

• Der EAN-13 Strichcode besteht also aus 2 aufeinanderfolgenden 

Codierungen. 

• Der 12-stellige amerikanische UPC-Code codiert nur anhand von 

Code A und Code C. Damit ist er vollständig kompatibel zum 

EAN-13 Code mit führender ”0”. 

• In Europa wird auch der 8-stellige EAN-8 benutzt. 

• Weitere Informationen finden sich im Internet unter anderem auf 

den folgenden zwei Webseiten: 

http://www.barcodeisland.com/ean13.phtml 

http://www.adams1.com/infos/barcode.htm 

(e) Prüfziffern-Code (2): ISBN 

Die International Standard Book Number ist ein 10-stelliger Code, der 

jedes Buch international erkennbar macht. Die ersten 9 Ziffern kennzeichnen 

Erscheinungsland, Verlag und Buch; an diese wird eine zehnte 

Prüfziffer angehängt. 

Kennzeichnung des 

Erscheinungslandes 

3 − 11 − 015873 − 6 

Verlagsnummer Verlagsinterne Nummer 

für das spez. Buch 

Abbildung 3: Beispiel einer ISBN-Nummer 

Prüfziffer 

Uncodierte Wörter sind aus dem Alphabet B = {0, . . . , 9} und 

Codewörter sind aus dem Alphabet A = {0, 1, . . . , 9, X}. Das


Anhängen der Prüfziffer geschieht nach folgender Regel: Stellen die 

Ziffern z10z9 . . . z2z1 in dieser Reihenfolge eine ISBN-Nummer dar, so 

wurde die Prüfziffer z1 so gewählt, dass für die gewichtete Quersumme 

gilt: 

10 

kzk ≡ 0 mod 11 

k=1 

Ist dabei z1 = 10, so wird z1 = X gesetzt; (Im obigen Beispiel: 10 · 3 + 

9 · 1 + 8 · 1 + 7 · 0 + 6 · 1 + 5 · 5 + 4 · 8 + 3 · 7 + 2 · 3 + 1 · 6 = 143 ≡ 0 

mod 11). Die Redundanz ist bei dieser Codierung sehr gering und dazu 

werden die zwei häufigsten Fehlertypen entdeckt (wenn nur einer der 

beiden auftritt): 

1. Vertauschung zweier Ziffern: Werden zi und zj vertauscht (1 ≤ 

i, j ≤ 10), so ist 

 

kzk + izj + jzi = 

k=i,j 

10 

k=1 

kzk + (j − i)(zi − zj) 

 

≡ 0 mod 11 

≡ 0 mod 11 

Denn für zi = zj gilt: 1 ≤ |zi − zj| ≤ 10 und 1 ≤ |i − j| ≤ 10. 

Damit ist die Quersumme nicht mehr durch 11 teilbar und die 

Vertauschung wird erkannt. 

2. Austausch einer Ziffer gegen eine andere: Wird zi durch xi ersetzt, 

so gilt für die Quersumme: 

 

kzk + ixi = 

k=i 

10 

k=1 

kzk − i (zi − xi) 

 

≡ 0 mod 11 

Dies folgt, da wiederum 1 ≤ |zi − xi| ≤ 10. 

≡ 0 mod 11 

Bemerkung: Die Beispiele (a), (d) und (e) nennt man auch Kontrollcodes 

oder Prüfziffersysteme. 

Das Wesentliche an den vorangegangenen Beispielen ist die Tatsache, 

dass nach der Codierung Wörter von fester Länge über einem Alphabet 

übermittelt werden, wobei nur gewisse aller möglichen Wörter dieser einen 

Länge tatsäch- lich Codeworte sind. Diese Tatsache lässt sich wie gesehen, 

zum Entdecken und ggf. Korrigieren von Fehlern ausnutzen. 

Im Folgenden werden wir uns, wie im Beispiel, vor allem solche Codes ansehen, 

für welche die codierte Information in Blöcke von je n Symbolen (für 

festes n) unterteilt werden kann, wobei jeder Block unabhängig von den anderen 

decodiert werden kann.


1.2 Definition (Blockcode). Es sei A eine endliche Menge (Alphabet) 

und n ∈ N. Ein Blockcode C (einfacher: Code) der Länge n über A ist eine 

Teilmenge von A n = A × . . . × A. Die Elemente von C heißen Codewörter. Ist 

|A| = 2, so heißt C binärer Blockcode (i.Allg. A = {0, 1}). 

1.3 Definition (Hamming-Abstand). Sei A ein endliches Alphabet, n ∈ 

N. Zu a = (a1, . . . , an), b = (b1, . . . , bn) ∈ A n heißt 

der Hamming-Abstand von a und b. 

d(a, b) = #{i : 1 ≤ i ≤ n, ai = bi} 

1.4 Satz. Für den Hamming-Abstand gilt: 

(a) 0 ≤ d(a, b) ≤ n ∀ a, b ∈ A n 

(b) d(a, b) = 0 ⇔ a = b 

(c) d(a, b) = d(b, a) ∀ a, b ∈ A n 

(d) d(a, b) ≤ d(a, c) + d(c, b) ∀ a, b, c ∈ A n (Dreiecks-Ungleichung) 

Damit ist d : A n × A n −→ {0, . . . , n} eine Metrik. 

Ist A eine Gruppe mit Verknüpfung +, so gilt zusätzlich: 

(e) d(a + c, b + c) = d(a, b) ∀ a, b, c ∈ A n (Translations-Invarianz) 

Beweis. (a), (b), (c) klar. (d) Ist ai = bi, so ist ai = ci oder bi = ci. Daraus 

folgt die Behauptung. (e) Da A eine Gruppe ist, gibt es zu ci aus A immer das 

Inverse bzgl. der Addition −ci in A. Damit gilt: ai+ci = bi+ci ⇔ ai = bi. 

Bemerkung. Wird ein Wort x aus einem Code C ⊆ A n gesendet und ein 

Wort y aus A n empfangen mit d(x, y) = k, so sind während der Übertragung 

k Fehler aufgetreten. 

1.5 Definition (Hamming-Decodierung und Minimalabstand). Sei C 

ein Blockcode aus A n . 

(a) Hamming-Decodierung (Maximum-Likelihood-Decodierung): Wird ein 

Wort y ∈ A n empfangen, so wird y als ein x ′ decodiert mit 

d(x ′ , y) = min d(x, y). 

x∈C 

(x ′ muss nicht eindeutig bestimmt sein!) Diese Decodierung ist sinnvoll, 

wenn jedes Symbol in einem Codewort mit gleicher Wahrscheinlichkeit 

gestört werden kann.


(b) Der Minimalabstand von C ist: 

d(C) = min 

x,x ′ ∈C, x=x ′ d(x, x′ ) 

(c) Ein Blockcode C heißt t-Fehler-korrigierend, falls 

d(C) ≥ 2t + 1. 

Ein Blockcode C heißt t-Fehler-erkennend, falls 

d(C) ≥ t + 1. 

Zur Bezeichnung in 1.5.(c): Ist d(C) ≥ 2t + 1 und ist x ∈ C, so liegt in der 

’Kugel’ 

Kt(x) = {y ∈ A n : d(x, y) ≤ t} 

genau ein Codewort - nämlich x. Treten also bei der Übermittlung eines 

Codewortes höchstens t Fehler auf, so wird mit der Hamming-Decodierung 

korrekt decodiert. 

t 

x1 

Kt(x1) 

d(C) 

t 

x2 

Kt(x2) 

Abbildung 4: Abstand zweier Codewörter 

Ist d(C) ≥ t + 1 und treten bei der Übermittlung eines Codewortes maximal 

t Fehler auf, wird entweder das ursprüngliche Codewort empfangen (kein 

Fehler), oder ein Wort, das kein Codewort ist. Es wird dann erkannt, dass 

Fehler aufgetreten sind. Die Hamming-Decodierung kann jedoch inkorrekt 

⌋ Fehler aufgetreten sind. 

sein, falls mehr als ⌊ t 

2 

1.6 Beispiele. 

(a) m-facher Wiederholungscode aus Beispiel 1.1.(b): ein Block der Länge k 

wird m-fach gesendet (Codewörter haben Länge m · k). In diesem Fall 

ist d(C) = m und C ist ⌊ m−1⌋-Fehler-korrigierend 

und (m-1)-Fehler- 

2 

erkennend.


(b) Code aus Beispiel 1.1.(c): Die Blocklänge beträgt n = 5 und d(C) = 3. 

C ist 1-Fehler-korrigierend und 2-Fehler-erkennend. 

Ziele: Die vorangegangenen Definitionen führen zu den folgenden Zielen. 

- Konstruktion von Codes mit möglichst großem Minimalabstand d(C), 

und damit einer geringeren Decodierfehlerwahrscheinlichkeit. 

- Zur Codierung eines Bits sollten nicht zu viele weitere Bits benötigt 

werden. Daher wird folgendes definiert: 

1.7 Definition (Informationsrate). Sei C ein Blockcode in A n , |A| = q. 

R = 1 

n logq|C| 

heißt Informationsrate (kurz: Rate) von C; 1 − R wird Redundanz von C 

genannt. 

Anschaulich: Die Informationsrate gibt an, wie groß der Anteil an reiner Information 

in einem Codewort ist. Oder: 1 ist der Faktor, der den Mehraufwand 

R 

bei Codierung angibt. 

1.8 Beispiele. (a) m-facher Wiederholungscode: R = 1 

m 

(b) Code aus Beispiel 1.1.(c) : R = 2 

5 

(c) ASCII-Code: R = 7 

8 

Umformulierung der Ziele: Finde Codes mit geringer Decodierfehlerwahrscheinlichkeit 

(bzgl. der Hamming-Decodierung) und hoher Informationsrate. 

Im Prinzip sind diese Ziele erreichbar, wie ein wichtiger Satz von Shannon 

besagt. Dazu wird ein Kanal betrachtet, für den die Wahrscheinlichkeit einer 

Störung von Zeichen aus einem Alphabet A für jedes Zeichen und zu jedem 

Zeitpunkt gleich ist, etwa p. Ist |A| = 2, so handelt es sich um einen binären 

symmetrischen Kanal. Die Kapazität eines solchen Kanals gibt an, welcher 

Anteil der Information korrekt übermittelt werden kann, und ist definiert als 

C = C(p) = 1 + p log2p + (1 − p) log2(1 − p).


C(p) 

1 

0.5 

0 

0.5 1 

Abbildung 5: Kapazität eines binären symmetrischen Kanals 

Ist p = 0 oder p = 1, so ist C maximal, da man die Nachricht nach der 

Übertragung vollständig rekonstruieren kann. Ist p = 1 

, so ist C = 0 mi- 

2 

nimal. Durch einen solchen Kanal wird aus jeder Folge mit gleicher Wahrscheinlichkeit 

jede andere Folge erzeugt; nichts ist rekonstruierbar. In der 

Regel ist p klein und C nahe bei 1. 

1.9 Satz (Shannons Hauptsatz der Kanalcodierung (1948) 1 ). 

Ist ein binärer symmetrischer Kanal mit Kapazität C und Fehlerwahrscheinlichkeit 

p gegeben und r ∈ R, r < C, so existiert ein Blockcode mit Informationsrate 

> r und beliebig kleiner Decodierfehlerwahrscheinlichkeit (bzgl. der 

Hamming-Decodierung). 

Dabei muss die Blocklänge n jedoch genügend groß gewählt werden. Der Beweis 

ist wahrscheinlichkeitstheoretisch und nicht konstruktiv; siehe [HQ83], 

[Rom92] und [vL99]. Ein kombinatorischer Beweis findet sich in [Her81]. 

Das Ziel der sogenannten algebraischen Codierungstheorie, mit der sich diese 

Vorlesung haupsächlich befassen wird, lässt sich folgendermaßen beschreiben: 

- Explizite Konstruktion von Codes mit möglichst großer Rate und 

großem Minimalabstand. 

- Gleichzeitig soll die Blocklänge n nicht zu groß sein (damit nicht zu 

lange gewartet werden muss, bis genug Nachrichten vorhanden sind, 

die in einen Block der Länge n codiert werden können). 

- Um Codierung und Decodierung zu vereinfachen, sollte der Code eine 

mathematisch einfache Struktur haben. Dies wird ermöglicht, wenn 

man das Alphabet A als Gruppe oder Körper wählt. Im letzten Fall ist 

dann A n ein Vektorraum, und Codes werden oft als Unterräume von 

1 siehe [Sha48] 

p


A n gewählt (lineare Codes). Dies vereinfacht in der Regel vor allem die 

Codierung. 

Dieser Ansatz - möglichst gute Codes explizit zu konstruieren - geht auf 

Hamming zurück, dessen erste grundlegende Arbeit wie die von Shannon in 

den späten 40er Jahren des letzten Jahrhunderts entstand; siehe [Ham50]. 

Die beiden Arbeiten von Shannon und Hamming sind die Grundpfeiler der 

Codierungstheorie.

2 HAMMING-SCHRANKE UND PERFEKTE CODES 14 

2 Hamming-Schranke und perfekte Codes 

Hat ein Blockcode der Länge n über A den Minimalabstand d, so sind die 

Kugeln vom Radius ⌊ d−1⌋ 

um die Codewörter disjunkt. Liegt jedes Element 

2 

aus An in einer dieser Kugeln, so kann jedes Wort in An bzgl. der Hamming- 

Decodierung eindeutig decodiert werden. Daher wird definiert: 

2.1 Definition (perfekter Code). Sei C ein Code der Länge n über A. C 

heißt perfekt, falls ein e ∈ N existiert mit: 

1. Ke(x) ∩ Ke(x ′ ) = ∅ ∀ x, x ′ ∈ C, x = x ′ 

2. A n = 

x∈C Ke(x). 

2.2 Satz. Sei C ein perfekter Code mit |C| > 1 und e wie in 2.1. Dann gilt 

d(C) = 2e + 1. 

Perfekte Codes haben also ungeraden Minimalabstand. 

Beweis. klar: d(C) > e, da |C| > 1. 

1. Angenommen: d(C) ≤ 2e. Dann existieren x, x ′ ∈ C, x = x ′ mit 

d(x, x ′ ) ≤ 2e. Ändere x an e Positionen, an denen sich x von x ′ unterscheidet, 

auf solche Weise, dass die betreffenden Einträge danach mit denen von 

x ′ übereinstimmen. Sei y ∈ A n das dadurch entstandene Wort. Dann ist 

d(x, y) = e. Da d(x, x ′ ) ≤ 2e, folgt d(x ′ , y) ≤ e. Damit ist y ∈ Ke(x)∩Ke(x ′ ). 

Widerspruch zu Eigenschaft 1 eines perfekten Codes. Daher ist d(C) ≥ 2e+1. 

2. Wähle ein x ∈ C und ändere es an e + 1 Stellen zu z ∈ A n ab. Dann gilt 

d(x, z) = e+1 und z /∈ Ke(x). Da der Code perfekt ist, existiert x ′ ∈ C, x = x ′ 

mit z ∈ Ke(x ′ ). Es gilt dann: d(C) ≤ d(x, x ′ ) ≤ d(x, z)+d(z, x ′ ) ≤ (e+1)+e = 

2e + 1. 

Insgesamt ist somit d(C) = 2e + 1. 

2.3 Lemma. Sei |A| = q, y ∈ A n und e ∈ N0 (e ≤ n). Dann ist 

|Ke(y)| = 

e 

j=0 

 

n 

(q − 1) 

j 

j 

Beweis. In Ke(y) liegen alle Elemente aus An , die Abstand 0, 1, . . . , e von y 

haben. Sei 0 ≤ j ≤ e. Dann gibt es n 

Möglichkeiten j Positionen aus den 

j 

n Positionen des Wortes y auszuwählen. Für jede Auswahl gibt es (q − 1) j 

Möglichkeiten, ein Element aus A n zu bilden, welches sich von y an genau 

diesen j Positionen unterscheidet. Das heisst: 

Daraus folgt die Behauptung. 

|{y ′ ∈ A n : d(y, y ′ ) = j}| = 

 

n 

(q − 1) 

j 

j .


2.4 Satz. Sei C ein Code der Länge n über A, |A| = q. Es sei d(C) ≥ 2e + 1 

mit e ∈ N0. 

(a) (Hamming-Schranke, Kugelpackungsschranke) Es gilt: 

|C| ≤ 

e 

j=0 

qn 

(q − 1) j 

(b) C ist genau dann ein perfekter Code, wenn in (a) die Gleichheit gilt. 

(Dann ist d(C) = 2e + 1). 

Beweis. Wegen d(C) ≥ 2e + 1 ist Ke(x) ∩ Ke(x ′ ) = ∅ für x, x ′ ∈ C, x = x ′ . 

Also: A n ⊇ ˙ 

x∈C Ke(x) 

(a) Mit 2.3 folgt: 

q n = |A n | ≥ | ˙ 

Dies liefert die Behauptung. 

n 

j 

x∈C Ke(x)| = 

|Ke(x)| = |C| 

(b) C ist perfekt ⇔ A n = ˙ 

x∈C Ke(x) ⇔ Gleichheit in (a). 

x∈C 

e 

j=0 

 

n 

(q − 1) 

j 

j 

Beispiel: Für einen Code der Länge 5 über einem Alphabet der Größe 2 mit 

d(C) ≥ 3 gilt: |C| ≤ ⌊ 25 

⌋ = 5. 

1 + 5 

ÜA: Gibt es einen Code C der Länge 5 über einem Alphabet der Größe 2 

mit d(C) = 3 und |C| = 5? (In Beispiel 1.1.c ist |C| = 4). 

Bemerkung. Die folgenden Codes werden triviale perfekte Codes genannt: 

• einelementige Codes 

• C = A n und e = 0 

• n-fache Wiederholungscodes C = {(1, . . . , 1) , (0, . . . , 0) }, n = 2e + 1. 

 

2e+1 2e+1


2.5 Beispiel (binärer Hamming-Code der Länge 7). Sei A = {0, 1} = 

F2. C sei der Code der Länge 7 über F2 (d.h. C ⊆ F7 2 ) gegeben durch 

C = {(c1 . . . c7) : ci ∈ F2, c1 + c4 + c6 + c7 = 0, 

c2 + c4 + c5 + c7 = 0, 

c3 + c5 + c6 + c7 = 0}. 

C ist ein linearer Unterraum von F 7 2 . Werden c4, . . . , c7 frei gewählt, so sind 

c1, c2, c3 eindeutig bestimmt und es ist dim (C) = 4 und |C| = 2 4 = 16. 

Anhand der definierenden Gleichungen ergibt sich: 

C = < (1101000), (0110100), (1010010), (1110001) > 

Da C ein linearer Raum ist, gilt mit der Translationsinvarianz des Hammingabstandes: 

d(C) = min d(0, x) 

x∈C,x=0 

und es folgt, dass d(C) die Minimalanzahl von Einsen in einem nichttrivialen 

Codewort ist. Anhand der Basis erkennt man, dass d(C) ≥ 3 sein muss. Jedes 

nichttriviale Codewort enthält jedoch mindestens drei Einsen ( Setze c7 = 1. 

Nach Addition der drei Gleichungen ergibt sich c1 + c2 + c3 = c7 = 1. Dann 

ist entweder c1 = c2 = c3 = 1 oder c1 = 1 und c2 = c3 = 0 und aus der 

zweiten Gleichung (c4 + c5 = 1) folgt c4 = 1 oder c5 = 1 (c7 = 0 ähnlich)). 

Also gilt d(C) = 3 = 2 · 1 + 1 und der Code ist 1-Fehler-korrigierend. Aus der 

Gleichheit: 

| ˙ 

folgt, dass C perfekt ist. 

x∈C K1(x)| = 16 · (1 + 7) = 16 · 8 = 2 7 = |F 7 2| 

Bemerkung. (a) C heißt binärer Hamming-Code der Länge 7 (Shannon, 

Golay, Hamming, 1948 - 1950). Dieser ist ein Beispiel aus einer Serie 

perfekter Codes (Hamming-Codes). Für jede Primzahlpotenz q und 

jede natürliche Zahl k ≥ 2 existiert ein perfekter linearer Code über 

Fq der Länge qk − 1 

q − 1 und der Dimension qk − 1 

− k mit d(C) = 3 (1q 

− 1 

Fehler-korrigierend). Wir werden diese Codes in Kapitel 3 behandeln. 

(b) Es gibt zwei weitere Beispiele perfekter linearer Codes mit Minimalabstand 

größer als 3: 

Der binäre Golay-Code G23 über F2 hat die Länge 23 und Dimension 

12 mit Minimalabstand d(C) = 7 (3-Fehler-korrigierend).


Der ternäre Golay-Code G11 über F3 hat die Länge 11 und Dimension 

6 (d.h. |C| = 3 6 ) mit Minimalabstand d(C) = 5 (2-Fehlerkorrigierend). 

(c) Die Hamming- und die Golay-Codes sind die einzigen nicht-trivialen 

perfekten linearen Codes (bis auf Äquivalenz); bewiesen von van Lint 

(1971), siehe [vL99], und Tietäväinen (1973). 

(d) Es gibt nicht-lineare perfekte Codes, die die gleichen Parameter haben 

wie die Hamming-Codes (Vasilev, 1962) 

(e) Die Golay-Codes sind die einzigen perfekten Codes über Alphabeten 

von Primzahlpotenzordnung, deren Minimalabstand d(C) größer gleich 

5 ist (van Lint, Tietäväinen). 

(f) Der binäre Golay-Code ist der einzige perfekte Code mit d(C) ≥ 7 (Best 

1978, Hong 1984).

3 LINEARE CODES 18 

3 Lineare Codes 

3.1 Definition. Sei K ein endlicher Körper und n ∈ N. Ein linearer Code C 

ist ein Unterraum des K-Vektorraums K n . 

Ist dim(C) = k (≤ n) und d(C) = d, so heißt C ein [n, k]-Code oder [n, k, d]- 

Code über K. n, k, d, q sind die Parameter des Codes. (Für |K| = q gibt es 

auch die Schreibweise [n, k, d]q-Code). 

Beispiel: Der binäre Hamming-Code der Länge 7 aus (2.5) ist ein [7, 4, 3]2- 

Code. 

3.2 Exkurs (Endliche Körper). 

(a) Für jede Primzahl p gibt es einen endlichen Körper Fp = {0, 1, . . . , p − 

1}. Addition und Multiplikation in Fp entsprechen der Addition und 

Multiplikation in Z reduziert modulo p. 

(b) Ist K ein endlicher Körper, so existiert eine Primzahl p und ein n ∈ N, 

so dass |K| = p n . 

(c) Zu jeder Primzahl p und jedem n ∈ N existiert ein Körper K mit 

|K| = p n . (Konstruktion: Wähle ein irreduzibles Polynom f vom Grad 

n aus Fp[X] und setze K = {g ∈ Fp[X] : grad(g) < n}. Definiere die 

Addition in K analog zur der in Fp[X]. Multiplikation in K entspricht 

der Multiplikation in Fp[X] reduziert modulo f.) 

Beispiel: Gesucht ist ein Körper der Größe 4 = 2 2 . Das Polynom f = 

X 2 + X + 1 aus F2[X] ist irreduzibel, da es keine Nullstellen in F2 hat. 

Es ist K = {0, 1, X, X + 1} und es gilt zum Beispiel: X · (X + 1) ≡ 

X 2 + X ≡ 1 · f + 1 ≡ 1 mod f, d.h. X(X + 1) = 1 in K. 

(d) Sind K, L endliche Körper, die die gleiche Anzahl von Elementen enthalten, 

dann ist K isomorph zu L. 

Für die Beweise siehe [Wil99] Abschnitt 2.2. 

3.3 Definition (Minimalgewicht). 

(a) Sei K ein endlicher Körper, x ∈ K n . Dann heißt 

das Gewicht von x. 

wt(x) := d(x, 0) = #{i : xi = 0}


(b) Ist {0} = C ⊆ K n , so heißt 

das Minimalgewicht von C. 

wt(C) = min 

x∈C,x=0 wt(x) 

3.4 Satz. Sei C = {0} ein linearer Code. Dann gilt: 

d(C) = wt(C) 

Beweis. Da C linear ist (x, x ′ ∈ C ⇒ x − x ′ ∈ C) und der Hamming-Abstand 

translationsinvariant ist, gilt: 

d(C) = min{d(x, x ′ ) : x, x ′ ∈ C, x = x ′ } 

= min{d(x − x ′ , 0) : x, x ′ ∈ C, x = x ′ } 

= min{d(y, 0) : y ∈ C, y = 0} 

= wt(C) 

3.5 Definition (Erzeugermatrix). Sei C ein [n, k]-Code über Fq 

g1, . . . , gk eine Basis von C (gi = (gi1, . . . , gin)). Dann heißt 

und 

⎛ ⎞ ⎛ 

⎞ 

G = 

⎜ 

⎝ 

eine Erzeugermatrix für C. 

g1 

. 

gk 

⎟ ⎜ 

⎠ = ⎝ 

g11 · · · g1n 

. 

gk1 · · · gkn 

. 

⎟ 

⎠ ∈ F k×n 

q 

3.6 Satz. Sei C ein linearer [n, k]-Code über Fq. Eine k × n-Matrix G über 

Fq ist genau dann eine Erzeugermatrix für C, wenn gilt: 

C = {uG : u ∈ F k q } 

Beweis. 1. Sei g1, . . . , gk eine Basis für C und G die entsprechende Erzeugermatrix. 

Für jedes u = (u1, . . . , uk) ∈ F k q gilt uG = u1g1 + . . . + ukgk ∈ C. Sei 

nun x ∈ C. Dann existieren u1, . . . , uk ∈ Fq, so dass x = u1g1+. . .+ukgk = uG 

mit u = (u1, . . . , uk). 

2. Sei C = {uG : u ∈ F k q}. Dann gilt (1, 0, . . . , 0)G = g1, . . . , (0, . . . , 0, 1)G = 

gk ∈ C. C wird als Vektorraum aufgespannt von g1, . . . , gk. Da dim(C) = k, 

ist g1, . . . , gk eine Basis von C. Und somit ist G Erzeugermatrix für C.


Beispiel. (a) Der ASCII-Code ist ein binärer [8, 7]-Code mit Erzeugermatrix: 

⎛ 

1 

⎜ 

G = ⎝ 

.. . 

0 

⎞ 

1 

⎟ 

. ⎠ 

0 1 1 

(b) Für den [7, 4]-Hamming Code über F2 ist eine Erzeugermatrix: 

⎛ 

1 

⎜ 

G = ⎜0 

⎝1 

1 

1 

0 

0 

1 

1 

1 

0 

0 

0 

1 

0 

0 

0 

1 

⎞ 

0 

0 ⎟ 

0⎠ 

1 1 1 0 0 0 1 

3.7 Satz (Kontrollmatrix). Sei C ein [n, k]-Code über Fn q . Dann existiert 

eine (n − k) × n-Matrix H, so dass gilt: 

x ∈ F n q : x ∈ C ⇔ Hx t = 0 

H heißt Kontrollmatrix von C. 

Es gilt: HG t = 0 für jede Erzeugermatrix G des Codes C. 

Damit liefert die Kontrollmatrix eine schnelle Art der Fehlererkennung. 

⎛ ⎞ 

Beweis. Sei g1, . . . , gk eine Basis von C und G = 

Gleichungssystem mit der Koeffizientenmatrix G: 

⎜ 

⎝ 

t1g11 + . . . + tng1n = 0 

t1gk1 + . . . + tngkn = 0 

. 

g1 

. 

gk 

⎟ 

⎠. Betrachte das lineare 

Da G den Rang k hat, ist die Dimension des Lösungsraumes ⎛n 

− k. ⎞Sei 

h1, . . . , hn−k ∈ F n q eine Basis des Lösungsraumes. Setze H = 

F (n−k)×n 

q . Dann gilt Hg t i 

⎜ 

⎝ 

h1 

. 

hn−k 

⎟ 

⎠ ∈ 

= 0 für alle i = 1, . . . , k. Ist also x ∈ C, so gilt 

Hx t = 0. Das heißt C ⊆ ker H. Die Dimension des Kerns von H ist jedoch 

k, da Rang(H) = n − k; also dim (ker H) = k = dim C. Daraus folgt, dass 

C = ker H. Das bedeutet: Hx t = 0 ⇔ x ∈ C.


Rezept: Um die Kontrollmatrix eines Codes mit Erzeugermatrix G zu bestimmen, 

wird ein homogenes lineares Gleichungssystem mit G als Koeffizientenmatrix 

aufgestellt. Die Basis des Lösungsraumes wird bestimmt und 

deren Elemente bilden die Zeilen der Kontrollmatrix. 

Beispiel. item Für den binären [7, 4]-Hamming-Code ist eine Kontrollmatrix: 

⎛ 

1 0 0 1 0 1 

⎞ 

1 

H = ⎝0 

1 0 1 1 0 1⎠ 

0 0 1 0 1 1 1 

(So war der binäre [7, 4]-Hamming-Code in 2.5 definiert.) 

Sei 

1 

0 

C 

1 

1 

ein binärer 

[4, 2]-Code mit der Erzeugermatrix G = 

0 1 

. Das lineare Gleichungssystem mit der Koeffizientenma- 

0 1 

trix G hat die Form: 

t1 + t2 + t4 = 0 

t2 + t4 = 0 

Werden t3 und t4 frei gewählt, so sind t1 und t2 festgelegt. Damit bilden 

(0101) und (0010) eine 

Basis und es ergibt sich folgende Kontrollmatrix: 

0 1 0 1 

H = 

. 

0 0 1 0 

(b) (a) Die Kontrollmatrix für den ASCII-Code ist (1 1 1 1 1 1 1 1). 

Für den ISBN-Code (betrachtet als linearer Code über F11) gilt: 

H = (10 9 8 7 6 5 4 3 2 1). 

3.8 Satz. Sei C ein nicht-trivialer [n, k]-Code über F n q (d.h. C = {0}, Fq) mit 

Kontrollmatrix H. Dann gilt: 

d(C) = wt(C) 

= min{r ∈ N : es gibt r linear abhängige Spalten in H } 

= max{r ∈ N : je r − 1 Spalten in H sind linear unabhängig} 

(insbesondere d(C) ≤ rg(H) + 1). 

Beweis. Seien h1, . . . , hn die Spalten von H. Da C nicht-trivial ist, existiert 

0 = x ∈ C, x = (x1, . . . , xn) mit h1x1 + . . . + hnxn = Hx t = 0. Das heißt, 

dass h1, . . . , hn linear abhängig sind.


Sei w ∈ N minimal, so dass es w linear abhängige Spalten gibt, etwa 

hi1, . . . , hiw. Damit existieren cj ∈ Fq mit n j=1 cjhj = 0 und cj = 0 genau 

für j = i1, . . . , iw. 

Für c = (c1, . . . , cn) ergibt sich Hct = 0, also c ∈ C mit wt(c) = w. Daraus 

folgt wt(C) ≤ w. Angenommen es gebe 0 = c ∈ C mit w = wt(c) < w. Dann 

folgt aus Hct = 0, dass es w linear abhängige Spalten in H gibt. Dies ist ein 

Widerspruch zur Wahl von w. Also wt(C) = w. 

Beispiel. Sei C ein [7, 3]-Code über F2 mit Erzeugermatrix 

⎛ 

0 0 1 1 0 1 

⎞ 

1 

G = ⎝1 

1 0 1 1 0 1⎠ 

0 1 0 1 0 0 1 

Um den Minimalabstand zu erhalten, wird die Kontrollmatrix berechnet. 

Zunächst werden die Zeilen in G vertauscht: 

⎛ 

1 1 0 1 1 0 

⎞ 

1 

G ∼ ⎝0 

1 0 1 0 0 1⎠ 

0 0 1 1 0 1 1 

Daran lässt sich die Kontrollmatrix ablesen: 

⎛ 

0 1 1 0 0 

⎜ 

H = ⎜0 

0 1 0 0 

⎝1 

0 0 0 1 

0 

1 

0 

⎞ 

1 

0 ⎟ 

0⎠ 

0 1 1 1 0 0 0 

Da die erste und die fünfte Spalte linear abhängig sind und es keine Nullspalte 

gibt, gilt d(C) = 2. 

Nun kann die schon vorher angesprochene Familie der Hamming-Codes definiert 

werden: 

3.9 Hamming-Codes. 

Sei q eine Primzahlpotenz, l ∈ N, n = ql−1 . Dann existiert ein perfekter 

q−1 

[n, n − l]-Code über Fq mit d(C) = 3, der Hamming-Code. 

Konstruktion. F l q enthält ql − 1 viele von 0 verschiedene Vektoren. Je q − 1 

von diesen erzeugen den gleichen 1-dimensionalen Unterraum. Also hat F l q 

genau n = ql −1 

q−1 

viele 1-dimensionale Unterräume. Wähle aus jedem einen von 

0 verschiedenen Vektor und bilde aus diesen n Spaltenvektoren die (l × n)- 

Matrix H. Sei C der Code mit der Kontrollmatrix H: 

C = {x ∈ F n q ; Hxt = 0}(Hamming − Code)


Der Rang von H ist l, da H l linear unabhängige Spalten enthält (Basis von 

Fl q ), und größer kann der Rang nicht werden. Daher ist dim C = n − l, d.h. 

|C| = qn−l . Je zwei Spalten in H sind linear unabhängig, aber es gibt drei 

linear abhängige Spalten. Aus (3.8) folgt d(C) = wt(C) = 3 und somit e = 1. 

Es gilt: 

1 

j=0 

Daraus folgt: 

 

n 

(q − 1) 

j 

j = 1 + n(q − 1) = 1 + ql − 1 

(q − 1) = ql 

q − 1 

q n 

q l = qn−l = |C| 

und C ist nach 2.4.b) perfekt. 

Es gibt jeweils mehrere Möglichkeiten für einen [n, k]-Hamming-Code, da die 

Spaltenvektoren von H nicht eindeutig gewählt werden (vgl. aber 3.15.c) ). 

Beispiel. (a) Seien q = 2 und l = 3 gegeben. Dann ist n = 23−1 = 7 und 

2−1 

die Matrix 

⎛ 

⎞ 

1 0 0 1 0 1 1 

H = ⎝0 

1 0 1 1 0 1⎠ 

0 0 1 0 1 1 1 

ist Kontrollmatrix des [7, 4]-Hamming-Codes aus 2.5 . 

(b) Seien q = 2 und l = 4 gegeben. Dann ist n = 24 −1 

2−1 

⎛ 

⎞ 

1 0 0 0 1 1 1 0 0 0 1 1 1 0 1 

⎜ 

H = ⎜0 

1 0 0 1 0 0 1 1 0 1 1 0 1 1 ⎟ 

⎝0 

0 1 0 0 1 0 1 0 1 1 0 1 1 1⎠ 

0 0 0 1 0 0 1 0 1 1 0 1 1 1 1 

= 15 und die Matrix 

ist Kontrollmatrix eines [15, 11]-Hamming-Codes, denn n − l = 11. 

Decodierung: 

Angenommen es wurde der Vektor y = (101101001111010) ∈ F15 2 empfangen. 

Mit Hilfe der Kontrollmatrix wird überprüft, ob y ein gültiges 

Codewort ist: 

Hy t ⎛ ⎞ 

0 

⎜ 

= ⎜0 

⎟ 

⎝1⎠ 

1


Da das Ergebnis nicht der Nullvektor ist, ist y /∈ C. Daher wird ein 

x ∈ C gesucht mit d(x, y) minimal. Da C ein 1-Fehler-korrigierender 

und perfekter Code ist, existiert genau ein Codewort x mit d(x, y) = 1. 

Wie sieht x aus? y unterscheidet sich von x an genau einer Stelle i 

(1 ≤ i ≤ 15). Statt yi steht in x an der Stelle i der Eintrag yi + 1, so 

dass Hx t = 0 ist. Damit dies erfüllt ist, muss gelten: 

Daraus folgt: ⎛ 

h1i(yi + 1) = h1iyi 

h2i(yi + 1) = h2iyi 

h3i(yi + 1) = h3iyi + 1 

h4i(yi + 1) = h4iyi + 1 

⎜ 

⎝ 

h1i 

h2i 

h3i 

h4i 

⎞ 

⎟ 

⎠ = 

⎛ ⎞ 

0 

⎜ 

⎜0 

⎟ 

⎝1⎠ 

= Hyt 

1 

Suche also in H die Spalte, die mit (0, 0, 1, 1) t übereinstimmt und 

ändere beim Index dieser Spalte den entsprechenden Eintrag von y. 

Hier ist i = 10. Damit wird y10 = 1 zu 0 geändert und y wird zu 

x = (101101001ˇ011010) ∈ C decodiert. Diese Decodierung ist genau 

dann korrekt, wenn in y nur ein Fehler aufgetreten ist. 

Allgemeine Decodierung binärer Hamming-Codes: Angenommen es 

wurde y empfangen: 

1. Fall: Hyt = 0: Decodierung y −→ y. 

2. Fall: Hy t = 0: Suche in H diejenige Spalte, die mit Hy t übereinstimmt. 

Ist dies die i-te Spalte, so ändere die i-te Komponente von y. Dies liefert 

ein x ∈ C. Decodierung: y −→ x. 

Wie decodiert man beliebige lineare [n, k]q-Codes? Wurde y empfangen, so 

wird dies zu x decodiert mit d(x, y) minimal. Man kann alle qk Codewörter auf 

den Abstand zu y testen und von den Codewörtern mit minimalem Abstand 

eines zur Decodierung auswählen. Dies ist im Allgemeinen nicht eindeutig. 

Bei großen Codes (2k > n) gibt es ein effizienteres Verfahren, die Syndrom- 

Decodierung. 

Exkurs (Nebenklassen von Unterräumen in Vektorräumen). 

Sei C ein Unterraum eines Vekorraums V . Dann heißt für jedes v ∈ V 

v + C := {v + x : x ∈ C} 

die Nebenklasse von C zu v.


(a) Für v1, v2 ∈ V gilt entweder v1 +C = v2 +C oder (v1 +C)∩(v2 +C) = ∅. 

Beweis: Sei (v1+C)∩(v2+C) = ∅. Dann gibt es ein y ∈ (v1+C)∩(v2+C) 

mit y = v1 + x1 = v2 + x2 für x1, x2 ∈ C. Daraus folgt: v1 = v2 + (x2 − 

x1) ∈ v2 + C. Für beliebiges x ∈ C ist auch v1 + x = v2 + (x2 − x1) + x ∈ 

v2 + C. Also ist v1 + C ⊆ v2 + C. Dasselbe Argument, aber mit 1 und 2 

getauscht, ergibt v2 + C ⊆ v1 + C. Insgesamt somit v1 + C = v2 + C. 

(b) v1 + C = v2 + C ⇔ v1 − v2 ∈ C 

Beweis: 1. v1+C = v2+C ⇒ v1 = v1 +0 ∈ v1 +C = v2+C ⇒ v1 = v2 +x 

für ein x ∈ C ⇒ v1 −v2 = x ∈ C. 2. Sei v1 −v2 = x ∈ C ⇒ v1 = v2 +x ∈ 

(v1 + C) ∩ (v2 + C) (a) 

⇒ v1 + C = v2 + C. 

(c) Für alle v ∈ v1 + C gilt v + C = v1 + C. 

(d) Wähle aus jeder Nebenklasse von C einen Vertreter vi: 

V = ˙ 

i vi + C 

(e) Sei V ein Vektorraum über einem endlichen Körper Fq. Dann gilt |C| = 

|v + C| für alle v ∈ V (da x ↦→ v + x bijektiv ist). 

(f) Aus (d) und (e) folgt: Ist C ein [n, k]-Code über Fq, so hat C genau q n−k 

viele verschiedene Nebenklassen. 

3.10 Syndrom-Decodierung linearer Codes. 

Sei C ein [n, k]-Code über Fq mit (n − k) × n-Kontrollmatrix H. Zu y ∈ Fn q 

heißt Hyt ∈ Fn−k q das Syndrom von y (bzgl. C und H). 

(a) y ∈ C ⇔ Hy t = 0 ⇔ x hat Syndrom 0 (kein ”Krankheitsbild”). 

(b) y1 + C = y2 + C ⇔ Hy t 1 = Hyt 2 , d.h. y1, y2 ∈ Fn q liegen genau dann in 

der gleichen Nebenklasse bzgl. C , wenn sie das gleiche Syndrom haben. 

(y1 + C = y2 + C ⇔ y1 − y2 ∈ C (a) 

⇔ 0 = H(y1 − y2) t = Hy t 1 − Hyt 2 ⇔ 

Hy t 1 = Hy t 2) 

(c) Jedes z ∈ F n−k 

q 

tritt als Syndrom auf. 

Daher: Wird x ∈ C gesendet und als y = x + f empfangen (f Fehlervektor), 

so haben y und f das gleiche Sydrom (Hy t = Hx t + Hf t = 0 + Hf t ). Damit 

liegt f in y + C. 

Syndrom-Decodierung: Bestimme in jeder Nebenklasse von C einen Vektor 

f von minimalem Gewicht (= Nebenklassenführer (i.A. nicht eindeutig)).


Stelle eine Liste der Nebenklassenführer von C mit zugehörigem Syndrom auf. 

Dafür sind insgesamt (n − k)q n−k + nq n−k Elemente aus Fq zu vergleichen. 

(Es gibt q n−k Nebenklassen, die Nebenklassenführer haben n Komponenten 

aus Fq und die Syndrome n − k Komponenten aus Fq). Zu empfangenem y 

wird das Syndrom Hy t berechnet und der Nebenklassenführer mit gleichem 

Syndrom gesucht. Decodierung: y → y − f. 

Ist 2k > n, so ist q n−k < q k ; d.h. es sind weniger Vergleiche durchzuführen, 

als bei dem vor 3.10 beschriebenen Verfahren. 

Beispiel. Sei C ein [5, 3]-Code über F2 mit Kontrollmatrix: 

 

0 1 0 0 1 

H = 

. 

1 0 1 1 0 

Damit gilt (x1, x2, x3, x4, x5) ∈ C, falls die beiden folgenden Gleichungen 

erfüllt sind: 

x2 + x5 = 0 

x1 + x3 + x4 = 0 

Und man erhält die Erzeugermatrix: 

⎛ 

0 1 0 0 

⎞ 

1 

G = ⎝1 

0 0 1 0⎠ 

. 

1 0 1 0 0 

Der Code C hat 2 3 = 8 Elemente und 2 n−k = 2 2 = 4 Nebenklassen, die 

wie folgt angegeben werden können (die möglichen Nebenklassenführer sind 

unterstrichen): 

1. (00000) + C = C = {(00000), (01001), (10010), (10100), 

(11011), (11101), (00110), (01111)} 

2. (10000) + C = {(10000), (11001), (00010), (00100), 

(01011), (01101), (10110), (11111)} 

3. (01000) + C = {(01000), (00001), (11010), (11100), 

(10011), (10101), (01110), (00111)} 

4. (11000) + C = {(11000), (01001), (01010), (01100), 

(00011), (00101), (11110), (10111)} 

Eine mögliche Liste von Nebenklassenführern und zugehörigen Syndromen 

kann folgende sein: 

Nkl-führer f1 = (00000) f2 = (10000) f3 = (01000) f4 = (11000) 

Syndrom Hf t 

 

0 

0 

1 

1 

0 

1 

0 

1


Wurde zum Beispiel y = (10011) empfangen mit Hy t = 1 

, so wird y zu 

0 

y − f3 = (11011) decodiert. 

Die Syndromdecodierung kann bei großen Codes immer noch sehr aufwändig 

sein. Zum Beispiel hat ein [70, 50]-Code C über F2 einen Speicherplatzbedarf 

für Nebenklassenführer und Syndrome von ca. 11 Megabyte: C hat 2 20 

viele Nebenklassen. Jeder Nebenklassenführer besteht aus 70 Bits und die 

Syndrome jedes Nebenklassenführers bestehen aus 20 Bits. Man erhält einen 

Speicherplatzbedarf von 70·2 20 +20·2 20 = 90·2 20 Bits ≈ 11 Megabyte. (Hätte 

man alle 2 50 Codewörter speichern müssen, so läge der Speicherplatzbedarf 

bei 70 · 2 50 Bits ≈ 10000 Terabyte). 

Der Speicherplatzbedarf lässt sich noch reduzieren, wenn man die Nebenklassenführer 

in lexikographischer Ordnung ihrer Syndrome speichert. Dann 

müssen die Syndrome nicht mehr gespeichert werden. Bei solchen Größenordnungen 

ist eine andere Methode praktischer: 

3.11 Schrittweise Decodierung (Step-by-Step-Decodierung). 

Bei diesem Verfahren müssen nur die Syndrome der Nebenklassenführer und 

deren Gewicht gespeichert werden. Es wird nur der Fall binärer Codes betrachtet: 

Sei y ∈ F2 n das empfangene Wort und seien e1, . . . , en die kanonischen Einheitsvektoren 

in Fn 2 . Die Decodierung geschieht nach folgendem Algorithmus: 

(1) i = 1 

(2) Berechne Hy t und stelle das Gewicht w des Nebenklassenführers mit 

gleichem Syndrom fest. 

(3) Ist w = 0, so gebe y als Decodierung aus. stop. 

(4) Hat H(y+ei) t kleineres zugeordnetes Gewicht, so ersetze y durch y+ei. 

(5) Setze i := i + 1. goto (2). 

Warum terminiert der Algorithmus und liefert ein Codewort? Dazu wird die 

lexikographische Ordnung auf F2 definiert durch: 

(a1, . . . , an) < (b1, . . . , bn) ⇔ ∃k : ai = bi für i ≤ k, ak+1 = 1, bk+1 = 0 

(z.B. ist (01011) < (01001) ) 

Satz: Schrittweise Decodierung entspricht der Syndrom-Decodierung, wenn 

aus jeder Nebenklasse unter den Vertretern mit minimalem Gewicht der lexikographisch 

erste als Nebenklassenführer ausgewählt wird.


Beweis. Der Abstand von y zum nächsten Codewort sei m. Dann hat y + C 

einen Nebenklassenführer f von Gewicht m. Sei i die Stelle, an der y zum 

ersten Mal geändert wurde, so dass das Gewicht des Nebenklassenführers ˜ f 

von (y+ei)+C kleiner als das von y ist. Der Abstand von y+ei zum nächsten 

Codewort ist mindestens m − 1. Da (y + ei) + ˜ f ∈ C ist und wt( ˜ f) < wt(f), 

folgt wt( ˜ f) = m − 1. 

Angenommen man kann y+ei an einer Stelle j ändern, j < i, so dass y+ei+ej 

einen Abstand < m − 1 von C hat. Dann hätte y + ej einen Abstand ≤ m − 1 

von C, und der Nebenklassenführer zu (y + ej) + C hätte Gewicht ≤ m − 1; 

Widerspruch zur Wahl von i. 

Somit kann y +ei nur an Stellen j > i geändert werden, um den Abstand von 

C zu verringern. Durch Induktion folgt nun, dass der Algorithmus terminiert. 

Man sieht sofort, dass y zu y+f decodiert wurde, wobei f ∈ y+C von minimalem 

Gewicht und lexikographisch der erste unter allen Nebenklassenführern 

ist. 

Beispiel. Wir betrachten das Beispiel aus 3.10 : 

Nkl-führer f1 = (00000) f2 = (10000) f3 = (01000) f4 = (11000) 

Syndrom Hf t 

 

0 

0 

1 

1 

0 

1 

0 

1 

Bei der schrittweisen Decodierung würde nur gespeichert werden: 

Syndrom 

Gewicht Nkl-führer 

0 

0 

0 

1 

1 

0 

1 

1 

1 

2 

Wurde zum Beispiel y = (10011) empfangen, so werden die folgenden Schritte 

zur Decodierung durchlaufen: 

y = (10011) : Hy t = 1 

wt = 1 

0 

y + e1 = (00011) : Hy t = 1 

wt = 2 (y lassen) 

1 

y + e2 = (11011) : Hy t = 0 

wt = 0 (y so decodieren) 

0 

y → (11011) = y + f3 ∈ C 

Es ist ein schwieriges Problem, allgemeine Aussagen über die Gewichte von 

Nebenklassenführern zu machen. Betrachten wir zum Beispiel den oben angesprochenen 

[70, 50]-Code. Angenommen die Nebenklassenführer haben alle 

Gewicht ≤ 12. Dann benötigt man maximal 4 Bits zur Auflistung der Gewichte 

der Nebenklassenführer. Zusammen mit den Syndromen liefert dies 

einen Speicherplatzaufwand von 20 · 2 20 + 4 · 2 20 = 24 · 2 20 Bits, eine Reduk- 

tion auf ca. 1 

4 

des Aufwandes für die Syndromdecodierung.


Allerdings sind hier maximal n = 70 Syndrom-Berechnungen und Gewichtsfeststellungen 

in der Liste notwendig - gegenüber einer einzigen bei der Syndromdecodierung. 

(Time-Space-Trade-Off!) 

Zur Definition der Äquivalenz von Codes wird der Begriff der Isometrie 

benötigt: 

3.12 Definition (Isometrie). Eine invertierbare n × n-Matrix A über Fq 

heißt Isometrie (bzgl. der Hamming-Metrik) von F n q , falls für alle u, v ∈ Fn q 

gilt: 

(∗) d(uA, vA) = d(u, v) 

Wegen d(uA, vA) = d(uA − vA, 0) = d((u − v)A, 0) = wt((u − v)A) ist (∗) 

äquivalent zu 

(∗∗) wt(uA) = wt(u) für alle u ∈ F n q 

Bemerkung. Die Isometrien von Fn q bilden bezüglich der Multiplikation eine 

Gruppe. 

Beispiele von Isometrien. 

(a) Sei Sn die Menge aller Permutationen auf {1, . . . , n} und π eine Permutation 

von {1, . . . , n} (also π ∈ Sn). Definiere zu π eine Permutationsmatrix 

P (π) = (Pij)i,j=1,...,n durch: 

 

1 : i = π(j) 

Pij = 

0 : sonst 

Zum Beispiel ist für die Permutation π = 

⎛ 

0 0 

⎞ 

1 

⎝1 

0 0⎠. 

0 1 0 

 

1 2 3 

: P (π) = 

2 3 1 

Für eine Permutationmatrix P (π) und einen Vektor u ∈ F n q gilt: 

(u1, . . . , un)P (π) = (uπ(1), . . . , uπ(n)) 

Die Permutationsmatrizen bilden eine Untergruppe der Isometrien, 

denn 

1. wt(u) = wt(uP (π)), d.h. jede Permutationsmatrix ist eine Isometrie 

2. P (π) · P (π ′ ) = P (π ◦ π ′ )


3. P (π) −1 = P (π −1 ) 

4. In = P (id) 

(b) Für ai ∈ Fq\{0} sei D die folgende invertierbare Diagonalmatrix: 

⎛ 

a1 

⎜ 

D = ⎝ 

. .. 

⎞ 

0 

⎟ 

⎠ 

0 an 

Dann ist für u ∈ F n q : (u1, . . . , un)D = (a1u1, . . . , anun) und wt(u) = 

wt(uD). Also sind invertierbare Diagonalmatrizen Isometrien - und sie 

bilden auch eine Untergruppe der Isometrien. 

(c) Eine Matrix M = D · P (π) aus einer invertierbaren Diagonalmatrix D 

und für π ∈ Sn heißt monomiale Matrix. Sie ist eine Isometrie. Und es 

gilt: 

M monomial ⇔ M hat in jeder Zeile und in jeder Spalte 

genau einen Eintrag = 0 

Es gilt im Allgemeinen nicht: D · P (π) = P (π) · D, sondern: 

⎛ ⎞ 

⎛ 

⎞ 

⎜ 

⎝ 

a1 

. .. 

an 

⎟ 

⎜ 

⎠ · P (π) = P (π) · ⎝ 

aπ(1) 

. .. 

aπ(n) 

⎟ 

⎠ . 

Die monomialen Matrizen bilden die sogenannte monomiale Gruppe 

M(n, Fq) 

3.13 Satz. Die Gruppe der Isometrien stimmt mit der Gruppe der monomialen 

Matrizen M(n, Fq) überein. 

Beweis. Es ist zu zeigen, dass jede Isometrie eine monomiale Matrix ist. Sei 

also A eine Isometrie und ei der i-te Einheitsvektor. Dann ist wt(eiA) = 

wt(ei) = 1, d.h. ei und damit auch eiA hat nur einen von 0 verschiedenen 

Eintrag. Es existiert also ein i ′ ∈ {1, . . . , n} und ai ∈ Fq\{0}, so dass eiA = 

aiei ′. 

Da die ei eine Basis bilden, ist die Zuordnung i → i ′ eine Permutation π. 

Also: 

⎛ ⎞ 

A = 

⎜ 

⎝ 

a1 

. .. 

an 

⎟ 

⎠ · P (π −1 ) monomial.


3.14 Definition (Äquivalenz von Codes). Zwei Codes C, C ′ ⊆ F n q heißen 

äquivalent (C ≈ C ′ ), falls ein A ∈ M(n, Fq) (also eine Isometrie von F n q ) 

existiert mit: 

CA = C ′ . 

(d.h. {xA : x ∈ C} = C ′ ) 

3.15 Bemerkung. (a) Äquivalente Codes haben die gleichen Parameter 

(d.h. gleiche Länge, gleiche Anzahl von Elementen und gleichen Minimalabstand). 

(b) Seien C und C ′ äquivalente lineare Codes mit CA = C ′ für ein A ∈ 

M(n, Fq). Dann gilt: 

G Erzeugermatrix für C ⇒ GA Erzeugermatrix für C ′ 

H Kontrollmatrix für C ⇒ H(A t ) −1 Kontrollmatrix für C ′ 

(GA Erzeugermatrix für C ′ ist klar. xA ∈ C ′ ⇔ x ∈ C ⇔ Hx t = 0 ⇔ 

H(A t ) −1 A t x t = 0 ⇔ H(A t ) −1 (xA) t = 0). 

(c) Elementare Zeilenumformungen an einer Erzeugermatrix bzw. an einer 

Kontrollmatrix eines linearen Codes ändern den Code nicht. Spaltenvertauschungen 

und Multiplikation von Spalten mit Skalaren = 0 

(bei der Erzeuger- oder Kontrollmatrix) ändern den Code zu einem 

äquivalenten Code. 

Insbesondere: Verschiedene Auswahlen und Anordnungen von Vektoren 

= 0 aus sämtlichen 1-dimensionalen Unterräumen von Fk q bei der 

Bildung der Kontrollmatrix der Hamming-Codes führt zu äquivalenten 

Codes. 

(d) Seien C und C ′ lineare Codes der Dimension k über Fn q . Angenommen, es 

existiert eine Fq-lineare Abbildung ϕ : C −→ C ′ mit wt(c) = wt(ϕ(c)) 

für alle c ∈ C. Dann ist C ≈ C ′ , d.h. es existiert eine Isometrie A von Fn q 

mit CA = C ′ . (Beachte: Umkehrung ist trivial). Dies ist ein Satz von 

MacWilliams; vgl. [MS77], Satz 4.1.2 . 

3.16 Satz. Sei C ein [n, k]-Code über Fq. Dann existiert ein zu C äquivalenter 

Code C ′ , dessen Erzeugermatrix von folgender Form ist: 

G ′ ⎛ 

1 

⎜ 

= (Ik | B) = ⎝ 

. .. 

0 ∗ . . . 

⎞ 

∗ 

⎟ 

⎠ 

0 1 ∗ . . . ∗ 

Eine solche Erzeugermatrix ist von Standardform.


Beweis. Sei G die Erzeugermatrix von C. Die k Zeilen von G sind linear unabhängig. 

,,Zeilenrang = Spaltenrang”⇒ G hat k linear unabhängige Spalten. 

Durch geeignete Spaltenvertauschung erhält man eine Matrix ˜ G in der die ersten 

k Spalten linear unabhängig sind. Durch elementare Zeilenumformungen 

kann man ˜ G auf die Form G ′ = (Ik | B) bringen. 

Nach 3.15 c) erzeugen G und ˜ G äquivalente Codes und ˜ G und G ′ den gleichen 

Code. 

Beispiel. Die folgende Matrix sei die Erzeugermatrix eines [5, 3]-Codes 

Cüber F2: 

⎛ 

1 1 0 1 

⎞ 

1 

G = ⎝1 

1 1 1 0⎠ 

1 1 0 0 1 

C hat keine Matrix in Standardform, denn jedes Element in C hat an den 

ersten beiden Stellen den gleichen Eintrag. Vertausche zuerst die 2te und 4te 

Spalte und wende elementare Zeilenumformungen an: 

⎛ 

1 1 0 1 

⎞ 

1 

⎛ 

1 1 0 1 

⎞ 

1 

⎛ 

1 0 0 1 

⎞ 

1 

⎝1 

1 1 1 0⎠ 

⎝0 

0 1 0 1⎠ 

⎝0 

1 0 0 0⎠ 

= G 

1 0 0 1 1 0 1 0 0 0 0 0 1 0 1 

′ 

G ′ ist in Standardform und erzeugt einen zu C äquivalenten Code C’. 

3.17 Bemerkung. Sei C ein [n, k]-Code über Fq mit Erzeugermatrix G. 

Dann kann man qk-viele Originalzeichen codieren. Üblicherweise ordnet man 

jedem Originalzeichen genau ein Element (x1, . . . , xk) ∈ Fk q zu. Dieses wird 

dann codiert in (x1, . . . , xk)G ∈ C (C = {xG : x ∈ F k q }). 

Ist G = (Ik | B) in Standardform, so bleiben bei der Codierung die ersten k 

Elemente gleich: 

(x1, . . . , xk) ↦−→ (x1, . . . , xk, ∗, . . . , ∗). 

Man kann also die Originalnachricht an den ersten k Stellen des Codewortes 

ablesen. 

Beispiel. Es sei C der [5, 3]-Code über Fq mit der Erzeugermatrix 

⎛ 

1 1 0 1 

⎞ 

1 

G = ⎝1 

1 1 1 0⎠ 

1 0 0 1 1 

(Dies ist gerade die Matrix aus dem Beispiel 3.16, wenn dort die zweite 

und vierte Spalte vertauscht werden.) Die Originalnachrichten sind aus F 3 2 .


Der Vektor (101) wird zunächst mit G codiert zu (101)G = (01000); oder 

allgemeiner: 

(a1, a2, a3) ↦−→ (a1 + a2 + a3, a1 + a2, a2, a1 + a2 + a3, a1 + a3) 

Nach dem Beispiel in 3.16 hat C eine Erzeugermatrix 

G ′ ⎛ 

1 0 0 1 

⎞ 

1 

= ⎝0 

1 0 0 0⎠ 

0 0 1 0 1 

in Standardform. Es ist (101)G ′ = (10110) und allgemein: 

(a1, a2, a3) ↦−→ (a1, a2, a3, a1, a1 + a3) 

Es gilt F 3 2 G = F3 2 G′ = C, aber die Codierung eines Elementes aus F 3 2 ist 

unterschiedlich.

4 ALLGEMEINE KONSTRUKTIONSPRINZIPIEN 34 

4 Allgemeine Konstruktionsprinzipien 

4.1 Definition. Für u, v ∈ F n q , u = (u1, . . . , un), v = (v1, . . . , vn) sei 

< u, v >:= 

n 

uivi = uv t . 

i=1 

(Für q = 2 gilt: < v, v >= 0 ⇔ wt(v) gerade). 

4.2 Bemerkung (Eigenschaften von < ·, · >). Seien u, v, w ∈ F n q und 

λ ∈ Fq. 

(a) = < u, w > + < v, w > 

(b) < λu, v > = λ < u, v > 

(c) < u, v > = < v, u > 

Diese Eigenschaften machen < ·, · > zu einer symmetrischen Bilinearform. 

(d) < 0, v > = < v, 0 > = 0 

(e) Ist u ∈ F n q mit < u, v >= 0 ∀v ∈ F n q , so ist u = 0. 

< ·, · > ist somit eine nicht-ausgeartete symmetrische Bilinearform. 

Beweis. a) - d) sind leicht. 

e) Sei u = (u1, . . . , un) ∈ F n q mit < u, v > = 0 für alle v ∈ F n q ; und sei ei 

der i-te Einheitsvektor. Dann gilt ui = < u, ei > = 0 für i = 1, . . . , n. Somit 

u = (0, . . . , 0). 

4.3 Definition (Dualer Code). Sei C ⊆ Fn q (C braucht kein Unterraum zu 

sein). Dann heißt 

C ⊥ = {y ∈ F n q 

: < y, x > = 0 ∀x ∈ C} 

der duale Code zu C. C ⊥ ist immer ein Unterraum, also ein linearer Code. 

4.4 Satz. Sei C ein [n, k]-Code über Fq. Dann gilt: 

(a) C ⊥ ist ein [n, n − k]-Code über Fq. 

(b) (C ⊥ ) ⊥ = C 

(c) G ist Erzeugermatrix für C ⇔ G ist Kontrollmatrix für C ⊥ 

H ist Kontrollmatrix für C ⇔ H ist Erzeugermatrix für C ⊥


(d) Ist (Ik | A) eine Erzeugermatrix von C (in Standardform), so ist 

(−A t | In−k) eine Erzeugermatrix von C ⊥ , also Kontrollmatrix von C. 

Beweis. (a) Sei G Erzeugermatrix von C, y ∈ F n q . Dann gilt: 

y ∈ C ⊥ ⇔ < x, y > = 0 ∀ x ∈ C 

⇔ < xi, y > = 0 für eine Basis x1, . . . , xk von C 

⇔ Gy t = 0 (Zeilen von G bilden Basis) 

Damit ist G Kontrollmatrix von C ⊥ mit dim(C ⊥ ) = n - rg(G) = n − k. 

(b) Klar, dass C ⊆ (C ⊥ ) ⊥ . Für die Dimensionen gilt: 

Also gilt die Gleichheit. 

dim(C ⊥ ⊥ (a) 

) = n − (n − k) = dim C. 

(c) Die erste Äquivalenz folgt aus dem Beweis von (a). Mit (b) folgt die 

zweite Äquivalenz aus der ersten. 

(d) Es gilt: 

(−A t | In−k)(Ik | A) t = (−A t | In−k) 

 

Ik 

At 

= −A t Ik + In−kA t = 0 

Daraus folgt, dass (−A t | In−k) eine Kontrollmatrix von C ist und nach 

(c) somit eine Erzeugermatrix für C ⊥ . 

4.5 Beispiel (Simplex-Codes). 

Für n = qk−1 sind die Hamming-Codes [n, n − k]-Codes über Fq. 

q−1 

Kontrollmatrix H: Wähle für jede Spalte aus jedem 1-dimensionalen Unterraum 

Fk q einen von 0 verschiedenen Vektor. 

Sei C der duale Code zum Hamming-Code. Nach 4.4.c) ist H eine Erzeugermatrix 

von C. C ist ein [n, k]-Code über Fq und heißt Simplex-Code. 

Jedes Codewort = 0 in C hat Gewicht qk−1 , d.h. der Abstand zwischen je 

zwei verschiedenen Codeworten ist immer konstant qk−1 , insbesondere d(C) 

= qk−1 : 

Seien z1, . . . , zk die Zeilen von H, 0 = x = (x1, . . . , xn) ∈ C. Da die Zeilen 

von H eine Basis von C bilden, gibt es ai ∈ Fq mit x = a1z1 + . . . + akzk = 

k i=1 ai(zi1, . . . , zin). Setze a = (a1, . . . , ak) ∈ Fk q und U = < a > ⊥ = {b ∈ 

Fk q : abt = 0}. Es ist dim U = dim Fk q − dim < a > = k − 1. Die Anzahl


der Elemente von U entspricht qk−1−1 vielen Spalten von H. Es gilt xj = 

q−1 

0 ⇔ k i=1 aizij = 0 ⇔ (z1j . . . zkj) t ∈ U. Damit sind in x genau qk−1−1 viele 

q−1 

Komponenten xj = 0. Und für das Gewicht gilt: 

wt(x) = n − qk−1 − 1 

q − 1 = qk−1 (q − 1) 

= q 

q − 1 

k−1 . 

Der Simplex-Code ist nicht perfekt, von kleiner Dimension, hat aber großen 

Minimalabstand d(C) = q k−1 . 

Speziell: Der Simplex-Code C zum [7, 4]-Hamming-Code hat die Erzeugermatrix: 

⎛ 

1 0 0 1 1 0 

⎞ 

1 

H = ⎝0 

1 0 1 0 1 1⎠ 

0 0 1 0 1 1 1 

C ist ein [7, 3]-Code mit Minimalabstand d(C) = 2 2 = 4 und 

C = {(0000000), (1001101), (0101011), (0010111), 

(1100110), (0111100), (1011010), (1110001)} 

(Andere Anordnungen der Spalten in H führen zu äquivalentem Code.) 

Beispiel. (Codierung und Decodierung mit Simplex-Code) 

Identifiziere die Buchstaben des Alphabets (I=J) mit den 25 Elementen von 

F 2 5 : 

A = 00 F = 10 L = 20 Q = 30 V = 40 

B = 01 G = 11 M = 21 R = 31 W = 41 

C = 02 H = 12 N = 22 S = 32 X = 42 

D = 03 I=J=13 O = 23 T = 33 Y = 43 

E = 04 K=14 P = 24 U = 34 Z = 44 

Der Simplex-Code der Dimension 2 über F5 hat die Länge 52−1 5−1 

Erzeugermatrix in Standardform ist: 

 

1 

H = 

0 

0 

1 

1 

1 

1 

2 

1 

3 

 

1 

4 

= 6, und eine 

Ein Element (x, y) ∈ F 2 5 wird mit der Erzeugermatrix des Simplex-Codes 

codiert zu: 

(x, y)H = (x, y, x + y, x + 2y, x + 3y, x + 4y) 

Dieser Simplex-Code hat 5 4 = 625 Nebenklassen in F 6 5 . Daher ist es sinnvoller 

anstatt durch Syndrom-Decodierung zu decodieren, die empfangenen Wörter 

mit der Liste der 25 Codewörter des [6, 2]-Simplex-Codes zu vergleichen:


Angenommen, man empfängt: 

000000 101111 202222 303333 404444 

011234 112340 213401 314012 410123 

022413 123024 224130 320241 421302 

033142 134203 230314 331420 432031 

044321 140432 241043 342104 443210 

341243 | 040300 | 342104 | 330241 | 004320 

Das erste, zweite, vierte und fünfte Wort ist jeweils kein Codewort. (Eine 

Decodierung anhand der jeweils ersten zwei Zeichen ergibt auch keinen Sinn: 

34,04,34,33,00 = UEUTA). 

Der Minimalabstand des [6, 2]-Simplex-Codes beträgt 5 2−1 = 5. Er ist also 2- 

Fehler-korrigierend. Unter der Annahmen, dass in jedem empfangenen Wort 

höchstens zwei Fehler aufgetreten sind, wird korrigiert zu: 

241043 | 000000 | 342104 | 320241 | 044320 

Dies wird decodiert zu 24,00,34,32,04 = PAUSE. 

4.6 Satz (Plotkin-Konstruktion). Für i = 1, 2 seien Ci [n, ki]-Codes mit 

d(Ci) = di. Dann ist 

C1 ∝ C2 := {(x1, x1 + x2) : xi ∈ Ci} ⊆ F 2n 

q 

ein [2n, k1 + k2]-Code über Fq mit d(C) = min{2d1, d2}. 

Beweis. i) Klar, dass C ⊆ F2n q . D.h. C ist von der Länge 2n. 

ii) Betrachte die Abbildung: 

α : C1 ⊕ C2 = {(x1, x2) : xi ∈ Ci} −→ C 

(x1, x2) ↦−→ (x1, x1 + x2) 

Die Abbildung α ist linear, injektiv und surjektiv, also ein Vektorraumisomorphismus. 

Damit gilt für die Dimension: 

dim C = dim C1 ⊕ C2 = k1 + k2. 

iii) Was ist d(C)? Ist C = {0}, so ist d1 = d2 = 0. Sei also C = 0 und 

0 = x = (x1, x1 + x2) ∈ C. Definiere für z = (z1, . . . , zn) ∈ F n q 

als den Träger von z. 

T r(z) := {j : zj = 0}


Ist x2 = 0, so gilt: wt(x) = 2wt(x1) ≥ 2d1 (da x1 = 0). 

Ist x2 = 0, so gilt: 

wt(x) = wt(x1) + wt(x1 + x2) 

≥ wt(x1) + wt(x1) + wt(x2) − 2|T r(x1) ∩ T r(x2)| 

≥ wt(x2) = d2 

( wt(x1) ≥ |T r(x1) ∩ T r(x2)| ) 

Also: d(C) ≥ min{2d1, d2}. Mit x1 = 0 und x2 von minimalem Gewicht in C2 

oder x2 = 0 und x1 von minimalem Gewicht in C1 wird das Minimum auch 

angenommen. 

4.7 Beispiel (Binäre Reed-Muller-Codes). (Reed, Muller; 1954) 

Seien r, m ∈ N0 mit 0 ≤ r ≤ m gegeben und K = F2. Konstruiere binäre 

lineare [2m , r 

m−r 

i=0 ]-Codes C = RM(r, m) mit d(C) = 2 . Setze 

m 

i 

RM(0, m) = {(0 . . . 0), (1 . . . 1)}, der [2 m , 1]-Wiederholungscode mit 

Minimalabstand 2 m . 

RM(m, m) = K2m , der [2m , 2m ]-Code mit Minimalabstand 1. 

Damit ist der Code für r = 0, r = m und m = 1 schon definiert. Für die 

Fälle m > 1 und 1 < r < m wird rekursiv definiert: 

Nach 4.6 gilt: 

RM(r, m) = RM(r, m − 1) ∝ RM(r − 1, m − 1) 

Länge von RM(r, m) ist 2 · 2 m−1 = 2 m 

Minimalabstand: d(RM(r, m)) = min{2 · 2 m−1−r , 2 m−1−(r−1) } = 2 m−r 

Dimension ist 

dim(RM(r, m)) = dim(RM(r, m − 1)) + dim(RM(r − 1, m − 1)) 

r 

 

m − 1 r−1 

 

m − 1 

= 

+ 

i 

i 

i=0 

i=0 

r−1 

 

m − 1 m − 1 

= 1 + 

+ 

i + 1 i 

i=0 

r−1 

r 

 

m m 

= 1 + 

= . 

i + 1 i 

i=0 

i=0


RM(r, m) heißen binäre Reed-Muller-Codes r-ter Ordnung. 

Beispiel. (a) C = RM(1, 2) ist ein binärer [4, 3]-Code mit d(C) = 2 und 

C = RM(1, 1) ∝ RM(0, 1) 

= {(00), (11), (10), (01)} ∝ {(00), (11)} 

= {(0000), (0011), (1111), (1100), 

(0101), (0110), (1010), (1001)} 

(b) C = RM(1, 3) ist ein binärer [8, 4]-Code bestehend aus |C| = 16 

Wörtern mit d(C) = 4 und 

C = RM(1, 2) ∝ RM(0, 2) 

(c) C = RM(1, 5) ist ein binärer [32, 6]-Code mit d(C) = 16 

RM(1, 5) wurde bei den Mariner Expeditionen 6, 7 und 9 zum Mars in 

den Jahren 1969 - 1972 eingesetzt, um Bilder zur Erde zu übertragen. 

Jedes der 26 = 64 Codewörter entsprach jeweils einer Graustufe. Ein 

Bild wurde in ein 600 × 600 Gitter zerlegt und jeder der 360.000 Bildpunkte 

in ein Codewort codiert. Wegen 7 ≤ d(C)−1 15 = konnten bis zu 

2 2 

7 Fehler in einem Codewort (der Länge 32) korrigiert werden. 2 

4.8 Satz. 

(a) RM(r − 1, m) ⊆ RM(r, m) ∀r ≤ m ∈ N0 

(b) (1, . . . , 1) ∈ RM(r, m) ∀r ≤ m ∈ N0 

(c) x ∈ RM(1, m), x = (0, . . . , 0), (1, . . . , 1) ⇒ wt(x) = 2 m−1 

(vgl. Simplex-Codes) 

(d) RM(m−1, m) besteht aus allen Worten des F 2m 

2 von geradem Gewicht. 

Beweis. (a) Induktion nach m. m = 1 : RM(0, 1) ⊆ RM(1, 1) klar. 

m − 1 → m: 

(i) r = m : RM(m − 1, m) ⊆ K2m = RM(m, m) 

(ii) r < m: 

RM(r − 1, m) = RM(r − 1, m − 1) ∝ RM(r − 2, m − 1) 

2 vgl. http://spacelink.nasa.gov 

IV 

⊆ RM(r, m − 1) ∝ RM(r − 1, m − 1) 

= RM(r, m).


(b) Folgt aus (a), da RM(0, m) ⊆ RM(r, m). 

(c) Induktion nach m. m = 1 : RM(1, 1) = {(00), (01), (10), (11)} und 

wt(01) = wt(10) = 1 = 2 1−1 

m > 1 : RM(1, m) = {(x1, x1 + x2) : x1 ∈ RM(1, m − 1), x2 = 

(0, . . . , 0), (1, . . . , 1)} = {(x, x), (x, x) : x ∈ RM(1, m − 1)}, wobei x 

aus x durch Vertauschen von Nullen und Einsen entsteht. 

(i) x = (0, . . . , 0), (1, . . . , 1): wt(x, x) = 2 m−1 . 

(ii) x = (0, . . . , 0), (1, . . . , 1): 

IV 

⇒ wt(x) = wt(x) = 2 m−2 

⇒ wt(x, x) = wt(x, x) = 2 m−1 . 

(d) Induktion nach m. m = 1 : RM(0, 1) = {(00), (11)} klar. 

m − 1 → m: 

RM(m − 1, m) = RM(m − 1, m − 1) ∝ RM(m − 2, m − 1) 

Ind. 

= {(x, x + y) : x ∈ F 2 m−1 

Sei c = |T r(x) ∩ T r(y)|. Dann ist 

wt(x + y) = wt(x) + wt(y) − 2c. 

2 

, y ∈ F 2m−1 

2 , wt(y) gerade} 

Damit ist wt(x, x + y) = wt(x) + wt(x + y) = 2wt(x) + wt(y) − 2c 

gerade; und es ist 

Und 2 2m −1 = 1 

2 22m 

dim RM(m − 1, m) = 

m−1 

i=0 

 

m 

= 2 

i 

m − 1. 

viele Elemente des F 2m 

2 haben gerades Gewicht. 

Wir werden uns später noch eingehender mit den Reed-Muller-Codes, vor 

allem ihrer Decodierung, befassen. Aufgrund eines einfachen Decodierverfahrens 

sind die Reed-Muller-Codes von praktischem Wert. 

Als nächstes werden drei weitere Konstruktionsverfahren für Codes vom Typ 

”aus alt mach neu” beschrieben.


4.9 Definition. Sei C ein [n, k]-Code über Fq. Dann heißt 

C := {(c1, . . . , cn, cn+1) : ci ∈ Fq, (c1, . . . , cn) ∈ C, 

die Erweiterung von C (durch ein parity-check-Symbol). 

4.10 Satz. (a) C ist ein linearer [n + 1, k]-Code über Fq mit 

(b) Ist C binär (q = 2), dann gilt 

d(C) ≤ d( C) ≤ d(C) + 1 

d( C) = d(C) + 1 ⇔ d(C) ungerade. 

(c) Ist H Kontrollmatrix von C, so ist 

⎛ 

1 

⎜ 

H 

⎜ 

= ⎜ 

⎝ 

. . . 

H 

1 

⎞ 

1 

0 ⎟ 

. ⎠ 

0 

eine Kontrollmatrix von C. 

n+1 

ci = 0} 

Beweis. (a) Klar, dass C ein linearer Code der Länge n + 1 ist. Da | C| = 

|C| = q k , folgt dim C = k. Die Aussage über die Minimaldistanz folgt 

aus 

wt(x) = wt(x1, . . . , xn) + wt(xn+1) 

für x = (x1, . . . , xn, xn+1) ∈ C. 

(b) ⇐: Sei 0 = ˆx = (c1, . . . , cn+1) ∈ C, so dass wt(ˆx) = d( C). Setze x = 

(c1, . . . , cn): 

1. cn+1 = 0 ⇒ wt(ˆx) = wt(x) ist gerade. Da d(C) ungerade ist, 

existiert ein 0 = y = (d1, . . . , dn) ∈ C mit d(C) = wt(y) < wt(x). 

Dann ist ˆy = (d1, . . . , dn, 1) ∈ C mit wt(ˆy) = wt(y) + 1 ≤ wt(x) = 

wt(ˆx) = d( C). Also d( C) = wt(ˆy) = wt(y) + 1 = d(C) + 1. 

2. cn+1 = 0 ⇒ wt(x) < wt(ˆx) = d( C). Damit ist nach (a) d(C) = 

d( C) + 1. 

i=1


⇒: Sei x ∈ C mit wt(x) = d(C). Angenommen d(C) wäre gerade. Dann 

wäre ˆx = (c1, . . . , cn, 0) ∈ C. Daraus folgt: d( C) ≤ wt(ˆx) = wt(x) = 

d(C) und mit (a) d( C) = d(C). Widerspruch. 

(c) (c1, . . . , cn, cn+1) ∈ C ⇔ H(c1, . . . , cn) t = 0 und n+1 i=1 ci = 0 

⎛ ⎞ ⎛ ⎞ 

1 

⇔ ⎝ 

. . . 

H 

1 

0⎠ 

⎜ 

⎝ 

0 

c1 

. 

cn+1 

⎟ 

⎠ = 0. 

4.11 Beispiel (erweiterter Hamming-Code). Sei C der [7, 4]-Hamming- 

Code über F2; dann ist d(C) = 3. Nach 4.10.b) ist C ein binärer [8, 4]-Code 

mit d( C) = 4 und Erzeugermatrix: 

⎛ 

1 

⎜ 

ˆG = ⎜0 

⎝1 

1 

1 

0 

0 

1 

1 

1 

0 

0 

0 

1 

0 

0 

0 

1 

0 

0 

0 

⎞ 

1 

1 ⎟ 

1⎠ 

1 1 1 0 0 0 1 0 

Da C Codewörter der Länge 8 Bit = 1 Byte hat, wird er häufig verwendet. 

4.12 Definition. Sei C ein [n, k]-Code über Fq, n ≥ 2 und 1 ≤ i ≤ n. 

(a) Č = Či = {(c1, . . . , ci−1, ci+1, . . . , cn) : (c1, . . . , ci−1, 0, ci+1, . . . , cn) ∈ C} 

heißt die Verkürzung von C an der Stelle i. 

(b) ◦ 

C = ◦ 

Ci = {(c1, . . . , ci−1, ci+1, . . . , cn) : ∃ci ∈ Fq mit (c1, . . . , ci, . . . , cn) ∈ 

C} heißt die Punktierung von C an der Stelle i. 

4.13 Satz. Sei C ein [n, k]-Code, n ≥ 2, k ≥ 1. 

(a) Či und ◦ 

Ci sind lineare Codes der Länge n − 1, 

Či ⊆ ◦ 

Ci, 

k − 1 ≤ dim Či ≤ dim ◦ 

Ci≤ k, 

d( Či) ≥ d( ◦ 

Ci) (falls Či = {0}). 

(b) dim Či = k − 1 ⇔ ∃(c1, . . . , ci, . . . , cn) ∈ C mit ci = 0. 

(c) dim ◦ 

Ci = k − 1 ⇔ ∃(0, . . . , 0, ci, 0, . . . , 0) ∈ C mit ci = 0. 

(Insbesondere dim ◦ 

Ci = k, falls d(C) ≥ 2).


(d) Či = ◦ 

Ci ⇔ (i) ∃(0, . . . , 0, ci, 0, . . . , 0) ∈ C mit ci = 0 oder 

(ii) ∀(c1, . . . , cn) ∈ C : ci = 0. 

(e) Ist Či = {0}, so ist d( Či) ≥ d(C). 

(f) Ist dim ◦ 

Ci = k (z.B. falls d(C) ≥ 2), so ist d(C) − 1 ≤ d( ◦ 

Ci) ≤ d(C). 

Beweis. (a) Klar bis auf die Dimensionsaussage: Weglassen der i-ten Komponente 

der Basisvektoren in C ergibt: dim ◦ 

Ci ≤ k. 

(i) Ist ci = 0 für alle (c1, . . . , cn) ∈ C, so ist dim Či = dim ◦ 

Ci = k. 

(ii) Sei x = (c1, . . . , cn) ∈ C mit ci = 0. Dann existiert eine Basis 

x = x1, . . . , xk von C. Es gibt α2, . . . , αk ∈ Fq, so dass x2−α2x1, . . . , xk− 

αkx1 an der i-ten Stelle eine Null haben; und sie sind linear unabhängig. 

⇒ dim Či ≥ k − 1 

(b) dim Či = k − 1 (a) 

⇔ | Či| < |C| ⇔ ∃(c1, . . . , cn) ∈ C mit ci = 0. 

(c) Die Projektion 

π : C −→ ◦ 

Ci 

(c1, . . . , cn) ↦−→ (c1, . . . , ci−1, ci+1, . . . , cn) 

ist eine surjektive lineare Abbildung mit dim ◦ 

Ci = dim C − dim ker π; 

wobei ker π = {(0, . . . , 0, ci, 0, . . . , 0) ∈ C}. Daraus folgt: 

dim ker π = 1 ⇔ ∃ci = 0, so dass (0, . . . , 0, ci, 0, . . . , 0) ∈ C 

(d) Či = ◦ 

Ci ⇔ dim Či = dim ◦ 

Ci⇔ dim ◦ 

Ci= k − 1 oder dim Či = k. 

(e) Sei 0 = x = (c1, . . . , ci−1, ci+1, . . . , cn) ∈ Či, wt(x) = d( Či). Dann ist 

ˆx = (c1, . . . , ci−1, 0, ci+1, . . . , cn) ∈ C. Damit: d( Či) = wt(x) = wt(ˆx) ≥ 

d(C). 

(f) Sei 0 = y = (c1, . . . , cn) ∈ C, wt(y) = d(C) (Beachte: C = {0}, da 

k ≥ 1). 

Dann ist ◦ y= (c1, . . . , ci−1, ci+1, . . . , cn) ∈ ◦ 

Ci; und ◦ y= 0, da sonst 

C ∩ {(0, . . . , 0, c, 0, . . . , 0) : c ∈ Fq} = {0}. Also: 

d( ◦ 

Ci) ≤ wt( ◦ y) ≤ wt(y) = d(C).


Sei 0 = x = (d1, . . . , di−1, di+1, . . . , dn) ∈ ◦ 

C, wt(x) = d( ◦ 

Ci). 

Dann existiert ˆx = (d1, . . . , di−1, di, di+1, . . . , dn) ∈ C und ˆx = 0. Somit: 

d(C) ≤ wt(ˆx) ≤ wt(x) + 1 = d( ◦ 

C) + 1. 

4.14 Beispiele. (a) Sei C = {(0, . . . , 0), (1, . . . , 1), (0, 1, . . . , 1), (1, 0, . . . , 0)}. 

C ist [n, 2]-Code über F2 mit d(C) = 1. Es ist 

Č1 = {(1, . . . , 1), 

((0, . . . , 0) } 

 

n−1 

n−1 

und d( Č1) = n − 1. ( In 4.13.e) gibt es also keine Konstante k mit 

d( Či) ≤ d(C) + k ). 

(b) Betrachte den folgenden Code und zwei verschiedene Punktierungen 

über F2: 

C = {(1101), (0110), (1011), (0000)}, d(C) = 2 

◦ 

C1= {(101), (110), (011), (000)}, d( ◦ 

C1) = 2 

◦ 

C2= {(101), (010), (111), (000)}, d( ◦ 

C2) = 1 

Dies zeigt, dass beide Fälle in 4.13.f) auftreten können. 

(c) Reed-Muller-Code der Ordnung 1: C = RM(1, m) ist [2 m , m + 1]- Code 

über F2 mit d(C) = 2 m−1 . 

- Či ist [2 m − 1, m]-Code über F2 mit d( Či) = 2 m−1 : 

Es ist RM(1, m) = RM(1, m − 1) ∝ RM(0, m − 1) 

(1, . . . , 1) ∈ RM(1, m − 1) ⇒ (1, . . . , 1, 0, . . . , 0) ∈ RM(1, m) und 

(0, . . . , 0, 1, . . . , 1) ∈ RM(1, m) 4.13.b) 

⇒ dim Či = dim C − 1 = m. 

Jedes Codewort = (0, . . . , 0), (1, . . . , 1) in C hat Gewicht 2 m−1 . 

Also liefert die Verkürzung außer (0, . . . , 0) nur Codeworte von 

Gewicht 2 m−1 . Damit ist d( Či) = 2 m−1 . Či hat die gleichen Parameter 

wie der binäre Simplex-Code der Länge 2 m−1 . Man kann 

zeigen, dass Či Simplex-Code ist. 

- ◦ 

Ci ist [2 m − 1, m + 1]-Code mit d( ◦ 

Ci) = 2 m−1 − 1 (für m ≥ 2): 

C enthält keine Codewörter vom Gewicht 1 (da m ≥ 2) ⇒ dim ◦ 

Ci= 

dim C = m + 1 (nach 4.13.c) ).


Die Punktierung von (1, . . . , 1, 0, . . . , 0) bzw. (0, . . . , 0, 1, . . . , 1) 

liefert ein Codewort in ◦ 

Ci vom Gewicht 2 m−1 − 1. 

Also nach 4.13.f): d( ◦ 

Ci) = 2 m−1 − 1. 

Wir beweisen nun mit Hilfe der Punktierungstechnik einen Zusammenhang 

zwischen n, k und d: 

4.15 Satz (Singleton-Schranke). Ist C ein [n, k, d]-Code über Fq, so ist 

k ≤ n − d + 1. 

Beweis. Induktion nach n. 

n = 1 :⇒ d ≤ 1, k ≤ 1 Behauptung richtig. 

n > 1: (i) Für d = 1 ist die Behauptung richtig. 

(ii) Sei d > 1: Punktiere C. Dies liefert nach 4.13.c) wegen d > 1 einen 

[n − 1, k, d (1) ]-Code mit d (1) ≥ d − 1 (nach 4.13.f) ). 

Induktion: k ≤ (n − 1) − d (1) + 1 ≤ (n − 1) − d + 1 + 1 = n − d + 1. 

(Anschaulich: Punktiere C (d−1)-mal. Dann erhält man einen [n−d+1, k, d ′ ]- 

Code, da der Minimalabstand in jedem Schritt ≥ 2 ist. Also n−d+1 ≥ k). 

Bemerkung. Die Aussage von 4.15 steht schon in 3.8. Wir haben sie hier 

nochmals bewiesen, um die Punktierungsmethode zu verdeutlichen. 

4.16 Bemerkung (MDS-Code). 

Ein [n, k, d]-Code mit k = n − d + 1 heißt MDS-Code (maximum distance 

separable). 

Der Begriff lässt sich folgendermaßen erklären: 

Ist C irgendein [n, k, d]-Code, so gibt es Indizes 1 ≤ j1, . . . , jk ≤ n, so dass 

gilt: 

(∗) Sind c = (c1, . . . , cn), c ′ = (c ′ 1 , . . . , c′ n ) ∈ C mit cj1 = c ′ , . . . , cjk = 

j1 

c ′ jk , so ist c = c′ . D.h.: Ist π die Projektion auf die Koordinaten 

j1, . . . , jk, so ist |π(C)| = |C| = qk . 

Denn die Erzeugermatrix G von C enthält (wegen Zeilenrang = Spaltenrang) 

k linear unabhängige Spalten. Und die quadratische Matrix, die man aus G 

durch Auswahl dieser k Spalten erhält, hat (wegen Zeilenrang = Spaltenrang) 

wieder k linear unabhängige Zeilen. Daraus folgt die Aussage. 

Nun gilt: 

C ist MDS-Code ⇔ 

(∗) gilt für alle k-Tupel von Indizes 

(j1, . . . , jk). (D.h. beliebige k Koordinaten 

trennen verschiedene Codewörter).


Beweis. ⇒: Nach Beweis von 4.15 liefert die Punktierung an d − 1 beliebigen 

Stellen einen Code der Dimension k. Ist n − k + 1 = k, so folgt 

die Behauptung. 

⇐: Ist 0 = c = (c1, . . . , cn) ein Codewort, so enthält c höchstens k − 1 viele 

Nullen (denn wenn es k viele Nullen enthält, so unterscheidet es sich 

an k Stellen nicht vom Nullvektor). Also wt(c) ≥ n−(k −1) und damit 

d ≥ n − k + 1. Nach 4.15 ist andererseits d ≤ n − k + 1, also Gleichheit. 

MDS-Codes sind relativ selten; Beispiele werden wir später noch kennenlernen. 

Es gilt z.B.: 

Ist C ein binärer MDS-Code mit Parametern n, k und d, so ist entweder 

C = {(0, . . . , 0), (1, . . . , 1)} (n = d, k = 1) oder C = Fn 2 (n = k, d = 1) oder 

C = {c ∈ Fn 2 : wt(c) gerade} (k = n − 1, d = 2). 

D.h. für K = F2 gibt es überhaupt keine interessanten MDS-Codes.

5 REED-MULLER-CODES UND MAJORITY-LOGIC-DECODIERUNG 47 

5 Reed-Muller-Codes und 

Majority-Logic-Decodierung 

Um ein wichtiges Decodierverfahren, Majority-Logic-Decodierung, am Beispiel 

der Reed-Muller-Codes zu beschreiben, benötigen wir eine andere Beschreibung 

der Reed-Muller-Codes durch Boolesche Polynome. 

5.1 Definition (Boolesche Funktionen). 

Wir betrachten Funktionen f : Fm 2 −→ F2. Davon gibt es genau 2 |Fm 2 | = 

22m viele. Jede solche Boolesche Funktion f(x1, . . . , xm) lässt sich durch eine 

Wertetabelle beschreiben: 

xm 0 0 0 0 . . . 1 1 1 1 

xm−1 0 0 0 0 1 1 1 1 

. . . . . . . . . 

x3 0 0 0 0 1 1 1 1 

x2 0 0 1 1 0 0 1 1 

x1 0 1 0 1 . . . 0 1 0 1 

f(x1, . . . , xm) ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ 

Im rechten oberen Teil stehen als Spalten die 2m Vektoren des Fm 2 , geordnet 

(von unten nach oben) nach aufsteigender Größe der Binärzahlen. 

An den ∗-Positionen stehen die Werte von f an den entsprechenden Vektoren 

des Fm 2 , d.h. ∗ ∈ {0, 1}. 

Diese Funktionen bilden mit punktweiser Addition und Multiplikation einen 

Ring. Man kann zeigen, dass jede solche Funktion eine Polynomfunktion ist. 

Was bedeutet das? Ein Beispiel einer Polynomfunktion ist folgendes: 

f(x1, x2, x3) = 1 + x1 + x1x2 + x2x3 

(Add. und Mult. in F2, d.h. x 2 i = xi und xixj = xjxi). 

Jede Polynomfunktion ist eine F2-Linearkombination der Monome 

(∗) 1, x1, x2, . . . , xm, x1x2, x1x3, . . . , x1xm, 

x2x3, . . . , xm−1xm, x1x2x3, . . . , x1x2 . . . xm 

Davon gibt es 2m viele (= Anzahl der Teilmengen von {x1, . . . , xm}), und sie 

sind über F2 linear unabhängig. Also gibt es 22m viele Polynomfunktionen. 

Und aus Anzahlgründen lässt sich jede Funktion Fm 2 −→ F2 als Polynomfunktion 

schreiben. 

Der Grad einer Polynomfunktion ist der höchste Grad der in der eindeutigen 

Linearkombination über F2 (mit Koeffizient 1) auftretenden Monome aus (∗); 

und der Grad eines der Monome in (∗) ist die Anzahl der auftretenden xi.


Wie schreibt man eine gegebene Funktion f als Polynomfunktion? 

Werden 0 und 1 als Wahrheitswerte interpretiert, so gilt: 

und damit 

f = 

· entspricht ∧ (und) 

+ entspricht XOR 

1 + f entspricht ¬f 

f + g + fg entspricht f ∨ g 

 

( 

{a∈Fm 2 : f(a)=1} {j: aj=1} 

xj ∧ 

{j: aj=0} 

¬xj) 

Beispiel. Die Funktion f : F 3 2 −→ F2 ist durch folgende Wertetabelle gegeben: 

x3 0 0 0 0 1 1 1 1 

x2 0 0 1 1 0 0 1 1 

x1 0 1 0 1 0 1 0 1 

f(x1, x2, x3) 0 0 0 1 1 0 0 0 

↑ ↑ 

und lässt sich mit + und · umschreiben: 

f = x1x2¬x3 ∨ ¬x1¬x2x3 

= x1x2(1 + x3) + (1 + x1)(1 + x2)x3 + x1x2x3(1 + x1)(1 + x2)(1 + x3) 

= x1x2 + x1x2x3 + x3 + x1x3 + x2x3 + x1x2x3 + 0 

= x3 + x1x2 + x1x3 + x2x3 

Der Grad eines Monoms xi1 . . . xik mit i1 < . . . < ik ist k. Der Grad eines 

Polynoms f ist das Maximum der Grade der Monome in der Darstellung von 

f als Linearkombination der Monome (∗), die mit Koeffizient 1 vorkommmen. 

Nun ordnen wir jeder Booleschen Funktion f : Fm 2 −→ F2 (also jedem Booleschen 

Polynom) den Vektor f ∈ F2m 2 zu, der die letzte Zeile in der Wertetabelle 

von f ausmacht (also die Folge der Funktionswerte). Für m = 3 ist


beispielsweise: 

f =(00011000) (aus obigem Beispiel) 

x1 =(01010101) 

x3 =(00001111) 

x1 x2 =(00010001) 

x1 x2 + x3 =(00011110) 

5.2 Definition. Für 0 ≤ r ≤ m sei R(r, m) ein linearer Code der Länge 2 m 

über F2, definiert durch: 

R(r, m) := {f ∈ F 2m 

2 : f : F m 2 −→ F2 Polynomfunktion vom Grad ≤ r} 

Beispiel. (a) R(0, m) = {1, 0} = {(1, . . . , 1), (0, . . . , 0)} = RM(0, m) 

(b) R(1, 3) = 

1, x1, x2, x3 Dabei sind 

x1 =(01010101) 

x2 =(00110011) 

x3 =(00001111) 

und in R(1, 3) sind alle Linearkombinationen der drei Vektoren (z.B. 

x2 + x3 = (00111100)) und deren Komplemente (d.h. +1) enthalten. 

Damit stimmen R(1, 3) und RM(1, 3) überein. 

5.3 Satz. R(r, m) = RM(r, m). 

Beweis. Sei f ∈ R(r + 1, m + 1), f = f(x1, . . . , xm+1) Polynom vom Grad 

≤ r + 1 mit 

f(x1, . . . , xm+1) = g(x1, . . . , xm) + xm+1h(x1, . . . , xm) 

( grad(g)≤ r + 1, grad(h) ≤ r ). Seien g und h die Vektoren der Länge 2 m in 

R(r + 1, m) bzw. R(r, m) mit g = (c1, . . . , c2 m) und h = (d1, . . . , d2 m). 

Als Polynome in x1, . . . , xm+1 betrachtet liefert g dann das Codewort 

und 

(c1, . . . , c2 m, c1, . . . , c2 m) 

xm+1h(x1, . . . , xm) = (0, . . . , 0, 1, . . . , 1)(d1, . . . , d2 m, d1, . . . , d2 m) 

= (0, . . . , 0, d1, . . . , d2 m).


Also ist f = (c1, . . . , c2m, c1 + d1, . . . , c2m + d2m). Und damit gilt die Rekursionsformel R(r+1, m+1) = R(r+1, m) ∝ R(r, m). 

Ausserdem ist R(0, m) = RM(0, m) und R(m, m) = RM(m, m), d.h. die 

Anfangsbedingungen stimmen ebenfalls überein. Es folgt jetzt 

5.4 Satz. Für 0 ≤ r ≤ m − 1 ist 

R(r, m) = RM(r, m). 

RM(r, m) ⊥ = RM(m − r − 1, m). 

(Insbesondere ist RM(r, 2r +1) ein selbstdualer Code der Dimension 2 2r und 

der Länge 2 2r+1 ). 

Beweis. Sei f = (a1, . . . , a2m) ∈ RM(r, m) und g = (b1, . . . , b2m) ∈ RM(m − 

r − 1, m), wobei f(x1, . . . , xm) vom Grad ≤ r, g(x1, . . . , xm) vom Grad ≤ 

m − r − 1. 

Dann ist grad (f ·g) ≤ m−r−1+r = m−1. Damit ist f · g ∈ RM(m−1, m) 

und hat nach 4.8.d) gerades Gewicht. 

Da f · g = (a1b1, . . . , a2mb2m) somit eine gerade Anzahl von Einsen hat, ist 

Also: 

Weiter gilt: 

2 

 

f, g = 

m 

 

aibi = 0 (gerechnet in F2). 

i=0 

(∗) RM(m − r − 1, m) ⊆ RM(r, m) ⊥ . 

dim RM(r, m) ⊥ = 2 m − dim RM(r, m) 

= 2 m − 

r 

i=0 

m 

i 

 

= 

m−r−1 

i=0 

= dim RM(m − r − 1, m). 

 

m 

i 

Aus Dimensionsgründen gilt also in (∗) schon die Gleichheit. 

Die binären Hamming-Codes Hm sind perfekte [2 m − 1, 2 m − 1 − m]-Codes. 

Sei Hm der erweiterte binäre Hamming-Code, also ein [2 m , 2 m −1−m]-Code. 

Jedes Wort in Hm hat gerades Gewicht. Aus 5.4 folgt nun:


5.5 Folgerung. Sei m ≥ 2. Dann ist 

RM(m − 2, m) = Hm. 

Beweis. Wir zeigen RM(1, m) = H ⊥ m. Dann gilt nach 5.4 und 4.4.b): 

RM(m − 2, m) = RM(1, m) ⊥ = ( H ⊥ m )⊥ = Hm. 

⊆: Sei 0 = y ∈ RM(1, m), a ∈ Hm, a = (a1, . . . , a2 m). 

Ist y = (1, . . . , 1), so ya t = 0, da wt(a) gerade. Also y ∈ Hm. 

Sei y = (1, . . . , 1). Angenommen die letzte Komponente von y ist Null, d.h. 

y = (y1, . . . , y2m−1, 0). Dann ist y = (y1, . . . , y2m−1) ∈ ( RM(1, ˇ m))2m 4.14.c) 

= 

Simplex-Code der Länge 2m − 1 und Dimension m = dualer Code zu Hm. 

Also: 

⎛ ⎞ 

Und damit: 

Also: y ∈ H ⊥ m . 

(y1, . . . , y2m ⎜ 

−1) ⎝ 

a1 

. 

a2 m −1 

< y, a >= (y1, . . . , y2m ⎜ 

−1, 0) ⎝ 

⎟ 

⎠ = 0. 

⎛ 

a1 

. 

a2 m 

⎞ 

⎟ 

⎠ = 0. 

∈RM(1,m) 

 

Ist die letzte Komponente von y gleich Eins, so gilt y = y + (1, . . . , 1) ∈ H⊥ m , 

da y letzte Komponente Null hat, also y = y + (1, . . . 1) ∈ H⊥ m . 

Daher: RM(1, m) ⊆ H⊥ m. 

Für die Dimension gilt: dim RM(1, m) = m + 1 = 2 m − (2 m − m − 1) = 

2 m − dim Hm = dim H ⊥ m. 

Wie im vorigen Beweis folgt, dass RM(1, m) = H ⊥ m. 

Wir benötigen noch eine dritte Beschreibung der Reed-Muller-Codes. Dazu 

müssen wir Fm 2 als affinen Raum betrachten: 

5.6 Fm 2 als affiner Raum. 

Fm 2 ist ein m-dimensionaler Vektorraum über F2. Jeder k-dimensionale Untervektorraum 

C von Fm 2 lässt sich als Lösungsmenge eines Systems homogener 

Gleichungen mit m − k vielen Gleichungen beschreiben: Ist H die Kontrollmatrix 

von C, dann gilt 

a ∈ C ⇔ Ha t = 0


Wenn man Fm 2 als affinen Raum betrachtet (oft mit A(m, 2) bezeichnet), so 

sind die affinen Unterräume gerade die Nebenklassen y + C, y ∈ Fm 2 , von 

Untervektorräumen C von Fm 2 . 

y + C 

y1 

y 

y − y1 

Ist dim C = m, so sagt man: y + C ist affiner Unterraum der Dimension m. 

• affine Unterräume der Dim. 0 : {y}, das sind 1-elementige Teilmengen 

von Fm 2 , also sämtliche Punkte. 

• affine Unterräume der Dim. 1 : {y, y +z}, z = 0, das sind 2-elementigen 

Teilmengen von F m 2 

• affine Unterräume der Dim. 2 : y + {0, z1, z2, z1 + z2}, 0 = z1 = z2 = 0, 

das sind alle 4-elementigen Teilmengen mit Summe der Vektoren = 0. 

Ist C ein k-dimensionaler Untervektorraum mit Kontrollmatrix H (eine (m− 

k) × m-Matrix), so gilt für y ∈ F m 2 : 

z ∈ y + C ⇔ Hz t = Hy t 

 

fester m − k-Vektor 

d.h. k-dimensionale affine Unterräume lassen sich als Lösungsmengen inhomogener 

Gleichungssysteme beschreiben (mit m−k vielen Gleichungen, deren 

Koeffizientenvektoren linear unabhängig sind). 

5.7 Bemerkung. (a) Sei y = (y1, . . . , ym) ∈ F m 2 . Ordne y diejenige Zahl 

z(y) ∈ [0, . . . , 2 m − 1] zu, deren Binärdarstellung durch y wird (gelesen 

von links nach rechts!): 

z(y) = 

m 

yi2 i−1 

i=1 

C


(In der Wertetabelle der Booleschen Funktionen waren die Elemente 

von Fm 2 gerade - in den Spalten und von unten nach oben zu lesend 

- in aufsteigender Reihenfolge der z(y) angeordnet). Das heißt, in der 

Wertetabelle kommt y genau an der Stelle z(y) vor; als Beispiel für F3 2 : 

x3 0 0 0 0 1 1 1 1 

x2 0 0 1 1 0 0 1 1 

x1 0 1 0 1 0 1 0 1 

z(y) 0 1 2 3 4 5 6 7 

Zum Beispiel ist z(y) = 3 für y = (110). 

(b) Es gibt eine 1-1-Beziehung zwischen: 

1. Boolesche Funktionen F m 2 −→ F2 (= Boolesche Polynome) 

2. Vektoren des F2m 2 

3. Teilmengen des Fm 2 

Die folgenden Abbildungen stellen die 1-1-Beziehung her: 

1. → 2: f ↦−→ f 

2. → 3: a ↦−→ Ma = {y ∈ F m 2 : az(y) = 1} 

3. → 1: M ↦−→ χM (charakteristische Funktion) 

 

1, a ∈ M 

χM(a) = 

0, a ∈ M 

Beispiel. f : F 3 2 −→ F2 gegeben durch folgende Wertetabelle: 

x3 0 0 0 0 1 1 1 1 

x2 0 0 1 1 0 0 1 1 

x1 0 1 0 1 0 1 0 1 

f(x1, x2, x3) 0 0 1 0 1 1 0 0 

M = {y ∈ F m 2 : f z(y) 

f 

↓ 

f = (00101100) 

↓ 

= 1} = {(010), (001), (101)} 

↓ 

χM = f


5.8 Satz. Sei 0 ≤ r ≤ m. Dann gilt 

RM(r, m) = span{χ M ∈ F 2m 

2 : M ist affiner Unterraum der Dim. d ≥ m−r}. 

Beweis. ⊇ Sei M ein (m − k)-dimensionaler affiner Unterraum von F m 2 , 

k ≤ r. Dann existiert eine k × m-Matrix H über F2 und b = 

(b1, . . . , bk) t ∈ F k 2 mit: 

y = (y1, . . . , ym) ∈ M ⇔ Hy t = b (5.6), 

d.h. M lässt sich als Lösungsmenge der k Gleichungen 

h11x1 + . . . +h1mxm − b1 + 1 = 1 

. 

hk1x1 + . . . +hkmxm − bk + 1 = 1 

beschreiben. Setze li(x1, . . . , xm) = hi1x1 + . . . + himxm − bi + 1 (Boolesches 

Polynom vom Grad 1) und 

p(x1, . . . , xm) = 

k 

li(x1, . . . , xm) 

i=1 

(Polynom vom Grad k ≤ r). Nun gilt: 

p(y1, . . . , ym) = 1 ⇔ li(y1, . . . , ym) = 1 ∀i = 1, . . . , k 

⇔ (y1, . . . , ym) ∈ M 

Also: p = χ M , d.h. χ M ∈ RM(r, m) nach 5.3 . 

⊆ RM(r, m) = span{p : p Monom vom Grad ≤ r}. 

Zeige: Ist p Monom vom Grad k ≤ r, so ist p charakteristischer Vektor 

eines (m − k)-dimensionalen affinen Unterraums von F m 2 . 

Ist nämlich p = xi1 . . . xik , i1 < . . . < ik, so ist p = χ mit M = 

M 

{(y1, . . . , ym) : yi1 = . . . = yik = 1}, affiner Unterraum der Dimension 

m − k. 

Beachte: Nicht jedes f ∈ RM(r, m) ist charakteristischer Vektor eines ddimensionalen 

affinen Unterraums, d ≥ m − r. Man kann sogar zeigen: 

5.9 Satz. Die Codewörter = 0 von minimalem Gewicht in RM(r, m) sind 

genau die charakteristischen Vektoren der (m−r)-dimensionalen affinen Unterräume 

von Fm 2 . Sie spannen RM(r, m) auf.


Beweis. [MS77], Chap. 13, §6 Th. 8,12 . 

(Beachte: Für p = xi1 . . . xik ist wt(p) = 2m−k , denn es gibt 2 m−k viele Vektoren 

in F m 2 , die an den Stellen i1, . . . , ik eine 1 stehen haben; Monome von 

Grad r liefern Codewörter von Minimalgewicht 2 m−r . In aller Regel gibt es 

mehr Codewörter vom Gewicht 2 m−r , die dann von Polynomen, die keine 

Monome sind, erzeugt werden.) 

Beispiel. RM(1, 3) = H3 (vgl. 5.5). Die Vektoren von minimalem Gewicht 

sind nach 5.9 von der Form χ , wobei M ein 3-1 = 2-dimensionaler affi- 

M 

ner Unterraum von F3 2 ist. Nach 5.6 kann man eine beliebige 3-elementige 

Teilmenge von F3 2 und einen vierten Vektor so wählen, dass deren Summe 

gleich Null ist. So erhält man alle 2-dimensionalen affinen Unterräume von 

F3 (8 

2 . Es gibt also 3) 

4 = 14 viele 2-dimensionale affine Unterräume von F32 . Sie 

entsprechen den 14 Vektoren minimalen Gewichts 23−1 = 4 in H3. 

Explizit: Sei 

Dann sind 

Damit ist 

M = {(100), (110), (011), (001)} = {y1, y2, y3, y4}. 

z(y1) = 1, z(y2) = 3, z(y3) = 6, z(y4) = 4. 

χ M = (0 1 0 1 1 0 1 0) ∈ RM(1, 3) = H3 

und vom Gewicht 4. Und x1 + x3 ist das zugehörige Polynom (kein Monom 

vom Grad 1). Alle 14 Polynome vom Grad 1 liefern Codewörter von minimalem 

Gewicht. (Das gilt im Allgemeinen nicht). 

5.10 Majority-(Logic)-Decodierung. 

Definition. Sei C ein [n, k]-Code, y (1) , . . . , y (l) ∈ C⊥ (d.h. 〈y (j) , x〉 = 0 für 

j = 1, . . . , l und x ∈ C), y (j) = (y (j) 

1 , . . . , y (j) 

n ). 

y (1) , . . . , y (l) heißen orthogonal bezüglich Position i (i ∈ {1, . . . , n}), falls gilt: 

(1) y (j) 

i 

= 1 für alle j = 1, . . . , l. 

(2) Ist k = i, so ist y (j) 

k = 0 für höchstens ein j. 

Wie kann man solche Elemente zur Decodierung nutzen ? 

Angenommen x ∈ C wurde gesendet und man empfängt ein Wort 

z = (z1, . . . , zn) ∈ Fn q 

, das t Fehler enthält, wobei t ≤ 1 

2 l.


Die Positionen zk1, . . . , zkt seien fehlerhaft. 

1.Fall: zi ist fehlerhaft, etwa zi = zk1. 

Aus Teil (2) der obigen Definition folgt, dass es maximal t − 1 viele y (j) gibt, 

die an einer der Stellen k2, . . . , kt einen Eintrag = 0 haben. 

Die übrigen l − (t − 1) vielen y (j) haben an den Stellen k2, . . . , kt den Eintrag 

0 und an der Stelle i einen Eintrag = 0. 

Für diese l − (t − 1) vielen y (j) liefert also der Ausdruck 

〈y (j) , z〉 = y (j) 

1 z1 + · · · + y (j) 

i zi + · · · + y (j) 

n zn 

einen Wert = 0, denn nur die Änderung an der Stelle i (xi in zi) ist für diese 

y (j) bemerkbar. (Beachte, dass y (j) 

1 x1 + · · · + y (j) 

i xi + · · · + y (j) 

n xn = 0.) 

2. Fall: zi ist korrekt. 

Es gibt maximal t viele y (j) , die an einer der Stellen k1, . . . , kt einen Eintrag 

= 0 haben. 

Die übrigen l − t vielen y (j) haben an diesen Stellen Eintrag 0. Der Ausdruck 

〈y (j) , z〉 = y (j) 

1 z1 + · · · + y (j) 

n zn 

liefert also für diese y (j) den gleichen Wert wie y (j) 

1 x1 + · · · + y (j) 

n xn, also 0. 

Fasst man die Fälle 1 und 2 zusammen, so ergibt sich: 

〈y (j) 

≤ t Werte von j, falls zi korrekt 

, z〉 = 0 für 

≥ l − (t − 1) Werte von j, falls zi fehlerhaft 

Nach Voraussetzung ist t ≤ 1l, 

d.h. l − (t − 1) > t. Daher liefert die Anzahl 

2 

der Werte = 0 von 〈y (j) , z〉 die Entscheidung, ob zi korrekt ist oder nicht: 

Sind maximal 1l 

Fehler aufgetreten, so gilt: 

2 

Mehrheit der Werte 〈y (j) , z〉 ungleich 0 genau dann, wenn zi fehlerhaft. 

(Majority-Logic-Decodierung) 

Im binären Fall kann natürlich zi korrigiert werden, wenn es fehlerhaft ist. 

Beispiel. Sei C der [7,3]-Simplex-Code (der duale Code zum [7,4]-Hamming- 

Code über F2). 

Eine Kontrollmatrix für C ist eine Erzeugermatrix des [7,4]-Hamming-Codes, 

also ⎛ 

⎜ 

⎝ 

1 1 0 1 0 0 0 

0 1 1 0 1 0 0 

1 0 1 0 0 1 0 

1 1 1 0 0 0 1 

⎞ 

⎟ 

⎠


(vgl. Beispiel nach 3.6). 

Wir wählen y (1) als erste Zeile, y (2) als dritte Zeile und y (3) als Summe der 

zweiten und vierten Zeile der Matrix, d.h. 

y (1) = (1101000) 

y (2) = (1010010) 

y (3) = (1000101) 

Dann sind y (1) , y (2) , y (3) ∈ C ⊥ orthogonal bezüglich Position 1. Mit Hilfe 

dieser Vektoren können wir Position 1 eines empfangenen Wortes auf 

Korrektheit überprüfen, falls maximal 1 Fehler aufgetreten ist. 

Wird z.B. z = (0100110) empfangen und ist 1 Fehler aufgetreten, so berechnen 

wir: 

〈y (1) , z〉 = 1, 〈y (2) , z〉 = 1, 〈y (3) , z〉 = 1. 

Die Mehrheit der Werte ist ungleich 0, also ist z1 = 0 fehlerhaft. Das 

gesendete Wort ist also (da nur 1 Fehler aufgetreten ist) x = (1100110). 

Wird z = (0110010) empfangen und ist maximal 1 Fehler aufgetreten, so 

berechnen wir: 

〈y (1) , z〉 = 1, 〈y (2) , z〉 = 0, 〈y (3) , z〉 = 0. 

Die Mehrheit der Werte ist gleich 0, also ist z1 = 0 korrekt. 

Wir verallgemeinern jetzt die Definition aus 5.10, und zwar der Einfachheit 

halber nur für binäre Codes. 

5.11 Definition. Sei C ein binärer [n, k]-Code, y (1) , . . . , y (l) ∈ C⊥ , y (j) = 

(y (j) 

1 , . . . , y (j) 

n ). 

y (1) , . . . , y (l) heißen orthogonal bezüglich der Positionen i1, . . . , is, falls gilt: 

(1) y (j) 

i1 

= · · · = y(j) 

is 

= 1 für alle j = 1, . . . , l. 

(2) Ist k = i1, . . . , is, so ist y (j) 

k = 0 für höchstens ein j. 

5.12 Satz. Die Bezeichnungen seien wie in 5.11. Wird ein Wort x ∈ C 

gesendet und z empfangen und sind maximal t ≤ 1l 

Fehler aufgetreten, so 

gilt: 

2 

Die Anzahl der Fehler in z an den Stellen i1, . . . , is ist ungerade 

⇐⇒ ♯{j : 〈y (j) , z〉 = 1} > ♯{j : 〈y (j) , z〉 = 0}.


Beweis. Angenommen, die Anzahl der Fehler an den Stellen i1, . . . , is ist 

ungerade, also mindestens 1. Dann gibt es maximal t − 1 viele Fehler 

außerhalb der Stellen i1, . . . , is und nach Teil (2) von Definition 5.11 daher 

auch nur maximal t − 1 viele y (j) , die an einer dieser Stellen den Eintrag 1 

haben. Die übrigen l − (t − 1) vielen bemerken nur die Fehler an den Stellen 

i1, . . . , is, d.h. für diese y (j) gilt: 

〈y (j) , z〉 = 〈y (j) , x〉 + Anzahl der Fehler an den Stellen i1, . . . , is(mod 2) = 1, 

denn die Anzahl der Fehler an den Stellen i1, . . . , is ist ungerade und 

〈y (j) , x〉 = 0. 

Angenommen, die Anzahl der Fehler an den Stellen i1, . . . , is ist gerade. 

Dann gibt es maximal t viele Fehler außerhalb der Stellen i1, . . . , is 

und nach Teil (2) von Definition 5.11 daher auch nur maximal t viele 

y (j) , die an einer dieser Stellen den Eintrag 1 haben. Die übrigen l − t 

vielen bemerken nur die Fehler an den Stellen i1, . . . , is, d.h. für diese y (j) gilt: 

〈y (j) , z〉 = 〈y (j) , x〉 + Anzahl der Fehler an den Stellen i1, . . . , is(mod 2) = 0, 

denn die Anzahl der Fehler an den Stellen i1, . . . , is ist gerade und 

〈y (j) , x〉 = 0. 

Es gilt also: 

Ist die Anzahl der Fehler an den Stellen i1, . . . , is ungerade, so ist 〈y (j) , z〉 = 1 

für mindestens l − (t − 1) viele y (j) . 

Ist die Anzahl der Fehler an den Stellen i1, . . . , is gerade, so ist 〈y (j) , z〉 = 1 

für höchstens t viele y (j) . 

Nach Voraussetzung ist l−(t−1) > l−t ≥ t, und damit folgt die Behauptung. 

5.13 Multistep Majority-Decodierung für Reed-Muller-Codes. 

C = RM(r, m), r < m; n = 2m , k = r 

m−r 

i=0 , d = 2 . 

x = (x0, . . . , x2 m −1) wurde gesendet, z = (z0, . . . , z2 m −1) empfangen. 

Annahme: z enthalte t viele Fehler, t ≤ 2 m−r−1 − 1 = ⌊ d−1 

2 ⌋. 

Ziel: Decodierverfahren, das z in x decodiert (und in der Regel schneller 

ist als Syndrom-Decodierung). 

m 

i


Wir wählen die folgende Bezeichnung für die Elemente des F m 2 : 

v0 v1 v2 · · · v2 m −1 

0 0 0 · · · 1 

. . . . 

0 0 1 · · · 1 

0 1 0 · · · 1 

Ist M eine Teilmenge von F m 2 , so meinen wir, wenn wir von den Positionen 

von M reden, diejenigen i, für die vi in M enthalten ist (äquivalent: 

diejenigen Positionen i, an denen χ M gleich 1 ist). 

Wir benötigen jetzt noch folgende Aussage: 

5.14 Bemerkung. Sei M ein p-dimensionaler Vektorunterraum von Fm 2 , 

p ≤ r. 

Seien M1, . . . , Mw die sämtlichen (p + 1)-dimensionalen Vektorunterräume 

von Fm 2 , die M enthalten. Dann gilt: 

a) w = 2 m−p − 1 

b) Die Anzahl der Fehler in z an den Positionen von M ist ungerade 

⇐⇒ 

♯{j : Anzahl der Fehler in z an den Positionen von Mj ist ungerade} 

> 

♯{j : Anzahl der Fehler in z an den Positionen von Mj ist gerade}. 

Beweis. (a) Es ist |M| = 2 p . Ist v ∈ F m 2 

\ M, so ist span(M ∪ {v}) 

ein (p + 1)-dimensionaler Vektorunterraum, der M enthält. Er enthält 

2 p+1 − 2 p = 2 p viele Vektoren, die nicht in M liegen. Jeder von diesen spannt 

also zusammen mit M den gleichen Unterraum auf. Da es 2 m − 2 p viele 

Vektoren außerhalb von M gibt, ist w = 2m −2 p 

2 p 

= 2 m−p − 1. 

(b) Es ist Mi ∩ Mj = M für i = j. Daher hat jedes χ an den Positionen 

Mi 

von M eine 1 und außerhalb der Positionen von M haben χ und χ für 

Mi Mj 

i = j an keiner Position eine 1 gemeinsam. (*) 

Angenommen, die Anzahl der Positionen von M, an denen z fehlerhaft ist, 

ist ungerade. 

Dann haben maximal t − 1 viele der χ eine 1 an einer der fehlerhaften 

Mj 

Positionen außerhalb der Positionen von M (wegen(*)). Der Rest, also mindestens 

w−(t−1) viele, trifft mit seinen Einsen außer auf korrekte Positionen


von z nur auf die fehlerhaften Positionen von M. 

Also: Es gibt mindestens w − (t − 1) viele Mj, an deren Positionen z eine 

ungerade Anzahl von Fehlern hat. 

Angenommen, die Anzahl der Positionen von M, an denen z fehlerhaft ist, 

ist gerade. 

Dann haben maximal t viele der χ Mj 

eine 1 an einer der fehlerhaften Positio- 

nen außerhalb der Positionen von M (wegen(*)). Der Rest, also mindestens 

w − t viele, trifft mit seinen Einsen außer auf korrekte Positionen von z nur 

auf die fehlerhaften Positionen von M. 

Also gibt es mindestens w − t viele Mj, an deren Positionen z eine gerade 

Anzahl von Fehlern hat, d.h. es gibt höchstens t viele, an deren Positionen z 

eine ungerade Anzahl von Fehlern hat. 

Da nach a) und Voraussetzung w − t = 2 m−p − t − 1 ≥ 2 m−r − t − 1 > t, folgt 

die Behauptung. 

(Beachten Sie die Ähnlichkeit des Beweises mit 5.12.) 

Beschreibung des Decodier-Verfahrens: 

1. Schritt: 

Wähle einen r-dimensionalen Vektorunterraum M von Fm 2 ; dieser enthält 

v0. Seien M1, . . . , Mw alle (r + 1)-dimensionalen Unterräume von Fm 2 , die M 

enthalten. Nach Teil a) der obigen Bemerkung ist w = 2m−r − 1. 

Nach 5.4 ist RM(r, m) ⊥ = RM(m − r − 1, m). Nach 5.8 liegen alle 

χ , j = 1, . . . , w, in RM(r, m) 

Mj 

⊥ , da r + 1 = m − (m − r − 1). 

Nun folgt aus Mi ∩ Mj = M für i = j, dass die χ orthogonal bezüglich 

Mj 

der Positionen von M sind. 

Berechne alle 〈χ , z〉. Ist die Mehrzahl der Werte ungleich 0, so ist die 

Mj 

Anzahl der Fehler in z an den Positionen von M ungerade, ansonsten gerade 

(nach 5.12, da t ≤ 2m−r−1 − 1 ≤ 1 

2 (2m−r − 1)). 

2. Schritt: 

Führe den ersten Schritt für alle r-dimensionalen Untervektorräume von F m 2 

durch. 

Nach dem 2. Schritt: 

Es ist für jeden r-dimensionalen Untervektorraum bekannt, ob die Anzahl 

der Fehler von z an dessen Positionen gerade oder ungerade ist. 

3. Schritt: 

Wähle einen (r − 1)-dimensionalen Vektorunterraum N von F m 2 

und bestim-


me alle r-dimensionalen Vektorunterräume, die N enthalten. 

Aufgrund von Schritt 2 und Teil b) der obigen Bemerkung können wir 

bestimmen, ob die Anzahl der Fehler von z an den Positionen von N gerade 

oder ungerade ist. 

Führe dies für alle (r − 1)-dimensionalen Untervektorräume durch. 

4. Schritt: 

Führe den dritten Schritt für alle (r − 2)−, . . . , 1−, 0−dimensionalen Untervektorräume 

durch. 

Der 0-dimensionale Fall betrifft nur den Nullraum {v0}. Wir wissen daher, 

ob z an der Position von v0 eine gerade oder ungerade Anzahl von Fehlern 

hat, d.h. ob z0 korrekt oder fehlerhaft ist. 

Da wir auch wissen, ob die Anzahl der Fehler von z an den Positionen der 

1-dimensionalen Vektorunterräume {v0, vi} gerade oder ungerade ist, können 

wir dann auch feststellen, ob zi korrekt oder fehlerhaft ist für i = 1, . . . , 2 m −1. 

5.15 Bemerkung. Ist r ≈ m 

, so benötigt das Multistep Majority-De- 

2 

codierverfahren O(m2m2 +m ) viele binäre Operationen, während bei der 

Syndrom-Decodierung O(22m−1) viele Nebenklassenführer zu berechnen und 

zu vergleichen sind. Für große m ist der Aufwand der Syndrom-Decodierung 

also erheblich höher. 

Es gibt Modifikationen und noch effizientere Versionen der Multistep 

Majority-Decodierung von Reed-Muller-Codes. Nähere Informationen: 

[MS77] , Chapter 10. 

5.16 Beispiel. 

Multistep Majority-Decodierung des Reed-Muller-Codes RM(1, 4) 

n = 2 m = 16, k = 1 + 4 = 5, d = 2 3 = 8 

RM(1, 4) ist 3-Fehler-korrigierend. 

Wir wählen folgende Bezeichnungen für die Elemente des F 4 2 : 

v0 v1 v2 v3 v4 v5 v6 v7 v8 v9 v10 v11 v12 v13 v14 v15 

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 

Die Elemente sind von oben nach unten zu lesen; die durch sie dargestellte 

Zahl in Binärschreibweise (niedrigstes Bit unten) gibt die Position in der


Tabelle an (v0 Position 0,. . . ,v15 Position 15). 

Angenommen, ein Wort x = (x0, . . . , x15) ∈ R(1, 4) wird gesendet und 

z = (1011010001001010) wird empfangen. 

Wir nehmen an, dass maximal drei Fehler aufgetreten sind und wollen z mit 

Multistep Majority-Logic decodieren. 

Da r = 1, bestimmen wir zunächst durch Betrachtung aller 1-dimensionalen 

Unterräume {v0, vi}, i = 1, . . . , 15, des F 4 2 , die v0 enthalten (vgl. 5.6), ob an 

den zugehörigen Positionen 0 und i von z eine gerade oder ungerade Anzahl 

von Fehlern aufgetreten ist. 

Wir beginnen mit M = {v0, v1} und müssen für alle 2-dimensionalen 

Unterräume Mj des F4 oder 1 ist. 

2, die M enthalten, überprüfen, ob 〈z, χ 〉 gleich 0 

Mj 

Es gibt sieben solcher Unterräume, nämlich 

M1 = {v0, v1, v2, v3}, M2 = {v0, v1, v4, v5}, M3 = {v0, v1, v6, v7}, 

M4 = {v0, v1, v8, v9}, M5 = {v0, v1, v10, v11}, M6 = {v0, v1, v12, v13}, 

M7 = {v0, v1, v14, v15}. 

Man erhält sie, indem man neben v0 und v1 einen dritten Vektor vs wählt; 

der vierte Vektor ist dann v0 + v1 + vs = v1 + vs, also gerade vs+1 (vgl. 5.6). 

〈z, χ 〉 rechnet man aus, indem man die Einsen in z, die an den durch M1 

M1 

bestimmten Positionen 0,1,2,3 stehen, addiert (modulo 2), also 1 + 1 + 1 = 

1. Analog verfährt man mit den übrigen Mj. Dann erhält man: 

j 1 2 3 4 5 6 7 

〈z, χ 〉 

Mj 

1 0 1 0 1 0 0 

Da die Mehrzahl der Werte von 〈z, χ 〉 gleich 0 ist, enthält 

Mj 

z an den Positionen 0,1 eine gerade Anzahl von Fehlern, d.h. 

(x0 − z0) + (x1 − z1) = (x0 − 1) + (x1 − 0) = 0 (modulo 2). 

Diese Rechnung haben wir jetzt für alle M = {v0, vi} durchzuführen. Die 

Ergebnisse sind in folgender Tabelle zusammengefasst:


M Mj 〈z, χ 〉 

Mj 

{v0, v1} Anzahl der Fehler 

siehe an den Positionen 0,1 

oben gerade 

{v0, v2} {v0, v2, v1, v3} 1 Anzahl Nullen 

{v0, v2, v4, v6} 0 > 

{v0, v2, v5, v7} 1 Anzahl Einsen 

{v0, v2, v8, v10} 0 Daher: 

{v0, v2, v9, v11} 1 Anzahl der Fehler 

{v0, v2, v12, v14} 0 an den Positionen 0,2 

{v0, v2, v13, v15} 0 gerade 


{v0, v3, v4, v7} 0 < 


{v0, v3, v8, v11} 0 Daher: 



{v0, v3, v13, v14} 1 ungerade 


{v0, v4, v2, v6} 0 > 


{v0, v4, v8, v12} 0 Daher: 



{v0, v4, v11, v15} 1 gerade 

Analog ergeben sich die übrigen Fälle: 

M Anzahl der Fehler 

{v0, v5} an den Positionen 0,5: gerade 


{v0, v7} an den Positionen 0,7: ungerade 




{v0, v11} an den Positionen 0,11: ungerade 




{v0, v15} an den Positionen 0,15: gerade


Da die Mehrzahl der Fehleranzahlen in den Positionen 0, i gerade ist, ist 

die Fehleranzahl an der Position 0 gerade, d.h. die Position 0, also die erste 

Koordinate von z ist korrekt. Da wir wissen, ob die Fehleranzahl an einem 

Positionenpaar 0, i gerade oder ungerade ist, folgt jetzt auch, dass genau an 

den Positionen 3, 7, 11 Fehler aufgetreten sind. 

z wird also decodiert zum Codewort x = (1010010101011010).

6 POLYNOMCODIERUNG UND ZYKLISCHE CODES 65 

6 Polynomcodierung und zyklische Codes 

6.1 Exkurs (Polynomringe, I). 

Sei K ein Körper und K[x] die Menge aller formalen Polynome über K (nicht 

Polynomfunktionen !). 

(1) Addition: 

n 

aix i + 

i=0 

Multiplikation mit Skalaren: 

a · 

n 

bix i := 

i=0 

n 

aix i := 

i=0 

n 

(ai + bi)x i 

i=0 

n 

(aai)x i 

i=0 

Damit ist K[x] ein Vektorraum über K. 

Für jedes n ≥ 0 ist 

K[x]n := {f ∈ K[x] : grad f < n} 

ein Untervektorraum von K[x] (grad 0 := −∞). 

(2) Multiplikation von Polynomen: 

 

n 

aix i 

 

m 

· bix i 

 

= 

i=0 

i=0 

n+m 

mit ci := a0bi + a1bi−1 + . . . + aib0, wobei aj = 0 für j > n und bj = 0 

für j > m zu setzen ist. 

Multiplikation mit Skalaren entspricht der Multiplikation mit Polynomen 

vom Grad ≤ 0. 

Beispiel: K = F2 

i=0 

cix i 

(x 2 + x + 1)(x 3 + x 2 + 1) = x 5 + x + 1 

(3) K[x] ist mit der in (1) definierten Addition und der Multiplikation aus 

(2) ein kommutativer Ring mit Eins. 

(4) In K[x] gibt es Division mit Rest: Seien f, g ∈ K[x] und g = 0. Dann 

gibt es eindeutig bestimmte Polynome h, r ∈ K[x] mit 

f = g · h + r


und grad r < grad g. 

Man schreibt auch: r = f mod g. 

Beispiel: Für f = x 4 + x 2 + 1 und g = x 2 + x + 1 ist: 

x 4 + x 2 + 1 : x 2 + x + 1 = x 2 − x + 1 

−(x 4 + x 3 +x 2 ) 

. 

0 

In obiger Notation ergibt sich h = x 2 − x + 1 und r = 0, und somit ist 

f mod g = 0. Das heisst g teilt f; g | f. 

Für f = x 4 + x + 1 und g = x 2 + 1 ist: 

x 4 + x + 1 : x 2 + 1 = x 2 − 1 

−(x 4 +x 2 ) 

. 

x + 2 

In obiger Notation ergibt sich h = x 2 − 1 und r = x + 2, also 

Ist K = F2, so ist f mod g = x. 

f mod g = x + 2. 

(5) Ein Polynom f ∈ K[x] vom Grad ≥ 1 heißt irreduzibel, falls f nicht 

Produkt zweier Polynome vom Grad ≥ 1 ist. (Entspricht einer Primzahl 

in Z). 

(6) Jedes Polynom f ∈ K[x] vom Grad ≥ 1 lässt sich eindeutig schreiben 

in der Form 

f = a · f1 · . . . · fs 

Dabei ist a ∈ K und fi sind irreduzible Polynome mit höchstem Koeffizienten 

1. (Entspricht der eindeutigen Primfaktorzerlegung in Z). 

6.2 Polynomcodierung. 

Sei k < n. Wir codieren Klartexte m ∈ F k q , m = (m0, . . . , mk−1) auf folgende 

Weise:


(1) Identifiziere m mit m(x) = m0 + m1x + . . . + mk−1x k−1 ∈ Fq[x]k. Diese 

Zuordnung 

ist ein Vektorraum-Isomorphismus. 

F k q −→ Fq[x]k 

m ↦−→ m(x) 

(2) Wähle ein Polynom g(x) vom Grad n − k. Multipliziere m(x) mit x n−k : 

x n−k m(x) = m0x n−k + m1x n−(k+1) + . . . + mk−1x n−1 

Codiere m(x) in c(x) := x n−k m(x) − (x n−k m(x) mod g(x) 

 

grad


so ist ⎛ 

−r 

⎜ 

⎝ 

(n−k) 

. 

0 . . . −r (n−k) 

n−k−1 

−r (n−1) 

0 . . . −r (n−1) 

n−k−1 

. 

⎞ 

1 0 

. .. 

⎟ 

⎠ 

0 1 

Erzeugermatrix von C, (wenn die Elemente von C als n-Tupel geschrieben 

sind). 

Beweis. (a) Zu m(x) ∈ Fq[x]k ist das Codewort 

c(x) = x n−k m(x) − (x n−k m(x) mod g(x)) 

ein Vielfaches von g(x), also in g(x)Fq[x]k. Also gilt C ⊆ g(x)Fq[x]k. 

C ⊇ g(x)Fq[x]k. Sei grad t(x) < k und g(x)t(x) = 

a0 + a1x + . . . + an−k−1x n−k−1 + m0x n−k + . . . + mk−1x n−1 ∈ Fq[x]n. 

Setze m(x) = m0 + . . . + mk−1x k−1 . Dann ist 

und 

g(x)t(x) = a0 + . . . + an−k−1x n−k−1 + x n−k m(x) 

−a0 − . . . − an−k−1x n−k−1 = x n−k m(x) mod g(x), 

d.h. g(x)t(x) = x n−k m(x) − (x n−k m(x) mod g(x)). Also g(x)Fq[x]k ⊆ 

C. 

(b) Folgt aus (a) (Basis g(x) · 1, g(x) · x, . . . , g(x) · x k ). 

(c) Sei m(x) = m0 + . . . + mk−1x k−1 . Dann x n−k · m(x) 

= m0x n−k + . . . + mk−1x n−1 

= m0rn−k(x) + . . . + mk−1rn−1(x) + g(x)(m0qn−k(x) + . . . + mk−1qn−1(x)). 

Also m0rn−k(x) + . . . + mk−1rn−1(x) = x n−k m(x) mod g(x). Daraus 

folgt die Behauptung. 

6.4 Bemerkung. (a) Polynomcodierung ist dort sinnvoll, wo es nur auf 

Fehlererkennung ankommt (Nachfragemöglichkeit !). 

(b) Polynomdivision lässt sich durch Schieberegister realisieren, ist also 

sehr schnell.


(c) Man kann bei gegebenen g(x) auch Nachrichten von beliebiger Länge 

k (d.h. Polynome vom Grad ≤ k − 1 ) codieren: 

Wähle g(x) vom Grad t und Nachrichten beliebiger Länge k, so ist 

c(x) = x t m(x) − (x t m(x) mod g(x)) 

vom Grad < k + t und entspricht einem Codewort der Länge k + 

t. Damit erhält man Codewörter variabler Länge, an deren letzten k 

Stellen jeweils die ursprüngliche Nachricht steht. 

Bei Ethernetanwendungen wir in der Regel ein Polynom vom Grad 16 

genommen. 

(d) Anwendung von Polynomcodierung (z.B. Ethernet-LAN) : 

m(x) = m0 + . . . + mk−1x k−1 (Nutzdaten) 

c(x) = −b0 − b1x − . . . − bn−k−1x n−k−1 + m0x n−k + . . . + mk−1x n−1 

↔ (−b0, −b1, . . . , −bn−k−1, 

m0, . . . , mk−1) ∈ F 

 

Ethernet-Trailer 

n q 

(e) Die Erzeugerpolynome sind zum Teil standardisiert: 

CRC-CCITT-Polynom: 

CRC-16-Polynom: 

g(x) = x 16 + x 12 + x 5 + 1 

g(x) = x 16 + x 15 + x 2 + 1 

CCITT: Comité Consultativ International de Téléphonique et Télégraphique, 

Vorläuferorganisation der ITU, einem internationalen Gremium 

zur Vereinheitlichung und Normierung von Telekommunikationsstandards. 

CRC: Cyclic Redundancy Code 

Mit diesen Polynomen ist die Division mit Rest sehr einfach durch 

Schieberegister realisierbar. 

6.5 Beispiel. Sei K = F2, n = 24, k = 8. Für eine Polynomcodierung sei 

g(x) = x 16 + x 15 + x 2 + 1.


Es soll die Nachricht m = (10110101) ∈ F 8 2 verschickt werden. Das m entsprechende 

Polynom ist: 

Multiplikation mit x n−k = x 16 ergibt: 

m(x) = 1 + x 2 + x 3 + x 5 + x 7 

x 16 m(x) = x 16 + x 18 + x 19 + x 21 + x 23 

Bei Division von x 16 m(x) durch g(x) erhält man: 

x 23 + x 21 + x 19 + x 18 + x 16 : x 16 + x 15 + x 2 + 1 = x 7 + x 6 + x 3 + 1 

−(x 23 + x 22 + x 9 + x 7 ) 

. 

x 15 + x 9 + x 8 + x 7 + x 6 + x 5 + x 3 + x 2 + 1 

 

x 16 m(x) mod g(x) 

Codierung: 

c(x) = 1 + x 2 + x 3 + x 5 + x 6 + x 7 + x 8 + x 9 + x 15 + x 16 + x 18 + x 19 + x 21 + x 23 

↔ (1011011111000001 

| 10110101 ) 

Ethernet-Trailer 

m 

Die Polynomcodierung wird vor allem auch für sogenannte zyklische Codes 

verwendet. Wir definieren zunächst, was das bedeuted. 

6.6 Definition. Sei C ein [n, k]-Code über Fq. C heißt zyklisch, falls gilt: 

(c0, . . . , cn−1) ∈ C ⇒ σ(c0, . . . , cn−1) := (cn−1, c0, . . . , cn−2) ∈ C 

6.7 Bemerkung. 

(a) Ist C ein zyklischer Code der Länge n, (c0, . . . , cn−1) ∈ C, so ist auch 

(ci+1, . . . , cn−1, c0, . . . , ci) = σ n−i−1 (c0, . . . , cn−1) ∈ C 

für alle i = 0, . . . , n − 1. 

(b) Ist C zyklischer Code und sind y1, . . . , yl ∈ C ⊥ orthogonal bezüglich 

Position 1, so sind σ(y1), . . . , σ(yl) ∈ C ⊥ orthogonal bezüglich Position 

2, σ 2 (y1), . . . , σ 2 (yl) ∈ C ⊥ orthogonal bezüglich Position 3, usw. .


Daher ist Majority-Logic Decodierung für zyklische Codes besonders effektiv: 

Wenn man eine Position korrigieren kann, so auch alle anderen. 

Äquivalente Codes zyklischer Codes sind nicht unbedingt zyklisch! 

6.8 Beispiele. (a) Vorbemerkung: Ist K ein endlicher Körper (|K| = q), 

so ist die multiplikative Gruppe K ∗ = K\{0} zyklisch, d.h. es existiert 

ein α ∈ K mit α q−1 = 1 und K ∗ = {1, α, α 2 , . . . , α q−2 }. 

(b) Der Körper F 2 l der Ordnung 2 l (l ∈ N) ist ein l-dimensionaler Vektorraum 

über F2. Bezüglich einer F2-Basis lassen sich die Elemente von 

F 2 l als 0-1-Vektoren der Länge l schreiben. 

Sei nach (a): F ∗ 

2 l = {1, α, α 2 , . . . , α 2l −2 } mit α 2 l −1 = 1. 

Sei H die l×(2 l −1)-Matrix über F2, deren Spalten gerade 1, α, . . . , α 2l −2 

sind (geschrieben als 0-1-Vektoren). 1, α, . . . , α 2l −2 sind also sämtliche 

Vektoren = 0 des F2-Vektorraums F 2 l. Sei Hl der binäre Hamming- 

Code bezüglich dieser Kontrollmatrix. 

Es gilt (mit n = 2 l − 1): 

und 

n−2 

i=0 

x = (x0, . . . , xn−1) ∈ Hl ⇔ Hx t = 0 

 

xi+1α i + x0α n−1 n−2 

= ( 

i=0 

n−1 

= ( 

i=0 

n−1 

⇔ xiα i = 0 

i=0 

xi+1α i+1 + x0α 0 )α −1 

xiα i )α −1 = 0. 

(α n = 1 = α 0 ) 

Also: (x1, x2, . . . , xn−1, x0) ∈ Hl, falls (x0, x1, . . . , xn−1) ∈ Hl. Somit ist 

Hl zyklisch. 

Also: Jeder binäre Hamming-Code ist äquivalent zu einem zyklischen 

Code. 

Dies gilt auch für die nicht-binären Hamming-Codes.


6.9 Beispiel (Reed-Solomon-Codes, 1960). Sei K = Fq und q eine Primzahlpotenz, 

q ≥ 3. Setze n = q − 1 und wähle d mit 2 ≤ d ≤ n. Nach 6.8.a) 

ist K ∗ zyklisch (d.h. K ∗ = {1, α, . . . , α n−1 }, α n = 1). 

Sei H die folgende (d − 1) × n-Matrix über K: 

⎛ 

⎜ 

H = ⎜ 

⎝. 

1 α α2 . . . αn−1 1 α2 α4 . . . α2(n−1) 1 α d−1 α (d−1)2 . . . α (d−1)(n−1) 

Mit Hilfe der Vandermonde-Determinante sieht man, dass jede 

(d − 1) × (d − 1)-Unterdeterminante von H ungleich 0 ist. 

Damit folgt: 

Je d − 1 Spalten von H sind linear unabhängig und rg(H) = d − 1. 

Der Reed-Solomon-Code über K = Fq ist der [n, n − d + 1]-Code mit der 

Kontrollmatrix H und wird mit RSq(d) bezeichnet. 

6.10 Satz. Sei q ≥ 3 eine Primzahlpotenz, n = q − 1, 2 ≤ d ≤ n. 

(a) RSq(d) ist ein zyklischer Code. 

(b) Die Minimaldistanz von RSq(d) ist d. 

(c) RSq(d) ist ein MDS-Code (vgl. 4.16 ). 

Beweis. (a) x = (x0, . . . , xn−1) ∈ RSq(d) ⇔ Hx t = 0 

⇔ n−1 

j=0 αij xj = 0 für alle i = 1, . . . , d − 1 

⇔ 0 = α i n−1 

j=0 αij xj = n−1 

j=0 αi(j+1) xj = xn−1 + α i x0 + α 2i x1 + . . . + 

α (n−1)i xn−2 für alle i = 1, . . . , d − 1 

⇔ (xn−1, x0, . . . , xn−2) ∈ RSq(d). 

(b) Da je d − 1 Spalten von H linear unabhängig sind (und wegen rg(H) = 

d−1 je d Spalten linear abhängig sind) - siehe 6.9 , folgt die Behauptung 

aus 3.8 . 

(c) Dies folgt aus dim RSq(d) = n − d + 1 und b). 

Reed-Solomon-Codes wurden bei den US-Raumfahrtprogrammen Galileo 

(Jupiter, 1989 - 2003), Magellan (Venus, 1989 - 1994) und der NASA-ESA 

Raumsonde Ulysses (Sonne, seit 1990) verwendet. 

. 

⎞ 

⎟ 

⎠


6.11 Exkurs (Polynomringe, II). 

(1) Sei R ein beliebiger kommutativer Ring (mit Eins). I ⊆ R heißt Ideal, 

falls gilt: 

a) I ist bezüglich der Addition eine Untergruppe von R. 

b) ri ∈ I für alle r ∈ R, i ∈ I, d.h. rI ⊆ I für alle r ∈ R. 

(2) Bedeutung von Idealen: 

Die Nebenklassen bezüglich der Addition von I in R, also die Mengen 

s + I, s ∈ R, bilden bezüglich 

und 

(s1 + I) + (s2 + I) := (s1 + s2) + I 

(s1 + I) · (s2 + I) := (s1 · s2) + I 

einen Ring R/I, den Faktorring von R nach I. (Wichtig: Da I Ideal ist, 

hängt die Definition der Verknüpfungen + und · auf den Nebenklassen 

nicht von den Vertretern ab). 

(3) Ist a ∈ R, so ist aR = {ar : r ∈ R} ein Ideal (Hauptideal). 

(4) In K[x] ist jedes Ideal ein Hauptideal, d.h. von der Form f(x) · K[x], 

f(x) ∈ K[x]. Dies liegt im Wesentlichen an der Division mit Rest. (Ein 

entsprechender Satz gilt für den Ring Z). 

(5) f1(x)K[x] ⊆ f2(x)K[x] ⇔ f2(x) | f1(x). 

Ist f(x) irreduzibel, so ist K(x)/f(x)K[x] ein Körper. 

(6) Die Ideale in R = K[x]/f(x)K[x] sind genau die von der Form 

g(x)K[x]/f(x)K[x] mit g(x) | f(x). 

(7) Gilt grad f = n, so bilden die Polynome vom Grad < n ein Vertretersystem 

der Nebenklassen von f(x)K[x] in K[x]: 

K[x]/f(x)K[x] = {g(x) + f(x)K[x] : grad g < n} 

Addition und Multiplikation auf K[x]/f(x)K[x] lassen sich auf K[x]n 

übertragen: 

Addition = übliche Addtion in K[x] 

Multiplikation = Multiplikation in K[x] und dann Reduktion 

mod f(x).


Dann: K[x]n =K[x]/f(x)K[x] (isomorphe Ringe). 

Beispiel. K = F2, f(x) = x 3 + x 2 + 1. 

K[x]/f(x)K[x] = {g(x) + f(x)K[x] : grad g < 3} 

K[x]3 = {0, 1, x, x + 1, x 2 , x 2 + 1, x 2 + x + 1} 

Multiplikation: (x 2 + 1) ⊙ (x 2 + x + 1) =? 

in K[x]: (x 2 + 1)(x 2 + x + 1) = x 4 + x 3 + x + 1 

x 4 + x 3 + x + 1 : x 3 + x 2 + 1 = x 

x 4 + x 3 + x 

1 

Also: (x 2 + 1) ⊙ (x 2 + x + 1) = 1. 

Mit dieser Multiplikation (und Addition) ist F2[x]3 ein Körper der Ordnung 

8. 

6.12 Satz. Sei C ein linearer Code der Länge n über Fq. Identifiziere F n q mit 

Fq[x]n wie bei der Polynomcodierung; dabei C ⊆ F n q ↔ C ⊆ Fq[x]n. 

Mache Fq[x]n zu einem Ring, indem man wie in 6.11(7) Addition und Multiplikation 

von Fq[x]/(x n − 1)Fq[x] auf Fq[x]n überträgt. 

Dann gilt: 

C ist zyklisch ⇔ C ist Ideal in Fq[x]n. 

Beweis. c = (c0, . . . , cn−1) ∈ C ↔ c(x) = c0 + c1x + . . . + cn−1x n−1 ∈ C. 

(cn−1, c0, . . . , cn−2) ∈ C ⇔ cn−1 + c0x + . . . + cn−2x n−1 ∈ C 

Also: C zyklisch ⇔ C Ideal. 

⇔ x ⊙ (c0 + c1x + . . . + cn−1x n−1 ) ∈ C 

( denn x n mod (x n − 1) = 1) 

⇔ h(x) ⊙ c(x) ∈ C für alle h(x) ∈ Fq[x]n. 

6.13 Satz. Sei C zyklischer [n, k]-Code über Fq, identifiziert mit einem Ideal 

C ⊆ Fq[x]n =Fq[x]/(x n − 1)Fq[x]. 

(a) Es existiert ein eindeutig bestimmtes Polynom g(x) vom Grad n − k 

mit höchstem Koeffizienten 1 und g(x) | x n − 1, so dass 

C = {m(x) ⊙ g(x) : grad m(x) < k} 

(⊙ entspricht hier genau der üblichen Multiplikation, da 

grad m(x)g(x) < n). g(x) ist also Erzeugerpolynom von C (vgl. 

6.2) (oder auch von C).


(b) Ist x n − 1 = g(x)h(x) (vgl. 6.1(5) ), so ist 

C = {f(x) ∈ K[x]n : f(x) ⊙ h(x) = 0}. 

h(x) heißt Kontrollpolynom von C (oder auch von C). 

Beweis. (a) Dies folgt aus 6.11 (6). 

(b) Es ist g(x) ⊙ h(x) = 0 in Fq[x]n. Also f(x) ⊙ h(x) = 0 für alle f(x) ∈ C 

nach a). 

Ist umgekehrt f(x) ⊙ h(x) = 0 für alle f(x) ∈ C, so g(x)h(x) = x n − 1 | 

f(x)h(x). Dann g(x) | f(x), also f(x) ∈ C nach a). 

6.14 Folgerung. (a) Es gibt genauso viele zyklische Codes der Länge n 

über Fq wie es Teiler von x n − 1 in Fq[x] gibt. 

(b) Sei C ein zyklischer [n, k]-Code über Fq, 

g(x) = g0 + g1x + . . . + gn−kx n−k Erzeugerpolynom (gn−k = 1) und 

h(x) = h0 + h1x + . . . + hkx k Kontrollpolynom. 

Dann ist die k × n-Matrix 

⎛ 

g0 

⎜ 0 

G = ⎜ 

⎝ . 

. . . 

. .. 

. .. 

. . . 

. .. 

gn−k 0 

. .. 

. . . 

. .. 

. .. 

0 

. 

0 

⎞ 

⎟ 

⎠ 

0 . . . 0 g0 . . . . . . gn−k 

Erzeugermatrix von C und die (n − k) × n-Matrix 

Kontrollmatrix von C. 

Beweis. (a) Das folgt aus 6.13.a) . 

⎛ 

hk 

⎜ 0 

H = ⎜ 

⎝ . 

. . . 

. .. 

. .. 

. . . 

. .. 

h0 0 

. .. 

. . . 

. .. 

. .. 

⎞ 

0 

⎟ 

. ⎟ 

0 ⎠ 

0 . . . 0 hk . . . . . . h0 

(b) Nach 6.13 a) sind g(x), x · g(x), . . . x k−1 · g(x) eine Basis von C. Daraus 

folgt, dass G eine Erzeugermatrix von C ist.


Es ist x n − 1 = gh = n 

i=0 ( n 

j=0 gjhi−j)x i (dabei sind alle nicht definierten 

hi, gj gleich 0 zu setzen). 

Koeffizientenvergleich ergibt n−k 

j=0 gjhi−j = 0 für alle i = 1, . . . , n − 1, 

d.h. GH t = 0. 

g0h0 = −1, also rg(H) = n − k. Also ist H Kontrollmatrix für C. 

Beispiel. Sei n = 4, K = F2. Zyklische Codes der Länge 4 über F2: 

Teiler: 

x 4 − 1 = (x − 1) 4 in F2[x] 

1 C = F4 2 ⎛ 

1 1 0 

⎞ 

0 

x − 1 Erzeugermatrix ⎝0 

1 1 0⎠ 

, dim C = 3 

(x − 1) 

0 0 1 1 

2 = x2 − 1 

(x − 1) 

 

1 0 1 0 

Erzeugermatrix 

dim C = 2 

0 1 0 1 

3 = x3 + x2 + x + 1 Erzeugermatrix 1 1 1 1 , dim C = 1 

(x − 1) 4 C = {0} 

Zyklische Codes sind häufig gut geeignet nicht nur zufällige Fehler gut zu 

erkennen (und zu korrigieren), sondern auch Fehlerbündel (mehrere nebeneinanderliegende 

Bits gestört), wie es bei Übertragungen oder Speicherungen 

auf CD’s oft passiert. 

Dazu: 

b Stellen 

 

6.15 Definition. Ein Vektor v = (0, . . . , 0, a, ∗, . . . , ã, 0, . . . , 0) ∈ Fn q mit 

a, ã = 0 heißt Bündel der Länge b (“burst”). 

Wird c ∈ C gesendet, v ∈ Fn q empfangen und ist f = v − c (der Fehlervektor) 

ein Bündel der Länge b, so heißt f Fehlerbündel der Länge b. 

6.16 Satz. Sei C ein zyklischer [n, k]-Code. Dann enthält C keine Bündel der 

Länge ≤ n − k. 

Daher entdeckt ein zyklischer [n, k]-Code Fehlerbündel der Länge ≤ n − k. 

Beweis. Angenommen (0, . . . , 0, ai, . . . , ai+b−1, 0, . . . , 0) ∈ C, ai, ai+b−1 = 0, 

b ≤ n − k. Dann auch c = (ai, . . . , ai+b−1, 0, . . . , 0 ) ∈ C. 

 

≥k Stellen


Die b-te Zeile der Kontrollmatrix H aus 6.14 b) ist h = (0, . . . , 0, hk = 

1, . . . , h0, 0, . . . , 0). 

hc t = ai+b−1 · hk = 0, also Hc t = 0. Widerspruch. 

Ist v = c + f, f Fehlerbündel der Länge ≤ n − k, so gilt: 

= Hf t = 0, da f ∈ C (siehe oben). 

Hvt = Hct t c∈C 

+ Hf 

6.17 Korrektur von Fehlerbündeln. 

dimensionaler Vektorraum über Fq. 

(a) Für K = Fqm ist K ein m- 

Jedem a ∈ K kann genau ein m-Tupel über Fq zugeordnet werden, und 

somit einem e-Fehler-korrigierenden Code C über K der Länge n ein 

Code C0 der Länge nm über Fq. 

Mit C0 können Fehlerbündel bis zur Länge (e−1)m+1 über Fq korrigiert 

werden, denn (e − 1)m + 1 Stellen über Fq beeinflussen höchstens e 

Stellen im zugehörigen Codewort in C. 

(b) Die Korrekturmöglichkeit von Fehlerbündeln wird durch Codeverschachtelung 

verbessert: 

Sei C ein [n, k]-Code über K, t ∈ N. Dann heißt 

C(t) := {(c11, . . . , ct1, . . . , c1n, . . . , ctn) : (ci1, . . . , cin) ∈ C, i = 1, . . . , t} 

Codeverschachtelung der Tiefe t (“interleaving”). 

Es gilt: 

Kann C Fehlerbündel der Länge ≤ b korrigieren, so kann C(t) Fehlerbündel 

der Länge ≤ bt korrigieren. 

(Außerdem: Ist C zyklischer [n, k]-Code, so ist C(t) zyklischer [nt, kt]- 

Code.) 

Die Techniken aus 6.17 werden bei der Codierung von Audio-Daten auf CD’s 

verwendet. 

Ausgangspunkt ist dabei ein Reed-Solomon-Code über F 2 8 mit d = 5; 

Näheres z.B. in [Wil99], S. 27-29 oder [Fri96], S. 425-429.

LITERATUR 78 

Literatur 

[Ber84] E. R. Berlekamp. Algebraic Coding Theory. Aegean Park Press, 

1984. 

[Fri96] B. Friedrich. Kanalcodierung. Springer, 1996. 

[Ham50] R. W. Hamming. The theory of error detecting and error correcting 

codes. Bell Systems Technical Journal, 29:147–160, 1950. 

[Her81] Ch. Hering. A combinatorial lemma and Shannon’s theorem for 

binary symmetric channels. Arch. Math., 36:476 – 480, 1981. 

[HQ83] W. Heise and P. Quattrocchi. Informations- und Codierungstheorie. 

Springer, 1983. 

[Jun95] D. Jungnickel. Codierungstheorie. Spektrum Akademischer Verlag, 

1995. 

[MS77] F. MacWilliams and N. J. A. Sloane. The Theory of Error- 

Correcting-Codes. North Holland, 1977. 

[PH98] V. S. Pless and W.C. Huffman, editors. Handbook of Coding Theory 

I, II. Elsevier, 1998. 

[Rom92] S. Roman. Coding and Information Theory. Springer, 1992. 

[Sha48] C. E. Shannon. A mathematical theory of communication. Bell 

Systems Technical Journal, 27:379–423, 623–656, 1948. 

[vL99] J. van Lint. Introduction to Coding Theory. Springer, 1999. 

[VO89] S. A. Vanstone and P. C. Oorschot. An Introduction to Error- 

Correcting Codes with Applications. Kluwer, 1989. 

[Wil99] W. Willems. Codierungstheorie. de Gruyter, 1999.

Codierungstheorie - Diskrete Mathematik - Universität Tübingen

Erfolgreiche ePaper selbst erstellen

Template löschen?

Als Template speichern?