Linearer Code

aus Wikipedia, der freien Enzyklopädie
Wechseln zu: Navigation, Suche

Ein linearer Code ist in der Kodierungstheorie ein spezieller Blockcode, bei dem die Codewörter Elemente eines endlichdimensionalen Vektorraums \mathbb{F}_q^n über einem endlichen Körper \mathbb{F}_q sind. Genau dann ist ein Code ein linearer Code, falls er ein Untervektorraum von \mathbb{F}_q^n ist.

Lineare Codes haben den Vorteil, dass Methoden der Linearen Algebra verwendet werden können. Sie sind somit einfach zu codieren und dekodieren. Die meisten wichtigen Codes sind linear: Hamming-Code, Reed-Muller-Code, Hadamard-Code, alle zyklischen Codes (damit auch BCH, Reed-Solomon-Codes, Golay-Codes und Goppa-Codes).

Ist die Vektorraumdimension des linearen Codes C gleich k, so nennt man C einen [n,k]-Code oder bei einem Hamming-Abstand von d auch [n,k,d]-Code.

Eigenschaften[Bearbeiten]

Da C ein Untervektorraum von V ist, existiert eine Basis g_1, \dots, g_k von C. Fasst man diese Basis in einer Matrix

 G=\begin{pmatrix}
g_1 \\
\vdots\\
g_k
\end{pmatrix}

zusammen, erhält man eine Erzeugermatrix. Des Weiteren besitzt der Code eine Kontrollmatrix H. Für sie gilt H c^T=0 genau dann, wenn c ein Codewort ist. Der Rang von G ist k, der von H ist n-k. Der Hammingabstand von C ist die minimale Anzahl linear abhängiger Spalten der Kontrollmatrix.

Das Hamminggewicht eines Codewortes c=(c_1,\dots,c_n) ist gleich der Anzahl der c_i, die von Null verschieden sind. Beispielsweise hat das Codewort (4 3 0 5 4 0) über \mathbb{F}_7^6 das Hamminggewicht 4. Der Hammingabstand des Codes ist gleich dem kleinsten Hamminggewicht aller Codewörter außer dem Nullwort.

Permutiert man die einzelnen Koordinaten der Codewörter, erhält man einen sogenannten äquivalenten Code. Damit und mittels linearer Algebra kann man zu jedem linearen Code einen äquivalenten finden, der eine Erzeugermatrix der Form G=(\mathbb{E}_k|P) hat. Dabei ist \mathbb{E}_k die (k \times k)-Einheitsmatrix, und P ist eine (k \times (n-k))-Matrix. Dann heißt G Erzeugermatrix in reduzierter Form. Die ersten k Koordinaten können als Informationssymbole und die letzten n-k als Kontrollsymbole interpretiert werden. Ist G eine Erzeugermatrix in reduzierter Form, kann eine Kontrollmatrix H sofort gefunden werden: H=(-P^T|\mathbb{E}_{n-k}). Ein linearer Code ist bereits durch seine Erzeugermatrix oder seine Kontrollmatrix bestimmt.

Beispiel[Bearbeiten]

Der binäre [7,4,3]-Hamming-Code besitzt folgende Erzeugermatrix in reduzierter Form sowie die dazugehörige Kontrollmatrix:

G=(\mathbb{E}_k|P)     H=(-P^T|\mathbb{E}_{n-k})

G=
\begin{pmatrix}
{\color{Brown}1} & 0 & 0 & 0 & 1 & 1 & 0 \\
0 & {\color{Brown}1} & 0 & 0 & 1 & 0 & 1 \\
0 & 0 & \color{Brown}{1} & 0 & 1 & 1 & 1 \\
0 & 0 & 0 & {\color{Brown}1} & 0 & 1 & 1 \\
\end{pmatrix}
\qquad     
H=
\begin{pmatrix}
1 & 1 & 1 & 0 & {\color{Brown}1} & 0 & 0 \\
1 & 0 & 1 & 1 & 0 & {\color{Brown}1} & 0 \\
0 & 1 & 1 & 1 & 0 & 0 & {\color{Brown}1} \\
\end{pmatrix}

Kodierung[Bearbeiten]

