Université de Strasbourg Licence 3 Informatique

UFR Mathématique et Informatique Année 2009/2010

Réseaux et Protocoles
TD05 : Codes correcteurs et détecteurs
Corrections

Rappels : Codes linéaires

Un code est linéaire si le codage utilisé est linéaire. Il peut alors être représenté par une matrice appelée matrice
génératrice (G) :
 
x

ky
 G 

| {z }
n

où k est le nombre de bits d’informations et n le nombre de bits codés.

Donc à partir d’un vecteur D de bits d’information et de la matrice génératrice G, on obtient le vecteur C correspondant
aux bits codés :
C = D.G (produit de matrice)
Les bits de contrôle dépendent linéairement des bits d’information. Un code linéaire ajoute n − k bits de contrôle au
k bits d’information. Les n − k bits de contrôle sont définis par l’équation :

H.C t = 0

où H est la matrice de contrôle de parité qui permet de définir chacun des n − k bits de contrôle en fonction des bits
d’information et C t la transposée du vecteur C correspondant aux bits codés.

Exercice 1
On considère un code C de répétition c’est-à-dire un code (mk, k) où chaque groupe de k bits est répété m fois.
1. Quelle est la distance minimale entre deux mots de code ?
2. Pour qu’un code soit 2-correcteur, quelle doit être la valeur minimale de m ? On considère dans la suite un tel
code.
3. Quel est son rendement ?
4. Combien d’erreurs peuvent être détectées ? Écrire en pseudo-code l’algorithme de décodage pour détecter un
nombre maximal d’erreurs mais n’en corriger aucune. Le résultat sera un booléen ayant pour valeur vrai si
aucune erreur n’a été détectée. L’entrée de l’algorithme est un code c donné sous la forme d’un tableau de
n = mk entiers.
5. Combien d’erreurs peuvent être corrigées ? Écrire en pseudo-code l’algorithme de décodage pour corriger un
nombre maximal d’erreurs. Le résultat sera le mot λ trouvé après correction.

1
Corrections
1. Deux mots distincts quelconques possèdent au moins 1 bit distinct, comme ce bit est répété m fois, on a au
moins entre les codes m bits différents, donc d(C) ≥ m. Prenons ensuite le mot nul m0 formé uniquement
de 0 et un mot quelconque m1 mais ne comprenant qu’un seul bit à 1, on a alors d(c(m0 ), c(m1 )) = m donc
d(C) ≤ m, ainsi d(C) = m.
2. Pour qu’un code corrige k erreurs, la distance d du code doit vérifier d ≥ 2k + 1. Pour qu’il puisse corriger 2
erreurs, il faut avoir d(C) ≥ 2 ∗ 2 + 1 = 5. Ainsi (5k, k) convient.
3. Rendement = nombre de bits d’information / nombre de bits total. Donc k/(5k) = 0.2.
4. La distance du code d = 5. Donc ce code permet de détecter 4 erreurs (d ≥ k + 1 avec k nombre d’erreurs
détectables). Pour l’algorithme on considère que le code se trouve dans un tableau c[n] avec n = m ∗ k.
x xxxx x
erreur ← faux
Pour i ← de k à n − 1
Si c[i] 6= c[i mod k]
Alors erreur ← vrai
Fsi
Fpour
Retourner non erreur
5. distance = 5 donc ce code corrige deux erreurs.
x xxxx x
Pour i ← de 0 à k − 1
NbUn[i] ← 0
Fpour
Pour i ← de 0 à n − 1
NbUn[i mod k] += c[i]
Fpour
Pour i ← de 0 à k − 1
Si NbUn[i] ≥ 3
Alors λ[i] = 1
Sinon λ[i] = 0
fsi
fpour
Retourner λ

