Channel Coding/Code Description with State and Trellis Diagram

1. Channel Coding
2. Convolutional Codes and Their Decoding
3. Code Description with State and Trellis Diagram

• Previous page
• Next page

• Previous page
• Next page

State definition for a memory register

A convolutional encoder can also be understood as an automaton with a finite number of states. The number of states results from the number of memory elements   ⇒   memory  $m$  thereby to  $2^m$.

Convolutional encoder with  $k = 1, \ n = 2, \ m = 2$

In this chapter we mostly start from the drawn convolutional encoder, which is characterized by the following parameters:

• $k = 1, \ n = 2$   ⇒   Coderate $R = 1/2$,
  

• Memory  $m = 2$   ⇒   influence length $\nu = 3$,
  

• Transfer function matrix in octal form  $(7, 5)$:

$$\mathbf{G}(D) = (1 + D + D^2, \ 1 + D^2).$$

The code sequence at time  $i$   ⇒   $\underline{x}_i = (x_i^{(1)}, \ x_i^{(2)})$  depends not only on the information bit  $u_i$  but also on the content  $(u_{i-1}, \ u_{i-2})$  of the memory.

• There are  $2^m = 4$  possibilities for this, namely the states  $S_0, \ S_1, \ S_2$  and  $S_3$.
• Let the register state  $S_{\mu}$  be defined by the index:

\[\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}.\]

To avoid confusion, we distinguish in the following by upper or lower case letters:

• the possible states  $S_{\mu}$  with the indices  $0 ≤ \mu ≤ 2^m \,-1$,
  

• the current states  $s_i$  at the times.  $i = 1, \ 2, \ 3, \ \text{...}$
  

$\text{Example 1:}$  The graph shows for the convolutional encoder sketched above

• the information sequence  $\underline{u} = (u_1,u_2, \text{...} \ ) $   ⇒   information bits  $u_i$,

• the current states at the times  $i$   ⇒   $s_i ∈ \{S_0, \ S_1, \ S_2, \ S_3\}$,
  

• the 2 bit sequences  $\underline{x}_i = (x_i^{(1)}, \ x_i^{(2)})$   ⇒   encoding the information bit $u_i$.
  

To illustrate the states  $S_{\mu}$

For example, you can see from this illustration (the colors are to facilitate the transition to later graphics):

• At time  $i = 5$  $u_{i-1} = u_4 = 0$,  $u_{i-2} = u_3 = 1$ holds. That is, the automaton is in state  $s_5 = S_2$. With the information bit  $u_i = u_5 = 0$  the code sequence  $\underline{x}_5 = (11)$ is obtained.
  

• The state for time  $i = 6$  results from  $u_{i-1} = u_5 = 0$  and  $u_{i-2} = u_4 = 0$  to  $s_6 = S_0$. Because of  $u_6 = 0$  now  $\underline{x}_6 = (00)$  is output and the new state  $s_7$  is again  $S_0$.
  

• At time  $i = 12$  the code sequence  $\underline{x}_{12} = (11)$  is output because of  $u_{12} = 0$  as at time  $i = 5$  and one passes from state  $s_{12} = S_2$  to state  $s_{13} = S_0$ .
  

• In contrast, at time  $i = 9$  the code sequence  $\underline{x}_{9} = (00)$  is output and followed by  $s_9 = S_2$  $s_{10} = S_1$. The same is true for  $i = 15$. In both cases, the current information bit is  $u_i = 1$.

$\text{Conclusion:}$  From this example it can be seen that the code sequence  $\underline{x}_i$  at time  $i$  alone depends on

• from the current state  $s_i = S_{\mu} \ (0 ≤ \mu ≤ 2^m -1)$, as well as
  
• from the current information bit  $u_i$.
  
  

Similarly, the successor state  $s_{i+1}$  is determined by  $s_i$  and  $u_i$  alone.

These properties are considered in the so-called state transition diagram  on the next page

.

Representation in the state transition diagram

The graph shows the  state transition diagram for our "standard encoder"'.

• 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.
  

Zustandsübertragungsdiagramm  $\rm A$  für  $n = 2, \ k = 1, \ m = 2$

Die  $2^{m+k}$  Übergänge sind mit "$u_i \ | \ \underline{x}_i$" beschriftet. Beispielsweise ist abzulesen:

• Durch das Informationsbit  $u_i = 0$  (gekennzeichnet durch eine rote Beschriftung) gelangt man vom Zustand  $s_i = S_1$  zum Zustand  $s_{i+1} = S_2$  und die beiden Codebits lauten  $x_i^{(1)} = 1, \ x_i^{(2)} = 0$.
  