Ein Wort x=(x_1, \dots, x_k) aus dem Raum \mathbb{F}_q^k wird kodiert, indem das Produkt x G gebildet wird. Die Kodierung des Wortes (0,0,1,1) mit dem [7,4,3]-Hamming-Code veranschaulicht beispielsweise die folgende Rechnung.

\begin{align}
x \cdot G &= c\\
\begin{pmatrix}0,0,1,1\end{pmatrix}
\cdot
\begin{pmatrix}
1 & 0 & 0 & 0 & 1 & 1 & 0 \\
0 & 1 & 0 & 0 & 1 & 0 & 1 \\
0 & 0 & 1 & 0 & 1 & 1 & 1 \\
0 & 0 & 0 & 1 & 0 & 1 & 1 \\
\end{pmatrix}
&= \begin{pmatrix}0,0,1,1,1,0,0\end{pmatrix}
\end{align}

Da hier die Addition in \mathbb{F}_2 erfolgt, gilt 1 + 1 = 0

Dekodierung[Bearbeiten]

Mit Dekodierung bezeichnet man das Zuordnen eines empfangenen, möglicherweise fehlerhaften Eingabevektors x zu einem Codevektor c'. Die Dekodierung ist nicht die Umkehrfunktion der Kodierung, die einem Codevektor wieder einen Vektor aus \mathbb{F}_q^k zuordnet.

Als Dekodierungsmethode wird in der Kodierungstheorie meistens die Methode der größten Wahrscheinlichkeit (englisch: maximum likelihood decoding) verwendet. Dabei wird ein empfangener Vektor x zu dem Codevektor c' dekodiert, der mit der größten Wahrscheinlichkeit zum tatsächlich versandten Codevektor c identisch ist. Häufig wird der Vektor, bei dem die wenigsten Stellen (Fehler) korrigiert werden müssen, als der Wahrscheinlichste angenommen. Mathematisch gesprochen heißt das, man sucht den Codevektor c' mit dem geringsten Hammingabstand zum empfangenen Vektor x. Dieser Fall wird auch als Methode des nächstgelegenen Nachbarn (englisch: nearest neighbor decoding) bezeichnet. Durch Kenntnis der Art der gesendeten Daten oder des verwendeten Kanals können gegebenenfalls andere Informationen verwendet werden, um die Wahrscheinlichkeit für bestimmte Codevektoren zu bestimmen.

Es sei c der tatsächlich versendete (Code-)Vektor und x der empfangene Vektor. Die Dekodierung sucht aus allen q^n Codevektoren den oder die Codevektoren c', die mit der größten Wahrscheinlichkeit versendet wurden.

c' = \operatorname{argmax}_{y \in C} \left\{ \operatorname{P}\left[y = c\right] \right\}

Bei der Nearest-Neighbor-Dekodierung also:

c' = \operatorname{argmin}_{y \in C} \left\{ wt(x - y) \right\}

Man sollte dabei beachten, dass diese Zuordnung bei den meisten Codes nicht für alle Fehlervektoren eindeutig ist. Es gibt dann einige Fehlervektoren, die nicht zugeordnet werden können, da sie mehr als einen nächstgelegenen Nachbarn haben. Ist für jeden Fehlervektor eine eindeutige Dekodierung möglich, so heißt der Code perfekt.

Syndromdekodierung[Bearbeiten]

Eine effizientere Methode für die Dekodierung stellt die sogenannte Syndrom-Dekodierung dar. Das Syndrom s_x eines Vektors x erhält man durch Multiplikation der Kontrollmatrix H mit x^T.

s_x^T = H x^T

Es sei e=x-c der Fehlervektor von x. In e sind genau die Koordinaten ungleich Null, bei denen während der Übertragung Fehler aufgetreten sind.

Für das Syndrom von x gilt wegen der Linearität des Codes:

s_x^T = H x^T = H c^T + H e^T

Da das Syndrom von fehlerfreien Codevektoren immer Null ist, folgt:

s_x^T = H e^T = s_e^T

Alle (fehlerhaften) Wörter mit dem gleichen Fehlervektor sind im gleichen affinen Unterraum, das heißt für solche Wörter ist das Syndrom s_e^T=H e^T konstant.

Alle Vektoren, die aus einem beliebigen, festen Vektor durch Subtraktion eines beliebigen Codevektors hervorgegangen sind, bilden eine Nebenklasse der Untergruppe C von \mathbb{F}_q^n. Der Vektor mit minimalem Gewicht in dieser Klasse heißt Führer der Nebenklasse (englisch: coset leader). Daher ist auch der Begriff „coset leader decoding” verbreitet.