Exercice 2
Un numéro de sécurité sociale comporte 15 chiffres. Il est d’abord composé d’un entier K de 13 chiffres : 1 chiffre
indiquant le sexe (1 ou 2), 2 chiffres pour l’année de naissance, 2 autres chiffres pour le mois de naissance, 2 chiffres
pour le numéro de département, 3 chiffres pour l’identifiant de la commune et les 3 derniers pour le rang de naissance
dans le mois. Cet entier est suivi d’une clef C de 2 chiffres servant à une vérification informatique et correspond au
complément à 97 du reste modulo 97 de l’entier de 13 chiffres. Ainsi l’entier K + C est un multiple de 97.
1. Calculez la clef du numéro 2850567482101 (482 correspond à Strasbourg).
2. Quel est le rendement de ce code ?
3. Combien d’erreurs de chiffres la clef peut-elle permettre de détecter ?

2
Corrections
1. 2850567482101 mod 97 = 88 => clef = 97-88 = 09
2. Rendement 13/15 = 0.87
3. Soit une erreur e 6= 0 au rang i sur le chiffre ci , et n le numéro de sécurité sociale. On a n′ = n + e.10i avec
−ci ≤ e ≤ 9 − ci . Or e et 10 sont premiers avec 97 (97 ne divise ni e ni 10) donc n′ mod97 6= 0. En revanche,
une erreur sur 2 chiffres n’est pas forcément détectée 2850567482198 a également pour clé 09.

Exercice 3
On considère le code linéaire dont la matrice génératrice est :
 
1 0 0 1 1 0
G= 0 1 0 0 1 1 
0 0 1 1 0 1

1. Par combien de bits d’information et de contrôle est constitué ce code ?

2. Avec ce code, comment est encodé la suite de bits 011001010101110001 ?
3. Calculer la matrice de parité H de ce code.
4. Quelles sont les images par H des mots 100000, 010000, 001000, 000100, 000010, 000001 ? Que pouvez-vous
déduire sur le pouvoir de correction de ce code ?

Corrections
1. On sait que C = D.G donc comme G à 3 lignes et 6 colonnes, la longueur du vecteur de bits d’information doit
donc être de 3 bits et le vecteur encodé aura une longueur de 6 bits, soit 3 bits de contrôle supplémentaires. On
peut noter que d’après la forme de la matrice génératrice (identité dans les 3 premières colonnes), les 3 premiers
bits d’un mot du code seront les bits de donnée.
2. On découpe la suite de bits en blocs de longueur 3 :

011|001|010|101|110|001

donc le calcul C = D.G donne :

(011).G = (011110)
(001).G = (001101)
(010).G = (010011)
(101).G = (101011)
(110).G = (110101)
(001).G = (001101)

Donc la suite de bits 011001010101110001 est codée par 011110001101010011101011110101001101.

3. La matrice génératrice G est de la forme G = (Ik , A) avec G possédant k lignes et n colonnes, Ik la matrice
identité de rang k et A une matrice possédant k lignes et n − k colonnes. On peut donc écrire que H = (At , Ik )
où H possède n − k lignes et n colonnes, d’où :
 
1 0 1 1 0 0
H= 1 1 0 0 1 0 
0 1 1 0 0 1

3
 4. Pour trouver s’il y a une erreur dans les mots reçus, on fait l’opération HC T = Y . Etant donné la structure de
notre vecteur encodé (bits de données au début), Y donnera une colonne de la matrice H qui révèlera la position
du bit erroné.

100000 → (110) = colonne 1 de H → 000

010000 → (011) = colonne 2 de H → 000
001000 → (101) = colonne 3 de H → 000
000100 → (100) = colonne 4 de H → 000
000010 → (010) = colonne 5 de H → 000
000001 → (001) = colonne 6 de H → 000

On peut remarquer ici qu’à partir du mot du code 000000, si on change un seul bit de ce mot (introduction
d’une seule erreur), on est capable de la corriger à la réception quelque soit la position du bit erroné. On peut en
déduire que ce code est au moins capable de corriger une erreur.

Exercice 4
On considère le code de Hamming (7,4).
1. Calculez les matrices génératrices et de parité de ce code.
2. Encodez la suite de bits 100101001010
3. Décodez la suite de bits 1110110011010101110001100111 (on suppose qu’il y a au plus 1 erreur sur 7 bits
consécutifs).

