Vous êtes sur la page 1sur 12

UFR de Sciences Université de Caen

THEORIE DE L’INFORMATION

___

CODAGE DE CANAL

CODES DE BLOCS LINEAIRES

___

G.BINET MdC 61
T_info_b_linéaires p.1
UFR de Sciences Université de Caen

CODAGE DE CANAL
CODES DE BLOCS LINEAIRES
I. DEFINITIONS ET PROPRIETES DES CODES DE BLOC
LINEAIRES
I.1 Code binaire :

I.2 Codes de blocs :

I.3 Poids d'un code :

I.4 Distance de Hamming :

I.5 Code linéaire :


Conséquence :
Distance minimale d'un code linéaire :

II. GENERATION D'UN CODE DE BLOC LINEAIRE SYSTEMATIQUE

II.1 Génération du mot de code :


Matrice de génération de code :
Principe de la réalisation du codeur :

II.2 Détection des erreurs de transmission :


Matrice de contrôle de parité :
Syndrôme :
Théorème :
Lien avec la distance minimale :
Code étendu :

II.3 Correction des erreurs :


Erreurs détectables :
Nombre d'erreurs corrigeables :

III CODES DE BLOCS LINEAIRES

III.1 Codes de Hamming :


matrice de contrôle :
erreurs corrigeables :

III.2 Codes de Hadamard :

G.BINET MdC 61
T_info_b_linéaires p.2
UFR de Sciences Université de Caen

CODAGE DE CANAL
CODES DE BLOCS LINEAIRES
Pour approcher au mieux la capacité C du canal si, conformément au théorème de Shannon, l'entropie
de la source H(X) < C nous pouvons ajouter de la redondance dans le codage de la source afin de diminuer les
erreurs de transmission. C'est le problème du codage de canal. A côté des premiers codes empiriques (bit de
parité, répétition,…) deux grandes catégories de codes ont été développées et sont actuellement utilisées en
faisant l'objet permanent de perfectionnements :
Les codes de blocs linéaires.
Les codes de convolution.

I. DEFINITIONS ET PROPRIETES DES CODES DE BLOC


LINEAIRES

I.1 Code binaire :

Le codage de canal utilise les symboles d'une source pour construire des objets appelés mots de codes.
Pour une source discrète binaire nous utiliserons deux symboles. Pour un alphabet non binaire de q symboles
(source q-ary) si q = 2b, un code de longueur N peut se ramener à l'étude d'un code binaire de longueur b.N.
Nous pouvons aussi montrer que si q ≠ 2b il est possible de se rapporter à une telle étude. Pour ces raisons,
l'étude des codes binaires est une bonne introduction et nous nous contenterons de ce cas particulier.

I.2 Codes de blocs :

L'information de la source est mise en trames de longueur fixe que nous devons transmettre : c'est le
message. Le codage de canal prend ce message pour en faire un mot de code :
message → codage de canal → mot de code
Le message est constitué de k caractères soit 2k messages possibles. Le mot de code utilisé sera lui aussi
de longueur fixe de n caractères soit 2n mots de code possibles. Avec n > k il y aura donc n-k caractères du mot
de code qui sont redondants et serviront à traiter les erreurs éventuelles. Par ailleurs, 2n > 2k donc un certain
nombre de mots de code ne correspondent pas à un message mais seulement à des erreurs de transmission.
On parle ainsi d'un code de bloc ( n , k ) et du rapport du code défini par Rc = k/n.
Un cas particulier des codes de blocs est celui des codes où le message apparaît explicitement sur ses k
caractères c'est à dire "en clair". A côté de ces k caractères seront donc ajoutés n-k caractères redondants. Nous
obtenons alors un code dit code systématique et c'est ce sous ensemble que nous étudierons.

I.3 Poids d'un code :

Le poids d'un mot de code est par définition le nombre de caractères non nuls que contient ce mot.
11001000 est de poids 3 10011010 est de poids 4 00000000 est de poids nul
A l'ensemble des mots d'un code on associe l'ensemble des poids qui est la distribution de poids du
code. Un code est dit de poids fixe (ou poids constant) si tous les mots du code ont le même poids.
G.BINET MdC 61
T_info_b_linéaires p.3
UFR de Sciences Université de Caen

I.4 Distance de Hamming :

