Code Description with State and Trellis Diagram

1 Zustandsdefinition für ein Speicherregister (1)
2 Zustandsdefinition für ein Speicherregister (2)
3 Darstellung im Zustandsübergangsdiagramm (1)
4 Darstellung im Zustandsübergangsdiagramm (2)
5 Darstellung im Trellisdiagramm (1)
6 Darstellung im Trellisdiagramm (2)
7 Definition der freien Distanz (1)
8 Definition der freien Distanz (2)
9 Terminierte Faltungscodes
10 Punktierte Faltungscodes
11 Aufgaben

Zustandsdefinition für ein Speicherregister (1)

Ein Faltungscodierer kann auch als Automat mit endlicher Anzahl von Zuständen aufgefasst werden. Die Zustandsanzahl ergibt sich dabei aus der Zahl der Speicherelemente ⇒ Gedächtnis m zu 2^m.

Im Kapitel 3.3 gehen wir meist vom gezeichneten Faltungscodierer aus, der durch folgende Kenngrößen charakterisiert wird:

k = 1, n = 2 ⇒ Coderate R = 1/2,

Gedächtnis m = 2 ⇒ Einflusslänge ν = 3,

Übertragungsfunktionsmatrix in Oktalform (7, 5) ⇒ G(D) =(1 + D + D², 1 + D²).

Die Codesequenz zum Zeitpunkt i ⇒ x_i = (x_i⁽¹⁾, x_i⁽²⁾) hängt außer vom Informationsbit u_i auch vom Inhalt (u_i_–1, u_i_–2) des Speichers ab. Hierfür gibt es 2^m = 4 Möglichkeiten, die man als die Zustände S₀, S₁, S₂ und S₃ bezeichnet. Der Registerzustand S_μ sei dabei über den Index definiert:

\[\mu = u_{i-1} + 2 \cdot u_{i-2}\hspace{0.05cm}, \hspace{0.5cm}{\rm allgemein\hspace{-0.1cm}:}\hspace{0.15cm} \mu = \sum_{l = 1}^{m} \hspace{0.1cm}2\hspace{0.03cm}^{l-1} \cdot u_{i-l} \hspace{0.05cm}.\]

Im Englischen verwendet man für „Zustand” den Begriff State. Entsprechend ist auch im deutschen Text manchmal vom Registerstatus die Rede.

Um Verwechslungen zu vermeiden, unterscheiden wir im Weiteren durch Groß– bzw. Kleinbuchstaben:

die möglichen Zustände S_μ mit den Indizes 0 ≤ μ ≤ 2^m – 1,

die aktuellen Zustände s_i zu den Zeitpunkten i = 1, 2, 3, ....

Auf der nächsten Seite verdeutlichen wir die Zustände an einem Beispiel.

Zustandsdefinition für ein Speicherregister (2)

: Die folgende Grafik zeigt für obigen Faltungscodierer jeweils den Beginn (i ≤ 15)

der Informationssequenz u ⇒ Informationsbits u_i,

der aktuellen Zustände s_i ∈ {S₀, S₁, S₂, S₃} zu den Zeitpunkten i, sowie

der jeweiligen Codesequenzen x_i = (x_i⁽¹⁾, x_i⁽²⁾).

Die Farbkennzeichnungen sollen den Übergang zu den nachfolgenden Grafiken auf den nächsten Seiten erleichtern. Man erkennt aus obiger Darstellung beispielsweise:

Zum Zeitpunkt i = 5 gilt u_i_–1 = u₄ = 0, u_i_–2 = u₃ = 1. Das heißt, der Automat befindet sich im Zustand s₅ = S₂. Mit dem Informationsbit u_i = u₅ = 0 erhält man die Codesequenz x₅ = (11).

Der Zustand für den Zeitpunkt i = 6 ergibt sich aus u_i_–1 = u₅ = 0 und u_i_–2 = u₄ = 0 zu s₆ = S₀. Wegen u₆ = 0 wird nun x₆ = (00) ausgegeben und der neue Zustand s₇ ist wiederum S₀.