• Mit dem Informationsbit  $u_i = 1$  (blaue Beschriftung) im Zustand  $s_i = S_1$  ergeben sich dagegen die Codebits zu  $x_i^{(1)} = 0, \ x_i^{(2)} = 1$, und man kommt zum neuen Zustand  $s_{i+1} = S_3$.
  
  

Betrachten wir nun einen weiteren systematischen Code, ebenfalls mit den Kenngrößen  $n = 2, \ k = 1, \ m = 2$. Es handelt sich hierbei um die  äquivalente systematische Repräsentation  des oberen Codierers. Man bezeichnet diesen auch als  RSC–Codierer  (englisch:  Recursive Systematic Convolutional Encoder).

Zustandsübertragungsdiagramm  $\rm B$  für  $n = 2, \ k = 1, \ m = 2$

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_{\mu}$  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 ebenfalls systematisch ist, gilt wieder  $x_i^{(1)} = u_i$. Die Herleitung der zweiten Codebits  $x_i^{(2)}$  finden Sie in der  Aufgabe 3.5. Es handelt sich um ein rekursives Filter, wie im Abschnitt  Filterstruktur bei gebrochen–rationaler Übertragungsfunktion  beschrieben.
  
  

$\text{Fazit:}$  Der Bildervergleich zeigt, dass sich für beide Codierer ein ähnliches Zustandsübergangsdiagramm ergibt:

• Die Struktur des Zustandsübergangsdiagramms ist allein durch die Parameter  $m$  und  $k$  festgelegt.

• Die Anzahl der Zustände ist  $2^{m \hspace{0.05cm}\cdot \hspace{0.05cm}k}$.
  

• Von jedem Zustand gehen  $2^k$  Pfeile ab.
  

• Man gelangt auch von jedem Zustand  $s_i ∈ \{S_0, \ S_1, \ S_2, \ S_3\}$  zu den gleichen Nachfolgezuständen  $s_{i+1}$.
  

• Ein Unterschied besteht allein hinsichtlich der ausgegebenen Codesequenzen, wobei in beiden Fällen  $\underline{x}_i ∈ \{00, \ 01, \ 10, \ 11\}$  gilt.

Darstellung im Trellisdiagramm

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 beide Diagramme für unseren "Standard–Codierer"  $(n = 2, \ k = 1, \ m = 2)$  gegenüber.

Zustandsübergangsdiagramm vs. Trellisdiagramm  $(n = 2, \ k = 1, \ m = 2)$

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_1 = S_0$. Zum nächsten Zeitpunkt  $(i = 2)$  sind dann nur die beiden (Start–)Zustände  $S_0$  und  $S_1$  möglich.
  

• Ab dem Zeitpunkt  $i = m + 1 = 3$  hat das Trellis für jeden Übergang von  $s_i$  nach  $s_{i+1}$  genau das gleiche Aussehen. Jeder Zustand  $S_{\mu}$  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 Abschnitt  Fehlergrößen und Gesamtfehlergrößen  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.
  
  

Das folgende Beispiel soll zeigen, dass zwischen der Aneinanderreihung der Codesequenzen  $\underline{x}_i$  und den Pfaden durch das Trellisdiagramm eine  $1\text{:}1$–Zuordnung besteht.

• Auch die Informationssequenz  $\underline{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$.
  

$\text{Beispiel 2:}$  Im  $\text{Beispiel 1}$  wurde für unseren Rate–$1/2$–Standardcodierer mit Gedächtnis  $m = 2$  sowie die Informationssequenz  $\underline{u} = (1, 1, 1, 0, 0, 0, 1, 0, 1, \ \text{...})$  die Codesequenz  $\underline{x}$  hergeleitet, die hier für  $i ≤ 9$  nochmals angegeben wird.

Trellisdiagramm einer Beispielssequenz

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 \in \{ 0, \ 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  $\underline{x}_i = (x_i^{(1)}, \ \text{...} \ , \ x_i^{(n)})$  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 Registerzustände  $S_{\mu}$. Bei einem Rate–$k/n$–Faltungscode mit der Gedächtnisordnung  $m$  gibt es  $2^{k \hspace{0.05cm}\cdot \hspace{0.05cm}m}$  verschiedene Zustände. Im vorliegenden Beispiel  $(k = 1, \ m = 2)$  sind dies die Zustände  $S_0, \ S_1, \ S_2$ und $S_3$.

Definition der freien Distanz

Eine wichtige Kenngröße der linearen Blockcodes ist die  minimale Hamming–Distanz  zwischen zwei beliebigen Codeworten  $\underline{x}$  und  $\underline{x}\hspace{0.05cm}'$:

\[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.03cm}'}}\hspace{0.1cm}d_{\rm H}(\underline{x}, \hspace{0.05cm}\underline{x}\hspace{0.03cm}')\hspace{0.05cm}.\]

