T HÉORIE DE L’ INFORMATION Session 9

Remarque préliminaire : Les exercices (ou parties d’exercice) marqués d’une étoile (F)
sont facultatifs et ne concernent que les élèves motivés et intéressés.

Exercice I :
Cet exercice s’inspire des exercices 4.3.1 et 4.3.2 page 56 du livre.

Soit un code linéaire binaire de matrice génératrice1

 
1 0 0 1 1
G= 0 1 0 1 1 
0 0 1 0 0

a– Quelle est la matrice de vérification (sous forme systématique) ?

b– Quelle est alors la distance minimale de ce code ? Combien d’erreurs peut-il au plus
corriger ?
F c– Combien ce code possède-t-il de mots (i.e. de vecteurs différents) ?
Solution de l’exercice I :
a Si la matrice génératrice est sous la forme

G = [In ∆]

avec ∆ une matrice de taille (n, k), alors la matrice de vérification est donnée par

H = ∆T I k
 

Or ici  
1 1
∆= 1 1 
0 0
D’où  
1 1 0 1 0
H=
1 1 0 0 1

b Comme une colonne nulle apparaît dans H, la plus petite famille non-libre de colonnes
de H est celle contenant uniquement ce vecteur nul. Cette famille est de taille 1. Et donc la
distance minimale de ce code est 1. Ce code ne peut donc corriger aucune erreur.

F c Le nombre de mots d’un code est très exactement le nombre de vecteurs c tels que
H · cT = 0. C’est donc, d’un point de vue algébrique, la taille du noyau de H. Or la dimen-
sion de ce noyau vaut dim(H) − rang(H), c’est-à-dire ici 5 − 2 = 3 (H est trivialement de
1
Lorsque la matrice génératrice n’est pas donnée sous forme systématique comme ici, pour obtenir la
forme systématique équivalente on transforme la matrice à l’aide de permutations sur les lignes et/ou les
colonnes, de multiplications de ligne ou colonne par un scalaire non nul ou encore d’addition de lignes (mais
l’addition de colonnes est interdite !).

ÉC O L E P O L Y T E C H N I Q U E
DI-LIA 1/9
FÉ DÉR A L E D E L A U S A N N E
 T HÉORIE DE L’ INFORMATION Session 9

rang 2 puisqu’il y a I2 dans ses colonnes). Comme la dimension du noyau de H vaut 3 et

que nous sommes en binaire, il y a donc 23 = 8 vecteurs de code.

Exercice II :
Considérons le code linéaire binaire dont la partie parité est engendrée par les équations :

z5 = s2 + s3 + s4
z6 = s1 + s2 + s3
z7 = s1 + s2 + s4
z8 = s1 + s3 + s4

le mot de source étant composé des bits (s1 s2 s3 s4 ) et le message codé :

(z1 z2 z3 z4 z5 z6 z7 z8 ). 2
a– Quelle est la matrice génératrice de ce code (sous forme systématique) ?
b– Coder la séquence 010110010111.
c– Quelle est la matrice de vérification de ce code ?
F d– Montrer que la distance minimale de ce code est 4.
e– Combien d’erreurs sur le mot transmis ce code peut-il corriger au maximum ? Combien
peut-il corriger de schémas d’erreur différents (c.-à-d. combien a-t-il de syndromes
différents) ?
f– On envisage l’utilisation de ce code sur un canal symétrique binaire. Pour cela les 15
schémas d’erreur à corriger choisis sont les 15 schémas d’erreur les plus probables.
Écrire la table de correction (c.-à-d. la table donnant pour chaque syndrome la cor-
rection à appliquer).
g– À l’aide de la table précédente, décoder 1111110000001100.
Solution de l’exercice II :
a La matrice de parité correspondant aux équations données est
 
0 1 1 1
 1 1 1 0 
P =
 1

1 0 1 
1 0 1 1
2
On parle de code (8, 4).

ÉC O L E P O L Y T E C H N I Q U E
DI-LIA 2/9
FÉ DÉR A L E D E L A U S A N N E
 T HÉORIE DE L’ INFORMATION Session 9

et donc la matrice génératrice de ce code est :

 
1 0 0 0 0 1 1 1
 0 1 0 0 1 1 1 0 
G=  0 0 1 0

1 1 0 1 
0 0 0 1 1 0 1 1

b La séquence se décompose tout d’abord en blocs de taille 4 : 0101 1001 0111 qui
sont chacun codés par G :

0101 −→ 0101 · G = 01010101

1001 −→ 10011100
0111 −→ 01111000

et donc toute la séquence sera codée 010101011001110001111000.