Auch zum Zeitpunkt i = 12 wird wegen u₁₂ = 0 die Codesequenz x₁₂ = (11) ausgegeben und man geht vom Zustand s₁₂ = S₂ in den Zustand s₁₃ = S₀ über.

Dagegen wird zum Zeitpunkt i = 9 die Codesequenz (00) ausgegeben und auf s₉ = S₂ folgt s₁₀ = S₁. Gleiches gilt auch für i = 15. In beiden Fällen lautet das aktuelle Informationsbit u_i = 1.

Aus diesem Beispiel ist zu erkennen, dass die Codesequenz x_i zum Zeitpunkt i allein

vom aktuellen Zustand s_i = S_μ (0 ≤ μ ≤ 2^m – 1), sowie

vom aktuellen Informationsbit u_i

abhängt. Ebenso wird der Nachfolgezustand s_i₊₁ allein durch s_i und u_i bestimmt. Diese Eigenschaften werden im so genannten Zustandsübergangsdiagramm auf der nächsten Seite berücksichtigt.

Darstellung im Zustandsübergangsdiagramm (1)

Die Grafik zeigt das Zustandsübergangsdiagramm (englisch: State Transition Diagram) für unseren Standardcodierer. Dieses liefert alle Informationen über den (n = 2, k = 1, m = 2)–Faltungscodierer in kompakter Form. Die Farbgebung ist mit der sequenziellen Darstellung auf der vorherigen Seite abgestimmt. Der Vollständigkeit halber ist auch die Herleitungstabelle nochmals angegeben.

Die 2^m⁺^k Übergänge sind mit „u_i | x_i” beschriftet. Beispielsweise ist abzulesen:

Durch das Informationsbit u_i = 0 (gekennzeichnet durch eine rote Beschriftung) gelangt man vom Zustand s_i = S₁ zum Zustand s_i₊₁ = S₂ und die beiden Codebits lauten x_i⁽¹⁾ = 1, x_i⁽²⁾ = 0.

Mit dem Informationsbit u_i = 1 (blaue Beschriftung) im Zustand s_i = S₁ ergeben sich dagegen die Codebits zu x_i⁽¹⁾ = 0, x_i⁽²⁾ = 1, und man kommt zum neuen Zustand s_i₊₁ = S₃.

Die Struktur des Zustandsübergangsdiagramms ist allein durch die Parameter m und k festgelegt:

Die Anzahl der Zustände ist 2^{m · k}.

Von jedem Zustand gehen 2^k Pfeile ab.

Ein weiteres Beispiel folgt auf der nächsten Seite.

Darstellung im Zustandsübergangsdiagramm (2)

Die obere Grafik zeigt nochmals das Zustandsübergangsdiagramm für unseren Standardcodierer. Dieses dient lediglich als Vergleichsgrundlage für das nachfolgende Beispiel.

Die untere Grafik gilt für einen systematischen Code, ebenfalls mit den Kenngrößen n = 2, k = 1, m = 2. Es handelt sich um die äquivalente systematische Repräsentation des obigen Codierers. Man bezeichnet diesen auch als RSC–Codierer (englisch: Recursive Systematic Convolutional Encoder).

Gegenüber dem oberen Zustandsübergangsdiagramm erkennt man folgende Unterschiede:

Da die früheren Informationsbits u_i_–1 und u_i_–2 nicht abgespeichert werden, beziehen sich hier die Zustände s_i = S_μ auf die verarbeiteten Größen w_i_–1 und w_i_–2, wobei w_i = u_i + w_i_–1 + w_i_–2 gilt.

Da dieser Code systematisch ist, gilt x_i⁽¹⁾ = u_i. Die Herleitung der zweiten Codebits x_i⁽²⁾ finden Sie in Aufgabe A3.5. Es handelt sich um ein rekursives Filter, wie in Kapitel 3.2 beschrieben.

Der Bildervergleich zeigt, dass sich für beide Codierer ein ähnliches Zustandsübergangsdiagramm ergibt:

Man gelangt von jedem Zustand s_i ∈ {S₀, S₁, S₂,S₃} zu den gleichen Nachfolgezuständen s_i₊₁.

Ein Unterschied besteht hinsichtlich der ausgegebenen Codesequenzen x_i ∈ {00, 01, 10, 11}.