• Aufgrund der Linearität gehört zu jedem Blockcode auch das Nullwort  $\underline{0}$. Damit ist  $d_{\rm min}$  identisch mit dem minimalen  Hamming–Gewicht  $w_{\rm H}(\underline{x})$  eines Codewortes  $\underline{x} ≠ \underline{0}$.
  

• Bei Faltungscodes erweist sich allerdings die Beschreibung der Distanzverhältnisse als wesentlich aufwändiger, da ein Faltungscode aus unendlich langen und unendlich vielen Codesequenzen besteht. Deshalb definieren wir hier anstelle der minimalen Hamming–Distanz:

$\text{Definition:}$ 

• Die  freie Distanz  $d_{\rm F}$  eines Faltungscodes ist gleich der Anzahl der Bits, in dem sich zwei beliebige Codesequenzen  $\underline{x}$  und  $\underline{x}\hspace{0.03cm}'$  (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:   $\underline{x}\hspace{0.03cm}' = \underline{0}$. Damit ist die freie Distanz  $d_{\rm F}$  gleich dem minimalen Hamming–Gewicht (Anzahl der Einsen) einer Codesequenz  $\underline{x} ≠ \underline{0}$.

$\text{Beispiel 3:}$  Wir betrachten die Nullsequenz  $\underline{0}$  (mit weiß gefüllten Kreisen markiert) sowie zwei andere Codesequenzen  $\underline{x}$  sowie  $\underline{x}\hspace{0.03cm}'$  (mit gelber bzw. dunkler Hinterlegung) in unserem Standard–Trellis und charakterisieren diese Sequenzen anhand der Zustandsfolgen:

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

Zur Definition der freien Distanz

Man erkennt aus diesen Darstellungen:

• Die freie Distanz  $d_{\rm F} = 5$  ist gleich dem Hamming–Gewicht  $w_{\rm H}(\underline{x})$. Keine andere Sequenz als die gelb hinterlegte unterscheidet sich von  $\underline{0}$  um weniger als fünf Bit. Beispielsweise ist  $w_{\rm H}(\underline{x}') = 6$.
  

• In diesem Beispiel ergibt sich die freie Distanz  $d_{\rm F} = 5$  auch als die Hamming–Distanz zwischen den Sequenzen  $\underline{x}$  und  $\underline{x}\hspace{0.03cm}'$, die sich genau in fünf Bitpositionen unterscheiden.

Je größer die freie Distanz  $d_{\rm F}$  ist, desto besser ist das "asymptotische Verhalten" des Faltungscoders.

• Zur genauen Fehlerwahrscheinlichkeitsberechnung benötigt man allerdings ebenso wie bei den linearen Blockcodes die genaue Kenntnis der  Gewichtsfunktion  (englisch:  Weight Enumerator Function ).
• Diese wird für die Faltungscodes im Detail erst im Kapitel  Distanzeigenschaften und Fehlerwahrscheinlichkeitsschranken  angegeben.

Optimale Faltungscodes der Rate  $1/2$

Vorneweg nur einige wenige Bemerkungen:

• Die freie Distanz  $d_{\rm F}$  nimmt mit wachsendem Gedächtnis  $m$  zu, vorausgesetzt, dass man für die Übertragungsfunktionsmatrix  $\mathbf{G}(D)$  geeignete Polynome verwendet.
• In der Tabelle sind für Rate–$1/2$–Faltungscodes die  $n = 2$  Polynome zusammen mit dem  $d_{\rm F}$–Wert angegeben.
• Von größerer praktischer Bedeutung ist der Industrie–Standardcode  mit  $m = 6$   ⇒   $64$  Zustände und der freien Distanz  $d_{\rm F} = 10$  (in der Tabelle ist dieser rot hinterlegt).

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

$\text{Beispiel 4:}$  Im  $\text{Beispiel 3}$  wurde gezeigt, dass unser Standard–Faltungscoder  $(n = 2, \ k = 1, \ m = 2)$  die freie Distanz  $d_{\rm F} = 5$  aufweist. Dieser basiert auf der Übertragungsfunktionsmatrix  $\mathbf{G}(D) = (1 + D + D^2, \ 1 + D^2)$, wie aus dem gezeigten Modell (ohne rote Streichung) hervorgeht.

Zustandsübergangsdiagramm  $\rm C$  für  $n = 2, \ k = 1, \ m = 2$

Verwendet man  $\mathbf{G}(D) = (1 + D, \ 1 + D^2)$   ⇒   rote Änderung, so ändert sich das Zustandsübergangsdiagramm gegenüber dem  Zustandsübergangsdiagramm $\rm A$  auf den ersten Blick nur wenig. Die Auswirkungen sind aber gravierend:

• Die freie Distanz ist nun nicht mehr  $d_{\rm F} = 5$, sondern nur noch  $d_{\rm F} = 3$, wobei die Codesequenz  $\underline{x} = (11, \ 01, \ 00, \ 00, \ \text{...})$  mit nur drei Einsen zur Informationssequenz  $\underline{u} = \underline{1} = (1, \ 1, \ 1, \ 1, \ \text{...})$  gehört.
  

• Das heißt:  Durch nur drei Übertragungsfehler an den Positionen 1, 2, und 4 verfälscht man die Einssequenz  $(\underline{1})$  in die Nullsequenz  $(\underline{0})$  und produziert so unendlich viele Decodierfehler im Zustand  $S_3$.
  

• Einen Faltungscodierer mit diesen Eigenschaften bezeichnet man als "katastrophal". Der Grund für dieses extrem ungünstige Verhalten ist, dass hier die beiden Polynome  $1 + D$  und  $1 + D^2$  nicht teilerfemd sind.

Terminierte Faltungscodes

Bei der theoretischen Beschreibung der Faltungscodes geht man stets von Informationssequenzen  $\underline{u}$  und Codesequenzen  $\underline{x}$  aus, die per Definition unendlich lang sind.

• In praktischen Anwendungen – 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 \cdot L$.
  

Terminierter Faltungscode der Rate  $R = 128/260$

Die Grafik ohne die graue Hinterlegung rechts zeigt das Trellis unseres Standard–Rate–$1/2$–Faltungscodes bei binärer Eingangsfolge  $\underline{u}$  der endlichen Länge  $L = 128$. Damit hat die Codefolge  $\underline{x}$  die Länge  $2 \cdot 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_0, \ \text{...} \ , \ S_3$  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} \text{...}\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} ) \hspace{0.3cm} \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} \text{...}\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_0$  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.
• Bei  $L \gg m$  ist dieser Verlust nur gering. Im betrachteten Beispiel ergibt sich anstelle von  $R = 0.5$  mit Terminierung die Coderate