La distance de Hamming dij entre deux mots de code est le nombre de bits dont ils diffèrent.
11001000
et 10011010 ont une distance de 3.
La distance minimale du code est le minimum de l'ensemble des distances entre codes :
dmin = min { dij }

I.5 Code linéaire :

Un code est linéaire s'il répond au principe de superpostion :


α i C i + α j C j = Ck
Pour tout αi, αj = {0 , 1 } (en binaire), si Ci et Cj sont des mots de code, alors Ck est aussi un mot de code.

Conséquence : Si αi = αj = 0 ⇒ Ck = "0"
Un code linéaire contient le code "0".
Un code de poids fixe ne peut être un code linéaire.

Distance minimale d'un code linéaire :


Ci = Cc + Cm
Cj = Cc + Cq avec : Cc = code commun constitué des bits "1" identiques de Ci et Cj.
Cm et Cq n'ont par conséquence aucun bit commun.
Ci = 11001000
Cj = 10011010 ⇒ Cc = 10001000 , Cm = 01000000 , Cq = 00010010
En appelant w les poids des codes : dij = wm + wq .
Quel est le minimum de dij ?
Un code linéaire contient le code "0" ⇒ parmi les { dij } il y a un sous ensemble minimal
correspondant à Cj = "0" soit wm = wi et dij = wi. Ce qui justifie le théorème suivant :

Pour un code linéaire, la distance minimale est le plus petit poids du code, mot de code nul exclus.
min { dij } = min { wk } pour Ck ≠ "0"

G.BINET MdC 61
T_info_b_linéaires p.4
UFR de Sciences Université de Caen

II. GENERATION D'UN CODE DE BLOC LINEAIRE SYSTEMATIQUE


A partir d'un message Xm tel que :
Xm = [ m0 m1 ............. mk-1 ]
144424443
k caractères du message
nous devons générer un mot de code de bloc linéaire systématique qui a la structure suivante :

Cm = [ b0 b1 ..................... bn-k-1 m0 m1 ............. mk-1 ]


1444424444 3 14442444 3
(n-k) caractères de contrôle k caractères du message
1444444442444444443
n caractères du mot de code

Soit Cm = [ Bm Xm ] où Bm contient les caractères de contrôle appelés aussi caractères de parité.

II.1 Génération du mot de code :

Matrice de génération de code :


Matrice notée G, elle sert à générer le mot de code Cm à partir du message Xm soit :
Cm = Xm.G
Nous nous intéressons à des codes systématiques, la matrice G est donc de la forme :
G = [ P Ik ]
G étant une matrice ( k ,n ), P une matrice ( k , n-k ) et Ik la matrice identité ( k , k ).

Code non systématique :


Un code non systématique serait tel que : G = [ P M ] où la matrice M est une matrice qui mélange les bits du
message pour le crypter. Nous pouvons bien sûr nous ramener à un code systématique par combinaison des
lignes entre elles pour faire intervenir la matrice Ik. Tout code de bloc peut ainsi se ramener à l'étude d'un code
systématique équivalent.

La partie essentielle de la matrice G est donc la matrice P appelée matrice de parité.

Principe de la réalisation du codeur :


k
Chaque bit de parité s'exprime donc par : bi = ∑ m j p ji
j =1
En binaire les pji ∈ { 0 ;1 } ⇒ les bi sont
obtenus par une simple addition binaire. m0 m1 m2 m3
message
Le principe de la réalisation technique en est
donc simple, il suffit de disposer de deux
registres à décalage et d'un inverseur (switch Mot de code
électronique bien sûr) ce qui donne le schéma ci-
contre.
b0 b1 b2

G.BINET MdC 61
T_info_b_linéaires p.5
UFR de Sciences Université de Caen

Cet exemple est celui d'un code ( 7 , 4 ) tel que :

1 0 1 1 0 0 0
1 1 1 0 1 0 0 
G= ⇒ b0 = m0 + m1 + m2 b1 = m1 + m2 + m3 b2 = m0 + m1 + m3
1 1 0 0 0 1 0
 
0 1 1 0 0 0 1

II.2 Détection des erreurs de transmission :

Matrice de contrôle de parité :


Nous définissons un espace dual engendré par la matrice H telle que :

H = [ In-k PT ]
En décomposant les matrices nous obtenons :

I 
G.HT = [ P Ik ]  n -k  = P + P = 0
 P 