Darstellung im Trellisdiagramm (1)

Man kommt vom Zustandsübergangsdiagramm zum so genannten Trellisdiagramm (oder kurz: Trellis), indem man zusätzlich eine Zeitkomponente ⇒ Laufvariable i berücksichtigt. Die folgende Grafik stellt die beiden Diagramme für unseren Standardcodierer (n = 2, k = 1, m = 2) gegenüber.

Die untere Darstellung hat Ähnlichkeit mit einem Gartenspalier – etwas Phantasie vorausgesetzt. Die englische Übersetzung hierfür ist „Trellis”. Weiter ist anhand dieser Grafik zu erkennen:

Da alle Speicherregister mit Nullen vorbelegt sind, startet das Trellis stets vom Zustand s₁ = S₀. Zum nächsten Zeitpunkt (i = 2) sind dann nur die beiden Zustände S₀ und S₁ möglich.

Ab dem Zeitpunkt i = m + 1 = 3 hat das Trellis für jeden Übergang von s_i nach s_i₊₁ genau das gleiche Aussehen. Jeder Zustand S_μ ist durch einen roten Pfeil (u_i = 0) und einen blauen Pfeil (u_i = 1) mit einem Nachfolgezustand verbunden.

Gegenüber einem Codebaum, der mit jedem Zeitschritt i exponentiell anwächst – siehe zum Beispiel Kapitel 3.8, Seite 2a im Buch „Digitalsignalübertragung” – ist hier die Zahl der Knoten (also der möglichen Zustände) auf 2^m begrenzt.

Diese erfreuliche Eigenschaft eines jeden Trellisdiagramms nutzt auch der Viterbi–Algorithmus zur effizienten Maximum–Likelihood–Decodierung von Faltungscodes.

Darstellung im Trellisdiagramm (2)

Das folgende Beispiel soll zeigen, dass zwischen der Aneinanderreihung der Codesequenzen x_i und den Pfaden durch das Trellisdiagramm eine 1:1–Zuordnung besteht. Auch die Informationssequenz u ist aus dem ausgewählten Trellispfad anhand der Farben der einzelnen Zweige ablesbar. Ein roter Zweig steht für das Informationsbit u_i = 0, ein blauer für u_i = 1.

: Auf der ersten Seite dieses Abschnitts wurde für unseren Rate–1/2–Standardcodierer mit Gedächtnis m = 2 sowie die Informationssequenz u = (1, 1, 1, 0, 0, 0, 1, 0, 1, ...) die Codesequenz x hergeleitet, die in nachfolgender Tabelle für i ≤ 9 nochmals angegeben ist.

Darunter gezeichnet ist das Trellisdiagramm. Man erkennt:

Der ausgewählte Pfad durch das Trellis ergibt sich durch die Aneinanderreihung roter und blauer Pfeile, die für die möglichen Informationsbits u_i = 0 bzw. u_i = 1 stehen. Diese Aussage gilt für jeden Rate–1/n–Faltungscode. Bei einem Code mit k > 1 gäbe es 2^k verschiedenfarbige Pfeile.