Corrections
Un code de Hamming (7,4) génère des mots de code de longueur 7 bits à partir de mots de d’information de longueur
4 bits. Ce codage utilise donc 3 bits de contrôle.

1. Dans la matrice de parité, chaque colonne doit être distincte d’une autre. A des permutations de colonnes près,
la matrice de parité est donc :
 
1 0 1 0 1 0 1
H = 0 1 1 0 0 1 1 
0 0 0 1 1 1 1
Les n − k bits de contrôle sont définis par l’équation H.C t = 0 donc :
 
c1
  c2  
 
 
1 0 1 0 1 0 1  c3 
  c1 + c3 + c5 + c7
 0 1 1 0 0 1 1  .  c4  =  c2 + c3 + c6 + c7  = 0
 
0 0 0 1 1 1 1  c5 
  c4 + c5 + c6 + c7
 c6 
c7
d’où :
c1 + c3 + c5 + c7 = 0
c2 + c3 + c6 + c7 = 0
c4 + c5 + c6 + c7 = 0

4
 Par définition, on place les bits de contrôle dans le vecteur C aux positions qui s’écrivent en forme de puissance
de 2, c-à-d aux positions 20 = 1, 21 = 2 et 22 = 4. Par conséquent, les bits de donnée seront alors aux positions
3, 5, 6 et 7. Donc :

 c1 = c3 + c5 + c7
c2 = c3 + c6 + c7

c4 = c5 + c6 + c7
Or C = D.G c-à-d :
 
w1 w2 w3 w4 w5 w6 w7

 x1 x2 x3 x4 x5 x6 x7 
c3 c5 c6 c7 . 
 y1

y2 y3 y4 y5 y6 y7 
z1 z2 z3 z4 z5 z6 z7


= c3 + c5 + c7 c3 + c6 + c7 c3 c5 + c6 + c7 c5 c6 c7
d’où
 
1 1 1 0 0 0 0
 1 0 0 1 1 0 0 
G=
 0

1 0 1 0 1 0 
1 1 0 1 0 0 1
2. Il faut couper la suite de bits en blocs de longueur 4 :

1001|0100|1010

puis faire la multiplication de matrice C = D.G d’où :

(1001).G = 0011001
(0100).G = 1001100
(1010).G = 1011010

La suite de bits 100101001010 est donc codée par 001100110011001011010.

3. Les mots du code ont une longueur de 7 bits, il faut donc découper la suite de bits par blocs de longueur 7 :

1110110|0110101|0111000|1100111

Le codage de Hamming permet de corriger 1 erreur dans un mot de n bits.

t
HC ′t = HC ′t − |HC ′t
{z } = H |(C {z− C t)
}
0 un seul 1

Or dans le codage de Hamming, toutes les colonnes de H sont distinctes et ici chacune représente l’entier i en
binaire. Donc H.C t représente l’indice du bit où il y a une erreur.

Pour détecter une erreur, on multiplie le vecteur reçu par la matrice de parité. Si on obtient un vecteur nul, le
mot reçu ne contient pas d’erreur. Si le résultat est différent de 0, il code la position de l’erreur dans le vecteur
reçu (dans le cas où le vecteur reçu ne comporte qu’une seule erreur).

5
  
1
1110110 → H.C t =  1 → erreur à la position 3, la donnée était 0110
0
 
1
0110101 → H.C t =  1 → erreur à la position 3, la donnée était 0101
0
 
1
0111000 → H.C t =  0 → erreur à la position 5, la donnée était 1100
1
 
1
1100111 → H.C t =  1 → erreur à la position 7, la donnée était 0110
1

Donc la suite de bits décodée donne 0110010111000110.

Exercice 5
On considère le code polynomial généré par le polynôme X 8 + X 4 + X 3 + X 2 + 1.
1. On suppose que la longueur du code est de 16 bits. Encoder la suite de bits 1010001000111101.

