Code Description with State and Trellis Diagram

\usepackage{color}

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 $\nu = 3$,

Übertragungsfunktionsmatrix in Oktalform $(7, 5)$ ⇒ $\mathbf{G}(D) = (1 + D + D^2, \ 1 + D^2)$.

Die Codesequenz zum Zeitpunkt $i$ ⇒ $\underline{x}_i = (x_i^{(1)}, \ x_i^{(2)})$ 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_0, S_1, S_2$ und $S_3$ bezeichnet. Der Registerzustand $S_{\mu}$ 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_{\mu}$ mit den Indizes $0 ≤ \mu ≤ 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 $\underline{u}$ ⇒ Informationsbits $u_i$,

der aktuellen Zustände $s_i ∈ \{S_0, \ S_1, \ S_2, \ S_3\}$ zu den Zeitpunkten $i$, sowie

der jeweiligen Codesequenzen $\underline{x}_i = (x_i^{(1)}, \ x_i^{(2)})$.

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_4 = 0$, $u_{i–2} = u_3 = 1$. Das heißt, der Automat befindet sich im Zustand $s_5 = S_2$. Mit dem Informationsbit $u_i = u_5 = 0$ erhält man die Codesequenz $\underline{x}_5 = (11)$.

Der Zustand für den Zeitpunkt $i = 6$ ergibt sich aus $u_{i–1} = u_5 = 0$ und $u_{i–2} = u_4 = 0$ zu $s_6 = S_0$. Wegen $u_6 = 0$ wird nun $\underline{x}_6 = (00)$ ausgegeben und der neue Zustand $s_7$ ist wiederum $S_0$.

Auch zum Zeitpunkt $i = 12$ wird wegen $u_{12} = 0$ die Codesequenz $\underline{x}_{12} = (11)$ ausgegeben und man geht vom Zustand $s_{12} = S_2$ in den Zustand $s_{13} = S_0$ über.

Dagegen wird zum Zeitpunkt $i = 9$ die Codesequenz $(00)$ ausgegeben und auf $s_9 = S_2$ folgt $s_{10} = S_1$. 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 $\underline{x}_i$ zum Zeitpunkt $i$ allein

vom aktuellen Zustand $s_i = S_{\mu} (0 ≤ \mu ≤ 2^m \, –1)$, sowie

vom aktuellen Informationsbit $u_i$

abhängt. Ebenso wird der Nachfolgezustand $s_{i+1}$ 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 \ | \ \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$.

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

Die Anzahl der Zustände ist $2^{m \cdot 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_{\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 systematisch ist, gilt $x_i^{(1)} = u_i$. Die Herleitung der zweiten Codebits $x_i^{(2)}$ 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_0, \ S_1, \ S_2, \ S_3\}$ zu den gleichen Nachfolgezuständen $s_{i+1}$.

Ein Unterschied besteht hinsichtlich der ausgegebenen Codesequenzen $\underline{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_1 = S_0$. Zum nächsten Zeitpunkt $(i = 2)$ sind dann nur die beiden 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 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 $\underline{x}_i$ und den Pfaden durch das Trellisdiagramm eine 1: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$.

: Auf der ersten Seite dieses Abschnitts 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, \ ...)$ die Codesequenz $\underline{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 $\underline{x}_i = (x_i^{(1)}, \ ... \ , \ 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 möglichen Registerzustände $S_{\mu}$. Bei einem Rate–$k/n$–Faltungscode mit der Gedächtnisordnung $m$ gibt es $2^{k \cdot m}$ verschiedene Zustände. Im vorliegenden Beispiel $(k = 1, \ m = 2)$ sind dies nur die Zustände $S_0, \ S_1, \ S_2$ und $S_3$.

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

: Wir betrachten die Nullsequenz $\underline{0}$ (weiß markiert) sowie zwei andere Codesequenzen $\underline{x}$ sowie $\underline{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_{\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 $5 \ \rm 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}'$, die sich genau in fünf Bitpositionen unterscheiden.

Definition der freien Distanz (2)

Je größer die freie Distanz $d_{\rm 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_{\rm F}$ nimmt mit wachsendem Gedächtnis $m$ zu, vorausgesetzt, man verwendet für die Übertragungsfunktionsmatrix $\mathbf{G}(D)$ geeignete Polynome. In der Tabelle sind für Rate–$1/2$–Faltungscodes die $n = 2$ Polynome zusammen mit dem $d_{\rm F}$–Wert angegeben. Von Bedeutung ist insbesondere der sog. Industriestandardcode mit $m = 6$ ⇒ $64$ Zustände und der freien Distanz $d_{\rm 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 $\mathbf{G}(D) = (1 + D + D^2, \ 1 + D^2)$. Dieser weist die freie Distanz $d_{\rm F} = 5$ auf.

Verwendet man $\mathbf{G}(D) = (1 + D, \ 1 + D^2)$, 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_{\rm F} = 5$, sondern nur noch $d_{\rm F} = 3$, wobei die Codesequenz $\underline{x} = (11, 01, 00, 00, \ ...)$ zur Informationssequenz $\underline{u} = \underline{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 $(\underline{1})$ in die Nullsequenz $(\underline{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^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, 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 \cdot L$.

Die Grafik zeigt ohne Hinterlegung 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, \ ... \ , \ 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} ...\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_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. Gilt $L >> m$, so ist dieser Verlust nur gering. Im betrachteten Beispiel ergibt sich mit Terminierung die Coderate $R' = 0.5 \cdot L/(L + m) \approx 0.492$ anstelle von $R = 0.5$.

Punktierte Faltungscodes

Wir gehen von einem Faltungscode der Rate $R_0 = 1/n_0$ 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_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 Faltungscodes ergibt sich als der Quotient aus $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.

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

Informationssequenz:$\hspace{2cm} \underline{u} = (1, 0, 0, 1, 1, 0, \ ...)$, *Codesequenz ohne Punktierung:$\hspace{0.2cm} \underline{x} = (11, 1 \textcolor{gray}{0}, \textcolor{gray}{1}1, 11, 0\textcolor{gray}{1}, \textcolor{gray}{0}1, \ ...)$ 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 $\underline{y}$ (markiert durch einen Unterstrich) wird also durch ein Erasure E ersetzt – siehe [http://en.lntwww.de/Kanalcodierung/Klassifizierung_von_Signalen#Binary_Erasure_Channel_.E2.80.93_BEC 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 der Aufgabe A3.8.