Codes correcteurs d`erreurs

Codes correcteurs d’erreurs
1
1.1
Partie théorique
Définition
Un code correcteur est une technique de codage de l’information basée sur la redondance, qui
vise à détecter et corriger des éventuelles erreurs de transmission d’un message sur une voie de
communication peu fiable (radio, câble, fibre optique, ....) ou depuis des supports de stockage (CD,
DVD, mémoire) où l’intégrité des données est importante.
1.2
Principe
Prenons l’exemple d’un message simple à transmettre, du type "01234". Si l’on transmet directement la suite de chiffres, l’information sera compacte, délivrera l’information, mais une erreur
en réception du type "01134" sera indétectable. Au contraire, une transmission du type "zéro un
deux trois quatre" est (trop) riche, contient la même information, mais une erreur en réception du
type "zéro un deux trois quatre" sera détectée et correctible. Ce principe de redondance permet
de construire les codes correcteurs d’erreurs.
En pratique, les messages sont transmis sur un canal sous la forme d’une suite de bits (des 0 et
de 1). Les canaux de transmission imparfaits entraînent des erreurs lors des échanges de données
(un zéro qui devient un 1 ou inversement). Par exemple, la probabilité d’erreur sur une ligne
téléphonique est de l’ordre 10−6 . Avec un tel taux d’erreur et une connexion à 1 Mo/s, en moyenne
8 bits erronés sont transmis chaque seconde.
Le principe général des codes correcteurs d’erreur est alors le suivant :
– Chaque suite de bits à transmettre est augmentée par une autre suite de bits dite de redondance ou de contrôle.
– Pour chaque suite de k bits transmise, on ajoute r bits. On dit alors que l’on utilise un code
C(n, k) avec n = k + r.
– À la réception, les bits ajoutés permettent d’effectuer des contrôles
1.3
Le code ISBN
L’International Standard Book Number (ISBN) est un numéro international qui permet d’identifier, de manière unique, chaque livre publié. Le numéro ISBN-10 se compose de trois segments
de longueur variable et d’un segment de longueur fixe. La longueur totale de l’ISBN comprend dix
chiffres (le 1er janvier 2007, la longueur a été étendue à 13 chiffres en ajoutant un groupe initial
de 3 chiffres). Si les quatre segments d’un ancien code ISBN à 10 chiffres sont notés S1 - S2 - S3 S4 :
1
–
–
–
–
S1 identifie un groupe de codes pour un pays, une zone géographique ou une zone de langue.
S2 identifie l’éditeur de la publication.
S3 correspond au numéro d’ordre de l’ouvrage chez l’éditeur.
S4 est un chiffre-clé calculé à partir des chiffres précédents et qui permet de vérifier qu’il n’y
a pas d’erreurs. Outre les chiffres de 0 à 9, cette clé de contrôle peut prendre la valeur X, qui
représente le nombre 10.
Pour calculer S4, on attribue une pondération à chaque position (de 10 à 2 en allant en sens
décroissant) et on fait la somme des produits ainsi obtenus. On conserve le reste de la division
euclidienne de ce nombre par 11. La clé s’obtient en retranchant ce nombre à 11. Si le reste de la
division euclidienne est 0, la clé de contrôle n’est pas 11 (11 - 0 = 11) mais 0. De même, si le reste
de la division euclidienne est 1, la clé de contrôle n’est pas 10 mais la lettre X. Le nombre 11 étant
premier, une erreur portant sur un chiffre entraînera automatiquement une incohérence du code
de contrôle. La vérification du code de contrôle peut se faire en effectuant le même calcul sur le
code ISBN complet, en appliquant la pondération 1 au dixième chiffre de la clé de contrôle (si ce
chiffre-clé est X, on lui attribue la valeur 10) : la somme pondérée doit alors être un multiple de
11.
Ce type de détection est appelé somme de contrôle (cheksum), cas particulier de contrôle par
redondance, qui permet la détection (mais pas la correction) des erreurs. Le principe est d’ajouter
aux données des éléments dépendant de ces dernières et simples à calculer. Cette redondance
accompagne les données lors d’une transmission ou bien lors du stockage sur un support quelconque.
Plus tard, il est possible de réaliser la même opération sur les données et de comparer le résultat
à la somme de contrôle originale, et ainsi conclure sur la corruption potentielle du message.
Pour un code ISBN 5-38733-044, la somme des produits fait 243. Le reste de la division euclidienne de 243 par 11 est 10, et la clé de contrôle est donc 11-10=1. l’ISBN complet est donc
5-38733-044-1. La vérification de la clé complète à 10 chiffres donne la somme pondérée 242, qui
est bien divisible par 11.
1.4
Le Code de Hamming
Un code de Hamming permet la détection et la correction automatique d’une erreur si elle ne
porte que sur une lettre du message. Un code de Hamming est parfait, ce qui signifie que pour
une longueur de code donnée, il n’existe pas d’autre code plus compact ayant la même capacité de
correction. En ce sens, son rendement est maximal.
Le code de Hamming se base également sur un checksum, sous la forme de bits de parité répartis
dans le message à transmettre. Un bit de parité est égal à zéro si la somme des autres bits est
paire. Dans le cas contraire, il est égal à un. Ainsi, si la somme des bits est impair, c’est qu’il y a
eu une erreur de transmission (attention, un nombre pair d’erreurs passe inaperçu). Par exemple,
1011001 (7 bits) devient 01011001 (8 bits).
Un code de Hamming se compose alors de m bits du message à transmettre et de n bits de
contrôle de parité. La longueur totale du message est de 2n − 1, et donc m = (2n − 1) − n. Les
bits de contrôle de parité Ci sont en position 2i , i ≥ 0, et les bits du message Dj occupent le reste
du code. On parle souvent d’un code de Hamming (n+m)-m. Ainsi, la structure d’un code 7-4 est
D3 D2 D1 C2 D0 C1 C0 .
Pour retrouver l’erreur dans un code de Hamming, on regarde les bits de parité. Dans le cas
précédent, si C2 , C1 , C0 ont tous la bonne valeur, il n’y a pas d’erreur. Dans le cas contraire, la
2
valeur des bits de contrôle indique la position de l’erreur entre 1 et 7. Le code de Hamming présenté
ici ne permet de retrouver et corriger qu’une erreur.
Pour connaître quels bits sont vérifiés par chacun des bits de contrôle de parité, il est utile de
construire le tableau suivant : les lignes sont numérotées dans la dernière colonne de 1 à 2n − 1
(dans l’exemple précédent 2n − 1 = 7), chaque nombre est converti en binaire et l’on écrit chaque
bit dans les colonnes de gauche. On colorie de la couleur de Ci les nombres de droite s’il y a un 1
dans dans la colonne Ci . Par exemple, 5 sera annoté en vert et en rouge, car sur la ligne du 5, il y
a un 1 dans les colonnes C2 et C0 . Les bits de contrôle d’une couleur donnée vérifient les bits du
message qui portent la même couleur. Chaque bit de données est coloré d’une manière différente,
ce qui permet de retrouver la position d’une erreur.
C2
0
0
0
1
1
1
1
C1
0
1
1
0
0
1
1
C0
1
0
1
0
1
0
1
décimal
1•
2•
3••
4•
5••
6••
7•••
Ainsi, si l’on souhaite envoyer 1010, le calcul des bits de parité amène à envoyer le message
1010010. Si le message effectivement reçu est 0010010 :
– C0 a la mauvaise valeur, car 0+1+0+0 est impair, donc il y a une erreur en position 7, 5, 3
ou 1.
– C1 a la mauvaise valeur, car 0+0+0+1 est impair, donc il y a une erreur en position 7, 6, 3
ou 2.
– C2 a la mauvaise valeur, car 0+0+1+0 est impair, donc il y a une erreur en position 7, 6, 5
ou 4.
On écrit alors le nombre binaire C2 C1 C0 où Ci vaut 0 si le bit de contrôle Ci a la bonne valeur et
1 sinon. On obtient alors 111, ce qui correspond à 7 en binaire. Le bit erroné est le numéro 7.
Si un des bits de parité Ci est altéré, la technique fonctionne encore. Par exemple, si le message
reçu est 1010011 :
– C0 a la mauvaise valeur, car 0+1+0+0 est impair, donc il y a une erreur en position 7, 5, 3
ou 1.
– C1 a la bonne valeur, car 1+0+0+1 est pair. Il n’y a pas d’erreur en position 7, 6, 3 et 2
– C2 a la bonne valeur, car 1+0+1+0 est pair. Il n’y a pas d’erreur en position 7, 6, 5 et 4.
et C2 C1 C0 =001.
Notons enfin qu’il existe un outil simple permettant de compter le nombre de bits altérés dans
la transmission d’un message d’une longueur donnée : la distance de Hamming. Ainsi, la distance
de Hamming entre 1011101 et 1001001 est 2 car deux bits sont différents. Il est souhaitable d’avoir
une certaine distance entre les mots envoyés, afin de détecter s’il y a eu une erreur de transmission.
Par exemple, si l’on a trois messages à transmettre de trois bits, il vaut mieux choisir les codages
qui sont à distance 2 les uns des autres, par exemple 000, 110 et 101. En effet, si un seul bit est
altéré, on recevra un message impossible. Par contre, en utilisant 000, 001 et 010, un bit altéré
pourrait passer inaperçu.
3
1.5
Code cyclique de redondance - CRC
Ce code utilise une représentation polynomiale des bits à transmettre. Le mot b1 · · · bn est
n
X
représenté par le polynôme P (x) =
bi xn−i . Ainsi, par exemple 1100101 est représenté par le
i=1
polynôme P (x) = x6 + x5 + x2 + 1. Toutes les expressions polynomiales sont manipulées par la
suite avec une arithmétique modulo 2.
Dans le mécanisme de détection d’erreur du CRC, un polynôme prédéfini (appelé polynôme
générateur et noté G(X)) est connu de l’émetteur et du récepteur. La détection d’erreur consiste
pour l’émetteur à ajouter au message à émettre un code de contrôle tel que le polynôme correspondant au message plus le code de contrôle soit divisible par le polynôme générateur choisi, et
de transmettre le message et le polynôme générateur au récepteur. Le message reçu qui contient
les données et le CRC doit être divisible par le polynôme générateur.Il suffit alors au récepteur
de vérifier par une division euclidienne en base 2 que le reste de la division du message par le
polynôme est nul.
Les polynômes générateurs (qui possèdent de bonnes propriétés) souvent utilisés sont
– CRC-12 =x12 + x11 + x3 + x2 + x + 1
– CRC-16 =x16 + x15 + x2 + 1
– CRC-CCITT =x16 + x12 + x5 + 1
– CRC-32 =x32 + x26 + x23 + x22 + x16 + x12 + x11 + x10 + x8 + x7 + x5 + x4 + x + 1
Prenons un cas pratique : on choisit le polynôme générateur G(x) = x4 + x2 + x et on le
transforme en un mot binaire, soit 10110. Pour une message 11100111 à transmettre, on ajoute m
zéros à ce mot binaire où m est le degré du polynôme générateur, ce qui donne 111001110000. On
ajoute alors itérativement à ce mot, le mot correspondant au polynôme générateur jusqu ?à ce que
le mot obtenu soit inférieur au polynôme générateur. Ce mot obtenu correspond au CRC à ajouter
au mot avant de l ?émettre. On effectue donc une division euclidienne dans laquelle on ne tient pas
compte du quotient.
1
1
0
1
0
1
1
0
1
1
0
0
0
0
1
1
1
0
0
0
0
1
1
1
0
1
1
1
0
0
0
0
1
0
1
0
1
1
0
1
1
0
0
0
0
1
1
0
0
0
1
1
0
1
1
1
0
0
0
0
1
1
0
1
0
0
0
0
0
0
1
1
0
0
0
1
1
0
0
0
Le CRC est donc 1110 et le mot à transmettre 11100111 1110.
A la réception : on effectue la division, le reste est nul il n’y a donc pas d’erreur.
1.6
D’autres codes
De nombreux autres codes correcteurs existent, et font appel à des notions et outils mathématiques intéressants, mais difficiles à mettre en oeuvre sur un cours restreint sur les codes correcteurs
4
d’erreurs. Parmi ceux ci, on peut citer :
– les codes BCH (Bose, Ray-Chaudhuri et Hocquenghem), qui sont des codes cycliques se
basant sur la théorie des corps finis, et en particulier les extensions de Galois ainsi que les
polynômes.
– le codage de Reed Solomon (utilisé par exemple dans les QR-codes), basé sur les corps de
Galois, et dont le principe est de construire un polynôme formel à partir des symboles à
transmettre et de le sur-échantillonner. Le résultat est alors envoyé, au lieu des symboles
originaux. La redondance de ce sur-échantillonnage permet au récepteur du message encodé
de reconstruire le polynôme même s’il y a eu des erreurs pendant la transmission.
– le code de Reed-Muller (utilisé par les sondes Mariner pour assurer une transmission des
photos de Mars)
2
Codes correcteurs en Python
2.1
Code ISBN
Le code ?? présente un exemple de réalisation d’un code ISBN.
# −∗− c o d i n g : u t f −8 −∗−
ISBN=i n p u t ( " E n t r e r u n c o d e
ISBN=s t r ( ISBN )
a
9
chiffres
:")
somme = 0
for i in range ( 9 ) :
somme = somme + i n t ( ISBN [ i ] ) ∗(10 − i )
r e s t e = somme%11
c h e c k=11− r e s t e
i f r e s t e ==1:
c h e c k=’ X ’
i f r e s t e ==0:
c h e c k =0
ISBNNumber=s t r ( ISBN )+s t r ( c h e c k )
print ( ’ I S B N - - >
’ + ISBNNumber )
Listing 1 – Exemple de réalisation d’un code ISBN
2.2
Code de Hamming
Le code 2 présente un exemple de réalisation d’un code de Hamming 7-4.
5
# −∗− c o d i n g :
import s y s
u t f −8 −∗−
K = 4
def encode ( s ) :
" " " L e c t u r e de p a q u e t s de 4 b i t s a l a f o i s
w h i le l e n ( s ) >= K :
paquet = s [ 0 : K]
s y s . s t d o u t . w r i t e ( Hamming ( p a q u e t ) )
s = s [K : ]
d e f Hamming ( b i t s ) :
""" C a l c u l e t i n s e r t i o n d e s
t1 = p a r i t e ( bits , [ 0 , 1 , 2 ] )
t2 = p a r i t e ( bits , [ 1 , 2 , 3 ] )
t3 = p a r i t e ( bits , [ 0 , 2 , 3 ] )
return b i t s + t 1 + t 2 + t 3
def
bits
de
et
encodage
de Hamming " " "
p a r i t e """
parite (s , indices ) :
" " " C a l c u l d e s b i t s de p a r i t s " " "
sub = " "
for i in i n d i c e s :
s u b += s [ i ]
return s t r ( s t r . c o u n t ( sub , " 1 " ) % 2 )
###################################################################################
# Main
i f __name__ == " _ _ m a i n _ _ " :
c h a i n e=raw_input ( " E n t r e z
encode ( chaine )
le
message :
")
Listing 2 – Code de Hamming 7-4
2.3
Codes CRC
L’écriture d’un code CRC peut se révéler délicate. Heureusement, plusieurs implémentations
sont disponibles gratuitement, dont pycrc ou crcmod
6