Correction :
Pour coder une suite de bits avec un polynôme générateur G(X) on applique la formule :

C(X) = X n−k D(X) + (X n−k D(X) mod G(X))

| {z }
bits de contrôle

Donc ici G(X) = X 8 + X 4 + X 3 + X 2 + 1 avec n = 16 et k = 16 − 8 = 8.

On découpe la suite en blocs de longueur 8 :

10100010|00111101

Pour 10100010 on a

D(X) = 1 ∗ X7 + 0 ∗ X6 + 1 ∗ X5 + 0 ∗ X4 + 0 ∗ X3 + 0 ∗ X2 + X + 0
= X7 + X5 + X

donc
X 8 D(X) = X 15 + X 13 + X 9
Il faut donc déterminer les bits de contrôle, donc il faut calculer X n−k D(X) mod G(X) ce qui donne :

X 15 + X 13 + X 9 mod G(X) = X 7 + X 4 + X 3 + X + 1 = 10011011 (attention, les - deviennent des +)

On fait de même pour le deuxième bloc de 8 bits à coder. Donc la suite 10100010|00111101 est codée par :

1010001010011011|0011110111001011

6
 2. Y-a-t-il une erreur dans la suite de bits 1010101001010101 ?

Correction :
Pour détecter si une erreur est présente, il suffit de vérifier que le polynôme reçu est divisible par G(X). Si le
reste de la division n’est pas nul, alors le mot comporte une erreur :

1010101001010101 mod 100011101 = 100110

donc le reste n’est pas nul, donc le mot contient une erreur.

Exercice 6
On considère un code polynomial (8, 5) généré par le polynôme G(X) = X 3 + X + 1. Un mot à encoder peut se
présenter sous la forme P (X) = a4 X 4 + a3 X 3 + ... + a0 X 0 .
1. Exprimez la valeur des bits de contrôle en fonction des ai .

Correction :
En effectuant formellement la division euclidienne X 3 .P (X)/G(X), on trouve :

X 3 .P (X) = G(X)Q(X) + R(X) avec

Q(X) = a4 X 4 + a3 X 3 + (a4 + a2 )X 2 + (a4 + a3 + a1 )X + (a4 + a3 + a2 + a0 )
R(X) = (a3 + a2 + a1 )X 2 + (a2 + a1 + a0 )X + (a4 + a3 + a2 + a0 )

2. En déduire les matrices génératrice et de parité de ce code.

Correction : on obtient
 
1 0 0 0 0 0 0 1

 0 1 0 0 0 1 0 1 

G=
 0 0 1 0 0 1 1 1 

 0 0 0 1 0 1 1 0 
0 0 0 0 1 0 1 1

et la matrice de parité (transposée de la partie contrôle de G + identité) :

 
0 1 1 1 0 1 0 0
H = 0 0 1 1 1 0 1 0 
1 1 1 0 1 0 0 1

3. Les codes polynomiaux sont des codes linéaires dont l’encodage et le décodage peuvent être réalisés sans mul-
tiplication de matrices mais en utilisant un circuit séquentiel contenant un registre à décalage. Dessinez un tel
circuit pour G(X).

Correction :
Lorsque le bit de poids fort est à 1, on applique (ou exclusif) le masque correspondant au polynôme générateur
(ici 1011). Le registre contient 3 bascules D (D2D1D0), soit s la sortie du circuit et e l’entrée, avec le polynôme
1011, on a :

7
 D0t+1 = s.e + s.e = s ⊕ e
D1t+1 = s.D0t + s.D0t = s ⊕ D0t
D2t+1 = D1t

D’où le circuit :

D2 D1 D0

4. Dans un tableau indiquez les valeurs contenues dans les bascules à chaque étape pour le décodage de 11010111.

Correction :
Etapes D2 D1 D0 entrée
0 0 0 0 1
1 0 0 1 1
2 0 1 1 0
3 1 1 0 1
4 1 1 0 0
5 1 1 1 1
6 1 0 0 1
7 0 1 0 1
8 1 0 1
Le reste de la division est donc X 2 + 1.

