F - Ensiwiki

Plan du cours
• 
• 
• 
• 
Introduction : Notion de code
Définition, distance, effacements et erreurs
Code de Hamming
Codes détecteurs d erreur
–  LFSR et polynômes.
Corps de Galois.
–  Codes CRC
–  Propriétés. Applications
•  Codes correcteurs : Code linéaire, Reed Solomon
–  Codes cycliques et Reed-Solomon
•  Autres codes et applications
–  Rafales d erreurs. Code CIRC.
55
Exemple: contrôle de parité dans TCP
7
Application
(HTTP,FTP, DNS)
4
Transport
(TCP, UDP)
3
Network
(IP)
2
1
TCP Packet Format
Data Link
(Ethernet, 802.11b)
Physical
•  TCP Checksum :bits de contrôle, calculés par l’émetteur à
partir de l’en-tête et des données, et vérifiés lors de la réception.
Exemple: Ethernet CRC-32
56
Linear Feedback Shift Registers (LFSRs)
•  LFSR : circuit élémentaire à base de registres à décalage et quelques xor.
•  Exemple 4-bit LFSR :
Q4
Q D
Q3
Q D
Q2
Q D
Q1
Q D
CLK
•  Avantages:
–  Hardware très simple => opération rapide
–  Rapide (débit élevé) : en général, nombre faible de xors ( 2 !)
•  Applications:
–  chiffrement (pas seuls ! avec des NLFSRs, des Sbox etc )
–  générateurs pseudo-aléatoires (non cryptographique), compteurs, arithmétique corps fini
–  détection et correction d’erreurs
57
4-bit LFSR binaire
Q4
Q D
Q3
Q D
Q2
CLK
•  Etat = valeur des registres [Q4,Q3,Q2,Q1]
•  Etat à t+1 = “Left-shift circulaire” état à t
suivi de xor avec bit le plus à gauche
•  Exemple:
Q D
Q1
0
xor 0
0
xor
–  Q4(t+1) = Q3(t)
Q3(t+1) = Q2(t)
Q2(t+1) = Q1(t) + Q4(t)
Q1(t+1) = Q4(t)
0
0
0
0
0
xor
0
0
0
0
0
0
0
xor
•  En général, avec n bascules, cycle sur 2n-1 valeurs
Q4 Q3 Q2 Q1
différentes non nulles :
–  Exemple: 15 valeurs (NB 0000 est absorbant)
–  générateur pseudo-aléatoire avec une longue période.
1
0
1
0
1
0
1
1
0
xor
0
0
0
0
0
0
0
0
0
0
0
xor
Q D
0
0
0
0
0
0
0
0
0
0
0
xor
0
0
0
1
1
0
1
0
1
1
0
0
1
1
0
1
0
1
0
1
0
0
0
0
0
0
0
0
0
0 0
1 1
1 1
0001
0010
0100
1000
0011
0110
1100
1011
0101
1010
0111
1110
1111
1101
1001
0001
58
4 bit LFSR binaire
•  Exercice: quel est le polynôme de rétroaction ?
Q4
Q D
Q3
Q D
Q2
Q D
Q1
Q D
CLK
59
Généralisation: LFSR (dans un corps)
g0
g1
R0
gr-1
R1
Rr-1
•  Valeurs des registres du LFSR :
•  à t
: [Rr-1, Rr-2, … R0]
•  à t+1 : [R r-1, R r-2, … R 0] avec R i = Ri-1 + gi.Rr-1
•  Polynôme générateur: g(X) = Xr – gr-1Xr-1 - … - g0X0.
•  Notation: K[X] = ensemble des polynômes à coefficients dans K
60
Généralisation: LFSR avec opérations dans K.
Lien avec polynôme dans K[X]
g0
g1
R0
vin
gr-1
R1
Rr-1
•  Valeurs des registres du LFSR :
•  à t : [R0, R1, … Rr-1]
•  à t+1 : [R 0, R 1,…R r-1]
avec R i = Ri-1 + gi.Rr-1
•  Polynôme caractéristique :
•  g(X) = Xr – gr-1Xr-1 - … - g0X0.
•  Valeurs des registres du LFSR, vues comme un polynôme :
•  à t : [R0, R1, … Rr-1] : Pt(X) = Rr-1.Xr-1+ Rr-2.Xr-2 + …+ R0.X0
•  à t+1: [R 0, R 1,… R r-1] :
Pt+1(X) = R r-1.Xr-1+ R r-2.Xr-2 + …+ R 0.X0
= (Rr-2 + gr-1.Rn-1)Xr-1+…+ (Ri-1 + gi.Rn-1)Xi+…+(vin+ g0.Rn-1)X0
= X.Pt(X) - Rn-1.g(X) + vin.X0
= [ X.Pt(X) mod g(X) ] + vin.X0
•  Si K=corps : Reste division euclidienne polynômiale par g(X) dans K[X] 61
Plan du cours
• 
• 
• 
• 
Introduction : Notion de code
Définition, distance, effacements et erreurs
Code de Hamming
Codes détecteurs d erreur
– 
– 
– 
– 
LFSR et polynômes.
Corps de Galois.
Codes CRC
Propriétés. Applications
•  Codes correcteurs : Code linéaire, Reed Solomon
–  Codes cycliques et Reed-Solomon
•  Autres codes et applications
–  Rafales d erreurs. Code CIRC.
62
Corps de Galois et Opérations + et . d’un LFSR
•  Un corps (K, +, x, “0”, “1”) est défini par:
–  deux opérations internes :
•  + “addition” et x “multiplication”
–  associatives et distributivité
–  Éléments neutres: “0” pour +, “1” pour x.
–  Chaque élément u a un opposé pour + : -u
u-u=“0”
–  Chaque élément u non nul a un inverse pour x : u-1
u x u-1=“1”
•  Les corps finis sont appelés “corps de Galois”.
•  Exemple de corps:
– 
– 
– 
– 
Q = ensemble des rationnels
R = ensemble des réels
Z/pZ avec p premier
C = R[i]/i2+1
•  Exemples de corps finis:
–  GF(p) = Z/pZ (p premier)
–  GF(2) = ({F,T}, xor, and, F, T )
–  GF(256) = corps des “octets”
•  Il existe un unique corps fini avec q éléments ssi
q = pm avec p premier et m≥1,
noté GF(q) ou Fq.
•  GF( pm ) est isomorphe à GF(p)/g(X) avec g(x) polynôme primitif de GF(p)[X]
•  Addition = vectorielle coef à coef
•  Multiplication = LFSR(g)
•  Exemple GF(256) : + = xor bit à bit ; x = LFSR(X8 + X4 + X3 + X1 + X0)
63
Corps finis
•  Propriétés élémentaires
64
Corps finis – Propriétés élémentaires (1/3)
•  Notation: F[X] = anneau des polynômes à 1 variable et à coefficients dans
le corps F.
Un polynome est dit unitaire ssi son coefficient de tête est 1.
•  Définition: Soit Q(X) F[X];
Q est irréductible ssi Q(X)=A(X).B(X) avec A(X) et B(X) dans F[X]
implique degré(A)=0 ou degré(B)=0.
•  Théorème: F[X] est factoriel (i.e. tout polynôme unitaire de F[X] s’écrit de manière
unique comme produit de polynômes unitaires irréductibles)
•  Théorème (fondamental de l’algèbre): soit Q(X)
alors Q(X) admet au plus d racines dans F.
F[X] de degré d;
65
Corps finis – Propriétés élémentaires (2/3)
•  Pour tout entier premier p, l’ensemble des entiers mod p est un corps noté
Fp :
Fp = ( {0, 1, …, p-1}, +mod p , *mod p , 0, 1)
•  Théorème: Soit h(X) un polynôme irrédictible de degré m :
l’anneau quotient F[X]/(h(X)) est un corps fini avec |F|p éléments.
F[X]/(h(X)) = ( { Σi=0m-1 aiXi ; ai F }, +mod h(X), *mod h(X), 0.X0, 1.X0)
Remarque: similaire à Fp = Z/(p)
•  Le corps F[X]/(h(X)) est une extension du corps F de degré m.
C’est aussi un espace vectoriel de dimension m sur F.
66
Corps finis – Propriétés élémentaires (3/3)
•  Théorème: Tout corps fini est de cardinal q=pm et est isomorphe à
Fp si m=1; Fp[X]/(h(X)) sinon, avec h F[X] irrédcutible de degré m.
Réciproquement: Pour tout q=pm, il existe (à un isomorphisme près) un
unique corps de cardinal q, noté Fq.
•  Théorème: Fq* = ( {x Fq; x≠0}, * ) est un groupe cyclique.
Un générateur γ de Fq* est appelé élément primitif :
Fq* = { 1, γ, γ2, …, γq-2 }.
•  Théorème: Il y a ϕ(q-1) éléments primitifs.
  ϕ(q-1) = Card{ i entier; 1≤i< q-1 et i premier avec q-1} [indicatrice d’Euler].