c La matrice de vérification est donnée par H = [P T I4 ], soit :

 
0 1 1 1 1 0 0 0
 1 1 1 0 0 1 0 0 
H=  1 1 0 1

0 0 1 0 
1 0 1 1 0 0 0 1

F d Rappel : La distance minimal d’un code linéaire est la taille de la plus petite famille
non libre de colonnes de la matrice de vérification.
– La distance minimale est plus grande que 1 car il n’y a pas de colonne nulle dans H.
– La distance minimale est plus grande que 2 car il n’y a pas deux fois la même colonne
H.
– Si on cherche une famille linéairement dépendante de 3 colonnes de H, on est obligé de
choisir au moins une colonne de P (car les colonnes de I4 sont linéairement indépen-
dantes).
D’autre part, la place des 0 dans les colonnes de P nous indique trivialement qu’elles
forment également une famille libre. On est donc obligé de choisir au moins une colonne
de P et une colonne de I4 .
Ce qui nous conduit à constater qu’il est impossible de trouver une famille non libre de
3 colonnes de H, car si on choisit encore une colonne de I4 pour le troisième vecteur
alors il faudrait nécessairement deux 0 sur les deux lignes du vecteur de P où les deux
colonnes de I4 n’ont pas de 1 ; et si l’on choisit une colonne de P comme troisième vec-
teur, il faudrait alors avoir deux 1 dans le vecteur de I4 sur les lignes où les deux vecteurs
de P ont des 0, ce qui est impossible.
Donc il n’existe pas de famille non libre de taille 3 (parmi les colonnes de H). Donc la
distance minimale est plus grande que 3.

ÉC O L E P O L Y T E C H N I Q U E
DI-LIA 3/9
FÉ DÉR A L E D E L A U S A N N E
T HÉORIE DE L’ INFORMATION Session 9

– La distance minimale est 4 car il existe un ensemble de 4 colonnes de H qui soient

linéairement dépendantes, par exemple les colonnes 1, 2, 5 et 8.
e La distance minimale du code étant 4, ce code peut au plus corriger 1 erreur. On a en
effet l’inégalité dmin > 2 t, qui impose :
 
dmin
tmax = −1
2

Le syndrome étant ici codé sur 4 bits, ce code peut au plus produire 2 4 = 16 syndromes
différents. Sachant que le syndrome nul 0000 est utilisé pour indiquer qu’il n’y a pas
d’erreur, cela laisse 15 schémas d’erreur possibles. Or il y a en tout
   
1 2
+ = 8 + 28 = 36
8 8

schémas d’erreurs différents contenant au plus deux erreurs. Il faut donc faire un choix des
schémas à corriger (en fonction de l’application). Ce qui montre d’une autre façon que le
code ne peut pas corriger de façon certaine plus d’une erreur (puisqu’il ne peut pas corriger
tous les schémas à deux erreurs !).

f Les 15 schémas d’erreur les plus probables sont les 8 contenant 1 seule erreur puis 7
des 28 contenant deux erreurs. Pour ces derniers nous avons choisi les 6 schémas contenant
2 erreurs sur le message lui-même et 1 (au hasard !) contenant 1 erreur sur le mots de code
et une erreur sur les bits de parité. La table de correction peut ensuite être obtenue à partir
des colonnes de H : la colonne de H correspondant au syndrome donnant la position de
l’erreur3 . On trouve alors la table suivante :

syndrome correction syndrome correction

0000 – 0001 00000001
0111 10000000 1001 11000000
1110 01000000 1010 10100000
1101 00100000 1100 10010000
1011 00010000 0011 01100000
1000 00001000 0101 01010000
0100 00000100 0110 00110000
0010 00000010 1111 10001000

Remarquez que les 28 schémas à deux erreurs sont équiprobables dans ce problème, et que
le choix des 7 qui seront corrigés est totalement arbitraire. Si deux erreurs sont apparues
lors de la transmission, elles ne sont pas bien corrigées dans trois cas sur quatre ; on ne
gagne donc pas beaucoup de sécurité à vouloir appliquer des corrections aux schémas à
En effet, si l’on considère le message M résultant d’un mot de code m et d’une erreur e i sur le ie bit,
3

son décodage par H nous donne la ie colonne de H : H · M t = H · mt + H · eti = 0 + (ie colonne de H)t

ÉC O L E P O L Y T E C H N I Q U E
DI-LIA 4/9
FÉ DÉR A L E D E L A U S A N N E
 T HÉORIE DE L’ INFORMATION Session 9

deux erreurs. En pratique, on pourra choisir d’utiliser les 7 syndromes restants comme
simples détecteurs d’erreur : si on les obtient, on demande une réémission du message par
la source, plutôt que de chercher à le corriger "aléatoirement".