Exercice 7
On considère le code constitué de 7 bits d’information et un bit de contrôle de parité pair.
1. Ce code est-il un code linéaire ? Si oui, donner sa matrice génératrice, son poids minimal et en déduire ses ca-
pacités de détection et de correction d’erreur.

Correction :
Ce code est linéaire parce que tous les mots de code s’obtiennent par combinaison linéaire des bits de données.
La méthode pour le vérifier est de s’assurer que les trois conditions suivantes sont respectées :
– le mot 0....0 doit appartenir au code
– si a et b sont des mots du codes, alors a + b doit aussi appartenir au code
– si a est un mot du code et λ appartient à [0, 1], alors λa doit aussi appartenir au code.

Le mot est représenté par le vecteur ligne I et le mot de code par le vecteur ligne C :

I = (i1 , i2 , i3 , i4 , i5 , i6 , i7 )
C = (c1 , c2 , c3 , c4 , c5 , c6 , c7 , c8 )

où c1 = i1 , c2 = i2 , c3 = i3 , c4 = i4 , c5 = i5 , i6 = i6 , i7 = i7 , c8 = i1 + i2 + i3 + i4 + i5 + i6 + i7 .

Dans ce cas, la matrice génératrice G vérifie : C = I.G avec :

8
  
1 1

 1 1 


 1 1 

G=
 1 1 


 1 1 

 1 1 
1 1
Lorsqu’on change un bit dans I, alors deux bits changent dans C. Donc le poids minimal est de 2. Si un code
linéaire a un poids minimal de d, alors il peut détecter d − 1 erreurs et il peut corriger (d − 1)/2 erreurs. Par
conséquent, ce code peut détecter une erreur par mot de code et ne peut en corriger aucune.

2. Même question pour le code à contrôle de parité impair.

Correction :
Le code de parité impaire n’est pas linéaire car le mot 0 n’appartient pas au code. Les mots de code ne sont
pas obtenus par combinaison linéaire des mots d’information. Le poids minimal du code est 1. Le pouvoir de
détection et de correction est équivalent au code précédent.

3. Montrer qu’un polynôme p(X) à coefficients dans Z2 est divisible par 1 + X si et seulement si la somme des
coefficients vaut modulo 2.

Correction :
On veut monter que 1 + X divise p(X) = an k n + an−1 k n−1 + ... + a0

ssi an + an−1 + ... + a0 = 0[2].

Soit R(X) = p(X) mod (1 + X), on a deg(R) < deg(1 + X) = 1.

Donc R est une constante r ∈ {0, 1}.

On a :
p(X) = (1 + X).q(X) + r → définition de la division euclidienne (1+1 = 0 en binaire)
p(1) = (1 + 1).q(1) + r donc r = p(1) = an + an−1 + ... + a0

⇔ R(X) = 0 → r = 0
⇔ an + an−1 + ... + ao = 0

4. Le code de parité pair est-il polynomial ? Si oui, donner son polynôme générateur.

Correction :
D’après la question précédente, si la somme des nombres d’un mot est nulle, alors forcément ce mot est divisible
par 1 + X. Donc la parité paire est polynomiale est son polynôme générateur est 1 + X.

5. Même question pour le code à parité impair.

Correction :
Les codes polynomiaux sont forcément linéaires or comme le code à parité impaire n’est pas linéaire, il n’est
pas polynomial.

9
Exercice 8
1. Montrer qu’une condition nécessaire et suffisante pour qu’un code polynomial détecte toute erreur portant sur
un unique bit est que son polynôme générateur admette au moins deux monômes.

Correction :
Toute erreur portant sur un seul bit est de la forme Pe = X i . Pour qu’une erreur ne soit pas détectée, son poly-
nôme doit être un multiple de Pg . Ainsi, lorsque Pg comporte deux monômes, il ne peut pas diviser Pe car toute
multiplication par un polynôme ayant un nombre pair de monômes produit un polynôme ayant un nombre pair
de monômes.