67
Exemple : GF(16) avec LFSR (X4+X+1)
α0 =
1
1
α =
x
2
2
α =
x
α3 = x3
α4 =
x +1
5
2
α =
x +x
6
3
α = x + x2
α7 = x3
+x +1
8
2
α =
x
+1
9
3
α =x
+x
10
2
α =
x +x +1
α11 = x3 + x2 + x
α12 = x3 + x2 + x + 1
α13 = x3 + x2
+1
14
3
α =x
+1
α15 =
1
•  X4 + X + 1 est un polynôme primitif.
.
α4 = x4 mod x4 + x + 1
= x4 xor x4 + x + 1
=x+1
Q4
Q D
Q3
Q D
Q2
Q D
Q1
Q D
CLK
68
Table de polynômes primitifs
x12 + x6 + x4 + x +1
x22 + x +1
13
4
3
x + x + x + x +1
x23 + x5 +1
x14 + x10 + x6 + x +1
x24 + x7 + x2 + x +1
15
x + x +1
x25 + x3 +1
16
12
3
x + x + x + x +1
x26 + x6 + x2 + x +1
x17 + x3 + 1
x27 + x5 + x2 + x +1
18
7
x +x +1
x28 + x3 + 1
19
5
2
x + x + x + x+ 1
x29 + x +1
x20 + x3 + 1
x30 + x6 + x4 + x +1
21
2
x +x +1
x31 + x3 + 1
Galois Field
Hardware
x32 + x7 + x6 + x2 +1
Multiplication by x
⇔ shift left
Taking the result mod p(x) ⇔
XOR-ing with the coefficients of p(x)
when the most significant coefficient is 1.
n
Obtaining all 2 -1 non-zero ⇔
Shifting and XOR-ing 2n-1 times.
elements by evaluating xk
for k = 1, …, 2n-1
x2 + x +1
x3 + x +1
x4 + x +1
x5 + x2 +1
x6 + x +1
x7 + x3 +1
x8 + x4 + x3 + x2 +1
x9 + x4 +1
x10 + x3 +1
x11 + x2 +1
69
Construction LFSR en configuration Galois à
partir d’un polynôme primitif
• 
• 
• 
• 
Pour un LFSR à k-bit, numéroter les registres-bascules avec Q1 à droite.
Le feedback vient du registre le plus à gauche (Qk).
Choisir un polynôme primitif de la forme xk + … + 1.
Chaque monôme de la forme 1.xi correspond à un xor entre Qi et Qi+1.
•  Exemple 4-bit: utiliser x4 + x + 1
– 
– 
– 
x4 ⇔ sortie de Q4
x ⇔ xor entre Q1 et Q2
1 ⇔ entrée de Q1
Q4
Q D
Q3
Q D
Q2
Q D
Q1
Q D
CLK
•  Pour un LFSR 8-bit, utiliser le polynôme primitif x8 + x4 + x3 + x2 + 1
and mettre des xors entre Q2 et Q3, Q3 et Q4, Q4 et Q5
Q8
Q D
Q7
Q D
Q6
Q D
Q5
Q D
Q4
Q D
Q3
Q D
Q2
Q D
Q1
Q D
CLK
70
Plan du cours
• 
• 
• 
• 
Introduction : Notion de code
Définition, distance, effacements et erreurs
Code de Hamming
Codes détecteurs d erreur
– 
– 
– 
– 
LFSR et polynômes.
Corps de Galois.
Codes CRC
Propriétés. Applications
•  Codes correcteurs : Code linéaire, Reed Solomon
–  Codes cycliques et Reed-Solomon
•  Autres codes et applications
–  Rafales d erreurs. Code CIRC.
71
Exemple: contrôle de parité dans TCP
7
Application
(HTTP,FTP, DNS)
4
Transport
(TCP, UDP)
3
Network
(IP)
2
1
TCP Packet Format
Data Link
(Ethernet, 802.11b)
Physical
•  TCP Checksum :bits de contrôle, calculés par l’émetteur à
partir de l’en-tête et des données, et vérifiés lors de la réception.
Exemple: Ethernet CRC-32
72
Codes réseaux informatiques : codes CRC (1)
•  CRC : cyclic redundancy check avec r bits de redondance
Polynome générateur g(X) = xr + Σi=0..r-1 gi.xi de degré r sur F2
•  Mots de code : les multiples de g(X)
–  Source: m=k bits ! m(x) polynome de degré k-1
•  Exemple: m=01101 m(x) = x+x2+x4
–  Codage: c = m.xr - (m.xr mod g) = m.xr + (m.xr mod g)
•  On a c multiple de g
•  Redondance r bits
(gr= 1)
-m.xr mod g
m
r bits
m= Bloc message source (k bits)
•  Décodage : détection d erreurs
–  Réception de y et vérification que y(x) mod g(x) = 0 !
73
Codeur et décodeur CRC par LFSR
Codeur
CRC
f0
mk-1… m1 m0
Décodeur
CRC
f1
R0
f0
fr-1
R1
f1
Rr-1
fr-1
mk-1… m1 m0
R0
R1
Rr-1
A0
A1
Ar-1
erreur détectée
bits source
74
Exemple: Ethernet CRC-32
•  CRC-32: G(x) = x32 + x26 + x23 + x22 + x16 + x12 + x11 +
x10 + x8 + x7 + x5 + x4 + x2 + x + 1
–  Utilisé dans ethernet
–  Initialisation des registres du LFSR à 1 (Il y a 32 bits à 1 ajouté
en tête de message)
•  Exercice:
–  Expliciter le circuit (ou l’algorithme) de codage et de décodage
75
Exemples de CRC standards
Exercice: construire le circuit de codage et décodage pour CRC-16 X25-CCITT
76
Construction de codes CRC :
propriétés pour le choix du polynôme.
•  Propriétés: un code CRC binaire détecte :
–  si g0 = 1, détecte les erreurs de poids 1
–  si g(x) a un facteur avec au moins 3 termes: détecte les erreurs de poids 2.
–  si g a (x+1) comme facteur: détecte un nombre impair d erreurs
–  Si g(X)=p(x).q(x) avec p polynome primitif de degré d
•  Détecte toute erreur sur 2 bits distants d au plus 2d-1 bits consécutifs
•  Souvent, on choisit g(x)=(X+1).p(X) avec p primitif : détecte
–  tout paquet de taille inférieure à deg(g)
–  1, 2 ou 3 erreurs isolées (si n < 2r pour détecter 2 erreurs)
•  Question: quelles propriétés sont vraies si V = GF(q) ?
77
Exercice
•  CRC-16: G(x) = x16 + x12 + x5 + 1 = (X+1)(X15 + … )
•  Donner le circuit de codage et décodage
•  Caractériser des erreurs détectées.
78
Plan du cours
• 
• 
• 
• 
Introduction : Notion de code
Définition, distance, effacements et erreurs
Code de Hamming
Codes détecteurs d erreur
–  LFRS, Codes CRC
–  Propriétés. Applications
•  Codes correcteurs
–  Codes linéaires, Hamming
–  Codes cycliques et Reed-Solomon (interpolation)
•  Autres codes et applications
–  Rafales d erreurs. Code CIRC.
79
Codes par blocs
×
×
×
×
×
×
×
80
Codes par blocs
×
×
×
Mot reçu *
×
×
×
×
81
Parité longitudinale et transversale
a00
a01
a02
a03
a04
a05
a06
P0
a10
a11
a12
a13
a14
a15
a16
P1
a20
a21
a22
a23
a24
a25
a26
P3
C0
C1
C2
C3
C4
C5
C6
N
1. 
2. 
3. 
4. 
Mots sur 3*7 = 21 bits
Parité par ligne : Pi
Parité par colonne : Cj
Parité globale : N
•  Détecte 2 ou tout nombre impair d erreurs
•  Corrige 1 erreur
–  Un des aij est faux : le recalcul de Pi et Cj donne l emplacement ij
–  Pi, Cj et N sont recalculés
•  Détecte si il y a 2 erreurs, mais ne permet pas de corriger
Rendement
•  Nombre de bits de message / Nombre de bits transmis
–  Parité : Rendement = 7/8 = 87.5 %
–  Parité long. & transv. : Rendement = 21/32 ≈ 65 %
82
III. Codes linéaires
•  Hypothèse sur V = vocabulaire source : corps
•  Code linéaire - caractérisation
•  Codage et décodage d un code linéaire
83
Généralisation : Code linéaire
•  Code correcteur (n,k): [x0,…,xk-1] " f([x0,…,xk-1])=[y0,…,yn-1]
•  f : fonction d un ensemble Vk vers un ensemble Vn
# Idée : si f est linéaire, alors les opérations de codage/décodage se font
en temps linéaire/taille de message
⇒ Rapide (proportionnel à la taille du message)
⇒ Il faut : Vk, Vn espaces vectoriels donc V un corps
$ Opérations modulo 2 (ex: parité) : V = Z/2Z est un corps !
$ On travaille en général avec V à 2, 28 ou 2256 éléments
⇒ Alors f linéaire correspond à une matrice G (génératrice) et f(m)=m G :
!%y0
y1  yn-1 "& = !%x 0
! g0;0
#
 xk-1 "& # 