g Pour décoder 1111110000001100 il faut d’abord le décomposer en blocs de 8

bits : 11111100 00001100, et décoder chaque bloc à l’aide de son syndrome (obtenu
par multiplication avec H) :

message codé syndrome correction message corrigé message décodé

11111100 0011 01100000 10011100 1001
00001100 1100 10010000 10011100 1001

Et donc le message final décodé : 10011001.

Exercice III :
On considère la matrice H de vérification du code de Hamming (7,4) vu en cours :
 
0 0 0 1 1 1 1
H= 0 1 1 0 0 1 1 
1 0 1 0 1 0 1

a– Un mot z = (z1 , ..., z7 ) fait partie du code de Hamming correspondant si et seulement

si : H ⊗ z T = 03 (où 03 est le vecteur colonne nul de dimension 3). Résoudre cette
équation en exprimant z5 , z6 et z7 en fonction de z1 , z2 , z3 et z4 . En déduire la forme
systématique de la matrice de codage G du code de Hamming dont H est la matrice
de vérification.
b– À partir de G, écrire la forme systématique H 0 de la matrice de vérification du code de
Hamming. Quel avantage présente la forme de l’énoncé ?
c– Coder 010110010111.
d– Décoder 0100110110011011011101100111.
e– Si l’on utilise ce code de Hamming sur un canal symétrique binaire de probabilité
de changement p, quel taux d’erreur par bloc PB aura-t-on ? Que vaut le taux de
transmission R ?
F f– Que vaut, en première approximation, le taux d’erreur par bit ?
Solution de l’exercice III :
a
 
 (1) : z 4 + z5 + z6 + z7 = 0 
H ⊗ z T = 03 ⇔ (2) : z 2 + z3 + z6 + z7 = 0
(3) : z1 + z3 + z5 + z7 = 0
 

ÉC O L E P O L Y T E C H N I Q U E
DI-LIA 5/9
FÉ DÉR A L E D E L A U S A N N E
 T HÉORIE DE L’ INFORMATION Session 9

 
 (1) et (2) → (10 ) : z5 = z2 + z3 + z4 
⇔ (1) et (3) → (20 ) : z6 = z1 + z3 + z4
(3) et (10 ) → (30 ) : z7 = z1 + z2 + z4
 

Ces trois équations donnent l’expression des trois derniers bits du code en fonction des
quatre premiers. Or les lignes de la matrice de codage représentent les mots de code asso-
ciés aux messages 1000, 0100, 0010 et 0001. Elle vérifient donc les équations précédentes.
Comme on veut de plus obtenir la forme systématique de G, on sait que les 4 premiers
bits du code sont les 4 bits du message. Ainsi, à l’aide des équation précédentes, on peut
associer les codes suivants aux messages :

1000 −→ 1000011
0100 −→ 0100101
0010 −→ 0010110
0001 −→ 0001111

La matrice de codage est donc :

 
1 0 0 0 0 1 1
 0 1 0 0 1 0 1 
G=
 0

0 1 0 1 1 0 
0 0 0 1 1 1 1

F b Si l’on considère ce code comme un code linéaire binaire quelconque, sa matrice de

vérification sous forme systématique s’écrit :
 
0 1 1 1 1 0 0
H0 =  1 0 1 1 0 1 0 
1 1 0 1 0 0 1

L’avantage de la forme « énumération binaire » (H) sur la forme systématique (H 0 ) est de

faciliter grandement le décodage : en effet le syndrome calculé avec H donne directement
en binaire le numéro du bit erroné. Un calcul d’erreur par H 0 nécessiterait quant à lui une
table de correction.

c La séquence se décompose tout d’abord en blocs de taille 4 : 0101 1001 0111 qui
sont chacun codés par G :

0101 −→ 0101 · G = 0101010

1001 −→ 1001100
0111 −→ 0111100

et donc toute la séquence sera codée 010101010011000111100.

ÉC O L E P O L Y T E C H N I Q U E
DI-LIA 6/9
FÉ DÉR A L E D E L A U S A N N E
 T HÉORIE DE L’ INFORMATION Session 9

d Pour décoder 0100110110011011011101100111, il faut tout d’abord le dé-

composer en blocs de 7 bits : 0100110 1100110 1101110 1100111 puis décoder
chaque bloc à l’aide de son syndrome (obtenu par multiplication avec H) :

message codé syndrome bit à corriger message corrigé message décodé

0100110 001 1 1100110 1100
1100110 000 – 1100110 1100
1101110 100 4 1100110 1100
1100111 111 7 1100110 1100

Et donc le message final décodé : 1100110011001100.