En effet P est constitué d'éléments binaires tels que : α + α = 0.
D'où la relation fondamentale : G.HT = 0
Avec l'exemple précédent :

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

Syndrôme :
A partir de la relation précédente nous pouvons établir la relation servant de base à la détection d'erreur :

Cm.HT = Xm.G.HT = 0 pour tout mot de code.


Le détecteur va utiliser cette relation. En effet, si le mot de code reçu Ym est entaché d'erreur nous pouvons
l'exprimer sous la forme :
Code reçu = code émis + erreur ⇒ Ym = Cm + Em
En effectuant le contrôle Ym.H = Cm.H + Em.H = Em.H . S'il n'y a pas eu erreur de transmission Em.HT = 0.
T T T T

Em.HT est par définition le syndrôme de l'erreur Sm.

Sm = Ym.HT = Em.HT
Le syndrôme ne dépend que de l'erreur de transmission commise et non du mot de code.

Théorème :
Supposons deux syndrômes Si = Ei.HT et Sj = Ej.HT.
Si Si = Sj ⇒ ( Ei - Ej ).HT = 0 ⇒ ( Ei - Ej ) est un mot de code.
⇒ deux vecteurs d'erreur qui diffèrent d'un mot de code ont même syndrôme.
Ce théorème montre qu'il peut y avoir ambiguïté dans la détection des erreurs.

G.BINET MdC 61
T_info_b_linéaires p.6
UFR de Sciences Université de Caen

Lien avec la distance minimale :


M = Cm.HT
( 1 , n-k) ( 1 , n) ( n ,n-k )

Chaque élément de la matrice M est : m j = ∑ ci h ji ce qui est une combinaison linéaire sur une ligne j de
i
tous les éléments des colonnes ⇒ M est une combinaison linéaire des colonnes de la matrice H et cette
combinaison linéaire est nulle.
⇒ les colonnes de H sont linéairement dépendantes.
Le nombre de colonnes intervenant dans la combinaison est égale au nombre de "1" du code Cm ce qui
est le poids de Hamming du mot de code.
La distance de Hamming du code étant le poids minimal de ce code ⇒ La distance minimale de Hamming
dmin d'un code est égale au nombre minimal de colonnes de la matrice H dont la somme est nulle.
Le nombre de colonnes de H linéairement indépendantes est dmin-1 et le rang maximal de cette matrice
est n-k ce qui établi la relation :
dmin ≤ n-k+1

Code étendu :
Pour améliorer la détection des erreurs, on ajoute des bits de parité aux colonnes de H ce qui créé à partir d'un
code ( n , k ) un code étendu ( n+1 , k ) tel que :

1 1 ← 1 1 → 1
0 
 
↑ ↑ 
He =   cela augmente la distance de Hamming dmin → dmin + 1
0 ← H → 
↓ ↓ 
 
 0 

II.3 Correction des erreurs :

Erreurs détectables :
Le nombre minimal de bits changeant entre chaque code est dmin la distance minimale du code. Compte tenu du
théorème du chapitre précédent, eD le nombre maximal d'erreurs détectables est donc :
eD = dmin-1

Nombre d'erreurs corrigeables :


Nous avons au maximum 2k messages à transmettre donc 2k mots de code corrects parmi les 2n possibles.
Si X est le mot de code émis, E l'erreur de transmission et Y le mot de code reçu :
Y=X+E
S'il y a t erreurs de transmission ⇒ la distance de Hamming entre Y et X est t.
Nous pouvons faire un schéma où un point représente un code, une croix un code correspondant à un message et
la distance entre deux points, la distance de Hamming.

G.BINET MdC 61
T_info_b_linéaires p.7
UFR de Sciences Université de Caen

S'il y a t erreurs de transmission, tous les mots de codes possibles correspondant à cette erreur sont situés dans
une sphère située autour du code réel transmis.
Soit deux codes Xi et Xj et t erreurs de transmission, si nous sommes dans la situation suivante :

t
t Xi Xj

Tout code appartenant à une sphère peut être sans ambiguïté attribué au code le plus proche ⇒ les erreurs
de transmission sont toutes corrigeables.
Une seconde situation:

t
Xj
Xi
t

Dans ce cas, les codes appartenant à l'intersection des sphères ne peuvent être attribués.
Pour éviter toute ambiguïté nous devrons donc respecter la condition :
2.t ≤ dmin-1
t étant un entier, eC le nombre maximum d'erreurs corrigeables sera :