Um x zu c' zu dekodieren, sucht man also den Fehlervektor e', dessen Syndrom identisch zum Syndrom von x ist und dessen Hamminggewicht minimal ist. Mit diesem Fehlervektor berechnet man c' = x - e' den nächstgelegenen Codevektor c'. Man kann also eine Tabelle mit bis zu q^{n-k} Zeilen aufstellen, die für jedes Syndrom eines empfangenen Vektors den entsprechenden Fehlervektor mit minimalem Hamminggewicht beinhaltet. Ist das Syndrom gleich 0, dann muss nichts korrigiert werden ansonsten beschränkt sich Dekodierung auf das Nachschlagen des Fehlervektors in dieser Tabelle und Korrigieren der so detektierten Fehler.

Anders interpretiert sind die Nebenklassen gerade die Äquivalenzklassen der Äquivalenzrelation x\equiv y \Leftrightarrow s_x^T = s_y^T Die Führer sind gerade Vertreter der Äquivalenzklassen, man wählt einen mit minimalem Hamminggewicht. Perfekte Codes zeichnen sich dadurch aus, dass die Führer eindeutig festgelegt sind.

Die Dekodierung von linearen Codes ist im Allgemeinen NP-vollständig, das heißt, es sind keine Algorithmen mit polynomieller Laufzeit bekannt.[1] Die bekannten linearen Codes, beispielsweise Hamming-Codes, zeichnen sich dadurch aus, dass für sie effiziente Dekodierungs-Algorithmen bekannt sind. Die Komplexität der linearen Dekodierung ist Grundlage für das McEliece-Kryptosystem, das als sicher gilt, aber aufgrund seiner vergleichsweise langen Schlüssel bisher selten eingesetzt wird.

Beispiel[Bearbeiten]

Will man den [7,4,3]-Hamming-Code (von oben) dekodieren, trifft man zuerst die Annahme, dass nur 1-Bit Fehler auftreten. (Falls mehr Fehler auftreten, ist keine Fehlerkorrektur, sondern nur noch eine Fehlererkennung möglich.) Die möglichen Fehlervektoren e sind dann

(1,0,0,0,0,0,0)
(0,1,0,0,0,0,0)
(0,0,1,0,0,0,0)
(0,0,0,1,0,0,0)
(0,0,0,0,1,0,0)
(0,0,0,0,0,1,0)
(0,0,0,0,0,0,1)

Für jeden dieser Fehlervektoren wird nun das Syndrom s^T=H e^T berechnet. Damit ergibt sich

e s
(1,0,0,0,0,0,0) (1,1,0)
(0,1,0,0,0,0,0) (1,0,1)
(0,0,1,0,0,0,0) (1,1,1)
(0,0,0,1,0,0,0) (0,1,1)
(0,0,0,0,1,0,0) (1,0,0)
(0,0,0,0,0,1,0) (0,1,0)
(0,0,0,0,0,0,1) (0,0,1)

Wird dann das fehlerhafte Wort x=(0,1,1,1,1,0,0) empfangen, ergibt dann s^T = H x^T=(1,0,1)^T. Damit ergibt sich der Fehlervektor e=e((1,0,1))=(0,1,0,0,0,0,0), und x wird somit nach c(x)=(0,1,1,1,1,0,0)-(0,1,0,0,0,0,0)=(0,0,1,1,1,0,0) dekodiert. Das Klartextwort ist dann (0,0,1,1).

Beispiel mit unvollständiger Dekodierung[Bearbeiten]

Gegeben sei der ternäre (q=3) Wiederholungscode der Länge 3:


G=
\begin{pmatrix}
1 & 1 & 1
\end{pmatrix}
\qquad     
H=
\begin{pmatrix}
2 & 1 & 0 \\
2 & 0 & 1 \\
\end{pmatrix}

Jeweils zwei Spalten von H sind linear unabhängig, alle drei dagegen linear abhängig. Der minimale Hammingabstand des Codes berechnet sich als minimale Anzahl linear abhängiger Spalten in H also zu 3. Es kann damit höchstens ein Zeichenfehler korrigiert werden. Die Syndromtabelle sieht folgendermaßen aus:

e s
(1,0,0) (2,2)
(2,0,0) (1,1)
(0,1,0) (1,0)
(0,2,0) (2,0)
(0,0,1) (0,1)
(0,0,2) (0,2)

Durch Ausnützen von Linearitäten könnte die Anzahl der Zeilen halbiert werden, man muss dann aber testen, ob ein linear abhängiges Syndrom in der Tabelle ist.

Man betrachte nun x=(1,1,0), y=(1,2,0). Bei x ist das Syndrom Hx^t=(0,2)^t, die Korrektur lautet: (1,1,0)-(0,0,2)=(1,1,1). Die Berechnung des Syndroms von y ergibt: Hy^t=(1,2)^t. Dieser Wert ist nicht in der Syndromtabelle enthalten, das Wort kann also nicht korrigiert werden.

Anwendung[Bearbeiten]

Die Kodierung und Dekodierung ist, so wie sie oben beschrieben ist, relativ aufwendig. Bei der Codierung muss die Erzeugermatrix im Speicher gehalten werden, was bei Systemen mit begrenzten Ressourcen (zum Beispiel mobile Endgeräte oder Weltraumsonden) problematisch ist. Bei der Dekodierung wird eine – je nach Korrekturrate – große Tabelle benötigt; der Speicherverbrauch ist dementsprechend groß. Aus diesem Grund werden in der Regel zusätzliche Eigenschaften der Codes benutzt, um diese effizient zu kodieren und dekodieren. Binäre zyklische Codes lassen sich beispielsweise sehr einfach mittels Schieberegister und XOR-Gatter realisieren.

Dualer Code[Bearbeiten]

Zu jedem (linearen) Code C gibt es einen dualen Code (oder auch Dualcode) C^\perp, der selbst ein linearer Code ist. Die Codewörter des dualen Codes sind alle Wörter aus \mathbb{F}_q^n, die zu den Codewörter aus C dual sind:

Man definiert hierzu ein inneres Produkt:

\langle \cdot ; \cdot \rangle \,: \; \mathbb{F}_q^n \times \mathbb{F}_q^n \to \mathbb{F}_q

das die Vektoren x=(x_1,x_2,\dots,x_n),y=(y_1,y_2,\dots, y_n) folgendermaßen abbildet:

\langle x;y\rangle=\sum_{i=1}^n x_i y_i

Trotz der ähnlichen Definition handelt es sich hierbei nicht um ein Skalarprodukt, da diese Bilinearform nicht positiv definit ist. Es gibt nämlich aufgrund der Eigenschaften von Endlichen Körpern meistens Vektoren, die ungleich dem Nullvektor sind und bei denen das innere Produkt 0 ergibt. Man denke beispielsweise an den binären Vektor (1,1).

Mit Hilfe dieser Definition ergibt sich der Duale Code als:

C^\perp = \{x \in \mathbb{F}_q^n \mid \langle x,c\rangle = 0\; \mathrm{f\ddot ur\; alle} \; c \in C \}

Eine Erzeugermatrix des dualen Codes ist eine Kontrollmatrix des Ursprungscodes und umgekehrt.

Der duale Code spielt bei der Analyse der Eigenschaften von Codes eine wichtige Rolle.

Ein Spezialfall sind die sogenannten selbstdualen Codes. Dies sind Codes, die mit ihrem Dualcode identisch sind. Aus Dimensiongründen haben diese immer die Dimension k=n/2. Das wichtigste Beispiel für einen selbstdualen Code ist der erweiterte Hamming-Code, bei dem der binäre [7,4,3]-Hamming-Code um ein Paritätsbit auf gerade Parität erweitert wird:


G=H=
\begin{pmatrix}
1 & 0 & 0 & 0 & 1 & 1 & 0 & 1\\
0 & 1 & 0 & 0 & 1 & 0 & 1 & 1\\
0 & 0 & 1 & 0 & 1 & 1 & 1 & 0\\
0 & 0 & 0 & 1 & 0 & 1 & 1 & 1\\
\end{pmatrix}

Quellen[Bearbeiten]

  1.  E. R. Berlekamp, R. J. McEliece, H. C. A. von Tilburg: On the inherent intractability of certain coding problems. In: IEEE Transactions on Information Theory 24. 1978.

Literatur[Bearbeiten]