e Les codes de Hamming ne corrigent qu’une seule erreur. On aura donc une erreur sur
le bloc (de 7 bits) si deux erreur ou plus ont eu lieu ; ce qui est le complémentaire de « zéro
ou une erreur a eu lieu ». D’où :

PB = 1 − (1 − p)7 + 7 p (1 − p)6

ce qui pour finir nous donne :

PB = 21 p2 − 70 p3 + 105 p4 − 84 p5 + 35 p6 − 6 p7

4
Quant au taux de transmission, il vaut trivialement R = .
7

F f La difficulté de cette question réside dans le fait de calculer la proportion d’erreurs non
corrigées ramenée aux « vrais » bits du message (et non pas aux bits de parité).

On obtient une erreur après décodage lorsque 2 erreurs ou plus se sont produites lors de la
transmission. Plaçons-nous dans le cas où exactement deux erreurs se produisent. Quand
p est suffisamment petit, c’est en effet le cas dominant car de probabilité 21p 2 (1 − p)5 (à
comparer avec p3 , p4 , ..., p7 )), les cas à plus de deux erreurs pouvant alors être négligés.

On considère un bit quelconque bi du message codé. Sachant que deux erreurs se sont
produites, bi a une probabilité de 2/7e d’être l’un des deux bits erronés. Mais il ne faut
pas oublier que la «correction» effectuée par le décodage peut modifier b i . De fait, lorsque
deux erreurs exactement se produisent lors de la transmission, le syndrome obtenu conduit
forcément à la modification d’un troisième bit. En effet, ce syndrome est la somme binaire,
bit-à-bit, des deux syndromes correspondant aux deux erreurs, et est donc différent de
ces deux syndromes, et non nul. En outre, en considérant tous les couples d’erreurs de
transmission possibles, on peut vérifier avec ce code de Hamming que chaque bit a la
même probabilité d’être modifié lors de la correction. Cette probabilité est donc de 1/7 e .

ÉC O L E P O L Y T E C H N I Q U E
DI-LIA 7/9
FÉ DÉR A L E D E L A U S A N N E
 T HÉORIE DE L’ INFORMATION Session 9

En résumé, bi est erroné après correction dans les cas où (1) bi est mal transmis ou (2) bi est
modifié par la correction. Ces deux évènements étant exclusifs, la probabilité que b i soit
erroné après correction sachant que deux erreurs ont été introduites lors de la transmission
est de (2/7) + (1/7) = 3/7. Pour trouver une valeur approchée du taux d’erreur par bit, on
multiplie par la probabilité (approchée) d’avoir deux erreurs en transmission :

3
Pb ' · 21 p2 = 9 p2
7

Exercice IV :
Cet exercice est l’exercice 4.7.1 page 67 du livre.

F On peut montrer que tous les codes cycliques de longueur n possibles 4 sont obtenus en
utilisant comme polynôme générateur un diviseur de X n − 1.
Montrer qu’il existe uniquement 3 codes cycliques binaires non triviaux de longueur 3.
Donner le polynôme générateur dans chaque cas.
Remarque : en binaire, c.-à-d. sur le corps GF(2), X n − 1 et X n + 1 sont les même poly-
nômes.
Solution de l’exercice IV :
Il nous faut donc trouver les diviseurs de X 3 + 1 dans GF[23 ]. On voit trivialement que 1
est racine, puisque 13 = 1 et que 1 + 1 = 05 . Donc X + 1 est un diviseur de X 3 + 1.

Effectuons la division euclidienne (en se souvenant que dans GF(2), −1 = 1) :

X3 +1 X +1
X 3 +X 2 X2 + X + 1
X2 +1
2
X +X
X +1

De plus X 2 + X + 1 est irréductible. En effet, 12 + 1 + 1 = 1 6= 0 et 02 + 0 + 1 = 1 6= 0

donc X 2 + X + 1 n’a pas de racines sur GF(2).

On a donc la factorisation suivante :

X 3 + 1 = (X + 1) · (X 2 + X + 1)
D’où les trois diviseurs : 1, X + 1 et X 2 + X + 1 qui sont les trois générateurs possibles.
4
et non triviaux, c.-à-d. différent du code nul composé d’un seul mot de code, le vecteur nul
5
Rappel : on travaille dans GF(2), c.-à-d. en binaire

ÉC O L E P O L Y T E C H N I Q U E
DI-LIA 8/9
FÉ DÉR A L E D E L A U S A N N E
T HÉORIE DE L’ INFORMATION Session 9

ÉC O L E P O L Y T E C H N I Q U E
DI-LIA 9/9
FÉ DÉR A L E D E L A U S A N N E