#g
% k-1;0
g0;1




gk-1;1
g0;n-1 "
$
 $
gk-1;n-1 $&
84
Exemple : la parité
!%x 0
x1
x 2 (x 0 + x 1 + x 2mod2 )"& = !%x 0
x1
!1 0 0 1 "
x 2 "& ##0 1 0 1 $$
#%0 0 1 1 $&
Temps de calcul
$  Pour tout code linéaire C(n,k), il existe une matrice normalisée G
= [ Ik | T ] qui engendre le même code
⇒ 
1. 
2. 
3. 
4. 
[y0,y1,…,yn-1] = [x0,x1,…,xk-1,bk,…,bn-1]
Codage : y = x G (temps quadratique)
Décodage : x = premiers bits de y (immédiat)
Détection : Si H=[Tt|-In-k], alors z erroné ssi Hz ≠ 0 !!! (quadratique)
Correction : table précalculée des e de poids min. tels que He=Hz≠0 % y=z-e
est le mot correct le plus proche de z (temps constant)
85
Hypothèse sur le vocabulaire V du canal
•  V est muni d une structure de corps fini :
soient a,b ∈ V : e0, e1, a+b, -a, a*b, a/b ∈ V
•  Possible ssi |V| = pm avec p premier
Soit q = pm : V est alors isomorphe à GFq
–  Exemple: V= {0,1} ; V={mots de 32 bits}
•  Implantation
–  GFq isomorphe à (Z/pZ[x])/Q(x) avec Q polynôme irréductible de degré
m à coefficients dans Z/pZ
–  NB avec p= 2: facile à implanter avec des registres à décalage !
86
Code linéaire
•  V corps => Vn est un espace vectoriel
•  Définition : code linéaire ! sev de Vn de dim k
–  Si x=[x0, …, x n-1] ∈C, y=[y0, …, y n-1] ∈C
=> x+y =[x0+y0,…, x n-1+y n-1] ∈C
•  C est engendré par une matrice génératrice G
k lignes
•  C=Im(G)
G=
n colonnes
87
Exemple 1
•  V = {a=00, b=01, c=10, d=11}
•  Code (6,4) engendré par G
G=
01 10 11 10 11 00
10 11 10 00 01 10
10 01 11 10 11 10
01 10 11 11 10 01
88
Exemple 2: code de Hamming (7,4)
•  C est aussi un code linéaire sur V = {0,1}
1 1 1 0 0 0 0
engendré par G =
1 0 0 1 1 0 0
0 1 0 1 0 1 0
1 1 0 1 0 0 1
•  Remarque: il est équivalent aux codes de matrices génératrices
G =L.G.P avec L inversible et P permutation. Par exemple:
G’=
1
0
0
0
1
1
0
0
1
0
0
1
0
1
0
0
1
0
0
1
1
0
0
0
1
1
1
1
G’’=
1
0
1
0
1
0
0
0
1
0
0
1
0
1
0
0
1
0
0
1
1
0
0
0
1
1
1
1
89
Distance d un code linéaire
•  d = Min { dH( x , y) ; ∀ x,y ∈ C }
= Min { wH(x - y) ; ∀ x,y ∈ C }
= Min { wH( z ) ; ∀ z ∈ C }
•  Borne de Singleton : d ≤ n-k+1 = r+1
•  On peut donc corriger :
–  jusqu à (d-1)/2 erreurs quelconques
–  Jusqu à (d-1) erreurs localisées (effacements)
•  Code MDS:
–  distance maximale: atteint la borne de Singleton: d = r+1
90
Décodage d un code linéaire
•  Un code linéaire est équivalent à un code de matrice
génératrice G = [Idk | A ]
•  code( [s0, …, sk-1] ) = s.G =[c0,…, ck-1 , ck…, cn-1] où:
[c0…, ck-1] = [s0, …, sk-1]
et
[ck…, cn-1] = [s0, …, sk-1].A = [c0, …, ck-1].A
Intérêt: coût de codage : calcul de c=s.G => O(k.r) opérations
•  De plus: [ck…, cn-1].Idn-k - [c0, …, ck-1].A = [0]n-k
•  Soit (en transposant)
[-At | Idn-k ] . ct = 0, i.e. H .ct = 0
On a aussi: H.Gt = 0
•  Rem: d = nbre minimal de cols indép. de H
H = Matrice de contrôle de
dimension (n-k, n)
91
Détection d erreurs
•  On émet x et on reçoit y;
y est un mot de code !H.yt = 0
•  Syndrome d erreur : s = H .yt
s ≠ 0 => il y eu erreur de transmission
•  Exemple: matrice de contrôle du code de Hamming.
92
Correction d erreurs
• 
x = [x1 .. xn] émis ; y = [y1.. yn] reçu
•  Corriger y !trouver x tq x=y- e appartient au code avec e = vecteur de
correction (=erreur) de poids minimum
•  Or: s = H .yt = H.xt + H.et = H.et
Le syndrome donne toute l information pour corriger :
e = vecteur d erreur de poids minimal tel que H.et = s
•  Deux méthodes possibles :
–  Localisation des erreurs puis résolution du système linéaire H.et = s
–  Par tabulation de la correction e associé à chaque syndrome possible
•  on stocke dans un tableau Cor[s] := e pour chaque syndrome s
•  Ex: V= {0,1}, n=64 k=52 :
On peut recevoir un mot parmi 264 mots possibles, dont 264 - 252 mots erronés
mais seulement 212=4096 syndromes possibles !
donc table des corrections de taille 4096
93
Bons codes
•  Facile et efficace à implémenter
–  Codage et décodage (détection/correction) peu coûteux
–  logiciel et/ou matériel
•  Etant donné un taux de correction « t/n » donné,
pouvoir facilement construire un code (n,k,d) qui permet ce
taux de correction
•  Exemples:
–  codes de Hamming
–  Codes de Reed-Solomon (cas particulier de codes cycliques)
–  beaucoup utilisés (applications, turbo-codes, décodage en liste, …)
94
Code de Hamming
•  Définition / Théorème de caractérisation :
–  Les codes de Hamming sont 1-correcteurs et 1-parfaits
–  Tout code binaire linéaire 1-correcteur parfait est un code de Hamming.
95
Exemple: Code de Hamming
96
Code binaire 1-correcteur
•  Code binaire de longueur n:
–  Si il y a 0 ou 1 erreur de bits => n+1 possibilités
•  Au moins r = log2 (n+1) bits pour coder une erreur possible
•  Code de Hamming: code (2r-1, k=2r-r-1, d=3)
c1… cn défini par :
–  Si i ≠ 2j alors ci est un bit de source
–  Si i = 2j alors ci est un bit de contrôle de parité = somme des ck tel que k
écrit en binaire a un 1 en position j
–  Exemple code de Hamming (7,4)
•  Détection: si au moins un des bits de parité est erroné
•  Correction: on change le bit d’indice la somme des indices des bits
de parité erronés
97
Code de Hamming
•  Code 1-correcteur à nombre de bits ajoutés minimal, δ = 3
# Idée : ajouter un contrôle de parité pour chaque puissance de 2
% b1, b2, b4, b8, b16, etc.
⇒ Cela suffit pour localiser l erreur !
⇒ C(n, n--log2(n).-1 ) " rendement ≈ 1-log2(n)/n
b1 b2
!%x 0
x1
x2
!1
#1
x 3 "& #
#0
#
%1
1
0
1
1
b4
1
0
0
0
0
1
1
1
0
1
0
0
0
0
1
0
0"
0 $$
0$
$
1&
⇒  rendements :
&  4/7 ≈ 57 %
& 11/15 ≈ 73 %
& 26/31 ≈ 84 %
98
…
Code de Hamming
•  Théorème:
–  Les codes de Hamming C(n, n--log2(n).-1 ) sont de distance 3 :
•  1-correcteurs
•  Tout mot reçu est corrigé avec 0 ou 1 erreur (code 1-parfait)
–  Tout code binaire linéaire 1-correcteur parfait est un code de Hamming.
•  Code de Hamming étendu C (n+1, n--log2(n).-1 )
–  Ajout d’un bit de parité = xor des n bits
–  Distance 4 (exercice) donc corrige 1 erreur et 1 effacement.
•  Rem.: code binaire étendu : obtenu par ajout d’un bit de parité:
C’ = {c1… cn cn+1 tq c1… cn ∈ C et c1+ …+ cn+1 =0 }
Propriété: Si d est impaire, alors C’ est de distance d’=d+1.
99
• 
Application: Code du minitel
•  Faible taux d erreur, mais paquets longs :
–  Code de Hamming + detection paquets
•  Source = suite de paquets de 15 octets = 120 bits
•  Auquel on ajoute 2 octets de redondance :
–  7 bits de redondance du code de Hamming (127,120,3)
–  1 bit de parité pour les 7 bits de contrôle (code étendu)
–  1 octet nul (ie 0x00)
•  Si erreur détectée ARQ (Automatic Repeat ReQuest)
•  Questions:
– 
– 
– 
– 
Quelles
Quelles
Quelles
Donner
sont les caractéristiques de ce codage et le rendement?
erreurs le code détecte-t-il ?
erreurs le code corrige-t-il ?
l’algorithme de codage et de décodage (envoyant le signal ARQ si nécessaire)
100
Exercice
•  Expliciter le code de Hamming de longueur 15,
le codage et le décodage.
101