eC = Int [ ½ (dmin-1 ) ]

Le nombre eDNC d'erreurs détectables et non corrigeables est tel que : eDNC + eC = eD. Compte tenu des relations
précédentes nous aurons aussi la relation : eDNC ≥ eC.
exemple :
dmin = 7 ⇒ erreurs détectables eD = 6.
erreurs corrigeables eC = 3.
Erreurs détectables non corrigeables eDNC = 3.

G.BINET MdC 61
T_info_b_linéaires p.8
UFR de Sciences Université de Caen

Correction des erreurs : méthode logicielle.


Il y a deux méthodes de correction des erreurs:
1. détecter la forme des signaux reçus et attribuer le symbole : cela dépend des formes d'ondes et donc de
la méthode de modulation choisie. C'est la méthode matérielle ("hard") de correction des erreurs.
2. interpréter la redondance d'un code pour lui attribuer un symbole : c'est la méthode dite logicielle
("soft") qui est celle que nous allons développer.
A la réception d'un mot de code, nous lui associons le message dont le mot de code est le plus proche au sens de
la distance entre mots de code. C'est le maximum de vraisemblance dont l'illustration a été faite dans l'étude des
erreurs corrigeables.
Pour un mot de code reçu le syndrôme associé est :
Sm = Ym.HT = Em.HT
Chaque ligne de HT (colonne de H) est le syndrôme d'une erreur simple. Pour un code (n , k), il y a n erreurs
simples possibles et avec ( n-k ) bits de contrôle nous pouvons coder ( 2(n-k) – 1 ) erreurs ( -1 car "000…" n'est
pas un code d'erreur) ⇒ il reste détectables ( 2(n-k) - 1 - n ) autres erreurs que des erreurs simples (erreurs
doubles, triples, ….).

Exemple: Soit le code (5 , 2) défini par

1 0 0 1 0
1 0 1 1 0
G=  H =  0 1 0 0 1 
0 1 1 0 1  0 0 1 1 1 
5 erreurs simples possibles avec leurs syndrômes associés et ( 2(n-k) - 1 – n ) = 2 autres syndrômes.
Table des erreurs :
Dans cette table apparaissent les deux syndrômes non Syndrômes Erreurs
associés à une erreur simple. possibles Sm probables Em
Prenons le syndrôme 110. Il peut être associé à une erreur 000 00000 Pas d'erreur
double du type ( bit 0 + bit 1 ) soit 11000 mais aussi à une 001 00100 Erreur bit 2
erreur du type ( bit 3 + bit 4 ) soit 00011. Il y a ici 010 01000 Erreur bit 1
ambiguïté entre deux erreurs doubles. 011 00001 Erreur bit 4
Pour le syndrôme 001 associé à une erreur bit 2 il pourrait 100 10000 Erreur bit 0
être associé à une erreur type ( bit 1 +bit 4 ) mais ici 101 00010 Erreur bit 3
l'ambiguïté est entre une seule erreur simple et d'autres 110
erreurs doubles, triples,… 111

Dans cet exemple, H a au plus trois colonnes linéairement indépendantes ⇒ dmin = 3.


Le nombre d'erreurs corrigeables est : ec = Int [ ½ (dmin-1) ] = 1.
Le nombre d'erreurs détectables est : eD = dmin – 1 = 2.
En effet, si nous affectons la solution la plus vraisemblable au sens de la distance minimale, toutes les erreurs
simples peuvent être corrigées. En ce qui concerne les erreurs doubles, elles sont détectables mais nous pouvons
soit les confondre entre elles, soit les confondre avec une erreur simple. Dans le second cas le maximum de
vraisemblance corrige comme une erreur simple ( c'est effectivement ce qui a la plus forte probabilité d'arriver )
et dans le premier elle tranche en faveur de la solution la plus probable qui, pour un code donné est toujours la

G.BINET MdC 61
T_info_b_linéaires p.9
UFR de Sciences Université de Caen

même. Qu'arrive-t-il pour des erreurs triples ? Au sens du critère, elles sont toujours systématiquement
confondues soit avec une erreur simple soit une erreur double, elles sont de ce fait non détectables et par là
même non corrigeables.

La correction des erreurs:


Les opérations s'ordonnent ainsi :
1. réception d'un mot de code Ym.
2. calcul du syndrôme associé Sm.
3. avec une table des erreurs, calcul de l'erreur la plus vraisemblable Em* associée au syndrôme.
4. calcul du mot de code le plus vraisemblable : Cm* = Ym ⊕ Em* ( en binaire, le + est un ou exclusif ).
5. extraction du message Xm* de Cm*.

Avec l'exemple précédent :


Xm = [ 1 0 ] ⇒ Cm = Xm.G = [ 1 0 1 1 0 ]

Erreur sur le bit 3 ⇒ Ym = [ 1 0 1 0 0 ] ⇒ syndrôme Sm = Ym.HT = [ 1 0 0 ]


⇒ table Em* = [ 0 0 0 1 0 ] ⇒ Cm* = Ym ⊕ Em* = [ 1 0 1 0 0 ] ⊕ [ 0 0 0 1 0 ] = [ 1 0 1 1 0 ] = Cm.

Erreur sur les bits 1 et 3 ⇒ Ym = [ 1 1 1 0 1 ] ⇒ syndrôme Sm = Ym.HT = [ 0 1 0 ]


⇒ table Em* = [ 1 0 0 0 0 ] ⇒ Cm* = Ym ⊕ Em* = [ 1 1 1 1 0 ] ⊕ [ 1 0 0 0 0 ] = [ 0 1 1 1 0 ] ≠ Cm.

G.BINET MdC 61
T_info_b_linéaires p.10
UFR de Sciences Université de Caen

III CODES DE BLOCS LINEAIRES

III.1 Codes de Hamming :

Les codes de Hamming sont des codes binaires qui ont la propriété :
( n , k ) = ( 2m-1 , 2m-1-m ) avec m entier.
m=2 code ( 3 , 1 ) peu d'intérêt, k = 1 on ne transmet qu'un bit de message.
m=3 code ( 7 , 4 )
m=4 code ( 15 , 11 )
……..

matrice de contrôle :
Elle est de dimensions ( n-k , n ) = ( m , 2m-1 ).
Une colonne est donc constituée de m éléments binaires et nous avons 2m-1 colonnes c'est-à-dire toutes les
combinaisons possibles moins une ( la combinaison "000…" ). Ceci nous permet pour ces codes de construire
très rapidement la matrice de contrôle H et d'en déduire la matrice de génération de code G. La procédure est la
suivante :
1. Commencer à remplir la matrice H en utilisant les combinaisons linéaires de m bits faisant apparaître la
matrice In-k.
2. Compléter cette matrice par les combinaisons de m bits non encore utilisées code "0" exclu. Il apparaît
dans cette opération que la solution n'est pas unique mais cela n'a aucune importance.

Exemple d'un code ( 7 ,4 ) :

 
1 0 0 1 1 0 1
 
H = 0 1 0 1 0 1 1
0 0 1 014
124 1 31 
1424 3 
 In-k PT 
Nous en déduisons G :

 
1 1 0 1 0 0 0
 
1 0 1 0 1 0 0
G=
0 1 1 0 0 1 0 
1 1 1 0 42
0 430 41 
14243 1 4 
 P Ik 
erreurs corrigeables :
Le nombre maximum de colonnes de H linéairement indépendantes est (n-k) = m= dmin.
⇒ eD = Int [ ½ (m-1) ]
m=3 eD = 1 ; m=4 eD = 1 ; m=5 eD = 2 ;……….

G.BINET MdC 61
T_info_b_linéaires p.11
UFR de Sciences Université de Caen

III.2 Codes de Hadamard :

Les codes de Hamming sont très populaires de par leur simplicité cependant, ils exigent un grand nombre de bits
de contrôle pour corriger des erreurs multiples.
Les codes de Hadamard sont constitués par itération à partir de matrices telles que :

M Mn 
M 2n =  n où Mn désigne la matrice complémentaire 0 → 1 et 1 → 0.
 Mn Mn 
La matrice initiale est :

0 0 0 0
0 1 
0 0 1 0
M2 =   ⇒ M4 = 
0 1 0 0 1 1
 
0 1 1 0

Les matrices Mn et Mn contiennent comme lignes ou colonnes les 2n mots du code. La structure de la matrice
permet donc de détecter des erreurs de transmission. Sans démonstration, on montre que dmin = ½ n.

G.BINET MdC 61
T_info_b_linéaires p.12

Vous aimerez peut-être aussi