2. Montrer que si la somme des coefficients du polynôme générateur d’un code est nulle, alors toute erreur portant
sur un nombre impair de bits est détectée.

Correction :
Si le polynôme générateur Pg contient un nombre pair de monômes non nuls, alors tout multiple de Pg contien-
dra un nombre pair de monômes (si au cours de la multiplication des monômes disparaissent, ils disparaissent
deux par deux. Par ex : (X 4 + X 2 ) ∗ (X 2 + 1) = X 6 + X 4 + X 4 + X 2 ).

Un nombre impair d’erreurs se traduit par un polynôme ayant un nombre impair de monômes non nuls, le poly-
nôme d’erreur ne peut donc pas être un multiple de Pg et le cas d’erreur sera donc détecté.

3. Montrer que si le polynôme générateur d’un code admet au moins 2 monômes ainsi qu’un facteur irréductible de
degré d, alors il détecte tout paquet d’erreurs (c’est-à-dire des erreurs consécutives) portant sur au plus d−1 bits.

Correction :
Pour un paquet d’erreurs, Pe = X k + X k−1 + ... + X i = X i (X k−i + ... + 1). Dans Z2 , tout polynôme se
décompose de manière unique en un produit de polynômes irréductibles et le lemme de Gauss s’applique. Pour
que g(x) divise Pe , soit g(x) divise X i ce qui est impossible si g(x) contient au moins 2 monômes, soit g(x)
divise X k−i + ... + 1 ce qui impossible si (k − i) < d.

Exercice 9
Pour leur pouvoir détecteur d’erreur et leur rapidité de décodage, les codes polynomiaux sont souvent employés dans
les réseaux locaux (taux d’erreur généralement très faible). En cas d’erreur, l’émetteur procède à une retransmission.
Dans les réseaux sans fil, le bruit est plus important et les temps de transmission plus long. Aussi, des codes correc-
teurs sont utilisés bien qu’ils nécessitent un plus grand débit car de nombreuses informations de contrôle doivent être
combinées à l’information utile.
Dans ce type de transmission, on trouve principalement des codes convolutifs. Un code convolutif est défini par un
triplet (n, k, K) où k est le nombre de bits utiles traités, n le nombre de bits d’un mot du code, et K la longueur de
contrainte, elle correspond aux nombres de bits intervenant dans la génération des mots du code.

Considérons un code (2, 1, 3) défini par vn1 = un ⊕un−1 ⊕un−2 et vn2 = un ⊕un−2 . On remarque qu’il ne s’agit pas
d’un code systématique (les bits d’informations ne sont pas présents en sortie du codeur). Pour coder la suite 01101, on
ajoute deux 0 au début pour correspondre aux un−1 et un−2 du 1er bit de la suite. Chaque bit d’information intervient
dans le calcul de son code mais aussi dans celui des codes suivants, ce bit information est donc contenu dans plusieurs
codes, c’est cela qui donne le pouvoir correcteur de ce code. Pour que le dernier bit intervienne également dans
plusieurs codes, deux 0 fictifs sont ajoutés à la suite (ils seront à supprimer au décodage). Ainsi, la suite (00)01101(00)
est codée 00 11 01 01 00 10 11.

10
Le diagramme de la figure 1a correspond au codage précédent. La figure 1b représente la machine à états finis de ce
code.

F IGURE 1 – Diagramme de codage et décodage

source : wireless communications and network, W. Stallings, Prentice Hall

Pour comprendre le décodage, la machine à états finis est généralement déployée en un diagramme appelé treillis (cf.
figure 2). Le code de l’exemple précédent suit le chemin : a-a-b-d-c-b-c-a.
Un code reçu doit correspondre à un chemin dans le treillis. Si aucun chemin ne convient, les différents chemins pos-
sibles sont envisagés, ne sont conservés que ceux qui possèdent une distance de Hamming minimale. La figure montre
le décodage d’un mot selon l’algorithme de Viterbi qui procède en b + 1 étapes où b est une taille de fenêtre choisie
au préalable. On voit sur ce schéma que le chemin aboutit à une correction du premier code, 10, en 11.