$$R\hspace{0.05cm}' = 0.5 \cdot L/(L + m) \approx 0.492.$$

Punktierte Faltungscodes

$\text{Definition:}$ 

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

Die Punktierung geschieht mittels der Punktierungsmatrix  $\mathbf{P}$  mit folgenden Eigenschaften:

• Die Zeilenzahl ist  $n_0$, die Spaltenzahl gleich der Punktierungsperiode  $p$, die durch die gewünschte Coderate bestimmt wird.
  

• Die  $n_0 \cdot 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 Codes ist gleich dem Quotienten aus der Punktierungsperiode  $p$  und der Anzahl  $N_1$  der Einsen in der  $\mathbf{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:   $\nu = m + 1)$,
  

• eine möglichst große freie Distanz  $d_{\rm F}$  besitzt, die natürlich kleiner ist als die des Muttercodes.
  
  

$\text{Beispiel 5:}$  Ausgehend von unserem  Rate–1/2–Standardcode  mit den Parametern  $n_0 = 2$  und  $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_1 = 3/4$. Wir betrachten hierzu folgende Konstellation:

• Informationssequenz: $\hspace{2.5cm} \underline{u} = (1, 0, 0, 1, 1, 0, \ \text{...}\hspace{0.03cm})$,
  

• Codesequenz ohne Punktierung: $\hspace{0.7cm} \underline{x} = (11, 1 \color{grey}{0}, \color{gray}{1}1, 11, 0\color{gray}{1}, \color{gray}{0}1, \ \text{...}\hspace{0.03cm})$,
  

• Codesequenz mit Punktierung: $\hspace{0.90cm} \underline{x}\hspace{0.05cm}' = (11, 1\_, \_1, 11, 0\_, \_1, \ \text{...}\hspace{0.03cm})$,
  

• Empfangssequenz ohne Fehler: $\hspace{0.88cm} \underline{y} = (11, 1\_, \_1, 11, 0\_, \_1, \ \text{...}\hspace{0.03cm})$,
  

• Modifizierte Empfangssequenz: $\hspace{0.8cm} \underline{y}\hspace{0.05cm}' = (11, 1\rm E, E1, 11, 0E, E1, \ \text{...}\hspace{0.03cm})$.
  

Jedes punktierte Bit in der Empfangssequenz  $\underline{y}$  (markiert durch einen Unterstrich) wird also durch ein  Erasure  $\rm 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_{\rm F} = 3$  sinkt. Demgegenüber besitzt der Muttercode die freie Distanz  $d_{\rm F} = 5$.

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

Aufgaben zum Kapitel

Aufgabe 3.6: Zustandsübergangsdiagramm

Aufgabe 3.6Z: Übergangsdiagramm bei 3 Zuständen

Aufgabe 3.7: Vergleich zweier Faltungscodierer

Aufgabe 3.7Z: Welcher Code ist katastrophal?

Aufgabe 3.8: Rate Compatible Punctured Convolutional Codes