Sauter au contenu
Logo image

Section 8.4 Décodage efficace

Nous sommes maintenant à un stade où nous pouvons générer des codes linéaires qui détectent et corrigent les erreurs assez facilement, mais le décodage d’un \(n\)-uplet reçu et la détermination du mot de code le plus proche demeure un processus chronophage, car le \(n\)-uplet reçu doit être comparé à chaque mot de code possible pour déterminer le décodage correct. Cela peut constituer un obstacle sérieux si le code est très grand.

Exemple 8.4.1.

Étant donné la matrice binaire
\begin{equation*} H = \begin{pmatrix} 1 & 1 & 1 & 0 & 0 \\ 0 & 1 & 0 & 1 & 0 \\ 1 & 0 & 0 & 0 & 1 \end{pmatrix} \end{equation*}
et les \(5\)-uplets \({\mathbf x} = (11011)^\transpose\) et \({\mathbf y} = (01011)^\transpose\text{,}\) nous pouvons calculer
\begin{equation*} H{\mathbf x} = \begin{pmatrix} 0 \\ 0 \\ 0 \end{pmatrix} \qquad \text{et} \qquad H{\mathbf y} = \begin{pmatrix} 1 \\ 0 \\ 1 \end{pmatrix}\text{.} \end{equation*}
Donc, \({\mathbf x}\) est un mot de code et \({\mathbf y}\) ne l’est pas, puisque \({\mathbf x}\) est dans le noyau et \({\mathbf y}\) ne l’est pas. Remarquez que \(H{\mathbf y}\) est identique à la première colonne de \(H\text{.}\) En fait, c’est là que l’erreur s’est produite. Si nous inversons le premier bit de \({\mathbf y}\) de \(0\) à \(1\text{,}\) alors nous obtenons \({\mathbf x}\text{.}\)
Si \(H\) est une matrice \(m \times n\) et \({\mathbf x} \in {\mathbb Z}_2^n\text{,}\) alors nous disons que le syndrome de \({\mathbf x}\) est \(H{\mathbf x}\text{.}\) La proposition suivante permet la détection et la correction rapides des erreurs.

Démonstration.

La démonstration découle du fait que
\begin{equation*} H{\mathbf x} = H({\mathbf c} +{\mathbf e}) = H{\mathbf c} + H{\mathbf e} = {\mathbf 0} + H{\mathbf e} = H{\mathbf e}\text{.} \end{equation*}
Cette proposition nous dit que le syndrome d’un mot reçu dépend uniquement de l’erreur et non du mot de code transmis. La démonstration du théorème suivant découle immédiatement de Proposition 8.4.2 et du fait que \(H{\mathbf e}\) est la \(i\)-ème colonne de la matrice \(H\text{.}\)

Exemple 8.4.4.

Considérons la matrice
\begin{equation*} H = \begin{pmatrix} 1 & 0 & 1 & 1 & 0 & 0 \\ 0 & 1 & 1 & 0 & 1 & 0 \\ 1 & 1 & 1 & 0 & 0 & 1 \end{pmatrix} \end{equation*}
et supposons que les \(6\)-uplets \({\mathbf x} = (111110)^\transpose\text{,}\) \({\mathbf y} = (111111)^\transpose\text{,}\) et \({\mathbf z} = (010111)^\transpose\) ont été reçus. Alors
\begin{equation*} H{\mathbf x} = \begin{pmatrix} 1 \\ 1 \\ 1 \end{pmatrix}, H{\mathbf y} = \begin{pmatrix} 1 \\ 1 \\ 0 \end{pmatrix}, H{\mathbf z} = \begin{pmatrix} 1 \\ 0 \\ 0 \end{pmatrix}\text{.} \end{equation*}
Donc, \({\mathbf x}\) a une erreur dans le troisième bit et \({\mathbf z}\) a une erreur dans le quatrième bit. Les mots de code transmis pour \({\mathbf x}\) et \({\mathbf z}\) devaient être \((110110)\) et \((010011)\text{,}\) respectivement. Le syndrome de \({\mathbf y}\) n’apparaît dans aucune des colonnes de la matrice \(H\text{,}\) donc des erreurs multiples ont dû se produire pour produire \({\mathbf y}\text{.}\)

Sous-section 8.4.1 Décodage par classes latérales

Nous pouvons utiliser la théorie des groupes pour obtenir une autre méthode de décodage des messages. Un code linéaire \(C\) est un sous-groupe de \({\mathbb Z}_2^n\text{.}\) Le décodage par classes latérales ou décodage standard utilise les classes latérales de \(C\) dans \({\mathbb Z}_2^n\) pour mettre en œuvre le décodage par maximum de vraisemblance. Supposons que \(C\) est un code linéaire \((n,m)\text{.}\) Une classe latérale de \(C\) dans \({\mathbb Z}_2^n\) s’écrit sous la forme \({\mathbf x} + C\text{,}\)\({\mathbf x} \in {\mathbb Z}_2^n\text{.}\) Par le théorème de Lagrange (Théorème 6.2.2), il y a \(2^{n - (n - m)} = 2^m\) classes latérales distinctes de \(C\) dans \({\mathbb Z}_2^n\text{.}\)

Exemple 8.4.5.