Algorithme de Viterbi :
Etape 0 : désigné par 0
Etape i + 1 : pour chaque état e au temps i + 1, tous les chemins actifs conduisant à e sont déterminés. Si plusieurs
chemins conduisent sur e, ceux qui minimisent la distance de Hamming sont conservés.
Etape b : si un état est étiquetté par une distance minimale et que le chemin pour y parvenir est unique, le code est
corrigé selon ce chemin.

11
 F IGURE 2 – Treillis de décodage
source : wireless communications and network, W. Stallings, Prentice Hall

F IGURE 3 – Décodage selon l’algorithme de Viterbi

source : wireless communications and network, W. Stallings, Prentice Hall

12
1. Le schéma de la figure 4 représente un codeur convolutif (3, 1, 3).

F IGURE 4 – Code convolutif

Représentez le diagramme de ce codeur.

Correction :
Examinons les différents cas :

un un−1 un−2 code généré

0 0 0 000
1 0 0 111
0 0 1 011
1 0 1 100
0 1 0 001
1 1 0 110
0 1 1 010
1 1 1 101
D’où le diagramme de la figure 5 :
000

a : 00
111 011

001

b : 10 c : 01

100

110

010
d : 11

101

F IGURE 5 – Machine à états pour codage et décodage

2. Représentez le treillis de ce codeur. Quel sera le trajet suivi par le mot 01011 ? En déduire le code produit en
sortie.

Correction :
La figure 6 illustre le treillis général (non développé) du codeur.

13
 a 000 a
11
1

1
01
b 00 b
1
0
10

11
0
c c

0
01
d d
101

F IGURE 6 – Treillis général

Le mot 01011(00) est codé 000 111 001 100 110 010 011.

3. Calculez la distance minimale du code, c’est-à-dire la plus petite distance de Hamming entre 2 mots du code.
Pour cela, déterminer le plus court chemin qui s’écarte de l’état (00) du codeur avant d’y revenir. En déduire la
capacité de correction d’erreur du code.

Correction :
Le plus court chemin est a − b − c − a ce qui conduit au code 111 001 011. Le poids du mot non nul de poids
minimum est donc 6, ce qui implique que le poids minimum du code est de 6. Le code peut donc corriger 2
erreurs (k ≤ (6−1)
2 ) division entière).

4. A l’aide de l’algorithme de Viterbi, décoder la séquence 101001000111010010000.

Correction :
La figure 7 présente le treillis déployé et le chemin suivi par l’utilisation de l’algorithme de Viterbi. On trouve 4
erreurs et la séquence corrigée est : 10110(00)

14
a 000 a 000 a 000 a 000 a 000 a 000 a
11 11 11 11 11 11
1 1 1 1 1 1
1

1
00

01

01

01

01

01
b 00 b 00 b 00 b 00 b 00 b
1 1 1 1 1
100 100 100 100 100
11

11

11

11

11
0

0
c c c c c

0 0 0 0
01 01 01 01
d d d d d
101 101 101 101

101 001 000 111 010 010 000

2 3 2 5 5 4 4
a 000 a 000 a 000 a 000 a 000 a 000 a 000 a
11 11 11 11 11 11 11
1 1 1 1 1 1 1
1

1
00

01

01

01

01

01

01
1 4 2 3 6 5 5
b 00 b 00 b 00 b 00 b 00 b 00 b
1 1 1 1 1 1
0 0 0 0 0
10 10 10 10 10
11

11

11

11

11

6
0

4
c 1 c5 c4 c3 c c

0 0 0 0 0
4 01 6 01 3 01 4 01 7 01 7
d d d d d d
101 101 101 101 101

F IGURE 7 – Treillis développé et décodage

15