Bei einem Rate–1/n–Faltungscode sind die Pfeile mit den Codeworten x_i = (x_i⁽¹⁾, ... , (x_i⁽ⁿ⁾) beschriftet, die sich aus dem Informationsbit u_i und den aktuellen Registerzuständen s_i ergeben. Für n = 2 gibt es nur vier mögliche Codeworte, nämlich 00, 01, 10 und 11.

In vertikaler Richtung erkennt man aus dem Trellis die möglichen Registerzustände S_μ. Bei einem Rate–k/n–Faltungscode mit der Gedächtnisordnung m gibt es 2^{k · m} verschiedene Zustände. Im vorliegenden Beispiel (k = 1, m = 2) sind dies nur die Zustände S₀, S₁, S₂ und S₃.

Definition der freien Distanz (1)

Als eine wichtige Kenngröße der linearen Blockcodes wurde in Kapitel 1.1 die minimale Hamming–Distanz zwischen zwei beliebigen Codeworten x und x' eingeführt:

\[d_{\rm min}(\mathcal{C}) = \min_{\substack{\underline{x},\hspace{0.05cm}\underline{x}' \hspace{0.05cm}\in \hspace{0.05cm} \mathcal{C} \\ {\underline{x}} \hspace{0.05cm}\ne \hspace{0.05cm} \underline{x}'}}\hspace{0.1cm}d_{\rm H}(\underline{x}, \hspace{0.05cm}\underline{x}')\hspace{0.05cm}.\]

Aufgrund der Linearität gehört zu jedem Blockcode auch das Nullwort 0. Damit ist d_min auch gleich dem minimalen Hamming–Gewicht w_H (x) eines Codewortes x ≠ 0.

Bei Faltungscodes erweist sich die Beschreibung der Distanzverhältnisse als wesentlich aufwändiger, da ein Faltungscode aus unendlich langen und unendlich vielen Codesequenzen besteht.

: Die freie Distanz d_F eines Faltungscodes ist gleich der Anzahl der Bits, in dem sich zwei beliebige Codesequenzen x und x' (mindestens) unterscheiden. Anders ausgedrückt: Die freie Distanz ist gleich der minimalen Hamming–Distanz zwischen zwei beliebigen Pfaden durch das Trellis.

Da Faltungscodes ebenfalls linear sind, kann man auch hier als Bezugssequenz die unendlich lange Nullsequenz heranziehen: x = 0. Damit ist die freie Distanz d_F gleich dem minimalen Hamming–Gewicht (Anzahl der Einsen) einer Codesequenz x ≠ 0.

: Wir betrachten die Nullsequenz 0 (weiß markiert) sowie zwei andere Codesequenzen x sowie x' (mit gelber bzw. dunkler Hinterlegung) in unserem Standard–Trellis und charakterisieren diese Sequenzen anhand der Zustandsfolgen:

\[\underline{0} \hspace{-0.15cm} = \hspace{-0.15cm} \left ( S_0 \rightarrow S_0 \rightarrow S_0\rightarrow S_0\rightarrow S_0\rightarrow \hspace{0.05cm}... \hspace{0.05cm}\right)= \left ( 00, 00, 00, 00, 00,\hspace{0.05cm} ... \hspace{0.05cm}\right) \hspace{0.05cm},\] \[\underline{x} \hspace{-0.15cm} = \hspace{-0.15cm} \left ( S_0 \rightarrow S_1 \rightarrow S_2\rightarrow S_0\rightarrow S_0\rightarrow \hspace{0.05cm}... \hspace{0.05cm}\right)= \left ( 11, 10, 11, 00, 00,\hspace{0.05cm} ... \hspace{0.05cm}\right) \hspace{0.05cm},\] \[\underline{x}' \hspace{-0.15cm} = \hspace{-0.15cm} \left ( S_0 \rightarrow S_1 \rightarrow S_3\rightarrow S_2\rightarrow S_0\rightarrow \hspace{0.05cm}... \hspace{0.05cm}\right)= \left ( 11, 01, 01, 11, 00,\hspace{0.05cm} ... \hspace{0.05cm}\right) \hspace{0.05cm}.\]

Man erkennt aus diesen Darstellungen:

Die freie Distanz d_F = 5 ist gleich dem Hamming–Gewicht w_H(x). Keine andere Sequenz als die gelb hinterlegte unterscheidet sich von 0 um weniger als 5 Bit. Beispielsweise ist w_H(x′) = 6.

In diesem Beispiel ergibt sich die freie Distanz d_F = 5 auch als die Hamming–Distanz zwischen den Sequenzen x und x′, die sich genau in fünf Bitpositionen unterscheiden.

Definition der freien Distanz (2)

Je größer die freie Distanz d_F ist, desto besser ist das asymptotische Verhalten des Faltungscoders. Zur genauen Berechnung von Fehlerwahrscheinlichkeit benötigt man allerdings – ebenso wie bei den linearen Blockcodes – die Gewichtsfunktion (englisch: Weight Enumerator Function) ⇒ siehe Kapitel 3.5.

Die freie Distanz d_F nimmt mit wachsendem Gedächtnis m zu, vorausgesetzt, man verwendet für die Übertragungsfunktionsmatrix G(D) geeignete Polynome. In der Tabelle sind für Rate–1/2–Faltungscodes die n = 2 Polynome zusammen mit dem d_F–Wert angegeben. Von Bedeutung ist insbesondere der sog. Industriestandardcode mit m = 6 ⇒ 64 Zustände und der freien Distanz d_F = 10.

Das folgende Beispiel zeigt, welche Auswirkungen es hat, wenn man ungünstige Polynome zugrundelegt.

: Unser (n = 2, k = 1, m = 2)–Standard–Coder basiert auf der Übertragungsfunktionsmatrix G(D) = (1+D+D², 1+D²). Dieser weist die freie Distanz d_F = 5 auf.

Verwendet man G(D) = (1+D, 1+D²), so ändert sich das Zustandsübergangsdiagramm gegenüber dem Standard–Coder ⇒ Seite 2a nur wenig. Die Auswirkungen sind aber gravierend:

Die freie Distanz ist nun nicht mehr d_F = 5, sondern nur noch d_F = 3, wobei die Codesequenz x = (11, 01, 00, 00, ...) zur Informationssequenz u = 1 = (1, 1, 1, 1, ...) gehört.

Das heißt: Durch nur drei Übertragungsfehler an den Positionen 1, 2, und 4 verfälscht man die Einssequenz (1) in die Nullsequenz (0) und produziert so unendlich viele Decodierfehler.

Einen Faltungscodierer mit diesen Eigenschaften bezeichnet man als katastrophal. Der Grund für dieses extrem ungünstige Verhalten ist, dass hier 1+D und 1+D² nicht teilerfemd sind.

Terminierte Faltungscodes

Bei der theoretischen Beschreibung der Faltungscodes geht man stets von Informationssequenzen u und Codesequenzen x aus, die per Definition unendlich lang sind. In praktischen Anwendungen, siehe zum Beispiel GSM und UMTS verwendet man dagegen stets eine Informationssequenz endlicher Länge L. Bei einem Rate–1/n–Faltungscode hat dann die Codesequenz mindestens die Länge n · L.

Die Grafik zeigt ohne Hinterlegung das Trellis unseres Standard–Rate–1/2–Faltungscodes bei binärer Eingangsfolge u der endlichen Länge L = 128. Damit hat die Codefolge x die Länge 2 · L = 256. Aufgrund des undefinierten Endzustands ist eine vollständige Maximum–Likelihood–Decodierung der gesendeten Folge allerdings nicht möglich. Da man nicht weiß, welcher der Zustände S₀, ... , S₃ sich für i > L einstellen würden, wird die Fehlerwahrscheinlichkeit (etwas) größer sein als im Grenzfall L → ∞.

Um dies zu verhindern, terminiert man den Faltungscode entsprechend der Hinterlegung in obiger Grafik:

Man fügt an die L = 128 Informationsbits noch m = 2 Nullen an ⇒ L' = 130.

Damit ergibt sich beispielsweise für den farblich hervorgehobenen Pfad durch das Trellis:

\[\underline{x}' = (11\hspace{0.05cm},\hspace{0.05cm} 01\hspace{0.05cm},\hspace{0.05cm} 01\hspace{0.05cm},\hspace{0.05cm} 00 \hspace{0.05cm},\hspace{0.05cm} ...\hspace{0.1cm},\hspace{0.05cm} 10\hspace{0.05cm},\hspace{0.05cm}00\hspace{0.05cm},\hspace{0.05cm} 01\hspace{0.05cm},\hspace{0.05cm} 01\hspace{0.05cm},\hspace{0.05cm} 11 \hspace{0.05cm} ) \]

\[\Rightarrow \hspace{0.3cm}\underline{u}' = (1\hspace{0.05cm},\hspace{0.05cm} 1\hspace{0.05cm},\hspace{0.05cm} 0\hspace{0.05cm},\hspace{0.05cm} 1 \hspace{0.05cm},\hspace{0.05cm} ...\hspace{0.1cm},\hspace{0.05cm} 0\hspace{0.05cm},\hspace{0.05cm}1\hspace{0.05cm},\hspace{0.05cm} 1\hspace{0.05cm},\hspace{0.05cm} 0\hspace{0.05cm},\hspace{0.05cm} 0 \hspace{0.05cm} ) \hspace{0.05cm}.\]

Das Trellis endet nun stets (also unabhängig von den Daten) im definierten Endzustand S₀ und man erreicht so die bestmögliche Fehlerwahrscheinlichkeit entsprechend Maximum–Likelihood.

Die Verbesserung hinsichtlich der Fehlerwahrscheinlichkeit erkauft man sich allerdings auf Kosten einer kleineren Coderate. Gilt L >> m, so ist dieser Verlust nur gering. Im betrachteten Beispiel ergibt sich mit Terminierung die Coderate R' = 0.5 · L/(L + m) ≈ 0.492 anstelle von R = 0.5.

Punktierte Faltungscodes

Wir gehen von einem Faltungscode der Rate R₀ = 1/n₀ aus, den wir Muttercode nennen. Streicht man von dessen Codesequenz einige Bits entsprechend einem vorgegebenen Muster, so spricht man von einem punktierten Faltungscode (englisch: Punctured Convolutional Code) mit der Coderate R > R₀.

Die Punktierung geschieht mittels der Punktierungsmatrix P mit folgenden Eigenschaften:

Die Zeilenzahl ist n₀, die Spaltenzahl gleich der Punktierungsperiode p, die durch die gewünschte Coderate bestimmt wird.

Die n₀ · p Matrixelemente P_ij sind binär (0 oder 1). Bei P_ij = 1 wird das entsprechende Codebit übernommen, bei P_ij = 0 punktiert.

Die Rate des punktierten Faltungscodes ergibt sich als der Quotient aus p und der Anzahl N₁ der Einsen in der P–Matrix.

Man findet günstig punktierte Faltungscodes üblicherweise nur mittels computergestützter Suche. Dabei bezeichnet man einen punktierten Faltungscode dann als günstig, wenn er

die gleiche Gedächtnisordnung m aufweist wie der Muttercode (auch die Gesamteinflusslänge ist in beiden Fällen gleich: ν = m + 1),

eine möglichst große freie Distanz d_F besitzt, die natürlich kleiner ist als die des Muttercodes.

: Ausgehend von unserem Rate–1/2–Standardcode mit den Parametern n₀ = 2, m = 2 erhält man mit der Punktierungsmatrix

\[{\boldsymbol{\rm P}} = \begin{pmatrix} 1 & 1 & 0 \\ 1 & 0 & 1 \end{pmatrix}\hspace{0.3cm}\Rightarrow \hspace{0.3cm} p = 3\hspace{0.05cm}, \hspace{0.2cm}N_1 = 4\]

einen punktierten Faltungscode der Rate R = p/N₁ = 3/4. Wir betrachten hierzu folgende Konstellation:

Informationssequenz: u = (1, 0, 0, 1, 1, 0, ...),

Codesequenz ohne Punktierung: x = (11, 10, 11, 11, 01, 01, ...),

Codesequenz mit Punktierung: x' = (11, 1_, _1, 11, 0_, _1, ...),

Empfangssequenz ohne Fehler: y = (11, 1_, _1, 11, 0_, _1, ...),

Modifizierte Empfangssequenz: y' = (11, 1E, E1, 11, 0E, E1, ...).

Jedes punktierte Bit in der Empfangssequenz y (markiert durch einen Unterstrich) wird also durch ein Erasure E ersetzt – siehe Binary Erasure Channel. Ein solches durch die Punktierung entstandene Erasure wird vom Decoder genauso behandelt wie eine Auslöschung durch den Kanal.

Natürlich erhöht sich durch die Punktierung die Fehlerwahrscheinlichkeit. Dies kann man bereits daran erkennen, dass die freie Distanz nach der Punktierung auf d_F = 3 sinkt. Demgegenüber besitzt der Muttercode die freie Distanz d_F = 5.

Eine Anwendung findet die Punktierung zum Beispiel bei den so genannten RCPC–Codes (Rate Compatible Punctered Convolutional Codes). Näheres hierzu in der Aufgabe A3.8.