Dernière mise à jour Informatique Denis DEFAUCHY
01/04/2021 Codes correcteurs d’erreurs Cours
Informatique
Cours
Page 1 sur 15
Dernière mise à jour Informatique Denis DEFAUCHY
01/04/2021 Codes correcteurs d’erreurs Cours
1.I. Codes correcteurs d’erreurs ................................................................................................ 3
1.I.1 Somme de contrôle - checksum ............................................................................................................. 3
1.I.1.a Principe ........................................................................................................................................... 3
1.I.1.b Bit de parité .................................................................................................................................... 3
1.I.2 Code de Hamming [7,4] .......................................................................................................................... 4
1.I.2.a Nombre de bits de contrôle ............................................................................................................ 4
1.I.2.b Bits de contrôle ............................................................................................................................... 5
1.I.2.c Mise en évidence d’une erreur ....................................................................................................... 6
1.I.2.d Codage ............................................................................................................................................ 8
1.I.2.d.i Principe ..................................................................................................................................... 8
• Graphiquement .............................................................................................................................. 8
• Par le calcul, sans matrices ............................................................................................................. 8
• Par le calcul matriciel ...................................................................................................................... 9
[Link] Exemple ................................................................................................................................. 11
• Graphiquement ............................................................................................................................ 11
• Par le calcul, sans matrices ........................................................................................................... 11
• Par le calcul matriciel .................................................................................................................... 11
1.I.2.e Décodage et correction ................................................................................................................. 12
1.I.2.e.i Détection de la présence d’une erreur ................................................................................... 12
• Graphiquement ............................................................................................................................ 12
• Par le calcul, sans matrices ........................................................................................................... 12
• Par le calcul matriciel .................................................................................................................... 13
[Link] Correction des erreurs ........................................................................................................... 14
• Graphiquement ............................................................................................................................ 14
• Par le calcul, avec ou sans matrices .............................................................................................. 14
[Link] Exemple................................................................................................................................. 15
• Graphiquement ............................................................................................................................ 15
• Par le calcul, sans matrices ........................................................................................................... 15
• Par le calcul matriciel .................................................................................................................... 15
Page 2 sur 15
Dernière mise à jour Informatique Denis DEFAUCHY
01/04/2021 Codes correcteurs d’erreurs Cours
1.I. Codes correcteurs d’erreurs
La transmission de données s’accompagne parfois d’erreurs. Il est possible d’ajouter des éléments qui
permettent de vérifier que le message reçu correspond au message transmis, voir même de corriger
le message erroné.
Le programme d’IPT propose de s’intéresser à la somme de contrôle (checksum) et au code de
Hamming [7,4].
Intéressons-nous au cas où l’alphabet est composé uniquement des valeurs 0 ou 1 et supposons que
les erreurs rencontrées sont des échanges de 0 en 1 et inversement.
1.I.1 Somme de contrôle - checksum
1.I.1.a Principe
La somme de contrôle est un nombre ajouté au message transmis dans le but de vérifier lors de la
réception d’une donnée qu’elle correspond à la donnée émise. Utilisée seule, la somme de contrôle
ne permet pas de corriger le code reçu en cas d’erreur.
Le principe consiste à créer une donnée transmise en plus des données normales, dont la création est
basée sur celles-ci. On parle de « redondance ».
1.I.1.b Bit de parité
Supposons que l’information à transmettre soit codée sur 7 bits à laquelle on ajoute un bit de parité.
Le principe consiste à ajouter une somme de contrôle (un bit dans ce cas) valant :
- 1 si la somme des 7 bits de l’information transmise est impaire
- 0 si la somme des 7 bits de l’information transmise est paire
Il est parfaitement possible d’inverser le résultat, impaire si la somme vaut 0 et paire si la somme vaut
1.
Page 3 sur 15
Dernière mise à jour Informatique Denis DEFAUCHY
01/04/2021 Codes correcteurs d’erreurs Cours
Déterminons la parité de quelques nombres codés sur 7 bits :
Nombre binaire 7 bits Parité Information transmise 8 bits
0010100 0 00010100
1001000 0 01001000
0001011 1 10001011
0111111 0 00111111
0000100 1 10000100
Ainsi, à la réception du message 10001111, on sait immédiatement qu’il y a eu une erreur de
transmission.
On comprendra que le bit de parité ne permet de détecter les erreurs que si elles se produisent en
nombre impaire. Si 2𝑛 erreurs se produisent, la parité sera respectée.
Par ailleurs, il n’est pas possible de corriger le message en cas de présence d’erreur puisque l’on ne
sait pas où elle se trouve.
1.I.2 Code de Hamming [7,4]
Le code de Hamming [7,4], du nom de Richard Hamming (1950) est un cas particulier des codes de
Hamming qui permet de transmettre un message de 4 bits accompagné de 3 bits de contrôle, soit un
mot de 7 bits. Une erreur (et une seule) sur l’un des 7 bits du message transmis peut être détectée à
la réception et corrigée.
1.I.2.a Nombre de bits de contrôle
Appelons « mot » le message à transmettre, codé sur 4 bits sous la forme 𝑑1 𝑑2 𝑑3 𝑑4 . Appelons
« message » le mot associé à ses 𝑝 bits de contrôle.
En supposant que le message ne contienne qu’une erreur, celle-ci aura lieu sur l’un des (4 + 𝑝) bits
du message. En ajoutant le cas où il n’y a pas d’erreurs, il y a (5 + 𝑝) cas de transmission possible avec
0 ou 1 erreur.
Les 𝑝 bits de contrôle peuvent contenir au plus 2𝑝 informations.
Il faut donc vérifier l’égalité :
5 + 𝑝 = 2𝑝
L’unique solution de cette équation est 𝑝 = 3. Ainsi, avec 3 bits de contrôle, il sera possible d’ajouter
23 = 8 informations associées aux 8 situations d’erreur possible. Concrètement, lors du décodage, à
l’aide de ces 3 bits de plus, il sera possible d’identifier l’une des 8 situations : Pas d’erreur, erreur bit 1,
erreur bit 2, …, erreur bit 7. Il suffira alors d’inverser le bit erroné.
Le code de Hamming [7,4] est dit parfait car il existe une et une seule solution pour chaque erreur
possible.
Page 4 sur 15
Dernière mise à jour Informatique Denis DEFAUCHY
01/04/2021 Codes correcteurs d’erreurs Cours
1.I.2.b Bits de contrôle
Les 3 bits de contrôle appelés 𝑝1 , 𝑝2 et 𝑝3 sont construits sur la base d’un calcul de bits de parité sur 3
des 4 bits du message appelés 𝑑1 , 𝑑2 , 𝑑3 et 𝑑4 selon le schéma suivant :
𝒑𝟏
𝑝1 = (𝑑1 + 𝑑2 + 𝑑4 )[2] 𝒅𝟏 𝒅𝟐
𝑝2 = (𝑑1 + 𝑑3 + 𝑑4 )[2]
𝒅𝟒
𝑝3 = (𝑑2 + 𝑑3 + 𝑑4 )[2]
𝒑𝟐 𝒅𝟑 𝒑𝟑
Voici quelques exemples de détermination des bits de contrôle :
𝟏
Message : 𝑑1 𝑑2 𝑑3 𝑑4 = 1101
𝟏 𝟏
𝑝1 = (1 + 1 + 1)[2] = 1
𝑝2 = (1 + 0 + 1)[2] = 0 𝟏
𝑝3 = (1 + 0 + 1)[2] = 0
𝟎 𝟎 𝟎
𝟏
Message : 𝑑1 𝑑2 𝑑3 𝑑4 = 1000
𝟏 𝟎
𝑝1 = (1 + 0 + 0)[2] = 1
𝑝2 = (1 + 0 + 0)[2] = 1 𝟎
𝑝3 = (0 + 0 + 0)[2] = 0
𝟏 𝟎 𝟎
Page 5 sur 15
Dernière mise à jour Informatique Denis DEFAUCHY
01/04/2021 Codes correcteurs d’erreurs Cours
1.I.2.c Mise en évidence d’une erreur
Compte tenu du mode de construction des bits de contrôle, on peut identifier une erreur en fonction
de la parité de la somme des bits d’un des 3 cercles. En effet, prenons l’exemple du cercle vert. Le bit
𝑝1 est de même parité que la somme 𝑑1 + 𝑑2 + 𝑑4 . Ainsi, s’il n’y a aucune erreur sur les bits 𝑝1 , 𝑑1 ,
𝑑2 et 𝑑4 , la somme 𝑝1 + 𝑑1 + 𝑑2 + 𝑑4 est forcément paire. Autrement dit, si cette somme est impaire,
il y a une erreur sur l’un des 4 bits du cercle vert. Cette propriété s’étend aux cercles violet et rouge.
𝒑𝟏
𝒅𝟏 𝒅𝟐
𝒅𝟒
𝒑𝟐 𝒅𝟑 𝒑𝟑
Appelons 𝑆1 la somme des bits à l’intérieur du cercle associé à 𝑝1 : 𝑆1 = 𝑝1 + 𝑑1 + 𝑑2 + 𝑑4
Appelons 𝑆2 la somme des bits à l’intérieur du cercle associé à 𝑝2 : 𝑆2 = 𝑝2 + 𝑑1 + 𝑑3 + 𝑑4
Appelons 𝑆3 la somme des bits à l’intérieur du cercle associé à 𝑝3 : 𝑆3 = 𝑝3 + 𝑑2 + 𝑑3 + 𝑑4
S’il n’y a aucune erreur, ces trois sommes 𝑆1 , 𝑆2 et 𝑆3 sont paires. Une erreur sur l’un des 4 éléments
de la somme concernée la rend impaire.
Les erreurs peuvent se produire soit sur les bits du message 𝑑𝑖 , soit sur les bits de parité 𝑝𝑖 . Voici
comment identifier une erreur :
Erreur sur un bit du message 𝑑𝑖 Erreur sur un bit de parité 𝑝𝑖
Sommes Sommes
Sommes paires Sommes paires
impaires impaires
Erreur sur 𝑑1 𝑆1 & 𝑆2 𝑆3 Erreur sur 𝑝1 𝑆1 𝑆2 & 𝑆3
Erreur sur 𝑑2 𝑆1 & 𝑆3 𝑆2 Erreur sur 𝑝2 𝑆2 𝑆1 & 𝑆3
Erreur sur 𝑑3 𝑆2 & 𝑆3 𝑆1 Erreur sur 𝑝3 𝑆3 𝑆1 & 𝑆2
Erreur sur 𝑑4 𝑆1 & 𝑆2 & 𝑆3
Le tableau suivant répertorie, pour chaque bit, l’état pair ou impaire des sommes des cercles associés
à chacun des 3 bits de contrôle :
𝑝1 𝑝2 𝑝3 𝑑1 𝑑2 𝑑3 𝑑4
𝑆1 𝐼 𝑃 𝑃 𝐼 𝐼 𝑃 𝐼
𝑆2 𝑃 𝐼 𝑃 𝐼 𝑃 𝐼 𝐼
𝑆3 𝑃 𝑃 𝐼 𝑃 𝐼 𝐼 𝐼
Page 6 sur 15
Dernière mise à jour Informatique Denis DEFAUCHY
01/04/2021 Codes correcteurs d’erreurs Cours
Remarque : si aucune erreur n’est présente, les 3 sommes de parité sont paires.
Finalement, proposons ce tableau réorganisé (lignes et colonnes) comme suit :
Aucune
𝑝1 𝑝2 𝑑1 𝑝3 𝑑2 𝑑3 𝑑4
erreur
𝑆3 𝑃 𝑃 𝑃 𝑃 𝐼 𝐼 𝐼 𝐼
𝑆2 𝑃 𝑃 𝐼 𝐼 𝑃 𝑃 𝐼 𝐼
𝑆1 𝑃 𝐼 𝑃 𝐼 𝑃 𝐼 𝑃 𝐼
Concrètement, si nous représentons les sommes 𝑆1 , 𝑆2 et 𝑆3 modulo 2, on a :
Aucune
𝑝1 𝑝2 𝑑1 𝑝3 𝑑2 𝑑3 𝑑4
erreur
𝑆3 [2] 0 0 0 0 1 1 1 1
𝑆2 [2] 0 0 1 1 0 0 1 1
𝑆1 [2] 0 1 0 1 0 1 0 1
On reconnaitra de gauche à droite les nombres binaires de 0 à 7 codés sur 3 bits.
𝑆3′ 𝑆3 [2]
Définissons un vecteur 𝑆 tel que : 𝑆 = (𝑆2′ ) = (𝑆2 [2])
′ ′
𝑆1′ 𝑆1 [2]
Il suffira finalement de déterminer le nombre 𝑖 = 𝑆3′ . 22 + 𝑆2′ . 2 + 𝑆1′ puis l’indice 𝑖𝑛𝑑 = (𝑖 − 1) qui
donnera l’indice du bit erroné dans le mot transmis :
Aucune
𝑝1 𝑝2 𝑑1 𝑝3 𝑑2 𝑑3 𝑑4
erreur
𝑆3′ 0 0 0 0 1 1 1 1
𝑆2′ 0 0 1 1 0 0 1 1
𝑆1′ 0 1 0 1 0 1 0 1
𝑖 0 1 2 3 4 5 6 7
𝑖𝑛𝑑 RAS 0 1 2 3 4 5 6
Page 7 sur 15
Dernière mise à jour Informatique Denis DEFAUCHY
01/04/2021 Codes correcteurs d’erreurs Cours
1.I.2.d Codage
Il faut coder le mot 𝑚 = 𝑑1 𝑑2 𝑑3 𝑑4 et l’envoyer sous la forme 𝑐 = 𝑝1 𝑝2 𝑑1 𝑝3 𝑑2 𝑑3 𝑑4
1.I.2.d.i Principe
• Graphiquement
Comme vu précédemment, il est assez simple de créer le codage d’un mot de 4 bits à l’aide de l’image
suivante :
𝒑𝟏
𝒅𝟏 𝒅𝟐
𝒅𝟒
𝒑𝟐 𝒅𝟑 𝒑𝟑
Après avoir remplacé les 4 bits 𝑑1 𝑑2 𝑑3 𝑑4 par leur valeur, il suffit de déterminer les 3 bits de contrôle
en déterminant la parité de la somme des bits dans chacun des 3 cercles associés. On écrit alors le
message codé 𝑐 = 𝑝1 𝑝2 𝑑1 𝑝3 𝑑2 𝑑3 𝑑4
• Par le calcul, sans matrices
Il suffit de calculer :
𝑝1 = (𝑑1 + 𝑑2 + 𝑑4 )[2]
𝑝2 = (𝑑1 + 𝑑3 + 𝑑4 )[2]
𝑝3 = (𝑑2 + 𝑑3 + 𝑑4 )[2]
Puis d’écrire le message codé 𝑐 = 𝑝1 𝑝2 𝑑1 𝑝3 𝑑2 𝑑3 𝑑4
Page 8 sur 15
Dernière mise à jour Informatique Denis DEFAUCHY
01/04/2021 Codes correcteurs d’erreurs Cours
• Par le calcul matriciel
Soit les ensembles :
- 𝐸 ensemble des mots de 4 lettres prises dans l’ensemble {0,1}
- 𝐹 ensemble des mots de 7 lettres prises dans l’ensemble {0,1}
𝐸 et 𝐹 peuvent être considérés comme des espaces vectoriels sur le corps binaire {0,1} avec les tables
d’addition et de multiplication suivantes :
+ 0 1
0 0 1
1 1 0
* 0 1
0 0 0
1 0 1
La construction d’un message sur 7 bits à partir des 4 bits du mot est donc une application linéaire. On
peut alors représenter l’encodage par la multiplication d’un vecteur par une matrice.
Le mot à transmettre s’écrit sous la forme :
𝑑1 𝑑2 𝑑3 𝑑4 = 𝑑1 ∗ 𝑒1 + 𝑑2 ∗ 𝑒2 + 𝑑3 ∗ 𝑒3 + 𝑑4 ∗ 𝑒4
𝑒1 = 1000 ; 𝑒2 = 0100 ; 𝑒3 = 0010 ; 𝑒4 = 0001
Remarque : dans cet espace vectoriel, on a : 0001 + 0001 = 0000
La connaissance de l’image de chaque vecteur 𝑒𝑖 de la base détermine entièrement l’application
d’encodage appelée 𝜑.
En utilisant le schéma des 3 cercles, on peut déterminer les valeurs de bits de contrôle pour chacun
des vecteurs 𝑒𝑖 :
𝑒𝑖 𝑑1 𝑑2 𝑑3 𝑑4 𝑝1 𝑝2 𝑝3 𝑝1 𝑝2 𝑑1 𝑝3 𝑑2 𝑑3 𝑑4
𝑒1 1000 110 1110000
𝑒2 0100 101 1001100
𝑒3 0010 011 0101010
𝑒4 0001 111 1101001
La matrice associée à cette application linéaire 𝜑 est donc la suivante :
1 1 0 1
1 0 1 1
1 0 0 0
𝐺= 0 1 1 1
0 1 0 0
0 0 1 0
(0 0 0 1)
Page 9 sur 15
Dernière mise à jour Informatique Denis DEFAUCHY
01/04/2021 Codes correcteurs d’erreurs Cours
Il est maintenant simple d’encoder n’importe quel mot 𝑚 = 𝑑1 𝑑2 𝑑3 𝑑4 .
𝜑(𝑚) = 𝜑(𝑑1 𝑑2 𝑑3 𝑑4 ) = 𝑑1 𝜑(𝑒1 ) + 𝑑2 𝜑(𝑒2 ) + 𝑑3 𝜑(𝑒3 ) + 𝑑4 𝜑(𝑒4 )
𝑑1
𝑑2
Ecrivons le mot 𝑚 sous forme de vecteur 𝑀 = ( )
𝑑3
𝑑4
𝑝1
𝑝2
𝑑1
Ecrivons le message codé 𝑐 sous forme de vecteur 𝐶 = 𝑝3
𝑑2
𝑑3
(𝑑4 )
1 1 0 1
1 0 1 1 𝑑1
1 0 0 0 𝑑
𝐶 = 𝐺𝑀 = 0 1 1 1 ( 2 ) = 𝑑1 𝜑(𝑒1 ) + 𝑑2 𝜑(𝑒2 ) + 𝑑3 𝜑(𝑒3 ) + 𝑑4 𝜑(𝑒4 ) = 𝜑(𝑚)
𝑑3
0 1 0 0
𝑑4
0 0 1 0
(0 0 0 1)
Remarque : on pensera que l’application de ce produit fait apparaître des sommes dans l’espace
vectoriel considéré, soit par exemple 0001 + 0001 = 0000
Page 10 sur 15
Dernière mise à jour Informatique Denis DEFAUCHY
01/04/2021 Codes correcteurs d’erreurs Cours
[Link] Exemple
Soit l’envoie du mot : 𝑚 = 1101
• Graphiquement
𝟏 𝟏
𝟏
𝟎 𝟎 𝟎
𝑐 = 1010101
• Par le calcul, sans matrices
𝑝1 = (1 + 1 + 1)[2] = 1
𝑝2 = (1 + 0 + 1)[2] = 0
𝑝3 = (1 + 0 + 1)[2] = 0
𝑐 = 1010101
• Par le calcul matriciel
1 1 0 1 1+1+0+1 1
1 0 1 1 1+0+0+1 0
1
1 0 0 0 1+0+0+0 1
1
𝐶 = 𝐺𝑀 = 0 1 1 1 ( )= 0+1+0+1 = 0
0
0 1 0 0 0+1+0+0 1
1
0 0 1 0 0+0+0+0 0
(0 0 0 1) (0 + 0 + 0 + 1) (1)
𝑐 = 1010101
Page 11 sur 15
Dernière mise à jour Informatique Denis DEFAUCHY
01/04/2021 Codes correcteurs d’erreurs Cours
1.I.2.e Décodage et correction
Le message codé reçu dans le codage Hamming [7,4] est de la forme :
𝑐 = 𝑝1 𝑝2 𝑑1 𝑝3 𝑑2 𝑑3 𝑑4
Il est donc simple de récupérer le mot 𝑑1 𝑑2 𝑑3 𝑑4 . Il faut ensuite contrôler la présence d’erreurs.
1.I.2.e.i Détection de la présence d’une erreur
• Graphiquement
Il est très simple de détecter une erreur en réalisant le schéma vu précédemment :
𝒑𝟏
𝒅𝟏 𝒅𝟐
𝒅𝟒
𝒑𝟐 𝒅𝟑 𝒑𝟑
On pourrit vérifier la parité des trois sommes 𝑆𝑖 mais cela revient à vérifier les 3 bits de contrôle. Si
l’un au moins est faux, il y a une erreur.
• Par le calcul, sans matrices
On détermine les 3 sommes :
𝑆1 = 𝑝1 + 𝑑1 + 𝑑2 + 𝑑4
𝑆2 = 𝑝2 + 𝑑1 + 𝑑3 + 𝑑4
𝑆3 = 𝑝3 + 𝑑2 + 𝑑3 + 𝑑4
Si l’une de ces sommes est impaire, il y a une erreur.
Page 12 sur 15
Dernière mise à jour Informatique Denis DEFAUCHY
01/04/2021 Codes correcteurs d’erreurs Cours
• Par le calcul matriciel
𝑝1
𝑝2
𝑑1
Appelons 𝐶 le vecteur associé au message codé reçu : 𝐶 = 𝑝3
𝑑2
𝑑3
(𝑑4 )
Il est possible de calculer les 3 sommes 𝑆𝑖 de manière matricielle à l’aide de la matrice de contrôle
suivante :
0 0 0 1 1 1 1
𝐻 = (0 1 1 0 0 1 1)
1 0 1 0 1 0 1
𝑝1
𝑝2
𝑆3 0 0 0 1 1 1 1 𝑑1
𝑆 = (𝑆2 ) = 𝐻𝐶 = (0 1 1 0 0 1 1 ) 𝑝3
𝑆1 1 0 1 0 1 0 1 𝑑2
𝑑3
(𝑑4 )
Si l’une de ces sommes est impaire, il y a une erreur.
Page 13 sur 15
Dernière mise à jour Informatique Denis DEFAUCHY
01/04/2021 Codes correcteurs d’erreurs Cours
[Link] Correction des erreurs
Remarque : il n’est pas nécessaire de corriger les bits de contrôles 𝑝𝑖 pour avoir le mot 𝑑1 𝑑2 𝑑3 𝑑4
transmis
• Graphiquement
Il est très simple de corriger une erreur en réalisant le schéma vu précédemment :
𝒑𝟏
𝒅𝟏 𝒅𝟐
𝒅𝟒
𝒑𝟐 𝒅𝟑 𝒑𝟑
Il suffit de vérifier les 3 bits de contrôle et d’identifier si :
- Ils sont tous justes, il n’y a pas d’erreur
- Un seul est faux, c’est lui qui est erroné
- 2 sont faux, le bit 𝑑1 , 𝑑2 ou 𝑑3 qui est inclus dans les deux cercles accosiés aux 2 bits erronés
est faux
- 3 sont faux, c’est le bit 𝑑4 qui est faux
• Par le calcul, avec ou sans matrices
Lorsque l’on connaît les 3 sommes 𝑆𝑖 , il suffit de calculer :
𝑆3′ 𝑆3 [2] (𝑝3 + 𝑑2 + 𝑑3 + 𝑑4 )[2]
𝑆 = (𝑆2′ ) = (𝑆2 [2]) = ((𝑝2 + 𝑑1 + 𝑑3 + 𝑑4 )[2])
′
𝑆1′ 𝑆1 [2] (𝑝1 + 𝑑1 + 𝑑2 + 𝑑4 )[2]
Il suffit alors de déterminer l’indice du bit erroné 𝑖𝑛𝑑 = 𝑆3′ . 22 + 𝑆2′ . 2 + 𝑆1′ − 1 à l’aide du tableau
suivant :
Aucune
𝑝1 𝑝2 𝑑1 𝑝3 𝑑2 𝑑3 𝑑4
erreur
𝑆3′ 0 0 0 0 1 1 1 1
𝑆2′ 0 0 1 1 0 0 1 1
𝑆1′ 0 1 0 1 0 1 0 1
𝑖𝑛𝑑 RAS 0 1 2 3 4 5 6
Ainsi, si et seulement si une erreur existe (𝑆 ≥ 0), il suffira de corriger le bit associé à l’indice donné
par le vecteur 𝑆 ′ .
Page 14 sur 15
Dernière mise à jour Informatique Denis DEFAUCHY
01/04/2021 Codes correcteurs d’erreurs Cours
[Link] Exemple
Soit la réception du message suivant : 𝑐 = 1010100
• Graphiquement
On peut reconstruire l’image suivante :
𝟏 𝟏
𝟎
𝟎 𝟎 𝟎
Les 3 bits de parité sont faux. On peut immédiatement identifier une erreur sur le bit 𝑑4 , soit le
message corrigé suivant : 𝑐 = 1010101. Le mot transmis est donc : 𝑚 = 1101
• Par le calcul, sans matrices
On détermine les 3 sommes :
𝑆1 = 𝑝1 + 𝑑1 + 𝑑2 + 𝑑4 = 1 + 1 + 1 + 0 = 3
𝑆2 = 𝑝2 + 𝑑1 + 𝑑3 + 𝑑4 = 0 + 1 + 0 + 0 = 1
𝑆3 = 𝑝3 + 𝑑2 + 𝑑3 + 𝑑4 = 0 + 1 + 0 + 0 = 1
𝑆3′ 𝑆3 [2] 1[2] 1
′ ′ ′ [2]
Le vecteur 𝑆 associé est le suivant : 𝑆 = (𝑆2 ) = (𝑆2 ) = (1[2]) = (1). A l’aide du tableau de
𝑆1′ 𝑆1 [2] 3[2] 1
correction d’erreurs, on détermine une erreur sur 𝑑4 , soit : 𝑐 = 1010101 − 𝑚 = 1101
• Par le calcul matriciel
1
0
𝑆3 0 0 0 1 1 1 1 1 1
𝑆 = (𝑆2 ) = 𝐻𝐶 = (0 1 1 0 0 1 1) 0 = (1)
𝑆1 1 0 1 0 1 0 1 1 3
0
(0)
𝑆3′ 𝑆3 [2] 1[2] 1
′ ′
𝑆 = (𝑆2 ) = (𝑆2 [2]) = (1[2]) = (1)
𝑆1′ 𝑆1 [2] 3[2] 1
Page 15 sur 15