Soit \(C\) le code linéaire \((5,3)\) donné par la matrice de contrôle de parité
\begin{equation*} H = \begin{pmatrix} 0 & 1 & 1 & 0 & 0 \\ 1 & 0 & 0 & 1 & 0 \\ 1 & 1 & 0 & 0 & 1 \end{pmatrix}\text{.} \end{equation*}
Le code est constitué des mots de code
\begin{equation*} (00000) \quad (01101) \quad (10011) \quad (11110)\text{.} \end{equation*}
Il y a \(2^{5-2} = 2^3\) classes latérales de \(C\) dans \({\mathbb Z}_2^5\text{,}\) chacune d’ordre \(2^2 =4\text{.}\) Ces classes latérales sont listées dans Table 8.4.6.
Table 8.4.6. Classes latérales de \(C\)
Représentant de Classe latérale
la classe latérale
\(C\) \((00000) (01101) (10011) (11110)\)
\((10000) + C\) \((10000) (11101) (00011) (01110)\)
\((01000) + C\) \((01000) (00101) (11011) (10110)\)
\((00100) + C\) \((00100) (01001) (10111) (11010)\)
\((00010) + C\) \((00010) (01111) (10001) (11100)\)
\((00001) + C\) \((00001) (01100) (10010) (11111)\)
\((10100) + C\) \((00111) (01010) (10100) (11001)\)
\((00110) + C\) \((00110) (01011) (10101) (11000)\)
Notre tâche est de comprendre comment la connaissance des classes latérales peut nous aider à décoder un message. Supposons que \({\mathbf x}\) était le mot de code original envoyé et que \({\mathbf r}\) est le \(n\)-uplet reçu. Si \({\mathbf e}\) est l’erreur de transmission, alors \({\mathbf r} = {\mathbf e} + {\mathbf x}\) ou, de façon équivalente, \({\mathbf x} = {\mathbf e} + {\mathbf r}\text{.}\) Cependant, cela revient exactement à dire que \({\mathbf r}\) est un élément de la classe latérale \({\mathbf e} + C\text{.}\) Dans le décodage par maximum de vraisemblance, nous attendons que l’erreur \({\mathbf e}\) soit aussi petite que possible ; c’est-à-dire que \({\mathbf e}\) aura le poids le plus faible. Un \(n\)-uplet de poids minimal dans une classe latérale est appelé un représentant minimal de la classe latérale. Une fois que nous avons déterminé un représentant minimal pour chaque classe latérale, le processus de décodage devient une tâche de calcul de \({\mathbf r} + {\mathbf e}\) pour obtenir \({\mathbf x}\text{.}\)

Exemple 8.4.7.

Dans Table 8.4.6, remarquez que nous avons choisi un représentant du poids le plus faible possible pour chaque classe latérale. Ces représentants sont les représentants minimaux des classes latérales. Supposons maintenant que \({\mathbf r} = (01111)\) est le mot reçu. Pour décoder \({\mathbf r}\text{,}\) nous trouvons qu’il est dans la classe latérale \((00010) + C\) ; par conséquent, le mot de code transmis à l’origine devait être \((01101) = (01111) + (00010)\text{.}\)
Un problème potentiel avec cette méthode de décodage est que nous pourrions avoir à examiner chaque classe latérale pour le mot de code reçu. La proposition suivante donne une méthode pour mettre en œuvre le décodage par classes latérales. Elle affirme que nous pouvons associer un syndrome à chaque classe latérale ; par conséquent, nous pouvons établir un tableau qui désigne un représentant minimal correspondant à chaque syndrome. Une telle liste est appelée une table de décodage.
Table 8.4.8. Syndromes pour chaque classe latérale
Syndrome Représentant minimal
\((000)\) \((00000)\)
\((001)\) \((00001)\)
\((010)\) \((00010)\)
\((011)\) \((10000)\)
\((100)\) \((00100)\)
\((101)\) \((01000)\)
\((110)\) \((00110)\)
\((111)\) \((10100)\)

Démonstration.

Deux \(n\)-uplets \({\mathbf x}\) et \({\mathbf y}\) sont dans la même classe latérale de \(C\) exactement quand \({\mathbf x} - {\mathbf y} \in C\) ; cependant, cela est équivalent à \(H({\mathbf x} - {\mathbf y}) = 0\) ou \(H {\mathbf x} = H{\mathbf y}\text{.}\)

Exemple 8.4.10.

Table 8.4.8 est une table de décodage pour le code \(C\) donné dans Exemple 8.4.5. Si \({\mathbf x} = (01111)\) est reçu, alors son syndrome peut être calculé comme suit :
\begin{equation*} H {\mathbf x} = \begin{pmatrix} 0 \\ 1 \\ 0 \end{pmatrix}\text{.} \end{equation*}
En consultant la table de décodage, nous déterminons que le représentant minimal est \((00010)\text{.}\) Il est maintenant facile de décoder le mot de code reçu.
Étant donné un code en blocs \((n,k)\text{,}\) la question se pose de savoir si le décodage par classes latérales est un schéma gérable. Une table de décodage nécessite une liste de classes latérales et de syndromes, une pour chacune des \(2^{n - k}\) classes latérales de \(C\text{.}\) Supposons que nous avons un code en blocs \((32, 24)\text{.}\) Nous avons un nombre énorme de mots de code, \(2^{24}\text{,}\) mais il n’y a que \(2^{32 - 24} = 2^{8} = 256\) classes latérales.