2 CC

Mathématiques des codes correcteurs d’erreurs
A. A. Pantchichkine∗
Institut Fourier, B.P.74, 38402 St.–Martin d’Hères, FRANCE

e-mail : panchish@mozart.ujf-grenoble.fr, FAX : 33 (0) 4 76 51 44 78
Résumé
L’objectif du présent cours n’est pas de proposer un exposé exhaustif de la théorie des codes
correcteurs d’erreurs. Tout d’abord parce que la tâche est bien trop complexe, ensuite car la jeunesse
de la théorie et son important développement actuel la rendent en perpétuel mouvement. Le but est
ici d’introduire les concepts, principes et méthodes de base de l’étude des codes correcteurs d’erreurs,
ainsi que de faire entrevoir certaines pistes permettant l’élaboration de codes performants.
La théorie des codes correcteurs d’erreurs se base pour l’essentiel sur l’étude des corps finis,
certains rappels concernant ces derniers sont donnés dans Annexe A.
On donnera les définitions des principaux objets et grandeurs liés aux codes correcteurs d’erreurs.
Les parties suivantes présenteront des classes de codes particulières, leurs propriétés et des procédures
de décodage.
Ce cours introduit les outils utilisés pour assurer la transmission d’informations correctes sur
des supports introduisant des erreurs. Les fondements mathématiques permettant la construction
de codes avec un rendement garanti sont présentés, en particulier les codes cycliques et les codes
géométriques de Goppa. Les applications dans l’industrie concernent le disque compact, le Minitel,
la transmission d’images par satellite, sont mentionnées.
∗ Un cours dans le cadre du DESS "Cryptologie, Sécurité et Codage d’Information" (Institut Fourier), 2003-2004, Module
C1A, préparé avec la participation de J.-B.Werner
1
Table des matières
1. Transmission d’information, codage et decodage optimal 6
1.1. Principe de transmission d’information . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
1.2. Hypothèses sur un canal bruité . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
1.3. Généralités sur les codes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
1.4. Codage et decodage optimal sur un canal bruité . . . . . . . . . . . . . . . . . . . . . . . 8
1.5. Théorème de Shannon (1948) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
2. Distance de Hamming, rendement et vitesse de transmission 11

2.1. Capacité de correction et rayon de recouvrement . . . . . . . . . . . . . . . . . . . . . . . 11
2.2. Borne de Hamming et borne de Singleton . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
2.3. Bonnes familles des codes et problèmes asymptotiques. . . . . . . . . . . . . . . . . . . . . 12
2.4. Borne de Hamming et borne de Singleton asymptotiques . . . . . . . . . . . . . . . . . . . 13
3. Codes linéaires et codes cycliques. Matrice génératrice et syndrome 18

3.1. Codes linéaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
3.2. Détection et correction d’erreurs, décodage . . . . . . . . . . . . . . . . . . . . . . . . . . 19
3.3. Classe des codes de Hamming . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
3.4. Codes cycliques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
3.5. Constructions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
3.5.1. Construction par polynôme générateur . . . . . . . . . . . . . . . . . . . . . . . . . 23
3.5.2. Construction par polynôme correcteur . . . . . . . . . . . . . . . . . . . . . . . . . 24
4. Polynômes locateurs d’erreurs. Application au décodage 27

4.1. Construction de codes cycliques à partir des racines. . . . . . . . . . . . . . . . . . . . . . 27
4.2. Exemples : codes de Golay . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
4.2.1. Code G23 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
4.2.2. Code G24 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
4.2.3. Code G11 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
4.2.4. Code G12 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
4.3. Polynômes locateurs d’erreurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
4.4. Décodage des codes cycliques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
4.4.1. Exemples de decodage des codes cycliques . . . . . . . . . . . . . . . . . . . . . . 41
5. Codes BCH et codes de Reed-Solomon. Codage et décodage 44

5.1. Classe des codes BCH (Bose, Ray-Chaudhuri et Hocquenghem) . . . . . . . . . . . . . . . 44
5.2. Codes de Reed-Solomon . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
5.3. Deuxième déscription des codes de Reed-Solomon . . . . . . . . . . . . . . . . . . . . . . . 48
5.4. Problèmes de décodage. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
5.4.1. Décodage BCH . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
5.5. Algorithme de Berlekamp-Massey . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
6. Bornes de Plotkin et de Gilbert-Varshamov 56

6.1. Rendement, taux de correction et domaine de codes . . . . . . . . . . . . . . . . . . . . . 56
6.2. Borne de Plotkin . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58
6.3. Borne de Gilbert-Varshamov . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62
6.4. Borne de la géométrie algébrique (sans démonstration) . . . . . . . . . . . . . . . . . . . . 64
2
7. Codes géométriques de Goppa. Systèmes affines et courbes algébriques 67
7.1. Systèmes affines et systèmes projectifs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67
7.1.1. Systèmes affines. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67
7.1.2. Systèmes projectifs. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68
7.2. Codes géométriques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69
7.3. Codes de Goppa rationnels . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70
7.3.1. Construction des bonnes familles . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72
7.4. Décodage des codes de Goppa rationnels . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74
7.5. Codes provenants des courbes algébriques : P-construction . . . . . . . . . . . . . . . . . . 75
7.5.1. P-construction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75
7.5.2. Borne de la géométrie algébrique . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76
7.6. Espace projectif Pn , variétés algébriques . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77
7.7. Diviseurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78
7.8. Courbes sur les corps finis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79
7.9. Théorème de Riemann-Roch, genre . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79
7.10. Codes géométriques de Goppa : L-construction. . . . . . . . . . . . . . . . . . . . . . . . . 79
7.11. Codes géométriques de Goppa : Ω-construction. . . . . . . . . . . . . . . . . . . . . . . . . 83
8. Exercices de préparation à l’exemen 85

8.1. Estimation des sommes binomiales. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85
8.2. Encadrement de la probabilité du decodage erroné. . . . . . . . . . . . . . . . . . . . . . 85
8.3. Codes de Golay et empilement de sphères. . . . . . . . . . . . . . . . . . . . . . . . . . . 85
8.4. Déscription géométrique des codes de Reed-Solomon . . . . . . . . . . . . . . . . . . . . . 85
8.5. Codes de Reed-Muller d’ordre 1. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86
8.6. Exemples de decodage des codes cycliques. . . . . . . . . . . . . . . . . . . . . . . . . . . 87
8.7. Codes de Reed-Solomon . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89
8.8. Décodage des codes de Goppa rationnels. . . . . . . . . . . . . . . . . . . . . . . . . . . . 89
8.9. Codes de Hermite. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90
A Annexe : Rappels sur les corps finis 92

A1. Structure . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92
A2. Polynômes sur les corps finis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92
B Annexe : Restes chinois, suite : Factorisation des Polynômes (F. Sergeraert) 94

B1. Rappels sur les corps finis. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94
B2. Bases de la méthode de Berlekamp. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96
B3. Trouver les facteurs irréductibles. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99
B4. Factorisation des polynômes à coefficients entiers. . . . . . . . . . . . . . . . . . . . . . . . 104
B5. Lemme de Hensel. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107
C Annexe : Bornes sur codes 114
D Annexe : Codes cycliques. Codes de Golay 131

D1. Exemple de correction de deux erreurs par un code cyclique . . . . . . . . . . . . . . . . . 131
D2. Codes de Golay . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132
E Annexe : Points des courbes algébriques sur les corps finis 142
F Annexe : Systèmes linéaires dans GF(pd )(F. Sergeraert) 152
3
Introduction
Ce cours introduit les outils utilisés pour assurer la transmission d’informations correctes sur des
supports introduisant des erreurs. Dans une première partie, les fondements mathématiques permettant
la construction de codes avec un rendement garanti sont présentés, en particulier les codes cycliques.
Dans les applications pratiques, notamment en informatique et télécommunications, des variantes de ces
codes sont utilisées, qui sont présentées dans la deuxième partie du cours.
Les applications des codes correcteurs d’erreurs dans l’industrie concernent le disque compact, le
Minitel, la transmission d’images par satellite, . . . (voir Chapitre XV de [Pa-Wo]).
Bases mathématiques :
1. Transmission d’information, codage et decodage optimal sur un canal bruité. Codes de répétition pure.
2. Distance de Hamming, rendement et vitesse de transmission, distance relative, borne de Hamming.
Codes de Hamming.
3. Codes linéaires et codes cycliques. Matrice génératrice et calcul du syndrome d’erreur.
4. Polynômes locateurs d’erreurs. Application au décodage.
5. Codes de Reed-Solomon et codes BCH. Codage et décodage.
6. Bornes de Plotkin et de Gilbert-Varshamov.
7. Codes géométriques de Goppa et courbes algebriques sur les corps finis.
A l’ère de l’information, un défi important à relever est celui de faire voyager celle-ci dans de bonnes
conditions, c’est à dire de faire en sorte que le transport de l’information n’en altère pas le contenu. Aucun
canal de transmission n’étant parfait, il va donc falloir «protéger» l’information pour qu’elle demeure
exploitable. Les outils pour y parvenir sont les codes correcteurs d’erreurs, théorie récente de par la
modernité de ses motivations.
Pour montrer de quoi il s’agit on commence par un exemple de réalisation effective d’une procedure
de codage correcteur d’erreur, voir [Pa-Wo], Chapitre X. Le 19.01.1972 la sonde spatiale "MARINER-9"
transmettait une photo du "Grand canyon" de la planète Mars. La très grande qualité de cette photo avait
été obtenue en protégeant la transmission contre les erreurs énentuelles au moyen du "Code correcteur
de Reed-Muller d’ordre 1 et de longueur 32".
On "discrétise" le problème : la photo est découpée en petits rectangles chacun d’entre eux étant
assimilé à un point muni d’un "niveau d’énergie". Il existe en tout 64 niveaux d’énergie, on a donc besoin
de 64 messages à transmettre, chacun représenté par une succession de 6 "bits" (symboles 0 et 1). Pour
pouvoir corriger les erreurs de transmission on represente chaque message par une suite de 32 bits :
u = (α1 , α2 , α3 , α4 , α5 , α6 ),
4
toutes les combinaisons linéaires mod 2 des lignes Ai de la matrice
 
α1 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
α2 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
 
α3 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1

0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1
 (∗)
α4  
α5 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1
α6 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1
E
F62 3 u = (α1 , α2 , α3 , α4 , α5 , α6 )7→E(u) := A1 α1 + A2 α2 + A3 α3 + A4 α4 + A5 α5 + A6 α6 ∈ F32
2
Cette transmission a la redondance = 32-6=26, le coefficient de redondance= 32/6.

Pour décrire les mots du code C = Im(E), on indexe les colonnes A(j) de la matrice (*) par les points
x = (x1 , x2 , x3 , x5 ) de l’espace affine F52 (il’y en a 32) :
j = 1 ↔ (0, 0, 0, 0, 0), j = 2 ↔ (0, 0, 0, 0, 1), . . . , j = 32 ↔ (1, 1, 1, 1, 1)
(on considère l’écriture binaire du nombre j − 1) :
j − 1 = x5 + 2x4 + 4x3 + 8x2 + 16x1 , xi = 0 ou 1,
alors
j ∈ {1, 2, · · · , 32} ←→ (x1 , x2 , x3 , x4 , x5 ) mod 2 ∈ F52 .
Ensuite, on considère chaque ligne Ai de la matrice (*) comme la fonction indicatrice d’une partie de F52 :
(1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1) ↔ {(∗, ∗, ∗, ∗, ∗) ∈ F 52 } = F52
(l’espace F52 tout entier) ,
(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1) ↔ {(1, ∗, ∗, ∗, ∗) ∈ F 52 }
(l’hyperplan {x1 = 1}, car la partie correspondant de F52 commence par le numero j = 17 ↔ (1, 0, 0, 0, 0).
Puis
(0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1) ↔ {(∗, 1, ∗, ∗, ∗) ∈ F 52 }
(l’hyperplan {x2 = 1}, les deux morceaux de la partie correspondant de F52 commencent par le numero
j = 9 ↔ (0, 1, 0, 0, 0) et le numero j = 25 ↔ (1, 1, 0, 0, 0)) etc.
On vérifie que les parties de F52 obtenues de toutes les combinaisons linéaires de A sont : l’espace F52
tout entier, ∅, tous les hyperplans affines linéaires
f (x1 , x2 , x3 , x5 ) = 1 de l’espace affine F52
(d◦ (f ) = 1).
En effet la première ligne A1 représente la fonction constante f : F52 → F2 :
A1 ←→ f ≡ 1, f : F52 → F2 ,
la ligne A2 représente la fonction f (x1 , x2 , x3 , x5 ) = x1
A2 ←→ f ≡ 1, f (x1 , x2 , x3 , x5 ) = x1 "le premier chiffre" de j − 1 mod 2 ∈ F2 ,

A3 ←→ f ≡ 1, f (x1 , x2 , x3 , x5 ) = x2 "le second chiffre" de j − 1 mod 2 ∈ F2 ,
A4 ←→ f ≡ 1, f (x1 , x2 , x3 , x5 ) = x3 "le troisième chiffre" de j − 1 mod 2 ∈ F2 ,
A5 ←→ f ≡ 1, f (x1 , x2 , x3 , x5 ) = x4 "le quatrième chiffre" de j − 1 mod 2 ∈ F2 ,
A6 ←→ f ≡ 1, f (x1 , x2 , x3 , x5 ) = x5 "le dernier chiffre" de j − 1 mod 2 ∈ F2 .
5
Ceci implique que la combinaison linéaire représant la fonction
α1 A1 + α2 A2 + α3 A3 + α4 A4 + α5 A5 + α6 A6 ←→ f = α1 + α2 x1 + α3 x2 + α4 x3 + α5 x4 + α6 x5 .
(la fonction indicatrice de la partie
f (x1 , x2 , x3 , x5 ) = 1 de l’espace affine F52 ).
On sait que l’intersection de deux hyperplans différents dans F52 contient au plus 8 éléments, donc les
mots du code sont bien ecartés : pour obtenir un mot à partir d’un autre, il faut changer au moins 16
symboles (soit 16 soit tous les 32). C’est-à-dire, que le code corrige jusqu’à 7 erreurs de transmission :
dans ce cas le résultat c01 de la transmission d’un mot c1 ne peut pas être obtenu d’un autre mot c2 (sinon
on pourrait obtenir c2 à partir de c1 en changeant ≤ 14 position.
Décodage d’un mot reçu y ∈ F32 5
2 vu comme une fonction y = y(x1 , x2 , x3 , x4 , x5 ) sur F2 : si y était
un mot de code ,
y(x1 , x2 , x3 , x4 , x5 ) = α1 + α2 x1 + α3 x2 + α4 x3 + α5 x4 + α6 x5 , (0.1)
alors


 α1 = f (0, 0, 0, 0, 0) = y1 ,



 α1 + α2 = f (1, 0, 0, 0, 0) = y17 ,

α1 + α3 = f (0, 1, 0, 0, 0) = y9 ,

 α1 + α4 = f (0, 0, 1, 0, 0) = y5 ,



 α1 + α5 = f (0, 0, 0, 1, 0) = y3 ,

α1 + α6 = f (0, 0, 0, 0, 1) = y2 .
Dans ce cas on vérifie si l’identité (0.2) est satisfaite en tous les autres 26 points (26 = 32-6 conditions
à vérifier !) Sinon, on considère toutes les 64 combinaisons linéaires
y(x1 , x2 , x3 , x4 , x5 ) − (β1 + β2 x1 + β3 x2 + β4 x3 + β5 x4 + β6 x5 ), (0.2)
et on choisit parmi eux un mot e = e(x1 , x2 , x3 , x4 , x5 ) avec le nombre minimum des valeurs non nulles.
C’est "l’erreur de transmission". Alors
y(x1 , x2 , x3 , x4 , x5 ) = β1 + β2 x1 + β3 x2 + β4 x3 + β5 x4 + β6 x5 + e(x1 , x2 , x3 , x4 , x5 )
et on obtient le décodage u0 du mot d’information u :
u0 = (β1 , β2 , β3 , β4 , β5 , β6 ).
Dans toute la suite les mots d’un même code auront la même longueur (le nombre de symboles d’un
alphabet fini F ). De tels mots sont appelés "codes en blocs" opposés aux "codes de longueur variable"
ou "codes convolutionnels" dont nous ne parlerons pas.
6
1. Transmission d’information, codage et decodage optimal sur
un canal bruité
Codes de répétition pure.
1.1. Principe de transmission d’information

On souhaite transmettre des informations via un canal de transmission. Celui-ci ne pouvant être par-
fait, l’information reçue par le destinataire peut être inexploitable ou erronée. Pour réduire au maximum
la probabilité d’erreur, on construit une procédure de codage-décodage de l’information à transmettre
qui, au prix d’éléments transmis supplémentaires, va permettre de détecter puis de corriger les altérations
du message dues à l’imperfection du canal. On se base pour ceci essentiellement sur l’étude des corps
finis et des polynômes sur ceux-ci.
L’objet de la théorie de l’information est la déscription et l’étude des systèmes de communications, où
l’information est considérée comme une grandeur mathématique, à partir du travail de Claude Shannon
(1948) "The mathematical theory of communication".
Le modèle général d’un système de communication comportant une protection contre les erreurs de
transmission est le suivant :
SOURCE ENCODEUR
message à message
−→ −→ ↓
transmettre codé
a emis c emis
CANAL e (erreur)
←− BRUIT
de transmission
DESTINARAIRE DECODEUR
message ← message ←− ↓
décodé a0 c0 = c + e reçu
Par
– "source" on nomme tout organe ou dispositif émettant un message,
– "encodeur" un organe qui assoocie au message un signal de forme convenable
– "canal" le milieu utilisé pour transmettre le signal
– "decodeur" l’organe de restitution du message à partir du signal reçu
– "destinataire" la personne ou appareil qui exploite ce message
1.2. Hypothèses sur un canal bruité

Le message à transmettre est un bloc de symboles tous issus d’un même alphabet. On formule deux
hypothèses fondamentales :
- Les perturbations de symboles au cours de la transmission sont indépendantes deux à deux et de
même probabilité p.
- Le bruit du canal peut substituer un symbole à un autre, mais ne peut en adjoindre ou en supprimer.
Le message reçu est ainsi de même longueur que le message émis.
1.3. Généralités sur les codes

Définition 1.1 (a) Soit F un ensemble de cardinal q, M, n deux entiers strictement positifs. On appelle
code C sur l’alphabet F de longueur n bloc-par-bloc toute partie C ⊂ F n de cardinal Card (C) = M .
7
(b) Un code C ⊂ F n est dit q-aire si C = ImE pour une application injective
E : F k −→ F n
L’élément E(u), pour un u de F k est appelé un mot code, k est dit la dimension du code, n est sa
longueur. Dans ce cas Card (C) = q k
Définition 1.2 (a) Soit F un ensemble fini non vide et n entier strictement positif. L’application d :
F n × F n −→ N
(a, b) 7→ Card {i ∈ {0, 1, . . . , n} | ai 6= bi }
avec a = (a1 , · · · , an ) et b = (b1 , · · · , bn ) est la distance de Hamming sur F n .
(b) Soit F un corps fini. L’application w : F n → N
a 7→ d(a, 0) = Card {i ∈ {0, 1, . . . , n} | ai 6= 0}
est le poids de Hamming.
Remarque 1.3 : La distance de Hamming sur F n est bien une distance sur F n . En effet, on a :
d(a, b) = 0 ⇐⇒ (ai = bi ; 1 ≤ i ≤ n) ⇐⇒ a = b
d(a, b) = d(b, a) pour tous a, b pour tous E n
d(a, c) ≤ d(a, b) + d(b, c) pour tous a, b, c pour tous E n .
Définition 1.4 Soit C ⊂ F n un code (a) On appelle écart ou "distance" de C le nombre
d = d(C) = min d(C(x), C(y))

x,y∈F k
x6=y
Soit C = ImE un code q-aire, E : F k → F n de distance d. Dans ce cas on dit que C est un [n, k, d]q -code.
(b) On appelle vitesse de transmission (le "rendement" ou "information rate" en anglais) de C le
rapport R = k/n
(c) 1/R est le coefficient de redondance de C.
(d) δ = d/n est la distance relative (ou le "taux de correction") de C
Soit x = (x1 , . . . , xn ) le mot transmis par le canal. Le mot reçu y = (y1 , y2 , . . . , yn ), eventuellement
entaché d’erreurs, diffère de x en d(x, y) positions.
Lorsque on suppose qu’il n’y a pas plus de t erreurs commises, d(x, y) ≤ t, on pourra retrouver x à
la condition que chaque mot erroné reçu ne puisse provenir que d’un seul mot du code.
Définition 1.5 Un code de longueur n sur l’alphabet F vérifie la condition de decodage d’ordre t si
pour tout y ∈ F n il existe au plus un mot x ∈ C ⊂ F n tel que d(x, y) ≤ t. Dans ce cas les boules
B(x, t) = {y ∈ F n | d(x, y) ≤ t} ⊂ F n
(pour la distance de Hamming) sont deux-à-deux disjointes.
Théorème 1.6 Un code C peut corriger t erreurs si son écart d est tel que d ≥ 2t + 1.
8
Preuve. Si c est envoyé et y reçu, tels que d(y, c) ≤ t, tout mot code c0 de C est tel que d(c, c0 ) ≥ 2t + 1.
Or, d est une distance, donc
d(y, c0 ) ≥ d(c, c0 ) − d(c, y)
d(y, c0 ) ≥ t + 1
C peut donc corriger t erreurs. Les boules B(c, t) sont donc deux-à-deux disjointes.
Définition 1.7 (a) Un décodage de E est une application
D : Fn → Fk
telle que D ◦ C = IdF k .
(b) On dit que D est standard ("de vraisemblence maximale") si
∀y ∈ F n ∀u ∈ F k , d(E(u), y) ≥ d(E(D(y)), y)
c’est-à-dire que E(D(y)) se trouve parmi les mots de codes E(u) les plus proches de y.
Remarque 1.8 L’existence d’un décodage est garantie par l’injectivité de E.
1.4. Codage et decodage optimal sur un canal bruité

On considère les problèmes mathématiques de transmission d’information (vue comme une longue
suite
F kN 3 a = (a1 , . . . , ak , ak+1 , . . . , akN ),
où
u1 = (a1 , . . . , ak ), u2 = (ak+1 , · · · , a2k ), · · · , uN = (ak(N −1)+1 , · · · , akN −1 , akN ),
avec les blocs d’information u1 , . . . uN . On transmet l’information bloc-par-bloc a l’aide du code
a 7→ EN (a) = (E(u1 ), . . . , E(uN )) ∈ F nN
avec les hypothèses 1.2. :
EN (a) 7→ ẼN (a) ∈ F nN
Il est possible de diminuer considerablement la proportion d’erreures de transmission d’information avec
des bons codes.
Le nombre total d’erreurs dans chaque bloc Ẽ(ui ) est d’espérance d’une distribution polynomiale,
donc ce nombre est ≤ (p + ε)n pour tout ε, avec n assez grand, et avec une grande probabilité souhaitée
≥ 1 − ε1 (très proche à 1). Une bonne mesure de qualité de code est la distance relative (où "taux de
correction") :
d δ
δ = , et on suppose que p est assez petit : p < .
n 2
Donc pour un choix de ε et de n on peut supposer aussi que p ≤ 2δ − ε − n1 . Dans ce cas

δ 1 d d−1
(p + ε)n ≤ ( − )n = − 1 ≤ t = ,
2 n 2 2
et toutes les erreurs de transmission serons corrigées par le code C.
C’est-à-dire, DN ◦ EN (a) = EN (a), si p < 2δ et n assez grand, avec une probabilité souhaité ≥ 1 − ε1
très proche à 1.
Donc le succès du decodage des mots ẼN (a) ∈ F nN dépend du fait si δ est assez grand p ≤ δ2 mais
kN
aussi depend du fait que de la vitesse de transmission R = nN (le rendement) est suffisante R > R0 pour
transmettre un mot de code de longueur n avant que le mot suivant soit fabriqué.
C’est pourquoi on est obligé d’utiliser des codes longs, avec n ≈ 300 ∼ 1000.
9
Définition 1.9 Une famille {Ci } des [ni , ki , di ]q -codes est dite bonne s’il existe et si sont positives toutes
les deux limites
ki di
lim = R > 0, lim = δ > 0,
i→∞ ni i→∞ ni
Avec toute bonne famille on peut faire tendre vers 1 la probabilité d’une transmission correcte ayant
en même temps la vitesse de transmission suffisante R > R0 pour pouvoir transmettre un mot de code
de longueur n avant qu’un mots suivant soit fabriqué. En réalité, on utilise R0 ≈ 0, 1 ∼ 0, 95.
Illustration de l’idée :
pour pouvoir reconnaître les erreures d’impression pendant la lecture on utilise un bon vocabulaire
où les mots sont écartés : il n’y a qu’un seul mot qui resemble au mot imprimé (erroné).
un procédé courant du "bit de parité", permet dans le cas d’une erreur de la "détécter" (sans la cor-
riger !) Pour cela on attribue à un mot d’information binaire u = (u1 , . . . , uk ) la somme des coordonnées :
E : Fk2 → Fk+1
2 ,
x = E(u) = (u1 , . . . , uk , xk+1 ), où xk+1 = u1 + · · · + uk ∈ F2 .
Une autre méthode est celle de répétition :
Em : F k → F km ,
elle consiste à envoyer m fois le même mot : n = mk. La suite de codes {Cm = Em } est mauvaise : le
km 1
rendement tend vers zéro : = → 0.
nm m
En réalité, si une source produit r symboles par minute, il y a une restriction sur la vitesse : un
canal peut transmettre seulement m0 r symboles par minute, m0 ≈ 1, 1 ∼ 10 donc il faut que n ≤ km0 ,
k 1
n ≥ m0 . On voit donc que la répétition est inutile à cause de la restriction sur la longuer
k 1
k = 1, ≥ ⇒ n ≤ m0 .
n m0
Exercice. Soit p = ps la probabilité des perturbations de symboles au cours de la transmission. On

considère F = {0, 1} et l’application E : F → F n du codage de répitition pure. Calculer la probabilité P
du decodage erroné.
(a) Montrer que
X n
P = (1 − p)l pn−l = O(pn/2 ) lorsque p → 0.
l
0≤l<n/2
En déduire, qu’on ne peut pas obtenir une très petite probabilité du decodage erroné à cause de la
restricion n ≤ m0 .
(b) Pour tout p < 81 , encadrer P (voir [vLi], p.24, et la section suivante).
1.5. Théorème de Shannon (1948)

dit qu’il existe des bonnes familles des codes. Shannon a considéré un canal binaire bruité (q = 2).
Théorème 1.10 (Shannon) Soit 0 < R < 1 + p log2 p + (1 − p) log2 (1 − p) < 1 et on pose Mn := 2[Rn] .
Soit P ∗ (Mn , n, p)= la valeur minimale de la probabilité de decodage incorrecte par un mot sur tous les
codes C ⊂ Fn2 du cardinal Card (C) = Mn . Alors P ∗ (Mn , n, p) → 0 si n → ∞ .
(voir [vLi], p.27) pour la preuve détaillée.
10
Représentation graphique : fonction d’entropie
> H(p):=- p*log(p)/log(2)-(1-p)*log(1-p)/log(2);
> ’H(p)=- p*log(p)/log(2)-(1-p)*log(1-p)/log(2)’;
p ln(p) (1 − p) ln(1 − p)
H(p) := − −
ln(2) ln(2)
p log(p) (1 − p) log(1 − p)
H(p) = − −
log(2) log(2)
> plot([1-H(p)], p = 0..1, R = 0..1,discont=true);

> ’R=1+p*log(p)/log(2)+(1-p)*log(1-p)/log(2)’;
0.8
0.6
R
0.4
0.2
0 0.2 0.4 0.6 0.8 1

p
p log(p) (1 − p) log(1 − p)
R =1+ +
log(2) log(2)
Remarque 1.11
Mn
X
P ∗ (Mn , n, p) = min(PC = Mn−1 Pi )
C
i=1
où Pi est la probabilité de decodage erroné d’un mot E(ui ) ∈ C. Le théorème signifie qu’il existe une
famille {Cn } ⊂ Fn2 des codes binaires de cardinal
Card (Cn ) = Mn = 2[Rn] → ∞
telle que la valeur minimale de la probabilité de decodage incorrecte par un mot du code C n ⊂ Fn2
Mn
X
P ∗ (Mn , n, p) = PCn = Mn−1 Pi → 0.
i=1
Remarque 1.12 Dans le cas d’un canal q-aire on utilise la borne de Gilbert -Varshamov R > 1 − H q (δ)
pour l’existence des bons codes, où Hq (δ) est la fonction d’entropie q-aire : pour δ ∈ [0, q−1
q ]
δ log(q − 1) δ log(δ) (1 − δ) log(1 − δ)

Hq (0) = 0, Hq (δ) = − − .
log(q) log(q) log(q)
11
2. Distance de Hamming, rendement et vitesse de transmission,
distance relative
Borne de Hamming. Borne de Singleton.
2.1. Capacité de correction et rayon de recouvrement

Soit C = ImE un [n, k, d]q -code, E : F k → F n . Rapellons que C vérifie la condition de decodage
d’ordre t (voir Définition 1.5) si pour tout y ∈ F n il existe au plus un mot x ∈ C ⊂ F n tel que d(x, y) ≤ t.
Dans ce cas les boules
B(x, t) = {y ∈ F n | d(x, y) ≤ t} ⊂ F n
pour la distance de Hamming soient deux-à-deux disjointes, et le code C peut corriger t erreurs si son
écart d est tel que d ≥ 2t + 1 (voir Théorème 1.6).

Définition 2.1 (a) Le nombre t = d−1 2 est dit la capacité de correction
(b) On appelle rayon de recouvrement ρ(C) du code C le plus petit rayon r tel que l’ensemble des
boules B(x, r) de rayon r centrées en chaque mot de code x ∈ C, forme un recouvrement de F n . On a
t ≤ ρ(C) et en cas d’égalité le code C est dit parfait.
Questions :
• 1) Quel est le nombre maximum de mots que peut contenir un code C de capacité de correction t ?
• 2) Quel est le nombre minimum de mots que doit contenir un code C pour avoir un rayon de
recouvrement ρ(C) fixé ?
Pour répondre à ces deux questions on montre tout d’abord que Card B(x, r) ne dépend pas de x ∈ C :
Card B(x, r) = |B(x, r)| =: Vq (n, r) ("le volume de la boule de Hamming").
Proposition 2.2 Pour tout entier r ≤ n, et tout x ∈ F n

r
X n
Card B(x, r) = Vq (n, r) = (q − 1)i
i=0
i
Preuve. On peut représenter B(x, r) comme la réunion des sphères S(x, i) centrées en x et de rayon
i ≤ r.
Calculons Card (S(x, i)) pour x et i fixés
Card (S(x, i)) = Card {y ∈ F n | d(x, y) = d}
l’ensemble des mots

dont le nombre de composantes distinctes de celles de x est i.
Il y a donc ni ensembles d’indices à i éléments possibles. Chacune des i composantes distinctes peut
être de q − 1 façons, c’est à dire
n
Card (S(x, i)) = (q − 1)i
i
12
2.2. Borne de Hamming et borne de Singleton
Théorème 2.3 (Borne de Hamming) Soit C ⊂ Fn un code (sur l’alphabet F de Card (F ) = q) de
distance d = d(C), la capacité de correction t = d−1
2 et de cardinal M = Card (C). Alors
t
X n
M (q − 1)i ≤ q n , donc Vq (n, t) ≤ q n /M ⇐⇒ M ≤ q n /Vq (n, t).
i=0
i
n

Preuve : Dans F n , il y a m (q − 1)m vecteurs de poids de Hamming m. Le code corrige t erreurs, donc
les boules
centrées sur les mots codes et de rayon t sont 2 à 2 disjointes. Chacune des M boules contient
1 + n1 (q − 1) + · · · + nt (q − 1)t vecteurs de Fqn , qui en contient en tout q n .
Corollaire 2.4 Soit C ⊂ F n un code sur l’alphabet F de Card (F ) = q de distance d = d(C) et la

d−1
capacité de correction t = 2 . Alors
max(Card (C)) ≤ q n /Vq (n, t)

C
Remarque 2.5 Soit C ⊂ F n un code (sur l’alphabet F de Card (F ) = q) ayant le rayon de recouvrement
ρ(C). Alors
min(Card (C)) ≥ q n /Vq (n, ρ(C))
C
Optimisation des paramètres : on considère les codes C ⊂ F n sur l’alphabet F de Card (F ) = q de

cardinal Card (C) = M , de distance d = d(C). Deux des paramètres (n, M, d) sont fixés, on cherche à
déterminer la plus grande valeur possible pour le troisième.
Théorème 2.6 (Borne de Singleton) Soit C = ImE un [n, k, d]q -code, E : F k → F n . Alors
k ≤ n − d + 1 ⇐⇒ R ≤ 1 − δ + 1/n,
où R = k/n, δ = d/n.
Preuve. On pose
x = (x1 , . . . , xn ) ∈ F n , x0 = (x1 , . . . , xn−d+1 ) ∈ F n−d+1 ,
alors l’application E 0 : F k → F n−d+1 obtenue de E : F k → F n par E 0 (u) := E(u)0 , reste injective car le
poids de C est d, d’où k ≤ n − d + 1.
Définition 2.7 Un code atteignant la borne de Singleton est dit M.D.S. ("maximum distance separable"
en anglais).
Le codes M.D.S. triviaux sont de type : [n, 1, n], [n, n − 1, 2], [n, n, 1].
2.3. Bonnes familles des codes et problèmes asymptotiques.

Un bon code est un code corrigeant de nombreuses erreurs compte tenu de sa longueur tout en ayant
une vitesse de transmission la plus élevée possible, ce qui correspond à des paramètres R et δ assez grands
dans [0, 1]. Rapellons (voir Definition1.9) qu’une famille {Ci } des [ni , ki , di ]q -codes est dite bonne s’il
existe et positives les limites
ki di
lim = R > 0, lim = δ > 0,
Toutefois, ces paramètres δ et R sont liés par des relations dites asymptotiques. Nous allons établir
quelques relations.
13
2.4. Borne de Hamming et borne de Singleton asymptotiques
Théorème 2.8 (Borne de Singleton asymptotique) Soit {Ci } une famille des [ni , ki , di ]q -codes,
on pose
ki di
R = lim sup , δ = lim sup ,
alors
R ≤1−δ
Preuve : Pour toute i, on pose Ri = ki /ni , δi = di /ni , alors Ri ≤ 1 − δi + 1/ni . Lorsque i → ∞, on

obtient le résultat : R ≤ 1 − δ.
q−1
Borne de Hamming asymptotique utilise la fonction d’entropie q-aire : pour δ ∈ [0, q ]

Hq (0) = 0, Hq (δ) = − −
Proposition 2.9
r r
r
1 nHq X
i n nHq
q n ≤ Vq (n, r) = (q − 1) ≤q n (2.1)
n+1 i=0
i
Preuve. On remarque tout d’abord, que pour tout z ∈]0, 1], et pour tout i ≤ r,
r X r
i n i n
X
i−r
z ≥ 1 =⇒ (q − 1) ≤ (q − 1) z i−r .
i=0
i i=0
i
Puis, on utilise l’inégalité : pour tout z ∈]0, 1],

r n
i n i n
X X
i−r
(q − 1) z ≤ (q − 1) z i−r = z −r (1 + (q − 1)z)n =: g(z).
i=0
i i=0
i
Pour trouver le minimum de g(z) on calcule la dérivée g 0 (z) :

> diff(z^(-r)*(1+(q-1)*z)^n,z);
z (−r) r (1 + (q − 1) z)n z (−r) (1 + (q − 1) z)n n (q − 1)

− +
z 1 + (q − 1) z
Ceci dit, g 0 (z) est égale à
−rz −1−r (1 + (q − 1)z)n + n(q − 1)z −r (1 + (q − 1)z)n−1 = −rz −1−r (1 + (q − 1)z)n−1 ((q − 1)(n − r)z − r).
Ceci implique
g 0 (z) = 0 ⇐⇒ −rz −1−r (1 + (q − 1)z)n−1 ((q − 1)(n − r)z − r) = 0.
donc
r r/n
z0 = = r ,
(q − 1)(n − r) (q − 1) 1 −
n
−r r n 1
g(z0 ) = z0 (1 + (q − 1)z0 )n , 1 + (q − 1)z0 = 1 + = = r,
n−r n−r 1−
n
et le minimum est r −r r n−r
g(z0 ) = (q − 1)r 1− .
n n
14
Un exemple numérique :
> restart;q:=3;r:=1;n:=3;
> g(z):=z^(-r)*(1+(q-1)*z)^n;
> gprime(z):=diff(z^(-r)*(1+(q-1)*z)^n,z);
q := 3
r := 1
n := 3
(1 + 2 z)3
g(z) :=
z
(1 + 2 z)3 6 (1 + 2 z)2
gprime(z) := − +
z2 z
> z0:=
> r /((q-1)*(n-r));
1
z0 :=
4
> plot([g(z)], z = 0 .. 1, y = 0..20, discont=true);
> ’y=g(z)’;
20
18
16
14
12
y 10
8
6
4
2
0 0.2 0.4 0.6 0.8 1

z
y = g(z)
D’autre part
r r
r log(q − 1) log( nr ) (1 − nr ) log(1 − nr )
nHq nn − n −
q n =q log(q) log(q) log(q) =
r −r r n−r
(q − 1)r 1− = g(z0 ),
n n
d’où l’inégalité supérieure.
L’inégalité inférieure : on montre qu’il existe z̃ ∈]0, 1] tel que
r
X n
i r n 1
(q − 1) > (q − 1) ≥ z̃ −r (1 + (q − 1)z̃)n ≥ g(z0 ). (2.2)
i=0
i r n + 1
15
Pn
En effet, le développement (1 + (q − 1)z̃)n = i=0 Ai z̃i contient n + 1 termes, Ai z̃ i = ni (q − 1)i z̃ i , et
on peut choisir z̃ de telle façon que le terme Ar z̃ r = ni (q − 1)r z̃ r soit maximal parmi Ai z̃ i :
−1
Ai−1 z̃ i−1 1 n n
i
= (q − 1)−1 = (2.3)
Ai z̃ z̃ i − 1 i
1 n! i!(n − i)! 1 Ai−1 1 i
· · = .
z̃ (i − 1)!(n − i + 1)! n! z̃ Ai z̃ (n − i + 1)(q − 1)
On voit donc que
Ai−1 z̃ i−1 1 i
=
Ai z̃ i z̃ (n − i + 1)(q − 1)
est une suite croissante pour 0 ≤ i ≤ n. On choisira z̃ de telle façon que cette suite dépasse 1 en r-ème
terme. Plus précisemment pour tout z̃ dans le segment

r r+1 Ar−1 z̃ r−1 Ar z̃ r
z̃ ∈ , ⇐⇒ 1 ∈ , ,
(n − r + 1)(q − 1) (n − r)(q − 1) Ar z̃ r Ar+1 z̃ r+1
on a (pour tous les i, j avec 0 ≤ i < r ≤ j ≤ n) :
Ai−1 z̃ i−1 Ai z̃ i Ar−1 z̃ r−1 Ar z̃ r Aj−1 z̃ j−1
i
≤ i+1
≤ ··· ≤ r
≤1≤ r+1
≤ ··· ≤ .
Ai z̃ Ai+1 z̃ Ar z̃ Ar+1 z̃ Aj z̃ j
Ceci implique
Ai−1 z̃ i−1 ≤ Ai z̃ i ≤ · · · ≤ Ar z̃ r , Ar z̃ r ≥ Ar+1 z̃ r+1 ≥ · · · ≥ Aj z̃ j ≥ . . . .

Mais par notre choix le terme Ar z̃ r = ni (q − 1)r z̃ r est maximal parmi Ai z̃ i , donc
r
i n
X
−r n
z̃ (1 + (q − 1)z̃) ≤ (n + 1)Ar ⇒ g(z0 ) ≤ (n + 1) (q − 1) .
i=0
i
Il reste à rapeller que r

nHq r −r r n−r
g(z0 ) = q n = (q − 1)r 1− ,
n n
ceci implique la borne inférieure :
r
r
1 nHq X n
q n ≤ Vq (n, r) = (q − 1)i .
n+1 i=0
i
r
Corollaire 2.10 Lorsque n → ∞, n → δ, on a

logq Vq (n, [δn]) Vq (n, [δn])
Hq (δ) = lim = lim logq
n→∞ n n→∞ Card (F n )
(la "proportion logarithmique de la boule de Hamming de rayon relative" δ dans F n ).
Preuve. On prend logq de l’inégalité (2.1 ) :
r r
r
1 nHq X n nH q
q n ≤ Vq (n, r) = (q − 1)i ≤q n
n+1 i=0
i
logq (n + 1) r log Vq (n, r)
q
r
⇒− + Hq ≤ ≤ Hq .
n n n n
r logq (n+1)
et si n → δ, n → ∞ alors n → 0 et on obtient le resultat.
16
Théorème 2.11 (Borne de Hamming asymptotique) Soit {Ci } une famille des [ni , ki , di ]q -codes,
on pose
ki di
i→∞ n i i→∞ n i
alors
R ≤ 1 − Hq (δ/2),
où Hq (x) est la fonction entropie q-aire définie sur [0, (q − 1)/q] par
Hq (0) = 0,
Hq (x) = x logq (q − 1) − x logq (x) − (1 − x) logq (1 − x) pour 0 ≤ x ≤ (q − 1)/q.

Preuve. Soit Ci ⊂ F n un code de la famille {Ci }, on pose ti = di2−1 . Alors

di − 2 di − 1 di − 1 ni δ i − 1 ti ni δ i − 1 δ
≤ ti = ≤ = ⇒ lim = lim =
2 2 2 2 i→∞ ni i→∞ 2ni 2
Selon Théorème 2.3 (la borne de Hamming) on a
Vq (ni , ti )q ki ≤ q ni ⇒ logq (Vq (ni , ti )) + ki ≤ ni
ti δ
Lorsque ni → ∞ , ni → 2 donc
logq (Vq (ni , ti ))
→ Hq (δ/2).
ni
Il vient que
Vq (ni , ti )q ki ≤ q ni ⇒ logq (Vq (ni , ti )) + ki ≤ ni
⇒ Hq (δ/2) + R ≤ 1 ⇒ R ≤ 1 − Hq (δ/2).
> restart;
FONCTION D’ENTROPIE
> q:=4:
> Hq(x):=x*log(q-1)/log(q)- x*log(x)/log(q)-(1-x)*log(1-x)/log(q);
x ln(3) x ln(x) (1 − x) ln(1 − x)

Hq(x) := − −
ln(4) ln(4) ln(4)
BORNES DE SINGLETON ET DE HAMMING (D’EMPILEMENT DE SPHÈRES)
ASYMPTOTIQUES
> f:=Hq(x);
x ln(3) x ln(x) (1 − x) ln(1 − x)
f := − −
ln(4) ln(4) ln(4)
> g1:=x/2;g:=algsubs(x=g1,f);
1
g1 := x
2
1 1 1 1
ln(1 − x) (1 − x) x (−ln( x) + ln(3))
g := − 2 2 + 2 2
ln(4) ln(4)
> plot([f,1-g(x),1-x], x=0..2,y=0..1);’y=Hq(x),1-Hq(x/2),1-x’;
17
1
0.8
0.6
y
0.4
0.2
0 0.2 0.4 0.6 0.8 1 1.2 1.4 1.6 1.8 2

x
1
y = Hq(x), 1 − Hq( x), 1 − x
2
18
3. Codes linéaires et codes cycliques. Matrice génératrice et cal-
cul du syndrome
d’erreur
3.1. Codes linéaires

Une classe de codes très importante est celle des codes linéaires, notamment en raison des outils dont
nous disposons pour manipuler et représenter les applications linéaires comme l’écriture matricielle.
En général, pour un alphabet fini F , étant donné une énumération de F k , la donnée d’un code
C = Im(E), E : F k → F n est la donnée de n × q k éléments de F , ce qui représente un gros volume
d’information.
Si l’on munit F k et F n de structures et si l’on prend une application E qui respecte ces structures, on
peut économiser sur le volume d’information représentant E au prix de calculs des valeurs non mémorisées
de E.
En ce sens le plus simple est de prendre pour q un nombre primaire, q = pr , pour F le corps Fq et
pour E une application linéaire injective de Fkq dans Fnq . Rapportant C aux bases canoniques adéquates,
on caractérise cette application par n × k éléments de Fq .
Définition 3.1 Soit F = Fq un corps fini. Un code linéaire C est un sous-espace vectoriel de dimension
k de l’espace vectoriel F n (vu comme l’image d’une application E : F k → F n linéaire injective). Les
vecteurs lignes a = (a1 , · · · , ak ) ∈ F k sont les mots d’information, et les vecteurs lignes c = E(a) =
(c1 , · · · , cn ) ∈ F n sont les mots de code. La matrice génératrice G du code E est la matrice attachée à
l’application linéaire E : F k → F n (dans les bases standards de F k et F n ), de telle façon que
c = E(a) = aG.
Remarque 3.2 Un code linéaire C est l’image d’une application linéaire injective, donc on peut considé-
rer C comme un sous-espace vectoriel de dimension k de l’espace vectoriel F n . On peut ainsi caractériser
les codes linéaires à partir de matrices à coefficients dans F comme noyau d’une autre application linéaire
S : F n → F n−k . La matrice H de S est appelée matrice de contrôle de C :
S(c) = Hct .
Exemple. Soit H une matrice (n − k) × n à coefficients dans Fq de rang n − k. Le noyau de l’application

représentée par H est un sous-espace vectoriel de Fqn . On peut donc définir un code linéaire par un
système d’équations linéaires :
n o
C = c = (c1 , · · · , cn ) Hct = 0 .

Posons  
1 0 1 1 1 0 0
H = (A, In−k ) =  1 1 0 1 0 1 0
1 1 1 0 0 0 1
et soit q = 2 (C code binaire) On désire transmettre le message
a = (a1 a2 a3 a4 ).
On le code en c = (a1 a2 a3 a4 c5 c6 c7 ), avec c5 , c6 , c7 tels que Hct = 0. Or,

a1 + a 3 + a 4 + c 5 = 0 c5 = a 1 + a 3 + a 4
Hct = 0 ⇐⇒ a1 + a2 + a4 + c6 = 0 ⇐⇒ c6 = a 1 + a 2 + a 4
a1 + a 2 + a 3 + c 7 = 0 c7 = a 1 + a 2 + a 3
19
On a E : F42 → F72
(a1 , a2 , a3 , a4 ) ↔ (a1 , a2 , a3 , a4 , a1 + a3 + a4 , a1 + a2 + a4 , a1 + a2 + a3 )
La matrice H est appelée matrice de contrôle de C.
Remarque 3.3 Si H = (A, In−k ), alors un message a = a1 · · · ak est codé en c = a1 · · · ak ck+1 · · · cn le

code est alors dit systématique. Ici A ∈ Matn−k,k (F )
De plus, on a
t t Ik
{Hc = 0} =⇒ c = at = [a(Ik , −At )]t
−A
c’est-à-dire,      
ck+1   ck+1   0
ck+2  a 1 a 1
 = −A · · · , ck+2  + A · · · =  0  .
   

 ···   ···  · · ·
ak ak
cn cn 0
Il vient la définition suivante :

Définition 3.4 G = (Ik , −At ) est la matrice génératrice canonique du code linéaire C de matrice de
contrôle H = (A, In−k ). D’une manière plus générale, toute matrice G engendrant un code C est une
matrice génératrice de C.
Remarque 3.5 Pour tout mot code c, on a Hct = 0 et c = aG. Donc
GH t = 0 ∈ Matk,n−k (F ), HGt = 0 ∈ Matn−k,k (F ),
puisque Hct = HGt at = 0 pour tous les a ∈ F k .
3.2. Détection et correction d’erreurs, décodage

Dans ce qui suit, nous noterons c un mot code émis, y le message reçu, et e = y − c le vecteur erreur.
La distance de Hamming d(y, c) est alors le nombre d’erreurs survenues au cours de la transmission.
Pour décoder y reçu, on peut supposer que le nombre d’erreurs est minimal, c’est à dire que l’on va
chercher le mot code c le plus proche de y au sens de la distance de Hamming. C’est la règle du décodage
par plus proche voisin.
Définition 3.6 Soit t un entier naturel. C un code linéaire de dimension r et de longueur n est dit
t-correcteur d’erreurs si
∀y ∈ Fqn , |{c ∈ C : d(y, c) ≤ t}| ≤ 1
Si alors c ∈ C est transmis et qu’au plus t erreurs surviennent, on a d(y, c) ≤ t et d(y, c 0 ) ≤ t pour tout
autre élément de C. Ainsi, la méthode du décodage par plus proche voisin donne le bon résultat.
Il apparaît qu’un des objectifs de la théorie du codage consiste à élaborer des codes dont les mots sont
très éloignés les uns des autres au sens de la distance de Hamming. Toutefois, un autre est de transmettre
un maximum d’information et donc de garder des vitesses de transmission acceptables, et réunir les deux
est épineux.
Théorème 3.7 Un code C peut corriger t erreurs si son écart d est tel que d ≥ 2t + 1
20
Preuve : On a déja vu ce resultat (Théorème 1.6) Si c est envoyé et y reçu, tels que d(y, c) ≤ t, tout
mot code c0 de C est tel que d(c, c0 ) ≥ 2t + 1. Or, d est une distance, donc
d(y, c0 ) ≥ d(c, c0 ) − d(c, y)
d(y, c0 ) ≥ t + 1
C peut donc corriger t erreurs.
Exemple. Reprenons le code déjà vu plus haut
E: F42 → F72 (3.1)

(a1 , a2 , a3 , a4 ) 7→ (a1 , a2 , a3 , a4 , a1 + a3 + a4 , a1 + a2 + a4 , a1 + a2 + a3 ) (3.2)
Soient a, b des éléments de F42

Si d(a, b) = 1, alors d(E(a), E(b)) = 3 ou 4.
Si d(a, b) = 4, alors d(E(a), E(b)) = 7.
Ceci dit, l’application E écarte vraiment les mots d’information.
En effet, on peut toujours supposer b = (0, 0, 0, 0), et on utilise directement la formule (3.1) pour le
mot E(a).
Donc d = 3, et le code corrige 1 erreur.
Lemme 3.8 Soit un code linéaire C de matrice de correction H et d’écart d. Alors d ≥ s + 1 si et

seulement si s colonnes de H sont linéairement indépendantes.
Preuve : Supposons que s colonnes de H soient linéairement dépendantes. Alors il existe c ∈ C non nul
tel que Hct = 0 et w(c) ≤ s. Ainsi, d ≤ s. Inversement, si s colonnes de H sont toujours indépendantes,
c ∈ C non nul est toujours tel que w(c) ≥ s et donc d ≥ s.
Ce qui suit est un algorithme simple de décodage des codes linéaires : le décodage par leader de classe.
Soit C un code linéaire de longueur n et de dimension k sur Fq . L’espace vectoriel Fnq /C est formé
de toutes les classes a + C, a ∈ Fqn . Pour tout a, |a + C| = q k , et
Fnq = (a(0) + C) ∪ · · · ∪ (a(s) + C),
avec a(0) = 0, s = q n−k − 1.

Alors, quel que soit le message y reçu, il existe i tel que y ∈ a(i) + C, et si c est le message envoyé,
e = y − c = a(i) + z ∈ a(i) + C. On peut ainsi construire une méthode de décodage des codes linéaires.
En effet, quel que soit y ∈ a(i) + C reçu, tous les vecteurs erreur possibles pour y sont également dans
a(i) + C. La règle de décodage par plus proche voisin nous conduit à choisir pour vecteur erreur le vecteur
e ∈ a(i) + C de poids de Hamming minimum, et on décode y en x = y − e. Nous allons voir maintenant
l’algorithme, à proprement parler, plus en détail.
Définition 3.9 Dans les conditions décrites précédemment, un élément de poids minimum dans a + C
est appelé un leader de classe.
k
Soient a(1) , · · · , a(s) les leaders des classes a + C, a 6= 0, et soient c(1) = 0, c(2) , · · · , c(q )
tous les mots
du code C et soit le tableau suivant :
k
c(1) c(2) ··· c(q )
k
a + c(1)
(1)
a + c(2)
(1)
··· a + c(q )
(1)
··· ··· ··· ···

k
a + c(1)
(s)
a + c(2)
(s)
··· a + c(q )
(s)
21
Si on reçoit le mot y = a(i) + c(j) , le vecteur erreur est e = a(i) et on décode y en x = y − e = c(j) ,
c’est à dire le mot du code (donc un terme de plus petit poids) de la colonne où est situé y. On peut
déterminer la classe de y en évaluant ce que l’on appelle le syndrome de y.
Définition 3.10 Soit H la matrice de correction d’un code linéaire C de longueur n et de dimension
k. Alors le vecteur S(y) = Hy t de longueur n − k est appelé le syndrome de y.
Théorème 3.11 Pour y, z éléments de Fnq , on a

(i) S(y) = 0 si et seulement si y ∈ C
(ii) S(y) = S(z) si et seulement si y + C = z + C
Preuve : S(y) = Hy t , et C = {y ∈ Fqn : Hy t = 0}, d’où le (i). De plus, S(y) = S(z) ⇐⇒ Hy t =

Hz t ⇐⇒ H(y − z)t = 0 ⇐⇒ y − z ∈ C ⇐⇒ y + C = z + C, d’où le (ii).
Si le message c est envoyé et y reçu, e = y − c, alors
S(y) = S(c + e) = S(c) + S(e) = S(e),
y et e sont dans la même classe, et le leader de cette classe a également le même syndrome.
Ceci nous permet d’améliorer l’algorithme précédent. Celui-ci consistait à rechercher le message reçu
y dans le tableau construit précédemment, et à le décoder en remontant au premier terme de la colonne
du tableau où il se situe. Or, de ce qui précède, tous les éléments d’une même ligne du tableau ont le
même syndrome. Ainsi, pour ne pas perdre du temps de chercher y dans le tableau, il suffit d’y rajouter
une colonne, celle des syndromes. Le décodage se fait alors comme suit :
(i) On calcule S(y) = Hy t .
(ii) On cherche S(y) dans la colonne des syndromes.
(iii) Le vecteur erreur e est le leader de cette classe, donc premier terme de la ligne où figure S(y).
(iv) On décode y en x = c(j) = y − e, qui est également un terme de plus petit poids de la colonne
de y.
Exemple. Soit C un code linéaire de matrice génératrice G et de matrice de contrôle H.

1 0 1 0 1 1 1 0
G= ,H =
0 1 1 1 0 1 0 1
Mots { 00 10 01 11
d’information
Mots { 0000 1010 0111 1101 0
codes 0
1
1000 0010 1111 0101 0
1
0100 1110 0011 1001 1
0
0001 1011 0110 1100 1
|{z} |{z}
Leaders de classe Syndromes
Si y = (1110) est le message reçu, plutôt que de chercher y dans le tableau, ce qui serait coûteux
pour de grands tableaux, on calcule son syndrome :

1
S(y) = Hy t =
1
22
Il vient ensuite immédiatement que le vecteur erreur est le leader de la classe correspondante, ayant le
même syndrome, donc e = (0100), et on décode y en x = y − e = (1010)
Cette méthode est toutefois limitée, car pour de très grands codes, il devient impossible de trouver
les leaders de classe. Un code binaire de longueur 50 et de dimension 20 possède ≈ 10 9 classes. Pour
surmonter ces difficultés, il va falloir construire des codes particuliers.
3.3. Classe des codes de Hamming

Théorème 3.12 Soit C un code linéaire binaire de matrice de correction H. Alors, le syndrome d’un
vecteur reçu est égal à la somme des colonnes de H correspondant aux positions des erreurs.
Preuve : On note hj la j me colonne de H, et soit y = x + e le message reçu, x ∈ C. Alors, S(y) = Het .

Si
e = (0, · · · , 0, 1 , 0, · · · , 0, 1 , 0, · · · ),
i1 i2
alors
S(y) = hi1 + hi2 + · · ·
Si toutes les colonnes de H sont différentes, une erreur simple en ime position entraîne S(y) = hj , donc
une erreur peut être corrigée. Dans le cas de codes visant à corriger une erreur, la classe des codes de
Hamming simplifie le problème de la localisation de l’erreur.
Définition 3.13 Un code binaire Cm , de longueur n = 2m − 1, m ≥ 2, de matrice de correction

m × (2m − 1) H est appelé code de Hamming binaire si les colonnes de H sont les écritures binaires de
1, 2, · · · , 2m − 1.
Lemme 3.14 Cm est de dimension 2m − m − 1 et corrige 1 erreur.
Preuve : Par construction, H est de rang m, et deux colonnes distinctes de H sont toujours linéairement
indépendantes. En revanche, comme H contient avec deux colonnes distinctes également leur somme, on
a l’écart de C d = 3, donc C corrige une erreur.
Exemple Soit C3 le code de Hamming binaire de longueur 7 et de dimension 4. Alors sa matrice de
correction est  
0 0 0 1 1 1 1
H= 0 1 1 0 0 1 1
1 0 1 0 1 0 1
Le message reçu y = (1101111) a pour syndrome S(y) = (011)t , alors nous pouvons affirmer qu’une
erreur s’est produite en 3me position, puisque 011 est l’écriture de 3 en base 2, donc le mot de code
corrigé est x = (1111111).
Remarque 3.15 On peut définir les codes de Hamming q-aires C(m, q) pour tout corps finis F q . Ils sont
de type [(q m − 1)/(q − 1), (q m − 1)/(q − 1) − m, 3], et la matrice de contrôle est formée par les colonnes
representant les coordonnées homogènes de points différents de l’espace projectif P m−1Fq
Remarque 3.16 Les codes de Hamming C(m, q) sont parfaits : ils réalisent un empilement de sphères
de rayon 1 dans Fnq .
Rapellons que
r
X n
Card B(x, r) = Vq (n, r) = (q − 1)i
i=0
i
23
donc
Vq (n, 1) = 1 + n(q − 1).
La borne d’empilement de sphères de rayon 1a la forme :
q n ≤ q k Vq (n, 1) ⇐⇒ q n−k ≤ 1 + n(q − 1),
et cette borne est atteinte puisque n − k = m, q m = 1 + n(q − 1).
3.4. Codes cycliques

Définition 3.17 Un code linéaire C ⊂ Fnq est dit cyclique si
(a0 , · · · , an−1 ) ∈ C ⇐⇒ (an−1 , a0 , . . . , an−2 ) ∈ C
Pour la suite, nous supposons que pgcd(n, q) = 1 et on notera (xn − 1) l’idéal de Fq [x] engendré
par xn − 1. Alors, tout élément de Fq [x]/(xn − 1) peut être représenté par des polynômes de degré
inférieur à n (ou le polynôme nul), et cet anneau est ainsi isomorphe à Fnq comme Fq -espace vectoriel.
Un isomorphisme est par exemple
(a0 , · · · , an−1 ) ↔ a0 + a1 x + a2 x2 + ... + an−1 xn−1
Cet isomorphisme permet de considérer les éléments de Fq [x]/(xn − 1) comme des vecteurs de Fnq ou
comme des polynômes de degré < n modulo xn − 1. La multiplication des polynômes modulo xn − 1 est
introduite de manière usuelle, c’est à dire que si f ∈ Fq [x]/(xn − 1), et g1 , g2 ∈ Fq [x], alors g1 g2 = f ⇐⇒
g1 g2 ≡ f mod (xn − 1).
3.5. Constructions
3.5.1. Construction par polynôme générateur
Pour obtenir un code cyclique de dimension k et de longueur n, on peut coder les messages à trans-
mettre (identifiés à des polynômes de degré ≤ k − 1) en les multipliant par un polynôme g donné de
degré n − k diviseur de xn − 1. La correspondance
(a0 , · · · , an−1 ) ←→ f (x) = an−1 xn−1 + · · · + a1 x + a0
entre les vecteurs et les polynômes permet d’interpréter C comme le sous-espace suivant :
C = h1 · g(x), x · g(x), x2 · g(x), · · · , xk−1 · g(x)i ⊂ Fq [x]/(xn − 1)
de l’anneau quotient
Fq [x]/(xn − 1).
Théorème 3.18 Le code linéaire C est cyclique si et seulement si C est un idéal de F q [x]/(xn − 1).
Preuve : Si C est un idéal de Fq [x]/(xn − 1), et (a0 , · · · , an−1 ) ∈ C, alors
x · (a0 , · · · , an−1 ) = (an−1 , a0 , · · · , an−2 ) ∈ C.
Inversement, si C est cyclique, pour tout a(x) ∈ C, xa(x) ∈ C, x2 a(x) ∈ C et ainsi de suite, donc
b(x)a(x) ∈ C et C est un idéal.
L’anneau Fq [x] est principal, donc tous les idéaux de l’anneau Fq [x]/(xn − 1) sont principaux. En
particulier, tout idéal non nul est engendré par un polynôme g(x) de plus bas degré qu’il contient, et
g(x) divise xn − 1 :
C = h1 · g(x), x · g(x), x2 · g(x), · · · , xk−1 · g(x)i,
24
3.5.2. Construction par polynôme correcteur
Si g(x) = g0 + g1 x + · · · + gn−k xn−k , une matrice génératrice du code C est
 
g0 g1 · · · gn−k 0 0 ··· 0
 0 g 0 g 1 · · · g n−k 0 ··· 0 
G= · · · · · · · · ·

··· ··· ··· ··· ··· 
0 ··· ··· 0 g0 g1 · · · gn−k
Les lignes de G sont, de manière évidente, linéairement indépendantes et rg(G) = k, la dimension du
code.
Proposition 3.19 Si h(x) = (xn − 1)/g(x) = h0 + · · · + hk xk , alors
 
0 0 ··· 0 hk hk−1 · · · h1 h0
 0 0 · · · h k h k−1 h k−2 ··· h0 0
H =  ···

··· ··· ··· ··· ··· ··· ··· · · ·
hk hk−1 · · · h0 0 ··· ··· ··· 0
est une matrice de contrôle de C.
Preuve. (voir [MW-S], p. 194) : En effet, soit
h(x) = (xn − 1)/g(x) (3.3)
k
X n−1
X
= h 0 + h 1 x + h 2 x2 + . . . + h k xk = h j xj = hj xj où hj = 0 pour j ≥ k + 1.
j=0 j=0
Alors une condition nécessaire pour que

f (x) = a0 + a1 x + a2 x2 + ... + an−1 xn−1
appartienne au code C = (g), est donnée par la congruence suivante :
f (x) = g(x) · u(x) ⇒ h(x) · f (x) = h(x)g(x) · u(x) ≡ 0 mod (xn − 1).
On calcule donc le produit
k
X n−1
X k n−1
X X
h(x) · f (x) = h j xj a i xi = hj ai xi+j , où i + j ≤ k + n − 1 ≤ 2n − 1.
j=0 i=0 j=0 i=0
De plus,
xi+j ≡ xi+j−n mod (xn − 1), si i + j ≥ n.
On pose l = i + j, alors
k n−1
X X
h(x) · f (x) = hj ai xi+j (3.4)
j=0 i=0
n−1
X n−1
X 2n−1
X n−1
X
= hl−i ai xl + hl−i ai xl
l=0 i=0 l=n i=0
n−1
X n−1
X n−1
X n−1
X 0
≡ hl−i ai xl + hl0 +n−i ai xl mod (xn − 1)
l=0 i=0 l0 =0 i=0
n−1
X n−1X n−1
X
= ( hl−i ai + hl+n−i ai )xl
l=0 i=0 i=0
25
(on a utilisé la notation l 0 = l − n pour l ≥ n). Puis, on observe que la somme sur l 0 dans (3.4) est nulle
dès que l0 ≥ k puisque l0 + n − i ≥ k + 1 et donc hl0 +n−i = 0 par (3.3).
Donc, pour tous les l = k, k + 1, · · · , n − 1 il n’y a qu’une seule somme , et on a la condition suivante :
pour tous les l = k, k + 1, · · · , n − 1
n−1
X
hl−i ai = 0.
i=0
Donc une condition nécessaire consiste a un système de k − n équations linéaires

n−1
X
hl−i ai = 0, (l = k, k + 1, · · · , n − 1) (3.5)
i=0
de plus, hl−i = 0 si l − i ≥ k + 1 ⇐⇒ hl−i = 0 si i ≤ l − k − 1. Le système devient donc



 (l = n − 1) 0 · a0 + · · · + hk · an−k−1 + · · · + h1 · an−2 + · · · + h0 · an−1 =0

(l = n − 2) 0 · a0 + · · · + hk · an−k−2 + hk−1 · an−k−1 + · · · + h0 · an−2 + 0 · an−1 =0
,

 ··· ······························ =0

(l = k) hk · a0 + · · · + h0 · ak + 0 · ak+1 + · · · + h0 · an−2 + · · · + 0 · an−1 =0
c’est à dire, la matrice du système est la matrice suivante (de rang n − k, puisque h 0 6= 0)
 
0 0 ··· 0 hk hk−1 · · · h1 h0
 0 0 · · · hk hk−1 hk−2 · · · h0 0
H =  ···

··· ··· ··· ··· ··· · · · · · · · · ·
hk hk−1 · · · h0 0 ··· ··· ··· 0
Comme la condition est nécessaire, ce système donne un sous-espace vecoriel de C de dimension n − (n −

k) = k. Mais la dimension du code C est égale à k donc la condition de contrôle (3.5) est nécessaire et
suffisante.
Définition 3.20 Soit C = (g(x)) un code cyclique. Alors g(x) est appelé polynôme générateur de C, et
h(x) = (xn − 1)/g(x) est appelé polynôme correcteur de C.
Soit xn − 1 = f1 (x)f2 (x) · · · fm (x) la décomposition de xn − 1 en facteurs irréductibles sur Fq . Nous

supposons dans cette partie que pgcd(n, q) = 1, ce qui élimine l’éventualité de facteurs multiples. Si f i (x)
est irréductible sur Fq , alors (fi (x)) est un idéal maximal et C est un code cyclique maximal. On engendre
tous les codes cycliques de longueur n sur Fq grâce à la factorisation ci-dessus, en choisissant n’importe
quel diviseur de xn − 1 (parmi les 2m diviseurs distincts de xn − 1) comme polynôme générateur. On a de
plus les mêmes propriétés que pour les codes construits à partir de matrices. En effet, si C est cyclique,
g(x) et h(x) sont des polynômes respectivement générateur et correcteur de C, alors v(x) ∈ F q [x]/(xn −1)
est un mot du code C si et seulement si v(x)h(x) ≡ 0 mod (xn − 1). Un message a(x) est codé en
w(x) = a(x)g(x). Si on divise le message reçu v(x) par g(x) et que le reste est non nul, on sait que des
erreurs sont survenues :
v(x) = b(x)g(x) + r(x).
Ceci dit, le syndrôme S(v) = r(x) est le reste de la division euclidienne. Un decodage possible de v(x)
est donc b(x).
Pour avoir un décodage standard ("de vraisemblence maximale") d’un mot v(x) on choisit parmi les
polynômes
v(x) − ã(x)g(x), ã(x) = a00 + a01 x + · · · a0k−1 xk−1
un polynôme de nombre minimum des coefficients non nuls. Avec ce choix, on déclare
ã(x) = a00 + a01 x + · · · a0k−1 xk−1
26
un mot décodé.
On peut obtenir la matrice génératrice canonique de C de la manière suivante (voir [Li-Ni],Ch. IX,
§2). Soit deg(g(x)) = n − k. Alors il existe avec unicité aj (x) et rj (x) avec deg(rj (x)) < n − k et tels
que xj = aj (x)g(x) + rj (x). Ainsi, xj − rj (x) ∈ C, ainsi que gj (x) = xk (xj − rj (x)) considéré modulo
xn − 1 Les polynômes gj (x), pour n − k ≤ j ≤ n − 1, sont linéairement indépendants et forment la
matrice génératrice canonique de C : (Ik , −R), où la ième ligne de R est le vecteur des coefficients de
rn−k−1+i (x) :
gn−k = xk (xn−k − rn−k (x)) ≡ 1 + xk rn−k (x) mod (xn − 1), deg xk rn−k (x) < n
gn−k+1 = xk (xn−k+1 − rn−k (x)) ≡ x + xk rn−k+1 (x) mod (xn − 1), deg xk rn−k+1 (x) < n
······························
gn−1 = xk (xn−1 − rn−1 (x)) ≡ xk−1 + xk rn−1 (x) mod (xn − 1), deg xk rn−1 (x) < n.
Exemple Soit n = 7, q = 2. Alors
x7 − 1 = (x + 1)(x3 + x + 1)(x3 + x2 + 1)
et g(x) = x3 + x2 + 1 engendre un code cyclique de longueur 7 et de dimension 4 de polynôme correcteur
h(x) = (x7 − 1)/g(x) = (x + 1)(x3 + x + 1) = x4 + x3 + x2 + x + 1

> restart;g:=x^3+x^2+1 mod 2;
g := x3 + x2 + 1
> r[3]:=rem(x^3, g,x)mod 2;

r3 := 1 + x2
> r[4]:=rem(x^4, g,x)mod 2;
r4 := x + 1 + x2
> r[5]:=rem(x^5, g,x)mod 2;
r5 := x + 1
> r[6]:=rem(x^6, g,x)mod 2;
r6 := x2 + x
Les matrices canoniques (voir Définition 3.4) génératrice et correctrice correspondantes sont
 
1 0 0 0 1 0 1  
1 1 1 0 1 0 0
 0 1 0 0 1 1 1 
G= , H = 0 1 1 1 0 1 0
 0 0 1 0 1 1 0
1 1 0 1 0 0 1
0 0 0 1 0 1 1
27
4. Polynômes locateurs d’erreurs. Application au décodage
4.1. Construction de codes cycliques à partir des racines.
Lorsque l’on définit un code cyclique par un polynôme générateur g, tous les mots du code sont
multiples de ce polynôme, et s’annulent donc sur l’ensemble des racines de g. De plus, on peut trouver
une extension de Fq contenant ces racines. Soient donc α1 , · · · , αs des éléments d’une extension Fqm de
Fq , et pi (x) le polynôme minimal de αi sur Fq , 1 ≤ i ≤ s. Soit n ∈ N tel que αni = 1, 1 ≤ i ≤ s, et soit
g(x) = ppcm(p1 (x), · · · , ps (x)). Dans ces conditions, g(x) divise xn − 1 et si C est le code de polynôme
générateur g, on a
v(x) ∈ C ⇐⇒ v(αi ) = 0, i = 1, · · · , s
Dans ce qui suit, nous allons étudier l’intérêt de cette méthode de construction de codes cycliques, par
rapport à la construction directe par polynôme générateur.
Théorème 4.1 : Soit C ⊂ Fq [x]/(xn −1) un code cyclique de polynôme générateur g dont les racines sont
α1 , · · · , αn−k . Alors, f ∈ Fq [x]/(xn − 1) est un mot du code si et seulement si le vecteur des coefficients
de f (f0 , · · · , fn−1 ) est dans le noyau de
 
1 α1 α21 · · · α1n−1
H = : : : : : 
2 n−1
1 αn−k αn−k · · · αn−k
Preuve : f ∈ C si et seulement si f (αi ) = 0 pour 1 ≤ i ≤ n − k, ce qui équivaut bien à l’assertion du

théorème.
Théorème 4.2 Le code cyclique binaire e de longueur n = 2m − 1 dont le polynôme générateur est
le polynôme minimal sur F2 d’un élément primitif de F2m est équivalent au code de Hamming binaire
(n, n − m).
Preuve : Si α est un élément primitif de F2m :

m
F∗2m = hαi = {1, α, α2 , · · · , α2 −2
}
alors son polynôme minimal sur F2 est

m−1
p(x) = (x − α)(x − α2 )(x − α4 ) · · · (x − α2 )
et
{1, α, α2 , · · · , αm−1 }
est une base de F2m sur F2 . Soit alors H la matrice dont la j ème colonne est (c0 , · · · , cm−1 )t , avec
αj−1 = c0 + c1 α + · · · + cm−1 αm−1 , et les ci dans F2 . Soit alors a(x) = a0 + a1 x + · · · + an−1 xn−1 ∈ F2 [x]
avec n = 2m − 1. On a Hat = a(α), exprimé dans la base {1, α, · · · , αm−1 }. La matrice H est donc
une matrice de contrôle du code engendré par p(x), et les colonnes de H sont une permutation des
représentations binaires des 2m − 1 premiers entiers, qui forment une matrice de correction du code de
Hamming binaire (n, n − m), et les deux codes sont donc équivalents.
Exemple. Considérons le polynôme p(x) = x4 + x + 1. Il est primitif sur F2 et une de ses racines α est
un élément primitif de F16 :
α4 = 1 + α, α5 = α + α2 , α6 = α2 + α3 , α7 = 1 + α + α3 , α8 = 1 + α2 ,
α9 = α + α3 , α10 = 1 + α + α2 , α11 = α + α2 + α3 , α12 = 1 + α + α2 + α3 ,
α13 = 1 + α2 + α3 , α14 = 1 + α3 , α15 = 1.
28
Ecrivons H dont la j ème colonne est αj−1 exprimé dans la base {1, α, α2 , α3 }, 0 ≤ j ≤ 14. Il vient
 
1 0 0 0 1 0 0 1 1 0 1 0 1 1 1
 0 1 0 0 1 1 0 1 0 1 1 1 1 0 0 
H =  0 0 1 0

0 1 1 0 1 0 1 1 1 1 0 
0 0 0 1 0 0 1 1 0 1 0 1 1 1 1
Si alors a(x) = a0 + · · · + a10 x10 est le message à transmettre, il sera codé en w(x) = a(x)(x4 + x + 1).
Supposons qu’une erreur survienne au cours de la transmission, le message reçu est alors v(x) = w(x) +
xe−1 . Son syndrome est S(v) = v(α) = w(α) + αe−1 = αe−1 , et on sait qu’une erreur est survenue en
eème position.
4.2. Exemples : codes de Golay

4.2.1. Code G23
On considère le groupe cyclique F∗211 d’ordre 211 − 1 = 23 · 89. Soit α ∈ F∗211 une racine primitive de
degré 23. On pose
( 22
)
X
23
G23 = x = (x0 , · · · , x22 ) ∈ F2 | xi α = 0 ⊂ F2 [x]/(x23 − 1).
i
i=0
On a n=23, q = 2,
X 23 − 1 = X 23 + 1 = (x + 1)g0 (x)g1 (x) =

(x + 1) (x11 + x10 + x6 + x5 + x4 + x2 + 1) (x11 + x9 + x7 + x6 + x5 + x + 1)
où
Y
g0 (x) = x11 + x10 + x6 + x5 + x4 + x2 + 1 = (x − αi ), I = {1, 2, 3, 4, 6, 8, 9, 12, 13, 16, 18}
i∈I
Y
11 9 7 6 5
g1 (x) = x +x +x +x +x +x+1= (x − αj ), J = {5, 7, 10, 11, 14, 15, 17, 19, 20, 21, 22}
j∈J
Remarque. L’ensemble
I = {1, 2, 3, 4, 6, 8, 9, 12, 13, 16, 18}
coïncide avec l’ensemble des résidues quadratiques modulo 23, et l’ensemble complémentaire
J = {5, 7, 10, 11, 14, 15, 17, 19, 20, 21, 22}
coïncide avec l’ensemble des non-résidues quadratiques modulo 23.

2
L’application de Frobenius αk 7→ α2k laisse
I et J stable puisque 23 = 1, et l’application αk 7→ α−k
−1
échange les ensembles I et J puisque 23 = −1, grâce à la loi de réciprocité quadratique de Gauss :
pour les nombres premiers positifs impairs p, q on a

p q (p−1) (q−1)
= (−1) 2 2 ,
q p
et on a les deux compléments suivants de cette loi :

2 2 −1
= (−1)(p −1)/8 , = (−1)(p−1)/2 ,
p p
29
Définition 4.3 Code de Golay G23 est un sous-espace vectoriel (g0 ) de dimension 12 dans le quotient
F2 [x]/(x23 − 1)
vu comme un espace vectoriel de dimension 23 sur F2 avec le polynôme générateur
g0 (x) = x11 + x10 + x6 + x5 + x4 + x2 + 1
et avec le polynome de contrôle
h(x) = (x + 1) (x11 + x9 + x7 + x6 + x5 + x + 1) = (x + 1)g1 (x)
C’est un [23, 12, 7]2-code.

> restart ;
> with(linalg) :
Warning, the protected names norm and trace have been redefined and
unprotected
> Factor(x^23+1) mod 2;
(x + 1) (x11 + x10 + x6 + x5 + x4 + x2 + 1) (x11 + x9 + x7 + x6 + x5 + x + 1)
> g:=x^11+x^10+x^6+x^5+x^4+x^2+1;irreduc(g) mod 2;
g := x11 + x10 + x6 + x5 + x4 + x2 + 1
true
> alias(alpha = RootOf(g)) ;
α
> Factor(g,alpha) mod 2;
(x + α9 ) (x + α6 ) (x + α9 + α8 + α6 + α5 + α2 + α) (x + α4 )
(x + α8 + α7 + α6 + α5 + α3 + α2 + 1) (x + α10 + α8 + α6 + α3 + α + 1)
(x + α10 + α7 + α4 + α3 + α2 + α + 1) (x + α) (x + α2 ) (x + α8 ) (x + α3 )
> for i from 0 to 23 do
> if Eval(g, x=alphaî) mod 2 = 0 then Expand (alphaî) mod 2;
> print(’i’=i, alphaî=Expand (alphaî) mod 2, ’g’(alphaî)=0) fi
> od ;
i = 1, α = α, g(α) = 0
i = 2, α2 = α2 , g(α2 ) = 0
i = 3, α3 = α3 , g(α3 ) = 0
i = 4, α4 = α4 , g(α4 ) = 0
i = 6, α6 = α6 , g(α6 ) = 0
i = 8, α8 = α8 , g(α8 ) = 0
i = 9, α9 = α9 , g(α9 ) = 0
i = 12, α12 = α10 + α7 + α4 + α3 + α2 + α + 1, g(α12 ) = 0
i = 13, α13 = α10 + α8 + α6 + α3 + α + 1, g(α13 ) = 0
i = 16, α16 = α9 + α8 + α6 + α5 + α2 + α, g(α16 ) = 0
i = 18, α18 = α8 + α7 + α6 + α5 + α3 + α2 + 1, g(α18 ) = 0
30
> if Eval(g, x=alpha^(-i)) mod 2 = 0 then Expand (alpha^(-i)) mod 2;
> print(’i’=i, alpha^(i)=Expand (alphaî) mod 2, ’g’(alpha^(-i))=0) fi
> od ;
1
i = 5, α5 = α5 , g( 5 ) = 0
α
1
i = 7, α7 = α7 , g( 7 ) = 0
α
1
i = 10, α10 = α10 , g( 10 ) = 0
α
1
i = 11, α11 = α10 + α6 + α5 + α4 + α2 + 1, g( 11 ) = 0
α
1
i = 14, α14 = α10 + α9 + α7 + α6 + α5 + α + 1, g( 14 ) = 0
α
1
i = 15, α15 = α8 + α7 + α5 + α4 + α + 1, g( 15 ) = 0
α
1
i = 17, α17 = α10 + α9 + α7 + α6 + α3 + α2 , g( 17 ) = 0
α
1
i = 19, α19 = α9 + α8 + α7 + α6 + α4 + α3 + α, g( 19 ) = 0
α
1
i = 20, α20 = α10 + α9 + α8 + α7 + α5 + α4 + α2 , g( 20 ) = 0
α
1
i = 21, α21 = α9 + α8 + α4 + α3 + α2 + 1, g( 21 ) = 0
α
1
i = 22, α22 = α10 + α9 + α5 + α4 + α3 + α, g( 22 ) = 0
α
> g[1]:=x^11+x^9+x^7+x^6+x^5+x+1;Factor(g[1],alpha) mod 2;
g1 := x11 + x9 + x7 + x6 + x5 + x + 1
(x + α10 + α9 + α7 + α6 + α3 + α2 ) (x + α10 + α6 + α5 + α4 + α2 + 1) (x + α7 )
(x + α8 + α7 + α5 + α4 + α + 1) (x + α10 ) (x + α5 ) (x + α10 + α9 + α5 + α4 + α3 + α)
(x + α9 + α8 + α7 + α6 + α4 + α3 + α) (x + α9 + α8 + α4 + α3 + α2 + 1)
(x + α10 + α9 + α7 + α6 + α5 + α + 1) (x + α10 + α9 + α8 + α7 + α5 + α4 + α2 )
Code de Golay G23 = (g) est un sous-espace vectoriel de dimension 12 dans le quotient
F2 [x]/(x23 − 1)
(vu comme un espace vectoriel de dimension 23 sur F2 ) avec le polynôme générateur
g := x11 + x10 + x6 + x5 + x4 + x2 + 1
et avec le polynome de contrôle h = (x + 1) (x11 + x9 + x7 + x6 + x5 + x + 1) ,
h = x12 + x11 + x10 + x9 + x8 + x5 + x2 + 1.
C’est un [23, 12, 7]2-code.

> if Eval(g[1], x=alphaî) mod 2 = 0 then Expand (alphaî) mod 2;
> print(’i’=i, alphaî=Expand (alphaî) mod 2, ’g[1]’(alphaî)=0) fi
> od ;
31
i = 5, α5 = α5 , g1 (α5 ) = 0
i = 7, α7 = α7 , g1 (α7 ) = 0
i = 10, α10 = α10 , g1 (α10 ) = 0
i = 11, α11 = α10 + α6 + α5 + α4 + α2 + 1, g1 (α11 ) = 0
i = 14, α14 = α10 + α9 + α7 + α6 + α5 + α + 1, g1 (α14 ) = 0
i = 15, α15 = α8 + α7 + α5 + α4 + α + 1, g1 (α15 ) = 0
i = 17, α17 = α10 + α9 + α7 + α6 + α3 + α2 , g1 (α17 ) = 0
i = 19, α19 = α9 + α8 + α7 + α6 + α4 + α3 + α, g1 (α19 ) = 0
i = 20, α20 = α10 + α9 + α8 + α7 + α5 + α4 + α2 , g1 (α20 ) = 0
i = 21, α21 = α9 + α8 + α4 + α3 + α2 + 1, g1 (α21 ) = 0
i = 22, α22 = α10 + α9 + α5 + α4 + α3 + α, g1 (α22 ) = 0
> (x^11+x^10+x^6+x^5+x^4+x^2+1)*(x+1)*(x^11+x^9+x^7+x^6+x^5+x+1);g:=x^1
> 1+x^10+x^6+x^5+x^4+x^2+1;
(x11 + x10 + x6 + x5 + x4 + x2 + 1) (x + 1) (x11 + x9 + x7 + x6 + x5 + x + 1)
g := x11 + x10 + x6 + x5 + x4 + x2 + 1
> G:= matrix(12, 23,
> [[1,0,1,0,1,1,1,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0],
> [0,1,0,1,0,1,1,1,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0],
> [0,0,1,0,1,0,1,1,1,0,0,0,1,1,0,0,0,0,0,0,0,0,0],
> [0,0,0,1,0,1,0,1,1,1,0,0,0,1,1,0,0,0,0,0,0,0,0],
> [0,0,0,0,1,0,1,0,1,1,1,0,0,0,1,1,0,0,0,0,0,0,0],
> [0,0,0,0,0,1,0,1,0,1,1,1,0,0,0,1,1,0,0,0,0,0,0],
> [0,0,0,0,0,0,1,0,1,0,1,1,1,0,0,0,1,1,0,0,0,0,0],
> [0,0,0,0,0,0,0,1,0,1,0,1,1,1,0,0,0,1,1,0,0,0,0],
> [0,0,0,0,0,0,0,0,1,0,1,0,1,1,1,0,0,0,1,1,0,0,0],
> [0,0,0,0,0,0,0,0,0,1,0,1,0,1,1,1,0,0,0,1,1,0,0],
> [0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,1,1,0,0,0,1,1,0],
> [0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,1,1,0,0,0,1,1]]) ;
 
1 0 1 0 1 1 1 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0
 0 1 0 1 0 1 1 1 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 
 
 0 0 1 0 1 0 1 1 1 0 0 0 1 1 0 0 0 0 0 0 0 0 0 
 
 0 0 0 1 0 1 0 1 1 1 0 0 0 1 1 0 0 0 0 0 0 0 0 
 
 0 0 0 0 1 0 1 0 1 1 1 0 0 0 1 1 0 0 0 0 0 0 0 
 
 0 0 0 0 0 1 0 1 0 1 1 1 0 0 0 1 1 0 0 0 0 0 0 
G := 
 0 0 0 0 0 0 1 0 1 0 1 1 1 0 0 0 1

 1 0 0 0 0 0 

 0 0 0 0 0 0 0 1 0 1 0 1 1 1 0 0 0 1 1 0 0 0 0 
 
 0 0 0 0 0 0 0 0 1 0 1 0 1 1 1 0 0 0 1 1 0 0 0 
 
 0 0 0 0 0 0 0 0 0 1 0 1 0 1 1 1 0 0 0 1 1 0 0 
 
 0 0 0 0 0 0 0 0 0 0 1 0 1 0 1 1 1 0 0 0 1 1 0 
0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 1 1 1 0 0 0 1 1
> transpose(G);
32
 
1 0 0 0 0 0 0 0 0 0 0 0

 0 1 0 0 0 0 0 0 0 0 0 0 


 1 0 1 0 0 0 0 0 0 0 0 0 


 0 1 0 1 0 0 0 0 0 0 0 0 


 1 0 1 0 1 0 0 0 0 0 0 0 


 1 1 0 1 0 1 0 0 0 0 0 0 


 1 1 1 0 1 0 1 0 0 0 0 0 


 0 1 1 1 0 1 0 1 0 0 0 0 


 0 0 1 1 1 0 1 0 1 0 0 0 


 0 0 0 1 1 1 0 1 0 1 0 0 


 1 0 0 0 1 1 1 0 1 0 1 0 


 1 1 0 0 0 1 1 1 0 1 0 1 


 0 1 1 0 0 0 1 1 1 0 1 0 


 0 0 1 1 0 0 0 1 1 1 0 1 


 0 0 0 1 1 0 0 0 1 1 1 0 


 0 0 0 0 1 1 0 0 0 1 1 1 


 0 0 0 0 0 1 1 0 0 0 1 1 


 0 0 0 0 0 0 1 1 0 0 0 1 


 0 0 0 0 0 0 0 1 1 0 0 0 


 0 0 0 0 0 0 0 0 1 1 0 0 


 0 0 0 0 0 0 0 0 0 1 1 0 

 0 0 0 0 0 0 0 0 0 0 1 1 
0 0 0 0 0 0 0 0 0 0 0 1
> (x^11+x^10+x^6+x^5+x^4+x^2+1)*(x+1)*(x^11+x^9+x^7+x^6+x^5+x+1);
(x11 + x10 + x6 + x5 + x4 + x2 + 1) (x + 1) (x11 + x9 + x7 + x6 + x5 + x + 1)
> ’h’=(x+1)*(x^11+x^9+x^7+x^6+x^5+x+1);
> h:=Expand((x+1)*(x^11+x^9+x^7+x^6+x^5+x+1)) mod 2;
h = (x + 1) (x11 + x9 + x7 + x6 + x5 + x + 1)
h := x12 + x11 + x10 + x9 + x8 + x5 + x2 + 1
> ’h’=(x+1)*(x^11+x^9+x^7+x^6+x^5+x+1);’h’=sort(h,x);
h = (x + 1) (x11 + x9 + x7 + x6 + x5 + x + 1)
h = x12 + x11 + x10 + x9 + x8 + x5 + x2 + 1
> Expand(h*g) mod 2;

1 + x23
33
> H:= matrix(11, 23,
> [[0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,1,0,0,1,0,1],
> [0,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,1,0,0,1,0,1,0],
> [0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,1,0,0,1,0,1,0,0],
> [0,0,0,0,0,0,0,1,1,1,1,1,0,0,1,0,0,1,0,1,0,0,0],
> [0,0,0,0,0,0,1,1,1,1,1,0,0,1,0,0,1,0,1,0,0,0,0],
> [0,0,0,0,0,1,1,1,1,1,0,0,1,0,0,1,0,1,0,0,0,0,0],
> [0,0,0,0,1,1,1,1,1,0,0,1,0,0,1,0,1,0,0,0,0,0,0],
> [0,0,0,1,1,1,1,1,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0],
> [0,0,1,1,1,1,1,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0],
> [0,1,1,1,1,1,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0],
> [1,1,1,1,1,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0]]) ;
 
0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 0 0 1 0 0 1 0 1
 0 0 0 0 0 0 0 0 0 1 1 1 1 1 0 0 1 0 0 1 0 1 0 
 
 0 0 0 0 0 0 0 0 1 1 1 1 1 0 0 1 0 0 1 0 1 0 0 
 
 0 0 0 0 0 0 0 1 1 1 1 1 0 0 1 0 0 1 0 1 0 0 0 
 
 0 0 0 0 0 0 1 1 1 1 1 0 0 1 0 0 1 0 1 0 0 0 0 
 
 0 0 0 0 0 1 1 1 1 1 0 0 1 0 0 1 0 1
H :=  0 0 0 0 0 

 0 0 0 0 1 1 1 1 1 0 0 1 0 0 1 0 1 0 0 0 0 0 0 
 
 0 0 0 1 1 1 1 1 0 0 1 0 0 1 0 1 0 0 0 0 0 0 0 
 
 0 0 1 1 1 1 1 0 0 1 0 0 1 0 1 0 0 0 0 0 0 0 0 
 
 0 1 1 1 1 1 0 0 1 0 0 1 0 1 0 0 0 0 0 0 0 0 0 
1 1 1 1 1 0 0 1 0 0 1 0 1 0 0 0 0 0 0 0 0 0 0
> K:=multiply(H,transpose(G)) ;
 
2 2 2 2 2 2 4 4 4 4 4 4
 2 2 2 2 2 4 4 4 4 4 4 4 
 
 2 2 2 2 4 4 4 4 4 4 4 2 
 
 2 2 2 4 4 4 4 4 4 4 2 2 
 
 2 2 4 4 4 4 4 4 4 2 2 2 
 
 2 4 4 4 4 4 4 4 2 2 2 2 
K :=  
 4 4 4 4 4 4 4 2 2 2 2 2 
 
 4 4 4 4 4 4 2 2 2 2 2 2 
 
 4 4 4 4 4 2 2 2 2 2 2 0 
 
 4 4 4 4 2 2 2 2 2 2 0 2 
4 4 4 2 2 2 2 2 2 0 2 0
• Les termes de la matrice obtenue ne sont pas « réduits » à leur forme canonique dans GF(2 11 ) = F2 [
α]. Pour obtenir la réduction, on utilise :
> map(item -> Expand(item) mod 2, K) ;
34
 
0 0 0 0 0 0 0 0 0 0 0 0

 0 0 0 0 0 0 0 0 0 0 0 0 


 0 0 0 0 0 0 0 0 0 0 0 0 


 0 0 0 0 0 0 0 0 0 0 0 0 


 0 0 0 0 0 0 0 0 0 0 0 0 


 0 0 0 0 0 0 0 0 0 0 0 0 


 0 0 0 0 0 0 0 0 0 0 0 0 


 0 0 0 0 0 0 0 0 0 0 0 0 


 0 0 0 0 0 0 0 0 0 0 0 0 

 0 0 0 0 0 0 0 0 0 0 0 0 
0 0 0 0 0 0 0 0 0 0 0 0
%1 := [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
Une autre matrice de contrôle :

on considère la matrice dont la j-me colonne est formée par les coordonnées de α j−1 (j = 1, 2, ..., 23)
dans la base
h1, α, α2 , . . . , α10 i
GF(211 ) = F2 [α].
> for j from 1 to 23 do print(alpha^(j-1)=Expand(alpha^(j-1)) mod 2) ;
> od;
1=1
α=α
α2 = α 2
α3 = α 3
α4 = α 4
α5 = α 5
α6 = α 6
α7 = α 7
α8 = α 8
α9 = α 9
α10 = α10
α11 = α10 + α6 + α5 + α4 + α2 + 1
α12 = α10 + α7 + α4 + α3 + α2 + α + 1
α13 = α10 + α8 + α6 + α3 + α + 1
α14 = α10 + α9 + α7 + α6 + α5 + α + 1
α15 = α8 + α7 + α5 + α4 + α + 1
α16 = α9 + α8 + α6 + α5 + α2 + α
α17 = α10 + α9 + α7 + α6 + α3 + α2
α18 = α8 + α7 + α6 + α5 + α3 + α2 + 1
α19 = α9 + α8 + α7 + α6 + α4 + α3 + α
α20 = α10 + α9 + α8 + α7 + α5 + α4 + α2
α21 = α9 + α8 + α4 + α3 + α2 + 1
α22 = α10 + α9 + α5 + α4 + α3 + α
35
> H1:= matrix(11, 23,
> [[1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,1,0,0,1,0],
> [0,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,1,0,0,1],
> [0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,1,1,1,0,1,1,0],
> [0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,1,1,1,0,1,1],
> [0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,1,0,0,0,1,1,1,1],
> [0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,1,1,0,1,0,1,0,1],
> [0,0,0,0,0,0,1,0,0,0,0,1,0,1,1,0,1,1,1,1,0,0,0],
> [0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,1,0,1,1,1,1,0,0],
> [0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,1,0,1,1,1,1,0],
> [0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,1,0,1,1,1,1],
> [0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,1,0,0,1,0,1]]) ;
 
1 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 0 0 1 0 0 1 0
 0 1 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 0 0 1 0 0 1 
 
 0 0 1 0 0 0 0 0 0 0 0 1 1 0 0 0 1 1 1 0 1 1 0 
 
 0 0 0 1 0 0 0 0 0 0 0 0 1 1 0 0 0 1 1 1 0 1 1 
 
 0 0 0 0 1 0 0 0 0 0 0 1 1 0 0 1 0 0 0 1 1 1 1 
 
 0 0 0 0 0 1 0 0 0 0 0 1 0 0 1
H1 :=  1 1 0 1 0 1 0 1 

 0 0 0 0 0 0 1 0 0 0 0 1 0 1 1 0 1 1 1 1 0 0 0 
 
 0 0 0 0 0 0 0 1 0 0 0 0 1 0 1 1 0 1 1 1 1 0 0 
 
 0 0 0 0 0 0 0 0 1 0 0 0 0 1 0 1 1 0 1 1 1 1 0 
 
 0 0 0 0 0 0 0 0 0 1 0 0 0 0 1 0 1 1 0 1 1 1 1 
0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 0 0 1 0 0 1 0 1
> K1:=multiply(H1,transpose(G)) ;
 
2 2 2 2 2 2 2 4 4 4 4 4

 0 2 2 2 2 2 2 2 4 4 4 4 


 2 2 2 0 0 2 4 4 2 2 4 4 


 0 2 2 2 0 0 2 4 4 2 2 4 


 2 2 2 0 2 2 2 2 2 4 4 4 

K1 := 
 2 2 0 2 2 4 2 2 2 4 4 4 


 2 2 2 2 2 2 4 4 4 4 2 4 


 0 2 2 2 2 2 2 4 4 4 4 2 


 0 0 2 2 2 2 2 2 4 4 4 4 

 0 0 0 2 2 2 2 2 2 4 4 4 
2 2 2 2 2 2 4 4 4 4 4 4
α]. Pour obtenir la réduction.
> map(item -> Expand(item) mod 2, K1) ;
36
 
0 0 0 0 0 0 0 0 0 0 0 0

 0 0 0 0 0 0 0 0 0 0 0 0 


 0 0 0 0 0 0 0 0 0 0 0 0 


 0 0 0 0 0 0 0 0 0 0 0 0 


 0 0 0 0 0 0 0 0 0 0 0 0 


 0 0 0 0 0 0 0 0 0 0 0 0 


 0 0 0 0 0 0 0 0 0 0 0 0 


 0 0 0 0 0 0 0 0 0 0 0 0 


 0 0 0 0 0 0 0 0 0 0 0 0 

 0 0 0 0 0 0 0 0 0 0 0 0 
0 0 0 0 0 0 0 0 0 0 0 0
%1 := [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
4.2.2. Code G24

de type [24, 12, 8]2 est un 3-correctur ; il est obtenu en ajoutant un contrôle total de parité à la matrice
H de code G23 .
Ce code est bien adapté à la transmission de 4096 nuances de couleur.
4.2.3. Code G11

On considère le groupe cyclique F∗35 d’ordre 35 − 1 = 11 · 22. Soit α ∈ F∗35 une racine primitive de
degré 11. On pose
( 10
)
X
11
G11 = x = (x0 , · · · , x10 ) ∈ F3 | xi α = 0 ⊂ F3 [x]/(x11 − 1).
i
i=0
On a n=11, q = 3,
X 11 − 1 = X 11 + 2 = (x + 2)g0 (x)g1 (x) = (x + 2) (x5 + 2 x3 + x2 + 2 x + 2) (x5 + x4 + 2 x3 + x2 + 2)
où
Y
g0 (x) = x5 + 2 x3 + x2 + 2 x + 2 = (x − αi ), I = {1, 3, 4, 5, 9}
i∈I
Y
5 4 3 2
g1 (x) = x + x + 2 x + x + 2 = (x − αj ), J = {2, 6, 7, 8, 10}
j∈J
Remarque. L’ensemble
I = {1, 3, 4, 5, 9}
coïncide avec l’ensemble des résidues quadratiques modulo 11, et l’ensemble complémentaire
J = {2, 6, 7, 8, 10}
coïncide avec l’ensemble des non-résidues quadratiques modulo 11.
3
L’application de Frobenius αk 7→ α3k laisse
I et J stable puisque 11 = 1, et l’application αk 7→ α−k
−1
échange les ensembles I et J puisque 11 = −1, grâce à la loi de réciprocité quadratique de Gauss :
pour les nombres premiers positifs impairs p, q on a

p q (p−1) (q−1)
= (−1) 2 2 ,
q p
37
et on a les deux compléments suivants de cette loi :

2 2 −1
= (−1)(p −1)/8 , = (−1)(p−1)/2 ,
p p
Définition 4.4 Code de Golay G11 est un sous-espace vectoriel (g0 ) de dimension 6 dans le quotient
F3 [x]/(x11 − 1)
vu comme un espace vectoriel de dimension 11 sur F3 avec le polynôme générateur
g0 (x) = g0 (x) = x5 + 2 x3 + x2 + 2 x + 2
et avec le polynome de contrôle
h(x) = (x + 2) (x5 + x4 + 2 x3 + x2 + 2) = (x + 1)g1 (x)
C’est un [11, 6, 5]3-code.

> q:=3;
q := 3
> restart ;
> with(linalg) :
unprotected
> Factor(x^11-1) mod 3;

(x + 2) (x5 + 2 x3 + x2 + 2 x + 2) (x5 + x4 + 2 x3 + x2 + 2)
> g:=x^5+2*x^3+x^2+2*x+2;irreduc(g) mod 3;

g := x5 + 2 x3 + x2 + 2 x + 2
true

α

(x + 2 α) (x + 2 α3 + α2 + 2 α + 2) (x + 2 α4 ) (x + α4 + 2 α3 + 2 α2 + 2 α + 1) (x + 2 α3 )
> od ;
i = 1, α = α, g(α) = 0
i = 3, α3 = α3 , g(α3 ) = 0
i = 4, α4 = α4 , g(α4 ) = 0
i = 5, α5 = α3 + 2 α2 + α + 1, g(α5 ) = 0
i = 9, α9 = 2 α4 + α3 + α2 + α + 2, g(α9 ) = 0
38
> od ;
1
i = 2, α2 = α2 , g( 2 ) = 0
α
1
i = 6, α6 = α4 + 2 α3 + α2 + α, g( 6 ) = 0
α
1
i = 7, α7 = 2 α4 + 2 α3 + α + 1, g( 7 ) = 0
α
1
i = 8, α8 = 2 α4 + 2 α3 + 2 α2 + 2, g( 8 ) = 0
α
1
i = 10, α10 = α4 + 2 α2 + α + 2, g( 10 ) = 0
α
> (x+2)*(x^5+2*x^3+x^2+2*x+2)*(x^5+x^4+2*x^3+x^2+2);
> ’h’=(x+2)*(x^5+x^4+2*x^3+x^2+2);
> h:= sort(Expand((x+2)*(x^5+x^4+2*x^3+x^2+2)) mod 3,x);
(x + 2) (x5 + 2 x3 + x2 + 2 x + 2) (x5 + x4 + 2 x3 + x2 + 2)
h = (x + 2) (x5 + x4 + 2 x3 + x2 + 2)
h := x6 + x4 + 2 x3 + 2 x2 + 2 x + 1
Code de Golay C11 = (g) est un sous-espace vectoriel de dimension 6 dans le quotient Z3 [
X]/( x11 − 1) vu comme un espace vectoriel de dimension 11 sur Z3 avec le polynôme
générateur
g := x5 + 2 x3 + x2 + 2 x + 2
et avec le polynome de contrôle h = (x + 2) (x5 + x4 + 2 x3 + x2 + 2) ,
h := x6 + x4 + 2 x3 + 2 x2 + 2 x + 1.
C’est un [12,6, 5 ] _ 3-code.
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%%
> G:= matrix(6, 11,

> [[2,2,1,2,0,1,0,0,0,0,0],
> [0,2,2,1,2,0,1,0,0,0,0],
> [0,0,2,2,1,2,0,1,0,0,0],
> [0,0,0,2,2,1,2,0,1,0,0],
> [0,0,0,0,2,2,1,2,0,1,0],
> [0,0,0,0,0,2,2,1,2,0,1]]);
 
2 2 1 2 0 1 0 0 0 0 0
 0 2 2 1 2 0 1 0 0 0 0 
 
 0 0 2 2 1 2 0 1 0 0 0 
G := 
 0

 0 0 2 2 1 2 0 1 0 0 

 0 0 0 0 2 2 1 2 0 1 0 
0 0 0 0 0 2 2 1 2 0 1
> ’h’= x^6+x^4+2*x^3+2*x^2+2*x+1;

h = x6 + x4 + 2 x 3 + 2 x 2 + 2 x + 1
39
> H:= matrix(5, 11,
> [[0,0,0,0,1,0,1,2,2,2,1],
> [0,0,0,1,0,1,2,2,2,1,0],
> [0,0,1,0,1,2,2,2,1,0,0],
> [0,1,0,1,2,2,2,1,0,0,0],
> [1,0,1,2,2,2,1,0,0,0,0]]);
 
0 0 0 0 1 0 1 2 2 2 1
 0 0 0 1 0 1 2 2 2 1 0 
 
 0
H :=  0 1 0 1 2 2 2 1 0 0 

 0 1 0 1 2 2 2 1 0 0 0 
1 0 1 2 2 2 1 0 0 0 0
> sort(Expand(h*g) mod 3,x);
x11 + 2
 
0 3 3 6 9 9

 3 3 6 9 9 12 
K := 
 3 6 9 9 12 12 

 6 9 9 12 12 9 
9 9 12 12 9 6
 
0 0 0 0 0 0

 0 0 0 0 0 0 


 0 0 0 0 0 0 

 0 0 0 0 0 0 
0 0 0 0 0 0
4.2.4. Code G12

de type [12, 6, 6]3 est un 2-correctur ; il est obtenu en ajoutant une ligne de contrôle total à la matrice H
de code G11 .
Exercice. (a) Calculer le volume de la boule de Hamming Vq (n, t), t = 1, 2, 3.
(b) Montrer que la borne de Hamming est atteinte pour les codes G23 et G11 donc on a un emplilement
parfait de sphères.
Remarque 4.5 On peut montrer que les codes G23 , G11 et C(m, q) (voir Section 3.16) sont tous les
codes parfaits.
4.3. Polynômes locateurs d’erreurs

Pour détecter et corriger les erreurs, nous avons vu qu’il fallait déterminer le syndrome du message
reçu. Dans le cas de certains codes cycliques, ce vecteur de longueur n − k peut être remplacé par un
objet plus léger ayant les mêmes possibilités. En effet, soit α une racine nème de l’unité, primitive dans
Fqm et considérons le code généré par g(x), le polynôme minimal de α sur Fq . Soit par exemple
H = (1 α α2 · · · αn−1 )
40
et
S(v) = Hv t = v(α).
Soit w le message émis, posons e(j) (x) = xj−1 , 1 ≤ j ≤ n, et plaçons-nous dans le cas d’une erreur
simple. Il existe donc j, 1 ≤ j ≤ n, tel que v = w + e(j) donc
S(v) = v(α) = w(α) + e(j) (α) = αj−1
e(j) (α) est appelé locateur d’erreur. En effet, comme on a e(j) (α) 6= e(i) (α) pour i 6= j, 1 ≤ i, j ≤ n, αj−1
détermine la position de l’erreur.
4.4. Décodage des codes cycliques

Soit C un code cyclique de polynôme générateur g et soient w le message émis et v le message reçu.
Supposons qu’au plus t erreurs se produisent, et on note t0 le nombre exacte d’erreurs, t0 ≤ t. On utilise
P0
maintenant plusieures racines α1 , · · · , αr de g pour détérminer le polynôme d’erreur e(x) = ti=1 ci xai ,
ou les ai sont tous différentes dans 0, 1, · · · , n − 1, et ci sont les valeurs d’erreurs. On suppose dans cette
section en simplifiant que parmi les racines de g il y a une racine nème de l’unité α , primitive dans Fqm ,
disons α = α1 , et considérons le code engendré par g(x), le polynôme minimal de α sur Fq . On utilise
les notations
0
t
X
bj bj
αj = α , Sbj = e(α ) = c i α bj a i , (4.1)
i=1
Posons alors  
1 α1 α21 ··· α1n−1
H = : : : : : 
1 αr α2r ··· αrn−1
et
S(v) = Hv t = (Sb1 , Sb2 , · · · , Sbr )t .
Soit w le message émis, v = w + e donc
Sbj = v(αj ) = w(αbj ) + e(αbj ) = e(αbj ).
On pose
η i = α ai
pour la racine α fixée, et on introduit le polynôme locateur d’erreur
0 0
t
Y t
X
s(x) = (1 − ηi x) = τt0 −i xi , avec ηi = αai (4.2)
i=1 i=0
Les racines de s(x) sont les ηi−1 , c’est à dire les α−ai .
Soit alors l’identité polynomiale
0 0
t
Y t
X 0 0
(ηj − x) = (−1)i σt0 −i xi = σt0 − σt0 −1 x + · · · + (−1)t σ0 xt . (4.3)
i=1 i=0
Les coefficients σi sont donc σ0 = 1 et pour 1 ≤ i ≤ t0 , les σi sont les polynômes élémentaires symétriques
en η1 , · · · , ηt0 , et τt0 −i = (−1)i σt0 −i xi . En remplaçant x par ηi dans (4.3), il vient
0 0 0 0
(−1)t σt0 + (−1)t −1 σt0 −1 ηi + · · · − σ1 ηit −1 + ηit = 0 (4.4)
41
pour tout 1 ≤ j ≤ t0 . En multipliant par ci ηib et en sommant pour 1 ≤ i ≤ t0 , il vient
0
(−1)t σt0 Sb + (−1)r−1 σr−1 Sb+1 + · · · − σ1 Sb+t0 −1 + Sb+t0 = 0 (4.5)
pour tout b.
Résumé de cette méthode : (on note τi = (−1)i σi ).
- 1ème étape : Déterminer le syndrome
S(v) = (Sb1 , Sb2 , · · · , Sbr )t .
Soit
0 0
t
X t
X n−1
X
a i bj b ibj
S bj = ci α = ci η i j = v i αi (4.6)
i=0 i=0 i=0
- 2ème étape : Trouver les coefficients τt0 −i du polynôme locateur d’erreurs (4.2). Ici on utilise des
relations entre Sbj , ηi et les syndrômes Sbj , par exemple (4.4), (4.5) (voir Section 5.).
- 3ème étape : Chercher les racines de s(x) en testant les différentes puissances de α pour déterminer
les locateurs d’erreurs ηi
- 4ème étape : Remplacer les ηi par leurs valeurs dans l’expression des Sj pour déterminer les valeurs
des erreurs ci (cas non binaire seulement). On obtient ainsi le vecteur erreur e et on peut décoder
w = v − e.
4.4.1. Exemples de decodage des codes cycliques

Soit α un élément primitif de F16 racine du polynôme x4 + x + 1 sur F2 , m(i) (x) le polynôme minimal
unitaire de αi . Alors
m(1) (x) = m(2) (x) = m(4) (x) = m(8) (x) = x4 + x + 1
m(3) (x) = m(6) (x) = m(12) (x) = x4 + x3 + x2 + x + 1
Ainsi, un code de polynôme générateur
g(x) = m(1) (x)m(3) (x) = 1 + x4 + x6 + x7 + x8
est un code cyclique dont les paramètres sont d = 5, q = 2, n = 15. Sa dimension est k = 7 et un
polynôme de correction est
h(x) = (x15 − 1)/g(x) = 1 + x4 + x6 + x7
On construit une matrice génératrice G dont la ième ligne est le vecteur xi−1 g(x), 1 ≤ 1 ≤ k. On obtient
 
1 0 0 0 1 0 1 1 1 0 0 0 0 0 0
 0 1 0 0 0 1 0 1 1 1 0 0 0 0 0 
 
 0 0 1 0 0 0 1 0 1 1 1 0 0 0 0 
 
G=  0 0 0 1 0 0 0 1 0 1 1 1 0 0 0  
 0 0 0 0 1 0 0 0 1 0 1 1 1 0 0 
 
 0 0 0 0 0 1 0 0 0 1 0 1 1 1 0 
0 0 0 0 0 0 1 0 0 0 1 0 1 1 1
La distance du code est 5 donc ce code corrige deux erreurs. Pour cela on considère les composantes
14
X 14
X
S1 = v i αi , S3 = vi α3i .
i=0 i=0
42
du syndrome S(v) = Hv t . Alors v ∈ C si et seulement si S(v) = Hv t = 0. Supposons que le vecteur
reçu v = (v0 , . . . v14 ) contient au plus deux erreurs. Par exemple e(X) = X a1 + X a2 , où 0 ≤ a1 , a2 ≤ 14,
a1 6= a2 . Alors
S1 = αa1 + αa2 , S3 = α3a1 + α3a2 .
Soit η1 = αa1 , η2 = αa2 les locateurs des erreurs, alors
S1 = η1 + η2 , S3 = η13 + η23 ,
ceci implique
S3 = S13 + S12 η1 + S1 η12 ,
donc
1 + S1 η1−1 + (S12 + S3 S1−1 )η1−2 = 0.

1 + S1 η2−1 + (S12 + S3 S1−1 )η2−2 = 0.
S’il y a deux erreurs, η1−1 et η2−1 sont des racines différentes de
s(X) = 1 + S1 X + (S12 + S3 S1−1 )X 2 .
S’il n’y a qu’une seul erreur, S1 = η1 , S3 = η13 donc S13 + S3 = 0, et on a
s(X) = 1 + S1 X.
S’il n’y a pas d’erreurs, S1 = S3 = 0, et on a reçu message correct w. Si S1 6= 0 et S13 + S3 = 0, le

polynôme s(X) a une seule racine dans F16 . Si
s(X) = 1 + S1 X + (S12 + S3 S1−1 )X 2
n’a pas de racines dans F16 , le vecteur d’erreurs e(X) a plus que deux composantes non nuls, et il n’est
pas possible de corriger les erreurs à l’aide de ce code.
Soit par exemple le mot reçu a la forme
v = (100111000000000).
Alors S(v) = (S1 (v), S3 (v)) est donné par
S1 = 1 + α 3 + α 4 + α 5 = α 2 + α 3 ,
S3 = 1 + α9 + α12 + α15 = 1 + α2 .
(rappelons que
α4 = 1 + α, α5 = α + α2 , α6 = α2 + α3 , α7 = 1 + α + α3 , α8 = 1 + α2 ,
α9 = α + α3 , α10 = 1 + α + α2 , α11 = α + α2 + α3 , α12 = 1 + α + α2 + α3 ,
α13 = 1 + α2 + α3 , α14 = 1 + α3 , α15 = 1).
Le polynôme s(X) a la forme suivante :
s(X) = 1 + S1 X + (S12 + S3 S1−1 )X 2 =

1 + (α2 + α3 )X + (1 + α + α2 + α3 + (1 + α2 )(α2 + α3 )−1 )X 2
= 1 + (α2 + α3 )X + (1 + α + α3 )X 2 .
43
On trouve les racines de ce polynôme : X = α et X = α7 . Alors η1−1 = α et η2−1 = α7 , c’est à direη1 = α14 ,
η2 = α8 . On connait alors les erreurs : elles sont dans les positions correspondantes aux X 8 et X 14 , c’est
à direla 9e et la 15e composantes de v. Alors le mot transmis était
w = (100111001000001).
On décode ce mot par la division du polynôme correspondant par le polynôme générateur g(X). On
obtient le polynôme 1 + X 3 + X 5 + X 6 et le reste nul. Alors le message initial était
(1001011)
Exemple.
Si le message reçu est v = (100100110000100), soit encore v(x) = 1 + x 3 + x6 + x7 + x12 . On calcule
alors les composantes du syndrome :
S1 = v(α) = 1 = S2 = S4 , S3 = v(α3 ) = α4
Cette fois on utilise le système linéaire d’équations des inconnues τi provenant des relations (4.4) :
S2 τ 1 + S 1 τ 2 = S 3
S3 τ 1 + S 2 τ 2 = S 4
qui s’écrit également
τ1 + τ 2 = α 4
α4 τ 1 + τ 2 = 1
et dont la matrice est régulière. Il vient
τ1 = 1
τ2 = α
τ0 = 1 par définition, et on a donc s(x) = 1 + x + αx2 .
En testant les différentes puissances de α, on trouve
η1−1 = α8 , η2−1 = α6 ,
et on a donc
η1 = α 7
η2 = α 9
ainsi, le polynôme erreur est
e(x) = x7 + x9
et on peut décoder
w(x) = v(x) − e(x)
= (1 + x3 + x6 + x7 + x12 ) − (x7 + x9 )
= 1 + x3 + x6 + x9 + x12
Le message émis était w = (100100100100100).
Pour retrouver le message original, il suffit de diviser w(x) par g(x). Il vient
a(x) = w(x)/g(x) = 1 + x3 + x4
et enfin
a = (1001100).
44
5. Codes BCH et codes de Reed-Solomon. Codage et décodage
Ce sont des codes cycliques particuliers qui permettent de prévoir la distance minimum avant la
construction.
5.1. Classe des codes BCH (Bose, Ray-Chaudhuri et Hocquenghem)

Lorsque l’on définit un code cyclique par polynôme générateur g, tous les mots du code sont multiples
de ce polynôme, et s’annulent donc sur l’ensemble des racines de g. De plus, on peut trouver une extension
de Fq contenant ces racines. Soient donc α1 , · · · , αs des éléments d’une extension de Fq et pi (x) le
polynôme minimal de αi sur Fq , 1 ≤ i ≤ s. Soit n ∈ N tel que αni = 1, 1 ≤ i ≤ s, et soit g(x) =
ppcm(p1 (x), · · · , ps (x)). Dans ces conditions, g(x) divise xn −1 et si C est le code du polynôme générateur
g, on a
v(x) ∈ C ⇐⇒ v(αi ) = 0, i = 1, · · · , s.
Dans ce qui suit, nous allons étudier l’intérêt de cette méthode de construction de codes cycliques, par
rapport à la construction directe par polynôme générateur.
Théorème 5.1 Soit C un code cyclique sur F de longueur n avec n premier avec q, et de polynôme
générateur g(x). Soit L le corps des racines nèmes de l’unité (le corps de décomposition de xn − 1 sur
Fq ). Soit b un entier, et β une racine primitive nèmes . Si g(x) possède, parmi les racines dans une
extension L de F = Fq , les puissances de β dont les exposants sont d0 − 1 entiers consécutifs, soit
0
β b , β b+1 , . . . , β b+d −2 ,
alors le poids du code C est supériereur ou égal à d0 : d ≥ d0 .
Définition 5.2 Un code BCH de distance construite d0 est un code cyclique dont le générateur est le
0
produit (sans répétition de facteurs) de polynômes minimaux de β b , . . . , β b+d −2 . Dans le cas b = 1 on
dit que c’est un code BCH au sens strict.
Exemple. Soit β un élément primitif de F16 racine du polynôme x4 + x + 1 sur F2 . Alors
m(1) (x) = m(2) (x) = m(4) (x) = m(8) (x) = x4 + x + 1
m(3) (x) = m(6) (x) = m(9) (x) = m(12) (x) = x4 + x3 + x2 + x + 1

g(x) = m(1) (x)m(3) (x) = 1 + x4 + x6 + x7 + x8
est un code BCH dont les paramètres sont b = 1, d0 = 5 = d, q = 2, n = 15 puisque β, β 2 , β 4 , β 8 sont les
racines de m(1) (x), et β 3 est une racine de m(3) (x) = x4 + x3 + x2 + x + 1 = (x5 − 1)/(x − 1) (β 3 )5 = 1,
et
β, β 2 , β 3 , β 4 ,
sont des racines d’exposants consécutifs de g(x). La dimension du code est k = 7, et un polynôme de
contrôle est
h(x) = (x15 − 1)/g(x) = 1 + x4 + x6 + x7
Exemple. On considère le polynôme g(x) = x6 + x3 + 1, un diviseur de
(x9 − 1) = (x2 + x + 1)(x6 + x3 + 1)(x + 1) ∈ F2 [x]
45
On voit que les racines de g sont β, β 2 , β 4 , β 5 , β 7 , et que α := β 5 +β 3 est un générateur du groupe cyclique
F∗64 , α7 = β, β 9 = 1. Il y a donc deux racines d’exposants consécutifs, β et β 2 . Le poids minimum du
code est ≥ 3, et le mot g est lui-même de poids 3. Donc le code C est un 1-correcteur.
> restart ;
> with(linalg) :
unprotected
(x6 + x3 + 1) (x2 + x + 1) (x + 1)
> g:=x^6+x^3+1;alias(beta = RootOf(g)) ;
g := x6 + x3 + 1
β
> if Eval(g, x=betaî) mod 2 = 0 then print(’i’=i, ’g’(betaî)=0) fi
> od ;
i = 1, g(β) = 0
i = 2, g(β 2 ) = 0
i = 4, g(β 4 ) = 0
i = 5, g(β 5 ) = 0
i = 7, g(β 7 ) = 0
i = 8, g(β 8 ) = 0
> Expand( beta^7) mod 2;
β4 + β
> Factor(x^7-beta, beta) mod 2;
(x + β 5 + β 4 + β 3 ) (x + β 5 + β 4 + β 2 + 1) (x + β 5 + β 2 + 1) (x + β 4 + β 3 + β 2 + 1)
(x + β 3 + β 2 + 1) (x + β 5 + β 3 ) (x + β 4 )
> alpha:=beta^5+beta^3;
> if Eval(x-1, x=alphaî) mod 2 = 0 then print(’i’=i, alphaî=1) fi
> od ;
α := β 5 + β 3
i = 0, 1 = 1
i = 63, (β 5 + β 3 )63 = 1
Le théorème permet de trouver un code corrigeant t erreurs pour tout entier t. Il suffit de trouver n
tel qu’un diviseur de xn − 1 satisfasse aux conditions du Théorème 5.1, par exemple le produit g(x) des
0
diviseurs de xn − 1, de racines β, β 2 , . . . , β d −1 .
Remarque 5.3 On peut poser d0 = 2t + 1 mais dans ce cas, n et k ne peuvent pas être choisies arbi-
trairement. Les entiers n − 1 et 0 serons considérés comme consécutifs puisque β n = β 0 = 1.
46
Rappelons qu’un code BCH de distance construite d0 est un code cyclique dont le générateur est le produit
0
(sans répétition de facteurs) de polynômes minimaux de β b , . . . , β b+d −2 . Dans le cas b = 1 on dit que
c’est un code BCH au sens strict.
Exemple. Pour obtenir BCH de longueur 9 sur F2 et de distance ≥ 4 on peut partir des racines
β, β 2 , β 3 ∈ F64 , donc d0 − 1 = 3,
g(x) = (x6 + x3 + 1) (x2 + x + 1) = x8 + x7 + x6 + x5 + x4 + x3 + x2 + x2 + x + 1.
Malheureusement, on obtient le code de répétition pure (de poids 9). C’est à dire, k = 1, n = d = 9 ; on
a vu qu’un tel code n’est pas efficace. Dans ce cas on a choisi d0 = 4, mais en réalité on a obtenu d = 9.
Remarquez que, a priori, on n’a, en général que d ≥ d0 .
Preuve du Theorème 5.1 Soit C un code cyclique sur F de longueur n avec n premier avec q, et de
polynôme générateur g(x). Soit L le corps des racines nèmes de l’unité (le corps de décomposition de
xn − 1 sur Fq ). Soit b un entier, et β une racine primitive nèmes . Le polynôme g(x) est un polynôme
de degré minimal qui possède, parmi les racines dans une extesion L de F = Fq , les puissances de β
suivantes 0
β b , β b+1 , . . . , β b+d −2 .
Soit a = (a0 , . . . , an−1 ) un mot du code, a ∈ C ⇐⇒ g(x)|a(x) ⇐⇒ a(x) s’annule sur les racines de g,
car g ne possède pas de racines multiples, d’où
 b
 a0 + a1 (β b+1
 ) + a2 (β b )2 + · · · + an−1 (β b )n−1 = 0
 a0 + a1 (β ) + a2 (β b+1 )2 + · · · + an−1 (β b+1 )n−1 = 0
(5.1)

 ....................................
 0 0 0
a0 + a1 (β b+d −2 ) + a2 (β b+d −2 )2 + · · · + an−1 (β b+d −2 )n−1 = 0
0
Soit Vi = t ((β b )i , (β b+1 )i , . . . , (β b+d −2 )i ), alors le système (5.1) ⇐⇒ a0 V0 + · · · + an−1 Vn−1 = 0. On
souhaite montrer que toutes les d0 − 1 colonnes Vi1 , Vi2 , . . . , Vid0 −1 sont linéairement indépendentes, voir le
lemme 3.8.
Mais 0 0
((β b )i , (β b+1 )i , . . . , (β b+d −2 )i ) = ((β i )b , (β i )b+1 , . . . , (β i )b+d −2 ),
donc la matrice du système avec les colonnes Vi1 , Vi2 , . . . , Vid0 −1 est
 
ub1 ub2 ... ubd0 −1
 ub+1 ub+1 ... b+1 
ud0 −1 
 1 2
 ... ... ... ... 
0 0
b+d0 −2
ub+d
1
−2
ub+d
2
−2
... ud0 −1
avec uj = β ij , j = 1, · · · , d0 − 1. Donc le déterminant (de type de Van der Monde) est non nul :

β bi1 β bi2 ··· β bid0 −1

β (b+1)i 1
β (b+1)i 2
··· β (b+1)id0 −1 b(i1 +i2 +···id0 −1 )
Y
= β (β ij − β ik ) 6= 0,

· · · · · · ··· ···

β (b+d0 −2)i1 β (b+d0 −2)i2 0 1≤k<j≤d −1
0
· · · β (b+d −2)id0 −1
car u1 = β i1 , . . . , ud0 −1 = β id0 −1 sont distincts.

En conséquance, le système (5.1) ne peut pas être satisfait avec moins de d0 coefficients non-nuls, et
donc le poids de a est au moins d0 .
47
Définition 5.4 (a) Soit b ∈ N et soit β ∈ Fqm une racine nème primitive de l’unité, où m est l’ordre
multiplicatif de q modulo n. Soit C le code BCH sur Fq de longueur n et de distance construite d0 ,
0
2 ≤ d0 ≤ n, défini par les racines β b , β b+1 , · · · , β b+d −2 .
Si m(i) (x) est le polynôme minimal de β i sur Fq , le polynôme générateur du code C est
0
g(x) = ppcm(m(b) (x), m(b+1) (x), · · · , m(b+d −2) (x))
(b) De plus, si n = q m − 1, les codes BCH correspondants sont appelés primitifs.

(c) Si n = q − 1, le code est dit de Reed-Solomon.
Exemple : Soit, avec les notations de la définition, m(1) (x) = x4 + x + 1 le polynôme minimal sur F2
de α élément primitif de F16 . On construit alors une matrice de correction H dont la ième colonne est
αi exprimé comme combinaison linéaire de 1, α, α2 , α3 . La matrice H obtenue définit un code équivalent
au code de Hamming de dimension 11 et de longueur 15 :
 
1 0 0 0 1 0 0 1 1 0 1 0 1 1 1
 0 1 0 0 1 1 0 1 0 1 1 1 1 0 0 
H = 
 0 0 1 0 0 1 1 0 1 0 1 1 1 1 0 
0 0 0 1 0 0 1 1 0 1 0 1 1 1 1
= (1 α α2 α3 α4 α5 α6 α7 α8 α9 α10 α11 α12 α13 α14 )
De plus, on a également m(1) (α2 ) = 0. Le code ainsi construit est donc un code BCH F2 avec b = 1
et d = 3, et corrige donc une seule erreur.
Pour décoder un message reçu v ∈ F15 t
2 , il faut calculer son syndrome Hv = v(α) exprimé dans la
2 3 (1)
base {1, α, α , α }. Il suffit pour cela de diviser v(x) par m (x). Si r(x) est le reste de la division, alors
v(α) = r(α).
Si par exemple
v = (010110001011101), v(x) = x + x3 + x4 + x8 + x10 + x11 + x12 + x14 ,
alors r(x) = 1 + x et donc Hv t = 1 + α. Or, on a d’après la matrice H : α4 = 1 + α, ce qui correspond

donc à une erreur en cinqième position. Le message émis était donc w = (010100001011101),
w(x) = x + x3 + x4 + x8 + x9 + x10 + x11 + x12 + x14 = (x10 + x8 − x5 + x2 + x) · (1 + x + x4 ).
Vérification :
> rem(x+x^3+x^8+x^(10)+x^(11)+x^(12)+x^(14), 1+x+x^4,x, ’q’) mod 2;
0
> q;
x10 + x8 − x5 + x2 + x
5.2. Codes de Reed-Solomon

Selon la définition 5.4, un code de Reed-Solomon est un code BCH sur Fq de longueur q − 1 et de
0
distance construite d0 , 2 ≤ d0 ≤ n, défini par les racines β b , β b+1 , · · · , β b+d −2 ∈ F∗q .
On utilise souvent q = 2m , et on va écrire α au lieu de β :
m Y m
x2 −1 − 1 = (x − u) = (x − 1)(x − α) · . . . · (x − α2 −2 )
u∈F∗
2m
48
donc 0
g(x) = (x − αb )(x − αb+1 ) · . . . · (x − αb+d −2 ), d◦ (g) = d0 − 1
avec les facteur linéaires dans F2m [x].
D’une part, par Théorème 5.1, k = 2m − 1 − d0 + 1 = 2m − d0 , d ≥ d0 . D’autre part, par la borne de
Singleton, Théorème 2.6, d ≤ n − k + 1 = 2m − 1 − (2m − d0 ) + 1 = d0 , donc le poids de C est exactement
d0 .
Exemple. 1) Soit F∗8 = hαi, α3 = α + 1, g(x) = (x − α)(x − α2 )(x − α3 ) = α6 + αx + α6 x2 + x3 . Alors
n = 7, k = 4, d = 4,  6 
α α α6 1 0 0 0
 0 α 6 α α6 1 0 0
G= .
0 0 α6 α α6 1 0
0 0 0 α 6 α α6 1
Q
2) Soit F∗256 = hαi, g = 43
12 (x − α
11j
), α8 = α7 + α2 + α + 1. Alors n = 255, k = 223, d = 33 (un code
utilsé par NASA).
5.3. Deuxième déscription des codes de Reed-Solomon

Théorème 5.5 (voir [Pa-Wo], p.139) Soit F2m = hαi, et soit p(x) ∈ F2m [x] pacourt le sous-espace
linéaire Pk ⊂ F2m [x] avec d◦ (p) ≤ k − 1 ou p ≡ 0. Alors l’ensemble des mots de la forme
m
(p(1), p(α), · · · , p(α2 −2
))
est un code de Reed-Solomon de longueur n = 2m − 1, de polynôme
g(x) = (x − α)(x − α2 ) · · · · · (x − αr )
avec r = 2m − 1 − k.
Remarque importante. Cette discription montre que les mots de code sont certaines fonctions poly-
nômiales sur l’ensemble des racines d’un polynôme.
Preuve. On remarque que l’application
m
Φ : p 7→ (p(1), p(α), . . . , p(α2 −2
)) ∈ Fnq
est injective puisque Ker(Φ) = 0 par l’interpolation de Lagrange. On pose C1 = Im(Φ) = Φ(Pk ).
Une base convenable de C1 :
m
ci = Φ(pi ), pi = xi (i = 0, 1, · · · , k − 1) : ci = (1, αi , α2i , · · · , α(2 −2)i
),
P2m −2
donc ci (x) := j=0 αji xj .
Ensuite, on calcule le syndrôme du polynôme ci (x) :
m m
2X −2 2X −2
t i+t j
ci (α ) := (α ) = β j , avec β = αi+t .
j=0 j=0
Puisque 1 ≤ t ≤ r, 0 ≤ i ≤ k − 1, alors 1 ≤ i + t ≤ r + k − 1 = 2m − 2, donc

m
β2 −1−2
β 6= 1, ci (αt ) = = 0.
β−1
Ceci dit, C1 ⊂ C, puisque tous les mots de C1 ont le syndrôme nul. Mais
dimF2m C = dimF2m C1 = k ⇒ C = C1 .
Exercice. Montrer un résultat analogue pour un corps fini Fq arbitraire.
49
5.4. Problèmes de décodage.
Nous avons vu que la classe des codes BCH permet, sous seule condition d’augmenter n et donc m,
de construire des codes de poids ≥ d0 pour tout entier positif d0 . Nous allons, dans ce qui suit, construire
un algorithme général de décodage des codes BCH, puis l’appliquer dans un exemple.
Considérons un code BCH de distance construite d0 ≥ 2t+1. Supposons que v, w et e soient le message
reçu, le message émis et le vecteur erreur, v = w + e. Il faut dans un premier temps calculer le syndrome
de v
S(v) = Hv t = (Sb , Sb+1 , · · · , Sb+d0 −2 )t
avec Sj = v(β j ) = e(β j ) pour b ≤ j ≤ b + d0 − 2.
Si r erreurs se produisent, avec r ≤ t, alors 2r + 1 ≤ d0 et
r
X
e(x) = c i xa i ,
i=1
où les ai sont tous différents dans 0, 1, · · · , n − 1. Les ηi = β ai sont les locateurs d’erreurs, et les ci , qui
sont des éléments de F∗q , sont les valeurs d’erreurs. Or,
r
X
Sj = e(β j ) = ci ηij (j = b, b + 1, · · · , b + d0 − 2).
i=1
Nous voyons donc que nous pourrons décoder dès lors que nous aurons obtenu les couples (c i , ηi ). Dans
le cas binaire, les ci sont de plus tous égaux à 1.
Remarque 5.6 On a Sjq = Sjq . En effet,

r
X r
X r
X
Sjq = ( ci ηij )q = cqi ηijq = ci ηijq = Sjq
i=1 i=1 i=1
Soit alors l’identité polynomiale

r
Y r
X
(ηi − x) = (−1)i σr−i xi = σr − σr−1 x + · · · + (−1)r σ0 xr
i=1 i=0
Les coefficients σi sont donc σ0 = 1 et pour 1 ≤ i ≤ r, les σi sont les polynômes élémentaires symétriques
en η1 , · · · , ηr . En remplaçant x par ηi , il vient
(−1)r σr + (−1)r−1 σr−1 ηi + · · · − σ1 ηir−1 + ηir = 0
pour tout 1 ≤ i ≤ r.
En multipliant par ci ηij et en sommant pour 1 ≤ i ≤ r, il vient
r
X
((−1)r σr ci ηij + (−1)r−1 σr−1 ci ηij+1 + · · · − σ1 ci ηij+r−1 + ci ηij+r ) = 0
i=1
donc
(−1)r σr Sj + (−1)r−1 σr−1 Sj+1 + · · · − σ1 Sj+r−1 + Sj+r = 0
pour tout b ≤ j ≤ b + r − 1, où j + r ≤ b + 2r − 1 ≤ b + d0 − 2 puisque 2r + 1 ≤ d0 . (On rappelle que
r
X
Sj = e(β j ) = ci ηij (j = b, b + 1, · · · , b + d0 − 2).)
i=1
50
Lemme 5.7 Le système d’équations
(−1)r σr Sj + (−1)r−1 σr−1 Sj+1 + · · · − σ1 Sj+r−1 + Sj+r = 0,
b ≤ j ≤ b + r − 1, des inconnues (−1)i σi est résoluble avec une seule solution si et seulement si r erreurs
se sont produites.
Preuve : La matrice du système est décomposable en produit suivant :

 
Sb Sb+1 · · · Sb+r−1
 Sb+1 Sb+2 · · · Sb+r  = V DV t
Sb+r−1 Sb+r · · · Sb+2r−2
avec    
1 1 ··· 1 c1 η1b 0 ··· 0
 η1 η2 ··· ηr   0 c2 η2b ··· 0 
V = ,D =  
 ··· ··· ··· ···   ··· ··· ··· ··· 
η1r−1 η2r−1 ··· ηrr−1 0 0 ··· cr ηrb
V est une matrice de Van der Monde régulière dès lors que les ηi sont tous distincts et D est diagonale,
donc régulière si et seulement si les ci et les ηi sont tous non nuls. Ces deux conditions sont remplies si
et seulement si r erreurs se produisent.
En effet, la multiplication des matrices montre
   
1 1 ··· 1 c1 η1b 0 ··· 0 1 η1 · · · ηrr−1
 η1 η2 ··· ηr   0 c2 η2b · · · 0   1
 η2 ··· ηr 
V DV t =   ···
 
··· ··· ···   ··· ··· ··· ···   ··· ··· ··· ··· 
η1r−1 η2r−1 · · · ηrr−1 0 0 · · · cr ηrb 1 η1r−1 · · · ηrr−1
   
c1 η1b c2 η2b ··· cr ηrb 1 η1 · · · ηrr−1
 c1 η1b+1 c2 η2b+1 ··· cr ηrb+1 
 1
 η2 ··· ηr 
=  
 ··· ··· ··· ···   ··· ··· ··· ··· 
c1 η1b+r−1 c2 η2b+r−1 · · · cr ηrb+r−1 1 η1r−1 · · · ηrr−1
 
Sb Sb+1 · · · Sb+r−1
=  Sb+1 Sb+2 · · · Sb+r 
Sb+r−1 Sb+r · · · Sb+2r−2
Définition 5.8 : On appelle polynôme locateur d’erreur le polynôme
r
Y n
X
s(x) = (1 − ηi x) = (−1)i σi xi
i=1 i=0
avec les notations utilisées précédemment. Les racines de s(x) sont les η i−1 , c’est à dire les β −ai . Il suffit
donc ensuite d’évaluer le polynôme s(x) pour les différentes puissances de β pour localiser les erreurs.
Après avoir trouvé les racines ηi , on utilise le lemme suivant :
P
Lemme 5.9 Le système Sj = ci ηij , b ≤ j ≤ b + r − 1 des inconnues ci est résoluble si les coefficients
ηi sont des éléments distincts de F∗qm .
Preuve : Le déterminant du système est alors

η1b η2b ··· ηrb

b+1 b+1
η1 η2 ··· ηrb+1
= η1b η2b · · · ηrb
Y
(ηi − ηj ) 6= 0

··· ··· ··· ···

η b+r−1 η b+r−1 · · · η b+r−1 1≤i<j≤r
1 2 r
Nous allons résumer cet algorithme en notant τi = (−1)i σi .
51
5.4.1. Décodage BCH
Soit C un code BCH de distance construite d0 ≥ 2t + 1, w le message émis et v le message reçu.
Supposons qu’au plus t erreurs se produisent.
- 1ère étape : Déterminer le syndrome
S(v) = (Sb , Sb+1 , · · · , Sb+d0 −2 )t .
(On rappelle que

r
X
Sj = e(β j ) = ci ηij (j = b, b + 1, · · · , b + d0 − 2).)
i=1
- 2ème étape : Déterminer l’entier r maximal tel que le système d’équations
Sj+r + Sj+r−1 τ1 + · · · + Sj τr = 0, b≤j ≤b+r−1
des inconnues τi soit résoluble avec une seule solution pour ainsi déterminer le nombre d’erreurs r. Ceci
permet de former le polynôme locateur d’erreur
r
Y r
X
s(x) = (1 − ηi x) = τ i xi
i=1 i=0
dont les coefficients se déduisent des Sj .

- 3ème étape : Chercher les racines de s(x) en testant les différentes puissances de β pour déterminer
les locateurs d’erreurs ηi .
- 4ème étape : Remplacer les ηi par leurs valeurs dans l’expression des Sj pour déterminer les valeurs
des erreurs ci (cas non binaire seulement). On obtient ainsi le vecteur erreur e et on peut décoder
w = v − e.
Remarque 5.10 : L’étape difficile est la 2ème . Pour parvenir à déterminer les coefficients τi , une
méthode possible est d’utiliser l’algorithme de Berlekamp-Massey (voir [Li-Ni], p.235-239, et [vLi-vdG],
p.20).
5.5. Algorithme de Berlekamp-Massey

(voir [vLi-vdG], p.20).
0
Soit C un [n, k, d, ]q -code BCH de zéroes β, β 2 , . . . , β d −1 , ou F∗q = hβi, β n = 1. Supposons que v, w
et e soient le message reçu, le message émis et le vecteur erreur, v = w + e, considères comme des
polynômes : v(x), w(x) et e(x) ∈ Fq [x].
On pose
v(x) = v0 + · · · + vn−1 xn−1 , w(x) = v0 + · · · + wn−1 xn−1 , e(x) := v(x) − w(x) = e0 + · · · + en−1 xn−1 ,
et soit I := {i | ei 6= 0}, et on considère le polynôme locateur d’erreurs

Y
s(x) = (1 − β i x),
i∈I
et le polynôme évaluateur d’erreurs

X Y
u(x) = ei β i (1 − β j x).
i∈I j∈I\{i}
52
On constate que
u(β −i ) X Y
ei = − 0 −i
, s0 (x) = −β i (1 − β j x)
s (β )
i∈I j∈I\{i}
puisque
Y Y
s0 (β −i ) = −β i (1 − β j−i ), u(β −i ) = ei β i (1 − β j−i ).
j∈I\{i} j∈I\{i}
d−1
De plus d◦ (s(x)) ≤ t = 2 , d◦ (u(x)) < t. Il reste à trouver les polynômes s(x), u(x). On utilise
l’identité formelle
∞ ∞
u(x) X ei β i X
−1
X
i l
X
= = e i x (β x) = xl−1 e(β l ), (5.2)
s(x) 1 − βix
i∈I i∈I l=1 l=1
puisque
X Y
u(x) = ei β i (1 − β j x) et e(x) = v(x) − w(x) = e0 + · · · + en−1 xn−1 .
i∈I j∈I\{i}
Les d0 − 1 premiers coefficients de la série à droite dans (5.2) sont connus :
e(β l ) = v(β l ) (1 ≤ l ≤ d0 − 1).

On pose
0
dX −1
S(x) = e(β l )xl−1
l=1
et on cherche u(x), s(x) à partir de l’égalité (5.2) comme une solution de la congruence :
0
u(x) ≡ s(x)S(x)(modxd −1 ) (5.3)
Pour résoudre la congruence (5.3) on utilise la division euclidienne et l’identité de Bezout : on calcule
trois suites sn (x), tn (x), un (x) avec la propriété
0
tn (x)xd −1 + sn (x)S(x) = un (x)
0
où le degré de un (x) décroît jusqu’au pgcd(xd −1 , S(x)) est atteint, à partir de
0 0 0
0 · xd −1 + 1 · S(x) = S(x), 1 · xd −1 + 0 · S(x) = xd −1
de telle façon que

0
(s0 (x), t0 (x), u0 (x)) = (0, 1, S(x)); (s1 (x), t1 (x), u1 (x)) = (1, 0, xd −1 )
Il est claire que le couple (u(x), s(x)) = (un (x), sn (x)) est un unique couple vérifiant (5.3).
Exercice. Ecrire un algorithme pour trouver s(x) et u(x).
Exemple : l’identité de Bezout et de l’algorithme de Berlekamp-Massey

> restart ;
> with(linalg) :
unprotected
53
> irr34 := op(1, select(has, Factor(x^81-x) mod 3, 4)) ;
irr34 := x4 + 2 x3 + 2
• Le polynôme irréductible obtenu par ce procédé n’est pas forcément le même d’une session à l’autre.
• On aliasse α à une racine de ce polynôme dans une extension de F3 , de sorte que GF(34 ) = F3 [ α].
> alias(alpha = RootOf(irr34) mod 3) ;
• La procédure rnd3 génére un entier modulo 3 pseudo-aléatoire.

> rnd3 := rand(0..2) :
> seq(rnd3(), i = 1..5) ;
0, 2, 0, 2, 1
• La procédure rnd34 génère un élément pseudo-aléatoire de GF( 34 ).

> rnd34 := () -> add(rnd3()*alphaî, i=0..3):
2 + 2 α + 2 α2 + α3 , 1 + α, 2 + 2 α + α2 , 2 α2 , α2
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%
• La procédure rndP34(n) génère un polynôme pseudo-aléatoire unitaire de GF( 2 4 ) de degré n.
> rndP34 := proc(n)

> RETURN(sort(X^n + add(rnd34()*Xî, i=0..(n-1))))
> end :
> rndP34(5);
X 5 + α2 X 4 + 2 α2 X 3 + (2 + 2 α + α2 ) X 2 + (1 + α) X + 2 + 2 α + 2 α2 + α3
> Bezout34 := proc( P::anything,
> A::anything,
> B::anything)
> local gcd, U, V ;
> gcd := gcdex(A, B, X, ’U’, ’V’) ; #A*U+B*V=gcd
> if gcd <> 1 then ERROR(
> sprintf("les polynômes %a et %a
> ne sont pas premiers entre eux.",
> A, B))
> fi ;
> RETURN(P, rem(P*U, B, X), rem(P*V, A, X)) #P, A*U+B*V=P
> end :
> _seed := 1925 :
> A, B, P:= X^(4), rndP34(2), rndP34(2);G := gcdex(A, B, X, ’U’, ’V’)
> ;#G=pgcd(A,B), A*U+B*V=P
A, B, P := X 4 , X 2 + (α + 2 α2 ) X + α + α2 + α3 , X 2 + (1 + α + 2 α3 ) X + 1 + α2 + 2 α3
G := 1
> P, U, V:= Bezout34(P, A, B);#A*U+B*V=P
54
P, U, V := X 2 + (1 + α + 2 α3 ) X + 1 + α2 + 2 α3 ,
−4 α4 + 8 α5 − 3 α7 − 20 α8 + 17 α6 + 2 α3 + 3 α2 − 1 + 16 α10
−
(1 + 16 α3 + 10 α2 + 4 α + 16 α5 + 10 α6 + 19 α4 + 4 α7 + α8 ) α2
(α3 + 6 α4 − 8 α6 − 2 α7 + 1 + 2 α − α2 + 2 α5 + 8 α8 ) X
− ,
(1 + 16 α3 + 10 α2 + 4 α + 16 α5 + 10 α6 + 19 α4 + 4 α7 + α8 ) α2
2 α3 + 1 + α 2 (2 α3 − 2 α2 − α + 1) α X
2
+
α (α + 1 + α) (α2 + 1 + α)2
(4 α7 − 2 α6 − 3 α5 + 2 α4 + α3 + 1) X 2
− 2
(α + 1 + α) (2 α + 3 α2 + α4 + 2 α3 + 1) α2
(α3 + 6 α4 − 8 α6 − 2 α7 + 1 + 2 α − α2 + 2 α5 + 8 α8 ) X 3
+
(2 α + 3 α2 + α4 + 2 α3 + 1)2 α2
> Expand(P - U*A - V*B) mod 3;
0
> G, U, V:= Bezout34(G, A, B) :#A*U+B*V=gcd
> Expand(G - U*A - V*B) mod 3;
0
> un,tn,sn:=Bezout34(G, X^4,
> B):#A=X^(d’-1),B=S(X),un=G(X),tn=U(X),sn=V(X)
> un:=sort(Expand(un) ,[alpha,X]) mod 3;
un := 1
> tn:=sort(Expand(tn) ,[alpha,X]) mod 3;
tn := α X + 2 α + 2
> sn:=sort(Expand(sn),[alpha,X]) mod 3;
sn := 2 α3 X 2 + α2 X 2 + 2 α X 3 + α3 + α2 X + α X 2 + α X + X 2 + α + 2 X + 1
> Expand(G - tn*A - sn*B) mod 3;
0
Pour résoudre la congruence
0
u(x) ≡ s(x)S(x)(modxd −1 )
on a utilisé la division euclidienne et l’identité de Bezout : on a calculé trois suites sn (x), tn (x), un (x)
avec la propriété
0
tn (x)xd −1 + sn (x)S(x) = un (x)
Exemple. Soit β un élément primitif de F16 racine du polynôme x4 + x + 1 sur F2 . Alors
m(1) (x) = m(2) (x) = m(4) (x) = m(8) (x) = x4 + x + 1
m(3) (x) = m(6) (x) = m(9) (x) = m(12) (x) = x4 + x3 + x2 + x + 1

g(x) = m(1) (x)m(3) (x) = 1 + x4 + x6 + x7 + x8
55
est un code BCH dont les paramètres sont b = 1, d0 = 5 = d, q = 2, n = 15. Sa dimension est k = 7 et un
polynôme de contrôle est
h(x) = (x15 − 1)/g(x) = 1 + x4 + x6 + x7
On construit une matrice génératrice G dont la ième ligne est le vecteur xi−1 g(x), 1 ≤ 1 ≤ k. On obtient
 
1 0 0 0 1 0 1 1 1 0 0 0 0 0 0
 0 1 0 0 0 1 0 1 1 1 0 0 0 0 0 
 
 0 0 1 0 0 0 1 0 1 1 1 0 0 0 0 
 
G=  0 0 0 1 0 0 0 1 0 1 1 1 0 0 0  
 0 0 0 0 1 0 0 0 1 0 1 1 1 0 0 
 
 0 0 0 0 0 1 0 0 0 1 0 1 1 1 0 
0 0 0 0 0 0 1 0 0 0 1 0 1 1 1
Si le message reçu est v = (100100110000100), soit encore v(x) = 1 + x 3 + x6 + x7 + x12 . On calcule alors
les composantes du syndrome :
S1 = S2 = S4 = v(β) = 1, S3 = v(β 3 ) = β 4
Il apparaît alors que le plus grand système linéaire d’équations des inconnues τi est de la forme
S2 τ 1 + S 1 τ 2 = S 3 S1 τ 2 + S 2 τ 1 = S 3
⇐⇒
S3 τ 1 + S 2 τ 2 = S 4 S2 τ 2 + S 3 τ 1 = S 4
qui s’écrit également
τ1 + τ 2 = β 4
β 4 τ1 + τ 2 = 1
et dont la matrice est régulière. Il vient
τ1 = 1
τ2 = β
τ0 = 1 par définition, et on a donc s(x) = 1 + x + βx2 .
En testant les différentes puissances de β, on trouve
η1−1 = β 8 , η2−1 = β 6 ,
et on a donc
η1 = β 7
η2 = β 9
ainsi, le polynôme erreur est
e(x) = x7 + x9
et on peut décoder
w(x) = v(x) − e(x)
= (1 + x3 + x6 + x7 + x12 ) − (x7 + x9 )
= 1 + x3 + x6 + x9 + x12
Le message émis était w = (100100100100100).
Pour retrouver le message original, il suffit de diviser w(x) par g(x). Il vient
a(x) = w(x)/g(x) = 1 + x3 + x4 ⇒ a = (1001100).
56
6. Bornes de Plotkin et de Gilbert-Varshamov
6.1. Rendement, taux de correction et domaine de codes
Soit C ⊂ F n un code de cardinal Card (C) = M sur l’alphabet F de Card (F ) = q de distance
d = d(C) et la capacité de correction t = d−1 2 . Nous avons vu la définition 1.4 du rendement et du taux
de correction : soit C un [n, k, d]q -code, alors
• la vitesse de transmission (le "rendement" ou "information rate" en anglais) de C est le rapport

R = k/n,
• δ = d/n est la distance relative (ou le "taux de correction") de C.

Un bon code est un code corrigeant de nombreuses erreurs compte tenu de sa longueur tout en ayant
une vitesse de transmission la plus élevée possible, ce qui correspond à des paramètres R et δ assez grands
dans [0, 1]. Rapellons (voir Definition 1.9) qu’une famille {Ci } des [ni , ki , di ]q -codes est dite bonne s’il
existe et positives les limites
ki di
lim = R > 0, lim = δ > 0,
On a vu que avec toute bonne famille on peut faire tendre vers 1 la probabilité de transmission
correcte. En réalité, on utilise R ≈ 0, 1 ∼ 0, 95.
Toutefois, ces paramètres δ et R sont liés par des relations dites asymptotiques.
Nous avons déjà établi quelques relations dans Section 2. :
1) Borne de Singleton (voir Théorème 2.6). Soit C = ImE un [n, k, d]q -code, E : F k → F n . Alors
k ≤ n − d + 1 ⇐⇒ R ≤ 1 − δ + 1/n
10 ) Borne de Singleton asymptotique (voir Théorème 2.8 ). Soit {Ci } une famille des [ni , ki , di ]q -
codes, on pose
ki di
i→∞ n i i→∞ n i
alors
R ≤1−δ
2) Borne de Hamming (voir Théorème 2.3). SoitC ⊂F n un code sur l’alphabet F de Card (F ) = q
de distance d = d(C) et la capacité de correction t = d−1
2 . Alors
t
X n
Card (C) (q − 1)i ≤ q n , donc Vq (n, t) ≤ q n /Card (C).
i=0
i
20 ) Borne de Hamming asymptotique voir Théorème 2.11. Soit {Ci } une famille des [ni , ki , di ]q -
codes, on pose
ki di
alors
R ≤ 1 − Hq (δ/2)
où Hq (δ) est la fonction entropie q-aire définie sur [0, (q − 1)/q] par
Hq (0) = 0,
Hq (δ) = δ logq (q − 1) − δ logq (δ) − (1 − δ) logq (1 − δ) pour 0 ≤ δ ≤ (q − 1)/q
57
Maintenant on va obtenir des meilleurs bornes (supérieures et inférieures), pour décrire le domaine de
codes, où se trouvent les bons codes.
Soit Cq l’ensemble des codes sur Fq et Vq l’image de l’application
F : Cq −→ [0, 1] × [0, 1], F(C) = (δ, R)
On note Uq l’ensemble des points d’accumulation de Vq . Les codes de Vq \Uq ont dits isolés.
On pose
n o
Aq (n, d) = max Card (C) = M il existe un code C ⊂ Fnq de distance d = d(C) ,

αq (δ) := lim sup n−1 logq Aq (n, d).

n→∞
Un code est dit optimal s’il atteint la borne αq (δ).

Un théorème de Yu.I.Manin (voir [Ts-V]) montre que αq (δ) est continue avec αq (0) = 1, αq (δ) = 0
pour (q − 1)/q ≤ δ ≤ 1 et αq (δ) est décroissante dans 0 ≤ δ ≤ (q − 1)/q ≤ 1.
On montrera en particuler :
– Borne de Plotkin asymptotique

q
αq (δ) ≤ max 1 − δ, 0
q−1
– Borne de Gilbert-Varshamov asymptotique Pour tout δ dans l’intervale ]0, (q−1)/q[ il existe
une famille {Ci } des [ni , ki , di ]q -codes, telle que
ki di
et
αq (δ) ≥ R ≥ 1 − Hq (δ),
c’est à direon a
αq (δ) ≥ 1 − Hq (δ)
où Hq (δ) est la fonction entropie q-aire
Représentation graphique des bornes : pour q = 49 :
58
1
0.8
0.6
R
0.4
0.2
0 0.2 0.4 0.6 0.8 1 1.2 1.4 1.6 1.8 2

delta
6.2. Borne de Plotkin

Théorème 6.1 (Borne de Plotkin). Soit C un code linéaire de longueur n et de dimension k sur F q ,
d’écart d. Alors
nq k−1 (q − 1) q−1 1
d≤ = n 1 + . (∗)
qk − 1 q qk − 1
Preuve : Soit 1 ≤ i ≤ n tel que C contienne un mot dont la ième coordonnée est non nulle. Soit
D le sous-espace de C constitué des mots codes dont la ième coordonnée est nulle. On a |C/D| = q,
donc, comme |C/D| = |C|/|D|, |D| = q k−1 . Il vient alors que la somme des poids des mots codes est
≤ nq k−1 (q − 1). Comme C comporte q k − 1 mots de poids non nul, on obtient la relation voulue :
d(q k − 1) ≤ nq k−1 (q − 1).
Remarque. Soit M = Card C = q k , alors il est commode d’écrire l’inégalité (*) sous la forme : si
d q−1
n 6= q , alors
−1
d q
M≤ −1 +1
nq−1
.
Théorème 6.2 (Borne de Plotkin asymptotique). Soit {Ci } une famille des [ni , ki , di ]q -codes, on
pose
ki di
59
alors
q
R ≤ max 1 − δ, 0
q−1
Preuve. Soit {Ci } une famille des [ni , ki , di ]q -codes, on pose
ki di
alors il y a trois possibilités :

q−1 q−1 q−1
δ> ,δ < , ou δ = .
q q q
q−1
1) Premier cas : δ > q . On écrit l’inégalité du Théorèmé 6.1 :

ni q ki −1 (q − 1) q−1 1
di ≤ ⇒ ni · · 1 + ki ≥ di .
q ki − 1 q q −1
Ceci implique
−1
ki di q 1
q ≤ −1 +1→ q + 1 > 0(une constante indépendent de n), (6.1)
ni q − 1 δ q−1 −1
q−1
puisque δ > q .
Donc ki sont uniformement bornés, cela signifie que

ki
R = lim sup = 0.
i→∞ ni
q−1
2) Deuxième cas : 0 < δ < q . Dans ce cas on peut supposer : pour ni assez grand
di q−1 di 1 q−1 q−1

= δi → δ < ⇒ − < ⇒ di − 1 < n i · .
ni q ni ni q q
On pose
q(di − 1) q(di − 1) q−1
n0i = ≤ ⇒ n0i ≤ di − 1 .
q−1 q−1 q
Ensuite, di = δi ni → ∞ donc
0 < n0i < ni
puisque

q(di − 1) q
n0i = ≥ (di − 1) · − 1 > 0,
q−1 q−1

q(di − 1) q
n0i = ≤ (di − 1) · < ni
q−1 q−1
Pour tout n = ni on considère les n − n0 derniers symboles des mots du code. Il existe un sous-ensemble
0
C 0 = C(ξ) ⊂ C formé par les mots avec les mêmes n − n0 derniers symboles ξ ∈ Fn−nq , et avec
0
M 0 := Card (C 0 ) ≥ M · q n −n .
60
Ainsi que C 0 n’est pas un sous-espace vectoriel de C, on peut fixer un c00 ∈ C 0 , alors l’ensemble de toutes
les différences
n o n o
Cn0 = c0 − c00 c0 ∈ C 0 = c = (c1 , · · · , cn0 , 0, · · · , 0) c0 ∈ C 0 ⊂ C,

est un sous-espace vectoriel de C ayant le même cardinal que C 0 . On utilise encore Théorème 6.1 pour
le sous-espace vectoriel C 0 de C donc
0
0 n0 q k −1 (q − 1) 0 q−1 1
d ≤ ⇒n · · 1 + k0 −1 ≥ d0 .
q k0 − 1 q q
Ceci résulte :
−1
0
d0 q
M · q n −n ≤ M 0 < n0 q−1 −1 +1 (6.2)
n0 (q − 1) n0 (q − 1) n0 (q − 1)
= +1≤ +1≤ +1≤d≤n
d0 q 0
− n (q − 1) 0
dq − n (q − 1) q
puisque d ≤ n, d0 ≥ d et

0 q(d − 1)
dq − n (q − 1) = dq − (q − 1) ≥ dq − q(d − 1) = q
q−1
(ne pas confondre la notation d0 avec la distance construite des codes BCH !).
Pour conclure, on prend logq de (6.2) : M = q k = Card (C), et
0 q(d − 1) q(d − 1)
M · q n −n < n ⇒ k + n0 − n ≤ logq n, − 1 < n0 ≤ .
q−1 q−1
Il reste à diviser par n = ni et passer à la limite n → ∞ :
q(d − 1) k q d logq n + 1
k ≤ n − n0 + logq n ≤ n − + logq n ⇒ ≤1− · +
q−1 n q−1 n n
q
⇒ R≤1− δ
q−1
3) Troisième cas (en exercice) : δ = q−1 q .

Pour montrer que R = 0 on raisonne par l’absurde. On suppose que
ki
R = lim sup > 0,
i→∞ ni
et on choisit une sous-suite des codes Ci avec ki /ni ≥ R0 > 0. On pose

0 q(di − 1) q(di − 1)
ni = ≤ .
q−1 q−1
Ensuite, di = δi ni → ∞ donc
0 < n0i < ni
puisque

q(di − 1) q
n0i = ≥ (di − 1) · − 1 > 0,
q−1 q−1
61
et pour voir que n0i < ni on remarque que par Théorème 6.1

0 q(di − 1) q q−1 1 q
ni = ≤ (di − 1) · ≤ · n i · 1 + ki −1 ·
q−1 q−1 q q −1 q−1
ni q ni
n i + ki − < n i , ( ki → 0)
q −1 q−1 q −1
puisque
q−1 1 ni
di ≤ · 1 + ki , et q ki > q R0 ni ⇒ ki → 0.
q q −1 q −1
Maintenant on répète le raisonnement du deuxième cas. Pour tout n = ni et n0 = n0i , on considère les
n − n0 derniers symboles des mots du code. Il existe un sous-ensemble C 0 = C(ξ) ⊂ C formé par les mots
0
avec les mêmes n − n0 derniers symboles ξ ∈ Fn−n
q , et avec
0
M 0 := Card (C 0 ) ≥ M · q n −n
Ainsi que C 0 n’est pas un sous-espace vectoriel de C, on peut fixer un c00 ∈ C 0 , alors l’ensemble de toutes
les différences
n o n o
Cn0 = c0 − c00 c0 ∈ C 0 = c = (c1 , · · · , cn0 , 0, · · · , 0) c0 ∈ C 0 ⊂ C,

est un sous-espace vectoriel de C ayant le même cardinal que C 0 . On utilise encore Théorème 6.1 pour
le sous-espace vectoriel C 0 de C donc
0
n0 q k −1 (q − 1) 0 q−1 1
d0 ≤ ⇒ n · · 1 + ≥ d0 .
q k0 − 1 q q k0 −1
Ceci résulte :
−1
0
d0 q
M · q n −n ≤ M 0 < n0 q−1 −1 +1 (6.3)
n0 (q − 1) n0 (q − 1) n0 (q − 1)
= +1≤ ≤ ≤n
d0 q 0
− n (q − 1) 0
dq − n (q − 1) q
puisque d0 ≥ d et

q(d − 1)
dq − n0 (q − 1) = dq − (q − 1) ≥ dq − q(d − 1) = q
q−1
Pour conclure dans ce cas, on prend de nouveaux logq de (6.3) :
q(d − 1) q(d − 1)
k + n0 − n ≤ logq n, ≤ n0 < + 1.
q−1 q−1
Il reste à diviser par n = ni et passer à la limite n → ∞ :
q(d − 1) k q d logq n + 1
k ≤ n − n0 + logq n ≤ n − + logq n ⇒ ≤ 1 − · +
q−1 n q−1 n n
q−1
Mais dans ce cas δ = q ,
q
⇒R ≤1− δ = 0.
q−1
62
6.3. Borne de Gilbert-Varshamov
Théorème 6.3 (Borne de Gilbert-Varshamov) Il existe un code linéaire de dimension k, de longueur n
sur Fq et d’écart ≥ d dès lors que
d−2
X n−1
q n−k > (q − 1)i = Vq (n − 1, d − 2).
i=0
i
Preuve du Théorème 6.3 : Soit C un code comme décrit ci-dessus. Construisons sa matrice de
correction H. On choisit pour la première colonne n’importe quel vecteur de Fqn−k non nul, puis pour la
seconde un vecteur non multiple scalaire de la première, et ainsi de suite jusqu’à obtenir j − 1 colonnes
dont d − 1 sont toujours linéairement indépendantes. Par combinaison linéaire de d − 2 ou moins de ces
j − 1 colonnes, on peut former au plus
d−2
X j−1
(q − 1)i = Vq (j − 1, d − 2).
i=0
i
colonnes.
Comme par combinaison linéaire de d − 2 ou moins de ces j − 1 colonnes, on peut former au plus
d−2
X j −1
(q − 1)i = Vq (j − 1, d − 2)
i=0
i
colonnes, on obtient une condition suffisante pour l’existence d’une j ème colonne cherchée. Elle est donnée
pour un choix de j − 1 ≤ n − 1 colonnes
d−2
n−k
X n−1
q > (q − 1)i = Vq (n − 1, d − 2)
i=0
i
(on obtient le nombre maximal possible des combinaisons linéaires de d − 2 colonnes choisis parmi n − 1
colonnes). Ainsi, si l’inégalité du théorème est vérifiée, on peut trouver une j ème colonne linéairement
indépendante de toutes d − 2 des j − 1 premières colonnes, et ce jusqu’à obtenir H de rang n − k, ce qui
fournit un code de distance ≥ d.
Remarque. La borne de Gilbert-Varshamov reste valable pour tous les codes sous une forme légé-
rement plus faible (voir [vLi], p. 56, [Ste], p.35, [MW-S], p.34) : Il existe un code C ⊂ Fnq de distance
minimale ≥ d et de cardinale M = Card (C) dès lors que
d−1
n
X n
q > Vq (n, d − 1)M, Vq (n, d − 1) = (q − 1)i M.
i=0
i
Pour un tel code on suppose qu’il n’est pas possible de trouver un mot c en dehors de C de distance ≥ d.
Alors
d−1
X n
q n ≤ Vq (n, d − 1)M, Vq (n, d − 1) = (q − 1)i M.
i=0
i
63
(c’est-à-dire, le rayon de recouvrement est ≤ d − 1). Dans le cas contraire on trouve un tel mot c et on
l’ ajout au code C (non-nécessarement linéaire), à partir du code trivial comportant un seul mot (on
raisonne par récurrence sur M ). Ceci dit, il existe un code du cardinal M pour le nombre

qn qn
M= −1⇒ M < ≤ M + 2.
Vq (n, d − 1) Vq (n, d − 1)
Borne de Gilbert-Varshamov asymptotique (voir Théorème 6.3).
Théorème 6.4 (Borne de Gilbert-Varshamov asymptotique) Pour tout δ dans l’intervale ]0, (q − 1)/q[
il existe une famille {Ci } des [ni , ki , di ]q -codes, telle que
ki di
et
αq (δ) ≥ R ≥ 1 − Hq (δ),
c’est à dire, qu’on a
αq (δ) ≥ 1 − Hq (δ)
Hq (0) = 0,
Hq (δ) = δ logq (q − 1) − δ logq (δ) − (1 − δ) logq (1 − δ) pour 0 ≤ δ ≤ (q − 1)/q.
Preuve : Soit ni → ∞ une suite arbitraire. On pose di = [δni ], et

ki = ni − logq Vq (ni − 1, di − 2) − 1
un nombre vérifiant l’inégalité du Théorème 6.3 :
dXi −2

ni − 1
q ni −ki > (q − 1)i = Vq (ni − 1, di − 2)
i=0
i
puisque
ki logq Vq (ni − 1, di − 2) 1 − ki ki − 1 logq Vq (ni − 1, di − 2) ki
− ≤ −1< , <1− ≤
ni ni ni ni ni ni
Selon Théorème 6.3, il existe un [ni , ki , di ]q -code {Ci }. Il reste à passer à la limite ni → ∞ :
logq Vq (ni − 1, di − 2) logq Vq (ni − 1, [δ · ni ] − 2) ki
= → Hq (δ), → R ⇒ R ≥ 1 − Hq (δ).
ni ni ni
r
Rappelons le corollaire 2.10 : Lorsque n → ∞, n → δ, on a

logq Vq (n, [δn]) Vq (n, [δn])
Hq (δ) = lim = lim logq .
n→∞ n n→∞ Card (F n )
Théorème 6.5 (Borne de Bassalygo-Elias, sans démonstration) Pour tout code de dimension
k, de longueur n et d’écart d sur Fq et pour tout entier w tel que 1 ≤ w ≤ n tel que
d − 2w + qw2 /(q − 1)n > 0
on a
n
n − k ≥ logq + w logq (q − 1) − logq d + logq r
w
64
Preuve : voir [Ste], p.32.
Théorème 6.6 (Borne de Bassalygo-Elias asymptotique , sans démonstration. Soit {Ci } une
famille des [ni , ki , di ]q -codes, on pose
ki di
alors  r 
qδ
q − 1 (q − 1) 1−
q − 1
R ≤ αq (δ) ≤ RBE , où RBE = 1 − Hq 
 q −
.
q 
6.4. Borne de la géométrie algébrique (sans démonstration)

Théorème 6.7 (Tsfasman-Zink-Drinfeld-Vladut). Il existe une famille{Ci } des [ni , ki , di ]q -codes
provenant des courbes algébriques sur Fq , telle que si l’on pose
ki di
i→∞ ni i→∞ n i
1)
1
αq (δ) ≥ R ≥ RGA = 1 − δ − √ . (6.4)
q−1
2) Si q est un carré, la borne (7.11) est atteinte
di 1
lim sup =√ .
i→∞ ni q−1
Remarque 6.8 Si q est un carré, alors la borne inférieure (7.11) est meilleure que la borne de Gilbert-
Varshamov asymptotique (voir Théorème 6.4, et la représentation graphique des bornes ci-dessou).
Représentation graphique des bornes : 1) Pour q = 49 :
65
1
0.8
0.6
R
0.4
0.2
0 0.2 0.4 0.6 0.8 1 1.2 1.4 1.6 1.8 2

delta
2) Pour q = 25 :
0.8
0.6
R
0.4
0.2
0 0.2 0.4 0.6 0.8 1 1.2 1.4 1.6 1.8 2

delta
66
Existence des bonnes familles et codes géométriques
Rappel : bonne famille, voir Definition 1.9
Une famille {Ci } des [ni , ki , di ]q -codes est dite bonne s’il existe et positive les limites
ki di
R = lim , δ = lim .
On montrera l’existence des bonnes familles, et même des familles excellentes :

Définition 6.9 Une bonne famille {Ci } des [ni , ki , di ]q -codes est dite excellente s’il existe
ki di
R = lim > 0, δ = lim ∈]0, (q − 1)/q[,
et
R ≥ 1 − Hq (δ)
Hq (0) = 0,
Représentation graphique : fonction d’entropie, q = 7

Hq (δ) = − −
1 1
0.8 0.8
0.6 0.6
R R
0.4 0.4
0.2 0.2
0 0.2 0.4 0.6 0.8 1 0 0.2 0.4 0.6 0.8 1

delta delta
R = Hq (δ) R = 1 − Hq (δ)
Pour construire une telle famille on utilise
Théorème 6.3 (Borne de Gilbert-Varshamov) Il existe un code linéaire de dimension k, de longueur n
sur Fq et d’écart ≥ d dès lors que
d−2
X n−1
q n−k > Vq (n − 1, d − 2) = (q − 1)i . (∗)
i=0
i
(Rappelons qu’on a montré l’existence d’un tel code en construisant sa matrice de contrôle H ∈
Mn−k,n (Fq ) avec la propriété que toutes les d − 1 colonnes sont linéairement indépendantes. La partie
gauche de (*) est le nombre total des colonnes, et la partie droite de (*) est le nombre maximum des
combinaisons linéaires de d − 2 colonnes parmi les colonnes construites par récurrence ; ceci dit que (*)
permet de choisir les colonnes d’une matrice H voulue)
67
Passage à la limite
Thèorème 6.4 (Borne de Gilbert-Varshamov asymptotique) Pour tout δ dans l’intervale ]0, (q − 1)/q[
il existe une famille {Ci } des [ni , ki , di ]q -codes, telle que
ki di
R = lim sup , δ = lim sup , et R = 1 − Hq (δ) ,
i→∞ ni i→∞ n i
Preuve : Soit ni → ∞ une suite arbitraire. On pose di = [δni ], et

ki = ni − logq Vq (ni − 1, di − 2) − 1
Alors on a l’encadrement :
ni − logq Vq (ni − 1, di − 2) > ki ≥ ni − logq Vq (ni − 1, di − 2) − 2
donc ki vérifie l’inégalité du Théorème 6.3 :

dX
i −2
ni −ki ni − 1
q > (q − 1)i = Vq (ni − 1, di − 2) ≥ q ni −ki −2 .
i=0
i
donc il existe un [ni , ki , di ]q -code Ci .

Il reste à passer à la limite ni → ∞ en utilisant l’encadrement ci-dessus :
ni − k i logq Vq (ni − 1, di − 2) ni − k i − 2
< ≤ .
ni ni ni
r
Rappelons le corollaire 2.10 : lorsque n → ∞, n → δ, on a
logq Vq (n, r) logq Vq (ni − 1, di − 2) logq Vq (ni − 1, [δ · ni ] − 2)

lim = Hq (δ) ⇒ = → Hq (δ),
n→∞ n ni ni
ki
→ R ⇒ 1 − R ≤ Hq (δ) ≤ 1 − R ⇒ R = 1 − Hq (δ) .
ni
7. Codes géométriques de Goppa. Systèmes affines et courbes

algébriques
sur les corps finis
7.1. Systèmes affines et systèmes projectifs

7.1.1. Systèmes affines.
Soit V un espace vectoriel sur Fq , dimFq V = k.
Définition 7.1 Un système affine

P = {P1 , · · · , Pn } ⊂ V
est un sous-ensemble dans V tel que P n’est pas contenu dans aucun hyperplan H ⊂ V .
68
On pose
d = d(P) = n − max{Card (P ∩ H) | H hyperplan } > 0
H
On considère l’application linéaire
EP : V ∗ → Fnq , EP (l) = (l(P1 ), . . . , l(Pn ))
alors on obtient le code

C = Im(EP ) = EP (V ∗ ) ⊂ Fnq
associé à P. On voit que C est un [n, k, d]q -code (voir la définition 1.4) : si c = (l0 (P1 ), · · · , l0 (Pn )) un
mot de code C avec l0 ∈ V ∗ , l0 6= 0, alors
Card {i ∈ {1, 2, · · · , n} | l0 (Pi ) 6= 0} = n − Card ({P ∩ H0 | H0 hyperplan l0 = 0}
donc
d = min Card {i ∈ {1, 2, · · · , n} | l(Pi ) 6= 0}.
l
Remarque Pratiquement une matrice-génératrice de C est donnée par les coordonnées des points
P1 , · · · , Pn dans une base de V : si l1 , · · · , lk ∈ V ∗ les fonctions des coordonnées (la base duale d’une
base de V ), alors
 
l1 (P1 ) . . . . . . l1 (Pn )
G =  ... ... ... . . .  (ne pas confondre avec une matrice de contrôle !)
lk (P1 ) . . . . . . lk (Pn )
Théorème 7.2 Soit Systq (n, k, d) l’ensemble des systèmes affines ci-dessus. Le groupe GLFq (V ) agit
sur Systq (n, k, d), et il y a une bijection
∼
ϕ : Systq (n, k, d)/GLFq (V ) → Codes([n, k, d]q )
Preuve. Pour g ∈ GLFq (V ) on pose
g · P = {g · P1 , · · · , g · Pn } ⊂ V
alors
Pi ∈ H ⇐⇒ g · Pi ∈ g · H un autre hyperplan .
D’autre part,
Ker(EP ) = {l ∈ V ∗ | (l(P1 ), . . . , l(Pn ))} = {0} ⇒ EP est injective
Eg·P (l) = (l(g · P1 ), . . . , l(g · Pn )) = (g ∗ l(P1 ), . . . , g ∗ l(Pn ))EP (g ∗ l)
mais g ∗ est un Fq -isomorphisme donc les systèmes P et g ·P donnent le même code Im(EP ). L’application
réciproque à ϕ :
ϕ−1 : C 7→ ϕ−1 (C) = {P1 , · · · , Pn } ⊂ V = C ∗ , Pi (c) = ci , ième coordonnée de c = (c1 , · · · , cn ) ∈ C
7.1.2. Systèmes projectifs.

Soit n ≥ 1 un entier. On appelle espace projectif de dimension n sur un corps F et on note PnF ou
simplement Pn l’ensemble des classes d’équivalence de (n+1)-uplets (x0 , · · · , xn ), xi ∈ F pour 0 ≤ i ≤ n ;
sous la relation (x0 , · · · , xn ) ∼ (λ0 x0 , · · · , λn xn ) pour tout λ ∈ F ∗ . Une classe d’équivalence x est un
point de Pn .
69
Définition 7.3 Un système projectif
P = {P1 , · · · , Pn } ⊂ PFk−1
q
est un sous-ensemble dans PFk−1

q
= P(V ) tel que P n’est pas contenu dans aucun hyperplan projectif
H ⊂ PFk−1
q
.
Soit
P ◦ = {P1◦ , · · · , Pn◦ } ⊂ V
un système affine dans V representant P. Tout autre système
Pλ◦ = {λ1 P1◦ , · · · , λn Pn◦ } ⊂ V
défini un code Cλ = Im(EPλ◦ ) = ϕ(Pλ◦ ) équivalent à C = Im(EP ◦ ) = ϕ(P ◦ ) :
C = ϕ(P ◦ ) = EP ◦ (V ∗ ) = {(l(P1◦ ), . . . , l(Pn◦ )) | l ∈ V ∗ }
Cλ = ϕ(Pλ◦ ) = EP ◦ (V ∗ ) = {(λ1 l(P1◦ ), . . . , λn l(Pn )◦ ) | l ∈ V ∗ , λi ∈ F∗q }.
C’est-à-dire, Cλ = σ(C) pour la bijection linéaire diagonale donnée par la matrice σ = diag{λ1 , · · · , λn }.
Théorème 7.4 Soit Systq (n, k, d) l’ensemble des systèmes projectifs ci-dessus. Le groupe PGLFq (V ) agit
sur Systq (n, k, d), et il y a une bijection
∼
ϕ : Systq (n, k, d)/PGLFq (V ) → {Codes([n, k, d]q )}/(mod ∼)
où ∼ désigne l’équivalence linéaire diagolale des [n, k, d]q codes.
Preuve. : en exercice.
7.2. Codes géométriques

On défini les codes géométriques à partir des sous-ensembles de
X = P = {P1 , · · · , Pn } ⊂ PFk−1
q
, et {P1 , · · · , Pn } ⊂ Fkq .
Une matrice génératrice du code C = ϕ(P) est donnée par des coordonnées des points P i :
 
a1j
a2j 
 · · ·  , j = 1, · · · , n.
P = (aij ), Pj =  
akj
On pose
d = d(C) = d(X) = n − max{Card (X ∩ H) | H hyperplan } > 0
H
Remarque 7.5 Le nombre Card (X ∩ H) est majoré par le "degré" de X. Pour une courbe planaire
X = X(Fq ) ⊂ P2Fq donnée comme l’ensemble des zéros d’un polynôme homogène de degré m, H est une
droite qui coupe X en maximum m points.
Exemple. Codes de Reed-Muller d’ordre 1. Soit Lm = Fq [T1 , · · · , Tm ]d◦ ≤1 le Fq -espace vectoriel

de tous les polynômes de degré ≤ 1 de m variables sur Fq (avec le polynôme nul), donc dimFq Lm = m + 1.
On considère un sous ensemble
P = {P1 , · · · , Pn } ⊂ Fm
q
tel que
∀l ∈ Lm (∀j = 1, · · · , n, l(Pj ) = 0 ⇒ l ≡ 0).
70
Définition 7.6
RMq (1, n, m) = ImEv, Ev : Lm → Fnq , f 7→ ((f (P1 ), · · · , f (Pn ))
est dit le code de Reed-Muller d’ordre 1.
On vérifie que RMq (1, n, m) est un [n, m + 1, n − q m−1 ]-code : tout polynôme de degré ≤1 de m variables
s’annule en ≤ q m−1 points. Pour q = 2, n = 32, m = 5 on obtient le code de l’Introduction.
Exercice. 1) Donner une version projective du code : on considère le Fq -space vectoriel L0m de tous les
polynômes homogènes de degré 1 de m+1 variables sur Fq (avec le polynôme nul), donc dimFq L0m = m+1.
On obtient un
qm − 1
n, m + 1, n −
q−1 q
-code pour tout
qm − 1
n≥ ,
q−1
(voir [Ste], p. 46).
2) Montrer que pour
q m+1 − 1
n=
q−1
on obtient un code se trouvant sur la borne de Plotkin (voir Théorème 6.1) de paramètres
m+1
q −1
, m + 1, q m .
q−1 q
7.3. Codes de Goppa rationnels

Ce sont des codes géométriques qui produisent une bonne famille des codes (dans le sens de la
définition 1.9.)
Soit g(x) un polynôme unitaire irréductible sur Fqm , L = {γ0 , γ1 , · · · , γn−1 } ⊂ Fqm avec g(γi ) 6= 0
pour tout i = 0, 1, 2, · · · , n − 1.
Définition 7.7 Le code de Goppa rationnel Γ(L, g) est

( )
n−1
X wi
Fnq

Γ(L, g) = w = (w0 , w1 , · · · , wn−1 ) ⊂ ≡ 0 mod g(x) (7.1)
i=0
x − γi
a(x)
(c’est-à-dire, la fraction à droite est de la forme d’une fraction irréductible b(x) avec g(x)|a(x).
Soient v = (v0 , v1 , · · · , vn−1 ) = w + e, un mot recu, w = (w0 , w1 , · · · , wn−1 ) ∈ Γ(L, g) un mot de code,
e = (e0 , e1 , · · · , en−1 ) ∈ Fnq le mot d’erreur, alors on considère les fractions suivantes
n−1 n−1 n−1
X vi X wi X ei
v(x) = , w(x) = , e(x) = .
i=0
x − γi i=0
x − γi i=0
x − γi
Pour écrire une matrice de contrôle du code Γ(L, g) on utilise pour tout i = 0, · · · , n − 1 un unique
polynôme fi (x) mod g(x) dans Fqm [x]/(g) tel que

1 g(x) − g(γi )
fi (x)(x − γi ) ≡ 1 mod g(x) ⇐⇒ fi (x) := − . (7.2)
g(γi ) x − γi
71
Soit
t
X 1
g(x) = g i xi , hj = ∈ F∗qm
i=0
g(γj )
alors
n−1
g(x) − g(y) X X X
= gk+j+1 y j xk ⇒ c i hi gk+j+1 · (γi )j xk ≡ 0 mod g
x−y i=0
k+j≤t−1 k+j≤t−1
(puisque
xi − y i X
= y j xk ).
x−y
k+j=i−1
Ceci implique
X
fi (x) ≡ gk+j+1 y j xk (7.3)
k+j≤t−1
Pour pouvoir travailler avec les polynômes, on fait correspondre (de façon unique) au mot v(x) un
polynôme fv (x) modulo g
n−1
X
v(x) 7→ fv (x) = vi fi (x),
i=0
alors
n−1
X
w(x) 7→ fw (x) = wi fi (x) ≡ 0 mod g.
i=0
En ettet,
1 fi (x)
fi (x)(x − γi ) ≡ 1 mod g(x) ⇒ fi (x)(x − γi ) = 1 + ui (x)g(x), =
x − γi 1 + ui (x)g(x)
donc
n−1
X Y
wi fi (x) (1 + uj (x)g(x))
n−1 n−1
X wi X wi fi (x) i=0 j6=i
= =
i=0
x − γi i=0
1 + ui (x)g(x) n−1
Y
(1 + uj (x)g(x))
j=0
Pn−1
Le dénominateur est congru à 1 mod g, et le numérateur est congru à i=0 wi fi (x) mod g. D’autre part,
le numérateur est congru à 0 mod g par Définition 7.9.
Si v = (v0 , v1 , · · · , vn−1 ) = w+e, un mot recu, w = (w0 , w1 , · · · , wn−1 ) ∈ Γ(L, g), e = (e0 , e1 , · · · , en−1 ) ∈
Fnq , alors
n−1
X n−1
X
fv (x) = S(x) = ei fi (x) ≡ vi fi (x) mod g
i=0 i=0
Pn−1
puisque i=0 wi fi (x) ≡ 0 mod g. On obtient maintenant une matrice de contrôle de la forme explicite
(7.3) :
n−1
X n−1
X X
wi fi (x) ≡ 0 mod g ⇒ w i hi gk+j+1 · (γi )j xk ≡ 0 mod g
i=0 i=0 k+j≤t−1
72
ceci dit, pour tous les k = 0, · · · , t − 1 le coefficient de xk à gauche est nul, donc une matrice de contrôle
du code Γ(L, g) est
 
h 0 gt h 1 gt ··· hn−1 gt
 h0 (gt−1 + gt γ0 ) h1 (gt−1 + gt γ1 ) ··· hn−1 (gt−1 + gt γn−1 ) 
 ··· ··· ··· ··· 
h0 (g1 + g2 γ0 + · · · + gt γ0t−1 ) h1 (g1 + g2 γ1 + · · · + gt γ1t−1 ) ··· t−1
hn−1 (g1 + g2 γn−1 + · · · + gt γn−1 )
On obtient une matrice simplifiée en faisant des transformations élémentaires :
 
h0 h1 ··· hn−1
 h0 γ 0
 h1 γ 1 · · · hn−1 γn−1 
 ··· ··· ··· ··· 
t−1 t−1 t−1
h0 γ 0 h1 γ 1 · · · hn−1 γn−1
Puis, on utilse comme syndrôme la fraction rationnelle
n−1
X ei
e(x) =
i=0
x − γi
(le vecteur d’erreurs), représenté comme le polynôme de syndrôme mod g

n−1
X
fe (x) ≡ S(x) ≡ fv (x) ≡ ei fi (x) mod g.
i=0
Théorème 7.8 Le code Γ(L, g) a :

(a) la dimension k(Γ(L, g)) ≥ n − mt,
(b) la distance d(Γ(L, g)) ≥ t + 1, f = deg(g)
Preuve. L’assértion (a) est immédiate de la taille de la matrice G vue comme une Matmt,n (Fq )-matrice
après un choix d’une base de Fqm sur Fq .
L’assértion (b) est impliquée par l’unicité de décomposition d’une fraction rationnelle en éléments
simples : pour avoir un élément non- nul
n−1
X ci a(x)
= (7.4)
i=0
x − γi b(x)
sous la forme d’une fraction irréductible a(x)

b(x) avec a(x) divisible par un polynôme irréductible g(x) de
degré t, il faut avoit au moins s ≥ t+1 termes non-nuls car après avoir amener au dénominateur commun
on aura le degré du polynôme a(x) ≤ s − 1 .
7.3.1. Construction des bonnes familles

Théorème 7.9 Pour tout δ ∈]0, (q − 1)/q[ on construit une famille {Ci } des [ni , ki , di ]q -codes, telle que
ki di
R = lim , δ = lim ,
et
R = 1 − Hq (δ)
Hq (0) = 0,
73
Rapellons
Définition 6.9. Une bonne famille {Ci } des [ni , ki , di ]q -codes est dite excellente s’il existe
ki di
R = lim , δ = lim ,
et
R ≥ 1 − Hq (δ)
Remarque 7.10 Théorème 7.9 donne une construction explicite d’une famille excellente {Ci } des [ni , ki , di ]q -
codes de Goppa rationnelles.
Preuve du Théorème 7.9. On choisit ni = q mi , m = mi , L = P = Fqm , d = di = [δni ], et on

précisera le polynôme g(x) = gi (x) ∈ Fqm [x] de degré t = ti à partir de considération suivante : Soit
c = (c0 , c1 , · · · , cn−1 ) un mot de code de poids j < d, alors le numérateur de la fraction 7.4 est de degré

j−1
≤ j − 1, donc le nombre maximal de ces diviseurs irréductibles de degré t est inférieur ou égal à .
t
Il nous faut donc exclure de considération au plus
d−1
X n j −1 d
(q − 1)j ≤ Vq (n, d)
j=1
j t t
puisque le nombre des numérateurs non-nuls de la fraction (7.4) est majoré par le nombre de toutes le
combinaisons linéaires non-triviales (sur Fq ) de d élements parmi n éléments.
D’autre part on sait que (voir Corollaire 2.10) que
logq Vq (n, [δn])
lim = Hq (δ),
n→∞ n
et que le nombre total des polynômes irréductibles de degré t sur Fqm [x] est (voir Théorème A17) :
1 mt
q (1 + o(1)) lorsque m → ∞.
t
On obtient donc une condition suffisante pour l’existance d’un polynôme voulu g de degré t
d 1
Vq (n, d) < q mt (1 + o(1)) ⇐⇒ d · Vq (n, d) < q mt (1 + o(1)) (m → ∞), (7.5)
t t
que signifie :
mt
Hq (δ) < + o(1), lorsque m → ∞.
n
Plus précisement, pour satisfaire les inégalités (7.5) et t < d = di , on prend logq de (7.5) :
logq (d · Vq (n, d)) = logq ([δn]) + logq (Vq (n, [δn])) = n(Hq (δ) + logq (n)) ≤ mt(1 + o(1)) (m → ∞),
Pour choisir g et t on pose

hn i
t= Hq (δ)(1 + o(1)) − 1 (7.6)
m
pour satisfaire (7.5), et pour avoir t < d, il suffit d’avoir
n
Hq (δ)(1 + o(1)) ≤ δn − 1
m
74
que est vraie pour
Hq (δ)(1 + o(1))
m≥ .
δ
Concernant le rendement de cette famille, Théorème 7.8 résulte que, avec n = ni , m = mi , k = ki , d = di
ce-dessus, et t = ti choisit comme dans l’égalité (7.6),
ki ni − m i t i
Ri = ≥ ≥ 1 − Hq (δ)(1 + o(1)) → 1 − Hq (δ) ⇒ R ≥ 1 − Hq (δ)
ni ni
donc la famille construite est excellente.
7.4. Décodage des codes de Goppa rationnels

On utilse comme syndrôme la fraction rationnelle
n−1
X ei
i=0
x − γi
(le vecteur d’erreurs), représenté comme un polynôme mod g

n−1
X
S(x) = ei fi (x) mod g
i=0
(le polynôme de syndrôme). Remarquer que si v = (v0 , v1 , · · · , vn−1 ) = w + e, un mot recu, w =

(w0 , w1 , · · · , wn−1 ) ∈ Γ(L, g), e = (e0 , e1 , · · · , en−1 ) ∈ Fnq , alors
n−1
X n−1
X
S(x) = ei fi (x) ≡ vi fi (x) mod g
i=0 i=0
puisque
n−1
X
ei fi (x) ≡ 0
i=0
Ensuite, on utise une version de l’algorithme de Berlekamp-Massey, voir Section 5.5.

Soit I := {i | ei 6= 0}, et on considère le polynôme locateur d’erreurs
Y
s(x) = (x − γi ),
i∈I

X Y
u(x) = ei (x − γj ).
i∈I j∈I\{i}
On cherche u(x), s(x) à partir de la définition (8.1) comme une solution de la congruence :
u(x) ≡ s(x)S(x)(modg(x)) (7.7)
Pour résoudre la congruence (7.7) on utilise la division euclidienne et l’identité de Bezout : on calcule
trois suites sn (x), tn (x), un (x) avec la propriété
tn (x)g(x) + sn (x)S(x) = un (x)
75
où le degré de un (x) décroît jusqu’au pgcd(g(x), S(x)) est atteint, à partir de
0 · g(x) + 1 · S(x) = S(x), 1 · g(x) + 0 · S(x) = g(x)
de telle façon que
(s0 (x), t0 (x), u0 (x)) = (0, 1, S(x)), (s1 (x), t1 (x), u1 (x)) = (1, 0, g(x)).
Il est clair que le couple (u(x), s(x)) = (un (x), sn (x)) est un unique couple satisfaisant (7.7) avec la
propriété que le degré de s(x) est inférieur de degré de g(x).
Exercice. Ecrire un algorithme pour trouver s(x) et u(x).
7.5. Codes provenants des courbes algébriques : P-construction

Tous les autres exemples considérés dans le reste de la Section proviennent d’une courbe algébrique
X sur Fq muni d’un plongement projectif
ϕ : X ,→ PN
Fq .
On utilise des sous-espaces vectoriels L(D) ⊂ Fq (X) de dimenion finie (voir définition 7.21) associés à
un diviseur D (voir Section 7.7.)
Il existe plusieures bonnes constructions des codes (L-construction, Ω-construction, P-construction,
voir [Ste], pp.243-248). Dans ce qui suit on donnera seulement quelques exemples.
7.5.1. P-construction
Dans ce cas P = X, n = Card (X(Fq )),
k = dim l(D) = dimFq L(D),
où L(D) ⊂ Fq (X) est un sous-espace de dimension finie dans le corps

u(T0 , · · · , TN )
Fq (X) = /mod ∼
v(T0 , · · · , TN )
des fonctions rationnelles sur X.

On utilise un plongement canonique
l(D)−1
ϕD : X ,→ PFq
attaché à un diviseur de degré deg(D) > 2g, où g = g(X) est le genre de X, voir [Ste], p.93 et la définition
7.27.
On pose a = deg D alors
d = n − max{Card (X ∩ H) | H hyperplan }
H
puisque deg D ≤ maxH {Card (X ∩ H) | H hyperplan } : selon la construction du plongement ϕD

l(D)−1
([Ste], p.92) avec N = l(D) − 1, il existe un hyperplan H ⊂ PFq tel que D = ϕ−1 D (H), donc
deg D ≤ maxH {Card (X ∩ H) | H hyperplan } (il se peut que les coordonnées des points d’intersection
appartiennent à une extenstion du corps de base Fq ).
76
7.5.2. Borne de la géométrie algébrique
On utilise le théorème 7.28 de Riemann-Roch (sous une forme faible) :
l(D) ≥ deg(D) − g + 1,
où g = g(X) est le genre de X, voir [Ste], p.93 et la définition 7.27. Ceci impliqie :

k = l(D) ≥ deg(D) − g + 1, où a = deg(D)
(7.8)
d ≥ n − a, (d := n − maxH {Card (X ∩ H) | H hyperplan })
donc l’addition directe dans 7.8 donne
k+d≥n−g+1 (7.9)
la borne de l’existence de la géométrie algébrique, comparer avec la borne de Singleton : k + d ≤ n + 1.
Ensuite on divise (7.9) par n :
g 1
R+δ ≥1−
+ (7.10)
n n
Théorème 7.11 (Ihara-Tsfasman-Zink-Drinfeld-Vladut, sans démonstration). Soit g = g(X)
est le genre de X, n = Card X(Fq )). Alors
(a)
g 1
lim inf ≥√ . (7.11)
X n q−1
(b) Si q est un carré, la borne (7.11) est atteinte
g 1
lim inf =√ .
X n q−1
Pour q = 49 :
0.8
0.6
R
0.4
0.2
0 0.2 0.4 0.6 0.8 1 1.2 1.4 1.6 1.8 2

delta
77
7.6. Espace projectif Pn , variétés algébriques
Soit F un corps algébriquement clos et n ≥ 1 un entier. On considère espace projectif de dimension n
sur F et on note Pnk ou simplement Pn l’ensemble des classes d’équivalence de (n + 1)-uplets (x0 , · · · , xn ),
xi ∈ F pour 0 ≤ i ≤ n ; sous la relation (x0 , · · · , xn ) ∼ (λ0 x0 , · · · , λn xn ) pour tout λ ∈ F ∗ . Une classe
d’équivalence x est un point de Pn . Soit F [T ] = F [T0 , · · · , Tn ]. On interprète les éléments de F [T ] comme
des fonctions régulières de l’espace affine An+1 , et on interprète les éléments de

T1 T2 Tn
F , ,··· ,
T0 T0 T0
comme des fonctions rationnelles de Pn
Définition 7.12 : Une partie X ⊂ Pn est dit une variété algébrique projective si
X = V (P ) = {x ∈ Pn | ∀F ∈ P, F (x) = 0}
où P est un idéal premier homogène de F [T0 , · · · , Tn ], c’est à dire premier engendré par des polynômes
homogènes. Tout sous-espace ouvert de X est une variété algébrique quasi-projective.
Définition 7.13 Soit U un voisinage ouvert d’un point x d’une variété projective X. Une application
f : U → F est une fonction régulière (ou lisse) au point x s’ils existent F, G ∈ F [T0 , · · · , Tn ] des
polynômes homogènes de même degré tels que G(x) ∈ 0 et f = F/G dans un voisinage ouvert de x ; f
est régulière sur U si elle est régulière en tout x de U .
Définition 7.14 Soit X une variété projective. L’idéal de X est l’ensemble
I(X) = {F ∈ F [T0 , · · · , Tn ]|F (x) = 0, ∀x ∈ X}.
On définit également le corps des fonctions F (X) de X comme le corps des fractions de la F -algèbre de
type fini F [T ]/I(X).
Soit x un point de X et soient les couples (U, f ) dans lesquels f est régulière sur U voisinage ouvert
de x. On définit la relation d’équivalence suivante :
(U, f ) ∼ (U 0 , f 0 ) ⇐⇒ f = f 0 sur U ∩ U 0
dont les classes d’équivalences forment un anneau.
Définition 7.15 L’anneau des classes d’équivalences de la relation ci-dessus est appelé l’anneau local
de x, noté Ox . Cet anneau est local au sens algébrique d’unique idéal maximal
mx = { classes d’équivalence de (U, f ) avec f (x) = 0}
Remarque 7.16 Tout idéal propre non nul de Ox est de la forme mnx pour un entier n > 0 (voir [Ste],
p.78).
Définition 7.17 Un anneau noethérien local O d’idéal maximal m et de corps résiduel k(m) = O/m est
dit régulier si le k(m)-espace vectoriel m/m2 a la même dimension que la dimension de l’anneau O.
Définition 7.18 Une variété projective X est dite non-singulière au point x si Ox est un anneau local
régulier. X est singulière au point x sinon. X est dite non-singulière ou lisse si elle est non singulière
en tout point. L’ensemble des points non-singuliers de X est un ouvert non vide de X dense dans X.
Définition 7.19 : On appelle courbe projective lisse toute variété algébrique projective lisse de dimen-
sion 1. La dimension de X est le degré de transcendance de F (X) sur F .
78
7.7. Diviseurs
Définition 7.20 Un diviseur sur une courbe projective lisse X est une combinaison linéaire
X
D= ax x,
la somme étant sur tous les points de X, et les ax entiers tous nuls sauf un ensemble fini appelé le support
de D. Si les ax sont tous positifs ou nuls, on note D ≥ 0.P Si les ax sont de plus tous non nuls, D est dit
positif, noté D > 0. On définit le degré de D : deg(D) = ax .
Soit x point non singulier de X, et f ∈ Ox . On pose vx (f ) = n si f ∈ mnx et f ∈ mn+1 x . Si

h = f /g ∈ F (X), on pose vx (h) = vx (f ) − vx (g). Si h ∈ mxP
, alors x est un zéro de h d’ordre vx (h). Si
h−1 ∈ mx , alors x est un pôle de h d’ordre vx (h − 1). (f ) = vx (f ) · x est le diviseur appelé diviseur de
f . Les diviseurs de la forme (f ) sont appelés principaux. On définit alors la relation d’équivalence
D ∼ D0 ⇐⇒ il existef de mx telle que D − D0 = (f )
La classe d’équivalence de D sous cette relation est appelée classe de diviseurs de D. On dit que D et D 0
sont équivalents.
Définition 7.21 Le F -espace vectoriel
L(D) = {f ∈ F (X)∗ |(f ) + D ≥ 0},

P P
C’est à dire que si D = − ax x+ ax0 x0 , avec les ax et les ax0 tous positifs ou nuls, L(D) est l’ensemble
des éléments non nuls de F (X) ayant des zéros d’ordre au moins ax aux points x et des pôles d’ordre au
plus ax0 aux points x0 . On note l(D) la dimension sur F de L(D).
Théorème 7.22 On a
l(D) = 0 si deg D < 0

l(D) ≤ deg D + 1 sinon.

Soit ω une forme différentielle régulière sur U ouvert non vide de X. Les classes de la relation
d’équivalence
(U, ω) ∼ (U 0 , ω 0 ) ⇐⇒ ω = ω 0 sur U ∩ U 0
sont appelées formes différentielles rationnelles dont l’ensemble Ω(X) est un F (X)-module.
Définition 7.23 Soit ω une forme différentielle rationnelle sur X courbe lisse. Au voisinage de x point
de X, ω s’écrit ω = f dt, avec f = fx une fonction rationnelle et t = tx un paramètre local. On définit le
diviseur de ω par X
(ω) = vx (fx ) · x
La classe de diviseurs d’une forme différentielle rationnelle sur X est appelée classe des diviseurs cano-
niques, notée W . Un représentatant de W est appelé diviseur canonique noté K.
Remarque 7.24 : On a L(K) ∼ = Ω[X] (l’espace des formes différentielles régulières sur X) par l’iso-
morphisme de F -espaces vectoriels f → f ω
79
7.8. Courbes sur les corps finis
Définition 7.25 : Soit F 0 un sous-corps de F . Un point x = (x0 , · · · , xn ) de PnF est dit F 0 -rationnel si
xi 6= 0 =⇒ xj /xi ∈ F 0 pour tout 0 ≤ j ≤ n
Définition 7.26 Soit X une courbe projective lisse sur F et σ l’automorphisme de Frobenius sur X.
Un diviseur D est dit F -rationnel si
σ(D) = D
7.9. Théorème de Riemann-Roch, genre

Définition 7.27 Soit X une courbe projective lisse définie sur F . On appelle genre de X
g = g(X) = l(K) = dimF L(K)
Théorème 7.28 (de Riemann-Roch). Soit D un diviseur sur une courbe projective et lisse X de genre
g et soit K un diviseur canonique. Alors
l(D) − l(K − D) = deg D − g + 1
Preuve : Voir [Ste], p.91.

Proposition 7.29 (Formule du genre de Plücker). Soit X une courbe plane lisse de degré m dans P 2 .
Alors
g = (m − 1)(m − 2)/2

Les codes de Goppa se basent sur une courbe algébrique lisse et un ensemble de points rationnels sur
cette courbe. Pour construire des codes efficaces, il est utile de choisir des courbes avec un grand nombre
de points rationnels.
Théorème 7.30 (Borne de Hasse-Weil). Soit Nqm (X) le nombre de points Fqm -rationnels sur la courbe
projective lisse X. Alors
|Nqm (X) − q m − 1| ≤ 2gq m/2
Il existe bien d’autres bornes concernant le nombre de points rationnels sur des courbes particulières, et
le lecteur est renvoyé à [Ste], chap.6 pour une connaissance plus approfondie sur celles-ci.
7.10. Codes géométriques de Goppa : L-construction.

Définition 7.31 : Soit XP une courbe projective lisse définie sur Fq . Soient x1 , · · · , xn des points de X
Fq -rationnels et soit D0 = xi . Soit enfin D un diviseur sur X Fq -rationnel tel que les supports de D0
et D soient disjoints. Le code linéaire C = C(D0 , D) q-aire de longueur n associé au couple (D0 , D) est
l’image de
Ev : L(D) → Fqn
f 7→ (f (x1 ), . . . , f (xn ))
Un tel code est appelé un code géométrique de Goppa.
Pour construire un code de Goppa sur Fq , nous devons choisir une courbe lisse X, et deux diviseurs
particuliers. En effectuant pour ces éléments des choix judicieux, nous allons pouvoir construire des
codes très efficaces. Afin de mieux guider notre choix, nous allons établir quelques relations entre les
divers paramètres du code et certaines grandeurs liées aux objets choisis.
80
Théorème 7.32 Soit X une courbe projective lisse de genre g et x1 , · · · , xn des points de X Fq -
rationnels. Alors le code de Goppa C(D0 , D) est de dimension k, de longueur n et d’écart d satisfaisant
k = l(D) − l(D − D0 ) = deg D − g + 1 + l(K − D) − l(D0 − D)

d ≥ n − deg D
Corollaire 7.33 : Si deg D < n, alors

(i) k ≥ deg D − g + 1 et d ≥ n − deg D
(ii) Si de plus 2g − 2 < deg D < n, alors k = deg D − g + 1
(iii) Si {f1 , · · · , fk } est une base de L(D), alors
 
f1 (x1 ) f1 (x2 ) · · · f1 (xn )
G= : : : : 
fk (x1 ) fk (x2 ) · · · fk (xn )
est une matrice génératrice de C(D0 , D).
Les paramètres kC = deg D − g + 1 et dC = n − deg D sont appelés dimension désignée et distance

désignée du code C(D0 , D). D’après le théorème plus haut, on a la distance de C d ≥ dC , et le corollaire
ci-dessus nous indique que si n > deg D > 2g − 2, alors k = kC .
Définition 7.34 : Soit XP une courbe projective lisse définie sur Fq . Soient x1 , · · · , xn des points de X
Fq -rationnels et soit D0 = xi . Soit enfin D un diviseur sur X Fq -rationnel tel que les supports de D0
et D soient disjoints. Le code linéaire C = C(D0 , D) q-aire de longueur n associé au couple (D0 , D) est
l’image de
Ev : L(D) → Fqn
f 7→ (f (x1 ), . . . , f (xn ))
Un tel code est appelé un code géométrique de Goppa.
Pour construire un code de Goppa sur Fq , nous devons choisir une courbe lisse X, et deux diviseurs
particuliers. En effectuant pour ces éléments des choix judicieux, nous allons pouvoir construire des
codes très efficaces. Afin de mieux guider notre choix, nous allons établir quelques relations entre les
divers paramètres du code et certaines grandeurs liées aux objets choisis.
Théorème 7.35 Soit X une courbe projective lisse de genre g et x1 , · · · , xn des points de X Fq -
rationnels. Alors le code de Goppa C(D0 , D) est de dimension k, de longueur n et de distance d sa-
tisfaisant
k = l(D) − l(D − D0 ) = deg D − g + 1 + l(K − D) − l(D0 − D)

d ≥ n − deg D
Corollaire 7.36 Si deg D < n, alors

(i) k ≥ deg D − g + 1 et d ≥ n − deg D
(ii) Si de plus 2g − 2 < deg D < n, alors k = deg D − g + 1
(iii) Si {f1 , · · · , fk } est une base de L(D), alors
 
f1 (x1 ) f1 (x2 ) · · · f1 (xn )
G= : : : : 
fk (x1 ) fk (x2 ) · · · fk (xn )
est une matrice génératrice de C(D0 , D).
81
Les paramètres kC = deg D − g + 1 et dC = n − deg D sont appelés dimension désignée et distance
désignée du code C(D0 , D). D’après le théorème plus haut, on a l’écart de C d ≥ dC , et le corollaire
ci-dessus nous indique que si n > deg D > 2g − 2, alors k = kC .
Remarque 7.37 Soit désormais C = C(D0 , D) un code sur une courbe lisse de genre zéro sur Fq , tel
que deg D < n. Alors les paramètres de C satisfont
k+d≥n+1−g
ou encore
R + δ ≥ 1 + (1 − g)/n
Or, d’après la borne de Singleton, on a k + d ≤ n + 1. Donc si g = 0, on a
k+d=n+1
et la borne est atteinte.
Exemple : Soit X = P1 (Fq ) la courbe lisse sur Fq de genre zéro et les diviseurs D = m · x et D0 tel que
SuppD0 63 x
Alors L(D) est l’espace des polynômes sur Fq de degré au plus m, et le code de Goppa généré est de
longueur q, de dimension m + 1 et d’écart q − m sur Fq qui est un code de Reed-Solomon.
Exemple : codes de Hermite. On considère la courbe projective et lisse X ⊂ P2Fq
X : uq+1 + v q+1 + wq+1 = 0

q(q − 1)
de genre g(X) = . Elle contient 3(q + 1) points sur Fq2 avec uvw = 0 :
2
(1, ζ, 0), (0, 1, ζ), (1, 0, ζ) ∈ X(Fq2 ) avec ζ q+1 = 1, ζ ∈ F∗q2 ,
de plus, il y a (q − 2)(q + 1)2 point avec uvw 6= 0 : dans ce cas on peut supposer u = 1, v q+1 6= −1, et le
nombre de solution de l’équation w q+1 = a ∈ F∗q égal à q + 1. Donc
Card (X(Fq2 )) = 3(q + 1) + (q − 2)(q + 1)2 = q 3 + 1 = q 2 + 1 + 2g(X)q.
C’est-à-dire, le nombre des points X(Fq2 ) de la courbe X est maximal possible. On pose n = q 3
D0 = {x1 , · · · , xn }, xi ∈ X(Fq2 )\x∞ , (x∞ = (0, 1, 1)), D0 = m · x∞ .
Soit C = C(D0 , D) = L(D0 − D) le code de Goppa correspondant, c’est un
[q 3 , m − g + 1, d]q − code , avec d ≥ n − m, avec le choix de m : q 2 − q < m < q 3 .
Si q = 2, g(X) = 1, X est une courbe elliptique, Card (X(F4 )) = 9 :

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
COURBE de FERMAT sur GF(4)

> restart ;
> with(linalg) :
unprotected
82
> g:=x^2+x+1 mod 2;
g := x2 + x + 1
α
> f:=(x,y,z)->x^3+y^3+z^3;
f := (x, y, z) → x3 + y 3 + z 3
> h:=(i,j)->x[i-1,j-1]: X:=Matrix(3,2,h);
 
x0, 0 x0, 1
X :=  x1, 0 x1, 1 
x2, 0 x2, 1
> u:=(i,j)-> alpha^(i-1):U:=Matrix(2,1,u);

1
U :=
α
> with(LinearAlgebra):
> Y:= Multiply(X, U);
Warning, the assigned name GramSchmidt now has a global binding
 
x0, 0 + x0, 1 α
Y :=  x1, 0 + x1, 1 α 
x2, 0 + x2, 1 α
> v[1]:=f(0, 1, x[2]);
v1 := 1 + x2 3
> v[2]:=f(1, x[1], x[2]);
v2 := 1 + x1 3 + x2 3
> vv[1]:=subs(x[0]=Y[1,1],x[1]=Y[2,1], x[2]=Y[3,1],v[1]) ;

vv 1 := 1 + (x2, 0 + x2, 1 α)3
> vv[2]:= subs(x[0]=Y[1,1],x[1]=Y[2,1], x[2]=Y[3,1],v[2]) ;
vv 2 := 1 + (x1, 0 + x1, 1 α)3 + (x2, 0 + x2, 1 α)3
> c:=0;
> if f(0,0,1) mod 2 =0 then c:=c+1;
> print (c, [0, 0, 1]) fi;
> for j from 0 to 1 do
> if Eval(vv[1],{x[2,0]=i,x[2,1]=j}) mod 2 =0 then c:=c+1;
> print (c,[0, 1, i+j*alpha]) fi ;od ;od;
> for i2 from 0 to 1 do
> for j2 from 0 to 1 do
> if Eval(vv[2],{x[2,0]=i2,x[2,1]=j2, x[1,0]=i1,x[1,1]=j1}) mod 2
> =0 then c:=c+1;
> print (c,[1, i1+j1*alpha, i2+j2*alpha])
> fi od; od ;od ;od;
c := 0
1, [0, 1, α]
2, [0, 1, 1]
83
3, [0, 1, 1 + α]
4, [1, α, 0]
5, [1, 1, 0]
6, [1, 1 + α, 0]
7, [1, 0, α]
8, [1, 0, 1]
9, [1, 0, 1 + α]
Dans ce cas q = 2, n = q 3 = 8, m = 2, k = 2, d = 6, et on obtient un [8, 2, 6]4 -code C donné par
l’espace vectoriel
u
h1, i
v+w
puisque la fonction
u u (v 2 + vw + w2 ) (v 2 + vw + w2 )
= =
v+w (v + w) (v 2 + vw + w2 ) u2
est finie aux points
{x1 , x2 , x3 , x4 , x5 , x6 , x7 , x8 )}
et appartient à L(2x∞ ).
Exercice. 1) Calculer une matrice génératrice et une mathrice de contrôle de C.
Exercice. 2) Construire un code analogue pour m = 2.
Remarque 7.38 Ainsi, la classe des codes de Goppa peut être vue comme une généralisation des codes
BCH. On peut d’ailleurs étendre la méthode de construction des codes BCH vue dans Section 5. pour
définir les codes de Goppa (comme dans Théorème 7.9. Cette classe possède plusieurs avantages sur la
classe des codes BCH, et notamment celui de fournir de bons codes de grande longueur.
Nous avons vu déjà (Théoème 7.9),qu’il existe une bonne famille de codes de Goppa sur Fq dont le
rendement tend vers la borne de Gilbert-Varshamov.
7.11. Codes géométriques de Goppa : Ω-construction.

A un couple (D0 , D) et une courbe lisse X, on peut également associer un autre code de Goppa.
Considérons l’espace de formes différentielles
Ω(D0 − D) = {ω ∈ Ω(X)∗ |(ω) + D0 − D ≥ 0} ∪ {0}
c’est à dire l’espace des formes différentielles ayant des zéros de multiplicités appropriées dans SuppD et
des pôles au plus simples dans SuppD0 . Alors l’application
Res : Ω(D0 − D) → Fqn

ω 7→ (Resx1 (ω), · · · , Resxn (ω))
définit un code q-aire linéaire C ∗ = C ∗ (D0 , D) de longueur n. Or, nous avons vu que l’on pouvait
identifier Ω(D0 − D) et L(K + D0 − D) par le morphisme
ω 7→ ω/ω0 = f
où ω0 est une forme différentielle rationnelle sur X fixée.
84
Conclusion
Nous avons vu que la théorie des codes correcteurs d’erreurs se doit de relever plusieurs défis s’op-
posant parfois. En effet, les paramètres principaux d’un code de dimension donnée sont sa vitesse de
transmission et sa distance relative. Or, afin d’augmenter la vitesse de transmission, il convient de li-
miter la longueur du code et donc sa distance relative, ce qui réduit le nombre d’erreurs que le code
est capable de corriger. Ainsi, selon le besoin et les moyens, on pourra privilégier l’un ou l’autre de ces
deux paramètres. D’autre part, nous avons vu dans la dernière partie de l’étude la classe des codes de
Goppa, qui se construisent à partir d’une courbe projective lisse et de deux diviseurs. Un moyen d’op-
timiser ces codes et d’en construire de performants est d’étudier plus en profondeur ces objets (comme
par exemple les courbes elliptiques, modulaires . . . ) ainsi que les bornes concernant les paramètres des
codes construits sur ces objets.
85
8. Exercices de préparation à l’exemen
8.1. Estimation des sommes binomiales.
Pour tout z ∈]0, 1], soit
n
X
in i−r
g(z) = (q − 1) z = z −r (1 + (q − 1)z)n .
i=0
i
Montrer que g(z) atteint le minimum en
r r/n
z0 = = r ,
(q − 1)(n − r) (q − 1) 1 −
n
et le minimum est r −r r n−r
g(z0 ) = (q − 1)r 1− .
n n
8.2. Encadrement de la probabilité du decodage erroné.

Soit p = ps la probabilité des perturbations de symboles au cours de la transmission. On considère
F = {0, 1} et l’application E : F → F n du codage de répétition pure. Calculer la probabilité P du
decodage erroné.
(a) Montrer que
X n
P = (1 − p)l pn−l = O(pn/2 ) lorsque p → 0
l
0≤l<n/2
(b) Pour tout p < 81 , encadrer P (voir [vLi], p.24).

(a) Calculer le volume de la boule de Hamming Vq (n, t), t = 1, 2, 3.
8.3. Codes de Golay et empilement de sphères.

(a) Calculer le volume de la boule de Hamming Vq (n, t), t = 1, 2, 3.
(b) Montrer que la borne de Hamming est atteinte pour les codes G23 et G11 donc on a un emplilement
de sphères parfait.
8.4. Déscription géométrique des codes de Reed-Solomon

(voir [Pa-Wo], p.139).
Soit F2m = hαi, et soit p(x) ∈ F2m [x] pacourt le sous-espace linéaire Pk ⊂ F2m [x] avec d◦ (p) ≤ k − 1
ou p ≡ 0. Alors l’ensemble des mots de la forme
m
(p(1), p(α), · · · , p(α2 −2
))
est un code de Reed-Solomon de longueur n = 2m − 1, de polynôme
g(x) = (x − α)(x − α2 ) · · · · · (x − αr )
avec r = 2m − 1 − k.
Solution. On remarque que l’application
m
Φ : p 7→ (p(1), p(α), . . . , p(α2 −2
)) ∈ Fnq
86
est injective puisque Ker(Φ) = 0 par l’interpolation de Lagrange. On pose C1 = Im(Φ) = Φ(Pk ). Une
base convenable de C1 :
m
ci = Φ(pi ), pi = xi (i = 0, 1, · · · , k − 1) : ci = (1, αi , α2i , · · · , α(2 −2)i
),
P2m −2
donc ci (x) := j=0 αji xj .
Ensuite, on calcule le syndrôme du polynôme ci (x) :
m m
2X −2 2X −2
t i+t j
ci (α ) := (α ) = β j , avec β = αi+t .
j=0 j=0
Puisque 1 ≤ t ≤ r, 0 ≤ i ≤ k − 1, alors 1 ≤ i + t ≤ r + k − 1 = 2m − 2, donc

m
t β2 −1−2
β 6= 1, ci (α ) = = 0.
β−1
Ceci dit, C1 ⊂ C, puisque tous les mots de C1 ont le syndrôme nul. Mais
dimF2m C = dimF2m C1 = k
donc C = C1 .
Montrer un résultat analogue pour un corps fini Fq arbitraire.
8.5. Codes de Reed-Muller d’ordre 1.

Soit Lm = Fq [T1 , · · · , Tm ]d◦ ≤1 le Fq -space vectoriel de tous les polynômes de degré 1 ou 0 de m
variables sur Fq (avec le polynôme nul), donc dimFq Lm = m + 1. On considère un sous ensemble
P = {P1 , · · · , Pn } ⊂ Fm
q
tel que
∀l ∈ Lm (∀j = 1, · · · , n, l(Pj ) = 0 ⇒ l ≡ 0).
RMq (1, n, m) = ImEv, Ev : Lm → Fnq , f 7→ ((f (P1 ), · · · , f (Pn ))

est dit le code de Reed-Muller d’ordre 1.
Vérifier que RMq (1, n, m) est un [n, m + 1, n − q m−1 ]-code : tout polynôme de degré 1 de m variables
s’annule en q m−1 points.
1) Donner une version projective du code : on considère le Fq -space vectoriel L0m de tous les polynômes
homogènes de degré 1 de m + 1 variables sur Fq (avec le polynôme nul), donc dimFq L0m = m + 1. On
obtient un
qm − 1
n, m + 1, n −
q−1 q
-code pour tout
qm − 1
n≥ .
q−1
2) Montrer que pour
q m+1 − 1
n=
q−1
on obtient un code se trouvant sur la borne de Plotkin (voir Théorème 6.1) de paramètres
m+1
q −1 m
, m + 1, q .
q−1 q
87
3) Code correcteur de Reed-Muller d’ordre 1 et de longueur 32. Trouver une matrice de contrôle du
code donné par toutes les combinaisons linéaires mod 2 des lignes Ai de la matrice
 
α1 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
α2 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
 
α3 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1

0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1
 (∗)
α4  
α5 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1
α6 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1
E
F62 3 u = (α1 , α2 , α3 , α4 , α5 , α6 )7→E(u) := A1 α1 + A2 α2 + A3 α3 + A4 α4 + A5 α5 + A6 α6 ∈ F32
2
8.6. Exemples de decodage des codes cycliques.

Soit α un élément primitif de F16 racine du polynôme x4 +x+1 sur F2 , m(i) (x) le polynôme minimale
unitaire de αi . Alors
m(1) (x) = m(2) (x) = m(4) (x) = m(8) (x) = x4 + x + 1
m(3) (x) = m(6) (x) = m(12) (x) = x4 + x3 + x2 + x + 1
g(x) = m(1) (x)m(3) (x) = 1 + x4 + x6 + x7 + x8
est un code cyclique dont les paramètres sont d = 5, q = 2, n = 15. Sa dimension est k = 7 et un
polynôme de correction est
h(x) = (x15 − 1)/g(x) = 1 + x4 + x6 + x7
On construit une matrice génératrice G dont la ième ligne est le vecteur xi−1 g(x), 1 ≤ 1 ≤ k.
(a) Montrer que
 
1 0 0 0 1 0 1 1 1 0 0 0 0 0 0
 0 1 0 0 0 1 0 1 1 1 0 0 0 0 0 
 
 0 0 1 0 0 0 1 0 1 1 1 0 0 0 0 
 
G=  0 0 0 1 0 0 0 1 0 1 1 1 0 0 0 

 0 0 0 0 1 0 0 0 1 0 1 1 1 0 0 
 
 0 0 0 0 0 1 0 0 0 1 0 1 1 1 0 
0 0 0 0 0 0 1 0 0 0 1 0 1 1 1
(b) Montrer que la distance du code est 5 donc ce code corrige deux erreurs.
(c) On considère les composantes
14
X 14
X
S1 = v i αi , S3 = vi α3i .
i=0 i=0
du syndrome S(v) = Hv t . Alors v ∈ C si et seulement si S(v) = Hv t = 0. Supposons que le vecteur

reçu v = (v0 , . . . v14 ) contient au plus deux erreurs. Par exemple e(X) = X a1 + X a2 , où 0 ≤ a1 , a2 ≤ 14,
a1 6= a2 . Alors
S1 = αa1 + αa2 , S3 = α3a1 + α3a2 .
Soit η1 = αa1 , η2 = αa2 les locateurs des erreurs, alors
S1 = η1 + η2 , S3 = η13 + η23 ,
88
Montrer que
S3 = S13 + S12 η1 + S1 η12 ,
donc
1 + S1 η1−1 + (S12 + S3 S1−1 )η1−2 = 0.

1 + S1 η2−1 + (S12 + S3 S1−1 )η2−2 = 0.
(d) Montrer que s’il y a deux erreurs, η1−1 et η2−1 sont des racines différentes du polynôme
s(X) = 1 + S1 X + (S12 + S3 S1−1 )X 2 .

S’il n’y a qu’une seul erreur, S1 = η1 , S3 = η13 donc S13 + S3 = 0, et on a
s(X) = 1 + S1 X.
S’il n’y a pas d’erreurs, S1 = S3 = 0, et on a reçu message correct w. Si S1 6= 0 et S13 + S3 = 0, le

polynôme s(X) a une seule racine dans F16 . Si
s(X) = 1 + S1 X + (S12 + S3 S1−1 )X 2
n’a pas de racines dans F16 , le vecteur d’erreurs e(X) a plus que deux composantes non nuls, et il n’est
pas possible de corriger les erreurs à l’aide de ce code.
(e) Soit par exemple le mot reçu a la forme
v = (100111000000000).
Montrer que a1 = 8 et a2 = 14. Corriger le mot v.

Solution. On a S(v) = (S1 (v), S3 (v)) est donné par
S1 = 1 + α 3 + α 4 + α 5 = α 2 + α 3 ,
S3 = 1 + α9 + α12 + α15 = 1 + α2 .
(rappelons que
α4 = 1 + α, α5 = α + α2 , α6 = α2 + α3 , α7 = 1 + α + α3 , α8 = 1 + α2 ,
α9 = α + α3 , α10 = 1 + α + α2 , α11 = α + α2 + α3 , α12 = 1 + α + α2 + α3 ,
α13 = 1 + α2 + α3 , α14 = 1 + α3 , α15 = 1).
Le polynôme s(X) a la forme suivante :
s(X) = 1 + S1 X + (S12 + S3 S1−1 )X 2 =

1 + (α2 + α3 )X + (1 + α + α2 + α3 + (1 + α2 )(α2 + α3 )−1 )X 2
= 1 + (α2 + α3 )X + (1 + α + α3 )X 2 .
On trouve les racines de ce polynôme : X = α et X = α7 . Alors η1−1 = α et η2−1 = α7 , c’est à direη1 = α14 ,
η2 = α8 . On connait alors les erreurs : elles sont dans les positions correspondantes aux X 8 et X 14 , c’est
à direla 9e et la 15e composantes de v. Alors le mot transmis était
w = (100111001000001).
On décode ce mot par la division du polynôme correspondant par le polynôme générateur g(X). On
obtient le polynôme 1 + X 3 + X 5 + X 6 et le reste nul. Alors le message initial était
(1001011)
89
8.7. Codes de Reed-Solomon
Q43
Soit F∗256 = hαi, g = 12 (x − α11j ), α8 = α7 + α2 + α + 1. Alors n = 255, k = 223 (un code de
Reed-Solomon utilsé par NASA). Montrer que d = 33.
8.8. Décodage des codes de Goppa rationnels.

Soit g(x) un polynôme unitaire irréductible sur Fqm , L = {γ0 , γ1 , · · · , γn−1 } ⊂ Fqm avec g(γi ) 6= 0
pour tout i = 1, 2, · · · , n − 1.
Le code de Goppa rationnel Γ(L, g) est
( )
n−1
X ci
n
Γ(L, g) = (c0 , c1 , · · · , cn−1 ) ⊂ Fq ≡ 0 mod g(x)
i=0
x − γi
a(x)
(c’est-à-dire, la fraction à droite est de la forme d’une fraction irréductible b(x) avec g(x)|a(x).
alors on considère les fractions suivantes
n−1 n−1 n−1
X vi X wi X ei
v(x) = , w(x) = , e(x) = .
i=0
x − γi i=0
x − γi i=0
x − γi
On utilse comme syndrôme la fraction rationnelle

n−1
X ei
i=0
x − γi
(le vecteur d’erreurs), représenté comme un polynôme mod g

n−1
X
S(x) = ei fi (x) mod g
i=0
(le polynôme de syndrôme).

(a) Montrer que si v = (v0 , v1 , · · · , vn−1 ) = w + e, un mot recu, w = (w0 , w1 , · · · , wn−1 ) ∈ Γ(L, g),
e = (e0 , e1 , · · · , en−1 ) ∈ Fnq , alors
n−1
X n−1
X
S(x) = ei fi (x) ≡ vi fi (x) mod g
i=0 i=0
puisque
n−1
X
ei fi (x) ≡ 0
i=0
(le vecteur d’erreurs).

(b) Soit I := {i | ei 6= 0}, et on considère le polynôme locateur d’erreurs
Y
s(x) = (x − γi ),
i∈I

X Y
u(x) = ei (x − γj ).
i∈I j∈I\{i}
90
Montrer que u(x), s(x) satisfont la congruence :
u(x) ≡ s(x)S(x)(modg(x)) (8.1)
(d) Une version de l’algorithme de Berlekamp-Massey. Pour résoudre la congruence (8.1) on utilise
la division euclidienne et l’identité de Bezout : on calcule trois suites sn (x), tn (x), un (x) avec la propriété
tn (x)g(x) + sn (x)S(x) = un (x)
où le degré de un (x) décroît jusqu’au pgcd(g(x), S(x)) est atteint, à partir de
0 · g(x) + 1 · S(x) = S(x), 1 · g(x) + 0 · S(x) = g(x)
de telle façon que
(s0 (x), t0 (x), u0 (x)) = (0, 1, S(x)), (s1 (x), t1 (x), u1 (x)) = (1, 0, g(x)).
Décrire un algorithme pour trouver s(x) et u(x).
8.9. Codes de Hermite.

On considère la courbe projective et lisse X ⊂ P2Fq
X : uq+1 + v q+1 + wq+1 = 0

q(q − 1)
de genre g(X) = . Elle contient 3(q + 1) points sur Fq2 avec uvw = 0 :
2
(1, ζ, 0), (0, 1, ζ), (1, 0, ζ) ∈ X(Fq2 ) avec ζ q+1 = 1, ζ ∈ F∗q2 ,
de plus, il y a (q − 2)(q + 1)2 point avec uvw 6= 0 : dans ce cas on peut supposer u = 1, v q+1 6= −1, et le
nombre de solution de l’équation w q+1 = a ∈ F∗q égale à q + 1. Donc
Card (X(Fq2 )) = 3(q + 1) + (q − 2)(q + 1)2 = q 3 + 1 = q 2 + 1 + 2g(X)q.
(a) Montrer que le nombre des points X(Fq2 ) de la courbe X est maximal possible.
On pose n = q 3
D0 = {x1 , · · · , xn }, xi ∈ X(Fq2 )\x∞ , (x∞ = (0, 1, 1)), D0 = m · x∞ .
Soit C = C(D0 , D) = L(D0 − D) le code de Goppa correspondant, c’est un
[q 3 , m − g + 1, d]q − code , avec d ≥ n − m, avec le choix de m : q 2 − q ≤ m < q 3 .
Si q = 2, g(X) = 1, X est une courbe elliptique, Card (X(F4 )) = 9

(b) Dans ce cas q = 2, n = q 3 = 8, m = 2, k = 2, d = 6, et on obtient un [8, 2, 6]4 -code C donné par
l’espace vectoriel
u
h1, i
v+w
puisque la fonction
u u (v 2 + vw + w2 ) (v 2 + vw + w2 )
= =
v+w (v + w) (v 2 + vw + w2 ) u2
est finie aux points
{x1 , x2 , x3 , x4 , x5 , x6 , x7 , x8 )}
et appartient à L(2x∞ ). Calculer une matrice génératrice et une mathrice de contrôle de C.
(c) Construire un code analogue pour m = 3.
91
Exemen du 13 janvier 2003, 10h-13h, Salle 014
1. a) Soient F un ensemble fini de cardinal q, d(x, y) la distance de Hamming sur F n , et
Bq (x, r) = {y ∈ F n | d(x, y) ≤ r} ⊂ F n .
Trouver Vq (n, r) = Card (Bq (x, r)).

b) Encadrer V5 (3n, n).
2. Soit p = ps la probabilité des perturbations de symboles au cours de la transmission sur un canal
bruité. On considère F = {0, 1} et l’application E : F 2 → F 2n du codage de répitition pure.
(a) Calculer la probabilité P du decodage erroné.
1
(b) Pour tout p < 100 , encadrer P
3. (a) Est-ce-que la borne de Singleton est atteinte pour les codes de Golay G 23 et G11 ?
(b) Même question pour la borne de Plotkin.
(c) Montrer que la borne de Hamming est atteinte pour les codes G23 et G11 .
4. Soit Fq un corps fini de q ≥ 3 éléménts, k, d deux nombres entiers.
(a) Montrer que pour tout couple (k, d) avec k + d = q il existe un code C de type [q − 1, k, d] q .
(b) Pour quelles valeurs k, d un tel code C soit parfait ?
(c) Pour q = 8, k = 5, d = 3, construire une matrice de contrôle de C.
5. On considère le Fq -space vectoriel Vm de tous les polynômes homogènes de degré 1 de m + 1 variables
sur Fq (avec le polynôme nul), donc dimFq Vm = m + 1 et soit
P = {P1 , · · · , Pn } ⊂ Fm+1
q \{0}
un sous-ensemble tel que l’espace vectoriel engendré par les {P1 , · · · , Pn } coïncide avec Fm+1
q , et les
points Pi ne sont pas proportionnels.

qm − 1 qm − 1
a) Montrer qu’obtient un n, m + 1, n − -code pour tout n ≥ .
q−1 q q−1
b) Montrer que pour
q m+1 − 1
n=
q−1
un tel code atteinte la borne de Plotkin.
6. Code correcteur de Reed-Muller d’ordre 1 et de longueur 32.
Décrire une matrice de contrôle du code donné par toutes les combinaisons linéaires mod 2 des lignes
Ai de la matrice
 
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
 
0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1
0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1
 
0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1
0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1
92
A Annexe : Rappels sur les corps finis
Cette partie est une somme d’éléments d’algèbre utiles dans la compréhension de la théorie des codes
correcteurs d’erreurs, sans faire partie à proprement parler de la théorie en elle-même qui est le sujet de
l’étude. C’est pourquoi rien de ce qui suit n’est démontré. Pour un plus large développement sur les corps
finis et les démonstrations de ce qui est affirmé ci-dessous, le lecteur est renvoyé aux textes d’E.Peyre
[Pey], ainsi que Lidl-Niederreiter, [Li-Ni].
A1. Structure
Proposition-Définition A1 : Soit A un anneau commutatif de caractéristique p un nombre premier.
L’application
F rp : x 7→ xp , x ∈ A
est un morphisme d’anneau appelé morphisme de Frobenius. Plus généralement, si A est un anneau
commutatif de caractéristique p premier et si q est une puissance de p, on note F r q : x 7→ xq .
Théorème A2 : Soit K un corps fini. Alors K est de caractéristique p premier, K est de cardinal
q = pd , avec d = [K : Fp ]. Inversement, si p est premier, d est un entier, il existe à isomorphisme près
un unique corps à q = pd éléments, qui est le corps de décomposition de X q − X sur Fp . On note ce corps
Fq . De plus, on a l’existence de deux isomorphismes : un de (Fq , +) sur ((Z/pZ)d , +) et un du groupe
multiplicatif F∗q sur Z/(q − 1)Z (F∗q est un groupe cyclique d’ordre q − 1).
Théorème A3 : Soit q = pn . Tout sous-corps de Fq est d’ordre pm , où m est un diviseur de n.
A2. Polynômes sur les corps finis

Théorème A4 : Soit p premier et q une puissance de p. Pour tout entier d strictement positif, il existe
un polynôme P irréductible de degré d sur Fq et Fqd est isomorphe à Fq [T ]/(P ).
Remarque A5 Si on a un tel polynôme unitaire et r une racine de P dans Fq , la famille {1, r, · · · , r d−1 }
est une base du Fp -espace vectoriel Fq .
Théorème A6 : Soit P un polynôme irréductible sur Fq et r une racine de P dans une extension de
Fq . Alors, pour tout polynôme Q sur Fq , Q(r) = 0 si et seulement si Q divise P .
n
Lemme A7 Soit P un polynôme irréductible sur Fq de degré m. Alors P divise xq − x si et seulement
si m divise n.
Théorème A8 : Soit P un polynôme irréductible sur Fq de degré m. Alors P possède une racine r dans
m−1
Fqm . De plus, toutes les racines de P sont simples et sont données par r, r q , · · · , rq , éléments distincts
de Fqm .
Corollaire A9 : Le corps de décomposition d’un polynôme P de degré m irréductible sur F q est Fqm .
Définition A10 Soit P un polynôme sur Fq tel que P (0) 6= 0. L’ordre de P est le plus petit entier
positif e tel que P divise xe − 1. Si P(0)=0, alors il existe Q sur Fq non nul en 0 et h un entier positif
tels que P = xh Q, et dans ce cas, ord(P ) = ord(Q).
Remarque A11 Si P est irréductible de degré m sur Fq , alors l’ordre de P divise q m − 1.
Théorème A12 Le nombre de polynômes irréductibles unitaires sur Fq de degré m et d’ordre e est
Nq,m,e = ϕ(e)/m si e > 1.
où ϕ(e) est l’indicateur d’Euler de e.
93
Remarque A13 : Le degré de P irréductible sur Fq d’ordre e est l’ordre multiplicatif de q modulo e.
Définition A14 Un polynôme P de degré m sur Fq est dit primitif sur Fq s’il est le polynôme minimal
sur Fq d’un élément primitif de Fqm .
Théorème A15 P est primitif sur Fq si et seulement si P est unitaire, non nul en 0 et d’ordre q m − 1.
Définition A16 On appelle fonction de Moebius la fonction définie sur N par :


 1 , si n = 1
µ(n) = (−1)k , si n est le produit de k nombres premiers distincts,

0 , si n est divisible par le carré d’un nombre premier.
Théorème A17 Le nombre de polynômes irréductibles unitaires de degré n sur F q est
1X 1X
Nq (n) = µ(n/d)q d = µ(d)q n/d
n n
d|n d|n
La somme se faisant sur tous les diviseurs positifs de n.
Théorème A18 Soit α un élément de Fqm extension de Fq . Soit d le degré de α sur Fq et P le polynôme
minimal de α sur Fq . Alors,
(i) P est irréductible sur F q et son degré d divise m.
(ii) Q polynôme sur Fq est tel que Q(α) = 0 si et seulement si P divise Q.
(iii) Q polynôme irréductible unitaire sur Fq et tel que Q(α) = 0 est tel que P = Q.
d m
(iv) P divise xq − 1 et xq − 1.
d−1
(v) Les racines de P sont α, αq , · · · , αq et P est le polynôme minimal sur Fq de toutes ces racines.
(vi) Si P (α) = 0, alors l’ordre de P est égal à celui de α dans le groupe multiplicatif F ∗qm .
(vii) P est un polynôme primitif sur Fq si et seulement si α est d’ordre q d − 1 dans F∗qm .
Théorème A19 (Critère d’irréductibilité) Soit P un polynôme de degré d sur Fq . Alors P est
irréductible si et seulement si le rang de F rq − 1 est égal à d − 1.
94
B Annexe : Restes chinois, suite : Factorisation des Polynômes
(F. Sergeraert)
• Référence : Don Knuth, The Art of Computer Programming, vol. 2, pp.

381-398.
> restart ;
> with(linalg) :
unprotected
• La factorisation des polynômes n’est pas un sujet vraiment facile, pas plus que la factorisation
des entiers ! On présente ici le principal outil, la méthode de Berlekamp, qui concerne en fait la
factorisation dans le cas du corps de base fini, puis on explique dans les cas les plus simples comment
elle peut être utillisée pour obtenir la factorisation des polynômes à coefficients rationnels.
B1. Rappels sur les corps finis.
• On rappelle que p est premier si et seulement si tous les coefficients du binôme C(p, k) sont divisibles
par p pour 0 < k < p :
> seq(evalb(binomial(13,k) mod 13 = 0), k = 0..13) ;
> seq(evalb(binomial(9,k) mod 9 = 0), k = 0..9) ;
false, true, true, true, true, true, true, true, true, true, true, true, true, false
false, true, true, false, true, true, false, true, true, false
• Il en résulte que si on travaille dans Z/ p, la formule (a + b)p = ap + bp est valide, en particulier

(a + 1)p = ap + 1 et il en résulte par récurrence, partant de 1p = 1, que ap = a dans Z/ p.
• Un corps K fini est de caractéristique bien définie p : c’est le plus petit entier positif vérifiant p x
1 = (déf.) 1 + 1 + ... + 1 ( p fois) = 0. Nécessairement, p est premier, sinon on aurait dans K
des diviseurs de 0. Le corps K contient donc en particulier le sous-corps {0, 1, 2, ..., p − 1} = Z/
p qu’on notera simplement Zp et K est donc un espace vectoriel sur Zp de dimension d ; il a alors
pd éléments. La formule démontrant que le morphisme de Frobenius a → ap est Z-linéaire (et donc
aussi Zp -linéaire) : (a + b)p = ap + bp reste valable, mais il est maintenant faux, sauf si d=1, que
ap = a pour tout a de K. En effet, puisque X p − X est de degré p, il ne peut avoir que p racines
dans K, à savoir les éléments de Zp dans K. On verra que cette remarque est la clé de la méthode
de Berlekamp pour factoriser un polynôme à coefficients dans Zp .
• Le groupe multiplicatif des éléments non nuls de K a pour cardinal pd − 1, et il en résulte que
d d
pour tous ces éléments, la relation a(p −1) = 1 est satisfaite ; le polynôme X (p ) − X a donc pour
racines tous ces éléments, et de plus l’élément nul. Les éléments de K sont donc tous racines de ce
d Q
polynôme,et il en résulte que X (p ) − X = a (X − a) où a parcourt exactement tous les éléments
de K. Donc K est un (donc le) corps de décomposition de ce polynôme et il en résulte qu’il n’existe
qu’un seul corps de cardinal pd .
• Soit P dans Zp [ X] un polynôme irréductible de degré d. Alors le quotient Zp [ X]/ P est un corps à
pd éléments. Il résulte de ce qui précède que la classe d’isomorphisme de ce corps est indépendante
d
de P . Le polynôme P divise nécessairement le polynôme X (p ) - X ; en effet, si x est la classe de X
95
dans Zp [ X]/ P , le polynôme minimal de x ne peut être que P , mais d’après ce qui est dit ci-dessus,
d
x est aussi racine de X (p ) - X et donc ce dernier polynôme est divisble par P . Il en résulte aussi
que P est entièrement scindé dans K, donc une seule extension suffit toujours pour obtenir le corps
de décomposition d’un polynôme irréductible : toute extension de Zp est galoisienne.
Illustration.
> rnd := rand(0..2) :
• Contrairement au cas des coefficients entiers banals, il faut «tâtonner» un peu pour trouver un
polynôme irréductible à coeffcients dans Z3 .
> _seed := 1639 :
> P := sort(X^3 + add(rnd()*Xî, i=0..2)) ;
P := X 3 + 2 X 2 + 1
> Irreduc(P) mod 3 ;
true
• Il en résulte que le même polynôme est Q-irréductible :

> irreduc(P) ;
true
• Mais la réciproque est fausse : il arrive souvent qu’un polynôme soit Q-irréductible, mais pas
Zp -irréductible ; il arrive même que ceci se produise quel que soit p pour le même polynôme Q-
irréductible, c’est le cas de X 4 + 1.
> irreduc(X^4+1) ;
true
> Irreduc(X^4+1) mod 67 ;
false
> Factor(X^4+1) mod 67 ;
(X 2 + 47 X + 66) (X 2 + 20 X + 66)
> Factor(X^4+1) mod nextprime(10^6) ;
(X 2 + 410588 X + 1000002) (X 2 + 589415 X + 1000002)
• Pour travailler sous Maple dans des extensions de Zp , on procède comme pour les extensions de
Q, mais il n’y a aucune différence dans l’usage initial de RootOf, c’est seulement en fin de calcul
qu’on précise qu’on veut travailler dans Zp et ses extensions, en suffixant par «mod p».
> alias(alpha = RootOf(P)) ;
α
• Le quotient Z3 [ X]/ P est un espace vectoriel de degré 3 sur Z3 , dont les éléments sont tous de la
forme i + j α + k α2 pour i, j et k parcourant Z3 .
• Calcul du polynôme ayant exactement tous les éléments de Z3 [ X]/ P comme racine
> mul(mul(mul(X-i-j*alpha-k*alpha^2,
> k=0..2),
> j=0..2),
> i=0..2) ;
96
X (X − α2 ) (X − 2 α2 ) (X − α) (X − α − α2 ) (X − α − 2 α2 ) (X − 2 α) (X − 2 α − α2 )
(X − 2 α − 2 α2 ) (X − 1) (X − 1 − α2 ) (X − 1 − 2 α2 ) (X − 1 − α) (X − 1 − α − α2 )
(X − 1 − α − 2 α2 ) (X − 1 − 2 α) (X − 1 − 2 α − α2 ) (X − 1 − 2 α − 2 α2 ) (X − 2)
(X − 2 − α2 ) (X − 2 − 2 α2 ) (X − 2 − α) (X − 2 − α − α2 ) (X − 2 − α − 2 α2 )
(X − 2 − 2 α) (X − 2 − 2 α − α2 ) (X − 2 − 2 α − 2 α2 )
• Développement du produit.
> Expand(%) mod 3 ;
2 X + X 27
• ... autrement dit X 27 − X. A comparer avec :

> collect(evala(expand(%%)), [X, alpha]) :
• Vérification de la propriété de divisibilité.

> Divide(X^27-X, P) mod 3 ;
true
• Et pour cause :
> Factor(P, alpha) mod 3 ;
(X + α2 + α + 1) (X + 2 α2 + 1) (X + 2 α)
• Car, comme expliqué plus haut, une seule extension suffit toujours à décomposer complètement le
polynôme initial. Propriété en général fausse dans le cas rationnel :
> factor(P, alpha) ;
(X − α) (X 2 + 2 X + X α + 2 α + α2 )
B2. Bases de la méthode de Berlekamp.
• On travaille dans l’anneau de polynômes Zp [ X], pour un premier p, et sauf indication contraire,
Z7 [ X] dans les exemples
• Soit P dans Zp [ X] et P = P1 ... Pr sa décomposition en facteurs irréductibles. On suppose d’abord

que P est sans facteur multiple, sinon ceci est détecté facilement par le PGCD du polynôme et du
polynôme dérivé. Construisons un exemple de cette sorte.
> rnd := rand(0..6) :
> rndP := proc(n)
> RETURN(sort(X^n + add(rnd()*Xî, i=0..(n-1))))
> end :
> _seed := 1730 :
> P1, P2 := rndP(3), rndP(3) ;
P1 , P2 := X 3 + X 2 + 2 X + 4, X 3 + 4 X 2 + 4 X + 2
• Le polynôme qui suit va certainement avoir un facteur multiple, mais on fait semblant de ne rien
savoir à ce propos.
> P := sort(Expand(P1^2 * P2) mod 7) ;
P := X 9 + 6 X 8 + 3 X 7 + 3 X 4 + 5 X 3 + 5 X 2 + 5 X + 4
97
• On détecte un facteur multiple éventuel par l’examen du PGCD entre le polynôme et son dérivé.
> Gcd(P, diff(P, X) mod 7) mod 7 ;
X3 + X2 + 2 X + 4
• Et on commencerait par factoriser X 3 + X 2 + 2 X + 4. Presque toujours (pas toujours, pourquoi ?)

le polynôme initial est divisible par le carré de ce terme.
> Rem(P, %^2, X) mod 7 ;
0
> Quo(P, %%^2, X) mod 7 ;
X3 + 4 X2 + 4 X + 2
• ce qui redonne comme par hasard nos polynômes initiaux.
• On suppose donc désormais qu’il n’y a aucun facteur multiple dans P .
• Si P = P1 ... Pr est la décomposition de P en facteurs irréductibles, le théorème du reste chinois

donne un isomorphisme canonique :
Zp
[ X]/ P = Zp [ X]/ P1 + ... Zp [ X]/ Pr . Les facteurs du second membre sont tous des corps, le
premier membre n’est un corps que si P est irréductible, autrement dit si r = 1.
• Il en résulte, c’est l’astuce de Berlekamp, un test permettant, sans connaître r, de «deviner» sa

valeur. Considérons en effet l’équation où l’inconnue V est un élément de Zp [ X]/ P :
VP −V =0
• Si on traduit cette équation vers le second membre (qu’on ne connaît pas !), l’inconnue V devient un
r-uplet ( V1 , ..., Vr ), et comme l’isomorphisme utilisé est un isomorphisme d’anneaux, l’équation
se transforme en r équations Vi p = Vi . Comme l’inconnue Vi est cette fois dans le corps Zp [
X]/ Pi , on sait qu’il y a exactement les p racines 0, ..., p − 1 dans Zp [ X]/ Pi . On en déduit que
le cardinal des solutions est exactement pr . Ainsi le cardinal de l’ensemble des solutions va nous
donner le nombre fatidique r. D’une façon très approximative, on peut dire que Berlekamp observe
que plus P est réductible, «moins» Zp [ X]/ P est un corps, et plus l’ensemble des solutions de
notre équation va être vaste.
• Le deuxième élément clé de la méthode de Berlekamp consiste à remarquer que puisque l’application
V → V p est linéaire, l’équation V p − V = 0 est, malgré les apparences, une équation linéaire, et on
dispose donc de tous les outils linéaires classiques pour la traiter.
• Exemple. Soit à étudier si notre polynôme P1 est irréductible dans Z7 . Il faut construire la
matrice de l’application linéaire V → V p − V dans Zp [ X]/ P1 . On prend la base canonique 1, X,
X 2 (ou plus précisément leurs classes modulo P1 ). L’image de X j est donc la classe de X (p j) − X j ,
et les éléments de colonne correspondants sont les coefficients appropriés. On construit à part la
procédure BerlTerm permettant le calcul du terme d’indices ( i, j) de la matrice de Berlekamp
du polynôme P par rapport à Zp .
98
> BerlTerm := proc(p::posint, P::polynom(integer, X),
> i::posint, j::posint)
> RETURN(coeff(Rem(X^(p*(j-1))-X^(j-1), P, X) mod p,
> X, i-1))
> end :
> BerlMatrix1 := matrix(3, 3, (i,j) -> BerlTerm(7, P1, i,j)) ;
 
0 0 1
BerlMatrix1 :=  0 3 0 
0 6 1
• La dimension du noyau nous donne la dimension de l’espace des solutions, c’est-à-dire le nombre des
facteurs irréductibles. On voit que le rang est 2, l’espace des solutions est donc de dimension 1, ce
ne peut être que Z7 , solutions «inévitables», et notre polynôme est donc irréductible. Pour obtenir
le rang de cette matrice dans le cas général, il faut utiliser la procédure Nullspace combinée avec
mod.
> Nullspace(BerlMatrix1) mod 7 ;
{[1, 0, 0]}
• Vérification.
> Irreduc(P1) mod 7 ;
true
• Mëme travail avec P2 .

> BerlMatrix2 := matrix(3, 3, (i,j) -> BerlTerm(7, P2, i,j)) ;
 
0 4 0
BerlMatrix2 :=  0 5 0 
0 1 0
{[1, 0, 0], [0, 0, 1]}

> Irreduc(P2) mod 7 ;
false
• On voit qu’ici notre équation V p − V a 49 solutions, 49 = 72 , et notre polynôme a donc deux

facteurs irréductibles. Il reste à les déterminer. Dans un cas si simple, c’est très facile, il suffit de
chercher l’élément a de Z7 nécessairement racine de P2 et le quotient par X − a donnera l’autre
facteur irréductible. Mais on veut expliquer comment il faut procéder dans le cas général. C’est le
sujet de la section suivante.
> if Eval(P2, X=i) mod 7 = 0 then print(i) fi
> od ;
3
> Quo(P2, X-3, X) mod 7 ;
X2 + 4
> Irreduc(%) mod 7 ;
true
> Factor(P2) mod 7 ;
(X 2 + 4) (X + 4)
99
B3. Trouver les facteurs irréductibles.
• Les solutions de l’équation V p − V = 0 ne donnent pas seulement le nombre de facteurs irréduc-

tibles, chaque solution donne aussi une décomposition, en général partielle, mais toujours non
triviale, du polynôme proposé en facteurs de degrés plus petits. Ceci est dû au fait que dans Z p ,
nous avons la décomposition :
V p − V = V (V − 1)
... ( V − p − 1).
• Dire que V est une solution de V p − V dans Zp [ X]/ P revient à dire que P divise V p − V , mais
la factorisation ci-dessus de V p − V va justement nous permettre de «découper en tranches» le
polynôme P .
• D’abord si P est irréductible, les seules solutions de V p − V = 0 sont les éléments de Zp , auquel cas
le «polynôme» V p − V est non seulement divisible par P , il est même nul ! et aucune «information»
ne peut être obtenue, heureusement.
• Par contre si P est factorisable, on va avoir des solutions différentes. Ces solutions vont être
de «vrais» polynômes (non constants), et un tel polynôme V va être de degré forcément <
d = degree(P ). On a alors le résultat suivant :
Qp−1
P = i=0 PGCD(P, V − i)
.
• En effet V p − V est divisible par P , et donc tout facteur irréductible de P va diviser V p − V et

se retrouver dans l’un des PGCD. Donc P divise le produit. Inversement, comme les V − i sont
premiers deux à deux (pourquoi ?), le même facteur de P ne peut pas se retrouver deux fois à
droite. Compte tenu par ailleurs du fait que degree(V − i) < d, on voit donc qu’on a ainsi, quel
que soit V solution «non constante» de V p − V = 0, une factorisation non triviale de P .
• Essayons ce mécanisme avec notre polynôme P2 . Un V non trivial est à trouver dans le noyau de
la matrice de Berlekamp :
> eval(BerlMatrix2) ;
 
0 4 0
 0 5 0 
0 1 0
{[1, 0, 0], [0, 0, 1]}
• Le générateur [1,0,0] du noyau correspond aux solutions triviales de V p − V = 0, mais l’autre,

[0,0,1], expression dans notre base du polynôme X 2 , est une solution non triviale.
> Divide(X^14-X^2, P2) mod 7 ;
true
> seq(Gcd(P2, X^2-i) mod 7, i=0..6) ;
1, 1, X + 4, X 2 + 4, 1, 1, 1
• Et on a bien notre décomposition.

> evalb(P2 = Expand(mul(gcdi, gcdi=[%])) mod 7) ;
100
true
• Dans le cas général, il n’y a pas de raison que la décomposition complète de P soit ainsi obtenue à
l’aide d’une seule solution non triviale V . C’est forcément ce qui arrive si le nombre de facteurs de
P est plus grand que p. Construisons P de sorte qu’il ait au moins 8 facteurs.
> _seed := 1054 :
> P||i := rndP(2)
> end do ;
P1 := X 2 + 4 X + 2
P2 := X 2 + 2 X + 3
P3 := X 2 + 3 X + 2
P4 := X 2 + 2 X
P5 := X 2 + 5 X + 5
P6 := X 2 + 2 X + 5
P7 := X 2 + 6 X
P8 := X 2 + 5 X + 1
> P := sort(Expand(mul(P||i, i=1..8)) mod 7) ;
P := X 16 + X 15 + 6 X 14 + 4 X 13 + 3 X 12 + 6 X 11 + 6 X 10 + 5 X 9 + 3 X 8 + 3 X 7 + 5 X 6 + X 5
+ 2 X4 + X3 + 2 X2
• Mais on peut avoir des facteurs multiples, qu’il faut éliminer pour que notre exemple soit correct.
> Gcd(P, diff(P,X) mod 7) mod 7 ;
X5 + 6 X4 + 4 X3 + 5 X2 + 5 X
> P := Quo(P, %, X) mod 7 ;
P := X 11 + 2 X 10 + 4 X 9 + 2 X 8 + 2 X 7 + 5 X 6 + X 5 + X 4 + 4 X 2 + 6 X
> Gcd(P, diff(P,X) mod 7) mod 7 ;
1
• Donc plus de facteurs multiples.

> BerlMatrix := matrix(11,11, (i,j) -> BerlTerm(7,P,i,j)) :
> Kernel := Nullspace(%) mod 7 ;
Kernel := {[0, 5, 3, 5, 0, 0, 1, 0, 0, 0, 0], [0, 5, 2, 5, 0, 0, 0, 0, 0, 0, 1],

[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0],
[0, 3, 0, 1, 0, 0, 0, 0, 0, 1, 0], [0, 1, 0, 3, 0, 1, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0], [0, 4, 6, 4, 1, 0, 0, 0, 0, 0, 0]}
• Les éléments du noyau sont des vecteurs, ce qui est techniquement désagréable pour la suite, on les
transforme tous en listes.
> Kernel := map(convert, Kernel, list) ;
Kernel := {[0, 5, 3, 5, 0, 0, 1, 0, 0, 0, 0], [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],

[0, 5, 2, 5, 0, 0, 0, 0, 0, 0, 1], [0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0],
[0, 3, 0, 1, 0, 0, 0, 0, 0, 1, 0], [0, 1, 0, 3, 0, 1, 0, 0, 0, 0, 0],
[0, 4, 6, 4, 1, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0]}
101
> r := nops(Kernel) ;
r := 8
• Donc 8 facteurs irréductibles. On retire l’élément de noyau correspondant aux solutions triviales.
> Kernel := Kernel minus {[1, 0$10]} ;
Kernel := {[0, 5, 3, 5, 0, 0, 1, 0, 0, 0, 0], [0, 5, 2, 5, 0, 0, 0, 0, 0, 0, 1],

[0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0], [0, 3, 0, 1, 0, 0, 0, 0, 0, 1, 0],
[0, 1, 0, 3, 0, 1, 0, 0, 0, 0, 0], [0, 4, 6, 4, 1, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0]}
> Vvector1 := Kernel[1] ;
Vvector1 := [0, 5, 3, 5, 0, 0, 1, 0, 0, 0, 0]
> V1 := sort(add(Vvector1[i]*X^(i-1), i=1..11)) ;
V1 := X 6 + 5 X 3 + 3 X 2 + 5 X
> factors1 := {seq(Gcd(V1-i, P) mod 7, i=0..6)} minus{1} ;
factors1 := {X 2 + 2 X + 5, X 2 + 5 X + 5, X + 1, X 3 + 4 X 2 + 6, X 3 + 4 X 2 + 2 X}
> nops(factors1) ;
5
> evalb(P = Expand(mul(gcdi, gcdi=factors1)) mod 7) ;
true
• On voit qu’une décomposition non triviale de P est bien obtenue, mais ce n’est évidemment pas
là la décomposition complète en facteurs irréductibles, puisqu’on a construit P comme un produit
de facteurs de degré 2. Comme seulement 7 cases sont disponibles dans le résultat, certainement
certains facteurs ainsi obtenus sont encore réductibles.
• Le point suivant consiste à dire qu’en essayant au besoin les autres éléments «non triviaux» du
noyau de la matrice de Berlekamp, on va réussir, en recoupant les résultats, à obtenir la factorisation
complète. Expliquons ce qu’il faut entendre par recouper.
• Prenons un autre vecteur de notre noyau.

> Vvector2 := Kernel[2] ;
Vvector2 := [0, 5, 2, 5, 0, 0, 0, 0, 0, 0, 1]
> V2 := sort(add(Vvector2[i]*X^(i-1), i=1..11)) ;
V2 := X 10 + 5 X 3 + 2 X 2 + 5 X
> factors2 := {seq(Gcd(V2-i, P) mod 7, i=0..6)} minus {1} ;
factors2 := {X 2 + X, X + 2, X + 5, X 4 + 4 X 3 + 5 X 2 + 2 X + 1, X 3 + 4 X 2 + 2}
> nops(factors2) ;
5
• On voit que la factorisation n’est pas la même que celle précédemment obtenue. On va démontrer
juste après que c’est toujours le cas. On obtient donc une «meilleure» factorisation en prenant
l’intersection, à coups de PGCD, des deux factorisations.
102
> factors12 := {seq(seq(Gcd(f1,f2) mod 7,
> f2 = factors2),
> f1 = factors1)}
> minus {1} ;
factors12 := {X 2 + 2 X + 3, X 2 + 2 X + 5, X 2 + 5 X + 5, X, X + 1, X + 2, X + 5, X + 6}
> nops(factors12) ;
8
• La factorisation est donc complète. D’autres fois, il faut encore continuer.
• Expliquons pourquoi la méthode des recoupements aboutit. Pour mieux faire comprendre, on se
contente du cas r = 3. Donc P = P1 P2 P3 et :
K [X]
/ P = K [X]/ P1 + K [X]/ P2 + K [X]/ P3 .
• Toute solution de notre équation V p − V = 0 a deux interprétations. Du côté «gauche», c’est

un polynôme «modulo P » ; mais du côté droit, comme pour chaque facteur les seules solutions
sont les polynômes «constants», ces solutions sont essentiellement des triplets ( α1 , α2 , α3 ) d’en-
tiers modulo p. La correspondance de la droite vers la gauche n’est rien d’autre que le théo-
rème des restes chinois. Le relèvement de (1,0,0) est le produit B1 P2 P3 de la relation de Bezout
A1 P1 + B1 P2 P3 = 1, car il s’agit d’avoir un polynôme divisible par P2 et P3 , mais égal à 1 mo-
dulo P1 . De la même façon, le relèvement de (0,1,0) (resp. (0,0,1)) est le produit B2 P1 P3 (resp.
B3 P1 P2 ) avec des interprétations analogues. Une solution «triviale» est de la forme ( α, α, α).
Donc une solution non triviale vérifie par exemple α1 <> α2 . Soit V l’interprétation polynôme
de cette solution. Alors V − α1 = (α2 − α1 ) B2 P1 P3 + (α3 − α1 ) B3 P1 P2 , alors que V − α2 =
(α1 − α2 ) B1 P2 P3 + (α3 − α2 ) B3 P1 P2 . Il en résulte que V − α1 est divisible par P1 et V − α2 est
divisible par P2 . Donc le «traitement» de V va forcément «séparer» les facteurs P1 et P2 . Main-
tenant l’ensemble des solutions à gauche correspond à l’ensemble des solutions à droite, et il y a
donc forcément une solution à gauche correspondant (sans qu’on le «voie») à un cas où α 1 <> α2 .
Il en est forcément de même pour l’un des vecteurs de la base du noyau, sinon on aurait α1 = α2
pour tous les éléments du noyau, ce qui est exclu. Le même travail peut être fait en général pour
toutes les paires d’indices, d’où le fait que les éléments de la base du noyau suffisent à complètement
factoriser. CQFD.
• On est prêt maintenant pour une procédure générale de factorisation. Elle va utiliser notre procédure
BerlTerm déjà construite.
103
> Berl := proc(p::posint, P::polynom(integer, X))
> local d, r, i,
> BerlMatrix, Kernel,
> Vvector, V,
> result, new_factors ;
> d := degree(P, X) ;
> # Erreur si facteur multiple.
> if Gcd(P, diff(P, X)) mod p <> 1 then
> ERROR(‘The polynom is not squarefree.‘)
> fi ;
> BerlMatrix := matrix(d,d, (i,j) -> BerlTerm(p,P,i,j)) ;
> Kernel := Nullspace(BerlMatrix) mod p ;
> # r = nombre de facteurs irréductibles.
> r := nops(Kernel) ;
> # Si r = 1, le polynôme est irréductible.
> if r = 1 then RETURN([P]) fi ;
> Kernel := map(convert, Kernel, list) ;
> # Suppression de la solution triviale.
> Kernel := Kernel minus {[1, 0$(d-1)]} ;
> # Pour signaler le début de l’algorithme.
> result := {} ;
> # Il faut parcourir les solutions non triviales et # arrêter quand le nombre de facteurs requis est
atteint.
> for Vvector in Kernel while nops(result) < r do
> # Expression polynômiale du nouveau vecteur solution considéré.
> V := add(Vvector[i]*X^(i-1), i=1..d) ;
> # Découpage en tranches.
> new_factors := {seq(Gcd(P, V-i) mod p, i=0..(p-1))}
> minus {1} ;
> # Recoupement (éventuel) avec ce qui a été précédemment fait.
> if nops(result) > 1 then
> result := {seq(seq(Gcd(f1,f2) mod p,
> f2 = new_factors),
> f1 = result)}
> minus {1}
> else result := new_factors
> fi
> od ;
> result := convert(result, list) ;
> result := map(sort, result) ;
> result := sort(result,
> (P1,P2)->evalb(degree(P1)<degree(P2))) ;
> RETURN(map(sort,result))
> end :
> fs := Berl(7, P) ;
fs := [X + 6, X + 5, X + 2, X + 1, X, X 2 + 5 X + 5, X 2 + 2 X + 5, X 2 + 2 X + 3]
> nops(fs) ;
8
> P - Expand(mul(f, f=fs)) mod 7 ;
0
> Berl(73, X^4+1) ;
[X + 51, X + 10, X + 63, X + 22]
• Des polynômes complexes peuvent ainsi être factorisés.

> _seed := 1535 :
> P := rndP(50) ;
104
P := X 50 + 2 X 49 + 5 X 48 + 6 X 47 + 3 X 46 + 2 X 45 + X 43 + X 42 + 4 X 41 + 2 X 40 + 5 X 39 + 5 X 38
+ 6 X 37 + 3 X 36 + 3 X 35 + 3 X 31 + 4 X 29 + 2 X 28 + 3 X 27 + 4 X 26 + 3 X 25 + X 23
+ 3 X 22 + 6 X 20 + X 19 + X 18 + 4 X 17 + 3 X 16 + 5 X 15 + 6 X 13 + X 12 + 6 X 11 + 3 X 10
+ 3 X9 + 6 X8 + X7 + 3 X6 + 5 X5 + 3 X4 + 2 X3 + 5 X + 6
> fs := Berl(7, P) :
> map(print, fs) :
X2 + 5 X + 2
X 11 + X 10 + X 9 + 6 X 7 + 6 X 6 + 5 X 5 + 5 X 4 + 4 X 3 + 2 X 2 + 4 X + 4
X 37 + 3 X 36 + 3 X 34 + 5 X 33 + X 31 + 5 X 30 + 5 X 28 + 3 X 27 + 3 X 26 + 5 X 25 + 3 X 24 + 2 X 23
+ 3 X 22 + 3 X 21 + 3 X 20 + X 19 + 6 X 17 + 3 X 16 + 6 X 15 + 6 X 14 + 6 X 13 + 4 X 12
+ 3 X 10 + 6 X 9 + X 8 + 6 X 7 + X 6 + 3 X 5 + 2 X 4 + 3 X 3 + 5 X + 6
> nops(fs) ;
3
> map(item -> Irreduc(item) mod 7, fs) ;
[true, true, true]

> P - Expand(mul(item, item=fs)) mod 7 ;
0
• Un cas irréductible.
> Berl(7, fs[1]) ;
[X 2 + 5 X + 2]
B4. Factorisation des polynômes à coefficients entiers.
• Les méthodes efficaces de factorisation des polynômes à coefficients entiers commencent toutes
par Zp -factoriser pour un p premier, ou puissance d’un nombre premier, avec p assez grand. Par
examen de la taille des coefficients pour une Z-factorisation éventuelle, on finit par en déduire la
Z-factorisation cherchée. Le point clé dans cette direction consiste à majorer les racines (en général
complexes) du polynôme à factoriser.
• Soit donc P = X n + an−1 X (n−1) + ... + a0 un polynôme unitaire à coefficients complexes. Alors
1
strictementmajorée par : A = 2 max(|ai | ( n−i ) , i = 0..n − 1). En effet on peut
toute racine de P est P
n an−i
écrire P = X n 1 + i=1 X i où |an−i | ≤ ( A i
2 ) . La somme de la dernière expression devient
une progression géométrique strictement majorée par 2AX 1−1 A = 2 X−A A
≤ 1 si A ≤ |X|. Donc
2X
la dernière inégalité implique P(X) non nul. Le raisonnement est en défaut si A = 0, mais ce cas
est sans intérêt, car alors toutes les racines sont nulles. Procédure conséquente.
> RootsSup := proc(P::polynom(rational, X))
> local dgr ;
> dgr := degree(P, X) ;
> if coeff(P, X, dgr) <> 1 then
> ERROR(sprintf("Polynôme %a non unitaire.", P))
> fi ;
> RETURN(2 * max(seq(evalf(abs(coeff(P, X, i))^(1/(dgr-i))),
> i=0..(dgr-1))))
> end :
105
• Soit donc P un Z-polynôme unitaire (il est facile de se ramener à ce cas par «changement de
variable») où les coefficients sont majorés par A. Il est élémentaire d’en déduire que les racines
(complexes) sont aussi strictement majorées en module par A + 1 ; il existe des inégalités sensible-
ment plus fines à ce sujet, mais pour simplifier, on se contentera ici de celle-ci. Puisqu’un facteur
potentiel de P est un produit de ( X − α) où α parcourt certaines racines de P , on en déduit
des majorations pour les coefficients d’une Z-factorisation éventuelle. On peut alors conclure en
examinant la Zp -factorisation de P pour p assez grand.
• Examinons par exemple le cas de X 4 + 1. Ici A = 2 mais on sait bien que les quatre racines sont
de module 1. Tentons la Z3 -factorisation.
> RootsSup(X^4+1) ;
> Berl(3, X^4+1) ;
2.
[X + 2 X + 2, X 2 + X + 2]
2
• Il en résulte qu’une Z-factorisation a au plus deux facteurs de degré 2, où les termes constants sont
de la forme 3 n + 2, mais ce pourrait être -1, et on ne peut conclure. On augmente p.
> Berl(5, X^4+1) ;
[X 2 + 3, X 2 + 2]
• Cette fois on a gagné, parce que l’un des facteurs a un terme constant de la forme 5 n + 2, incompa-
tible avec les modules connus des racines de X 4 + 1. Donc X 4 + 1 est Z-irréductible et donc (voir
la démonstration du théorème de Gauss sur la factorialité de Z[ X]) Q-irréductible.
> irreduc(X^4+1) ;
true
• Avec un polynôme moins trivial.

> _seed := 921 :
> P := rndP(10) ;
> RootsSup(P) ;
P := X 10 + 2 X 9 + 3 X 8 + 5 X 7 + 2 X 6 + 4 X 5 + 4 X 4 + 2 X 3 + 5 X 2 + X + 6
4.
• Toute racine est majorée par 4, et si une factorisation non triviale est possible, elle aura un facteur
de degré au plus 5 où le coefficient du terme après le terme de plus haut degré sera donc majoré
par 20 d’où l’idée d’utiliser 41.
> Berl(41,P) ;
[X 10 + 2 X 9 + 3 X 8 + 5 X 7 + 2 X 6 + 4 X 5 + 4 X 4 + 2 X 3 + 5 X 2 + X + 6]
• On est chanceux, le polynôme est donc irréductible.

> _seed := 1529 :
> P := rndP(10) ;
> RootsSup(P) ;
P := X 10 + 6 X 9 + 3 X 8 + 6 X 7 + X 6 + 6 X 5 + 2 X 4 + 2 X 3 + 5 X 2 + 2 X + 3
12.
• On essaie un nombre premier > 10 . 12 = 120, par exemple 127
106
> Berl(127, P) ;
[X + 45, X + 6, X 3 + 86 X 2 + 108 X + 28, X 5 + 123 X 4 + 105 X 3 + 51 X 2 + 13 X + 19]
• Le facteur X + 45 seul ne peut pas provenir d’une Z-factorisation, ni le facteur de degré 3. Dans
une telle situation il faut essayer si -6 est racine :
> subs(X=-6, P) ;
3361563
• Le produit (X + 6) (X + 45) va commencer par X 2 + 51 X et est aussi exclu. Essayons un autre

nombre premier, pour voir.
> Berl(131, P) ;
[X 2 + 104 X + 55, X 8 + 33 X 7 + 53 X 6 + 15 X 5 + 111 X 4 + 82 X 3 + 41 X 2 + 5 X + 112]
• Mais le facteur de degré 2 est impossible et le polynôme P est donc Q-irréductible. Vérification.
> irreduc(P) ;
true
• Il se trouve qu’on aurait pu essayer dans ce cas un entier un peu plus... petit. Ce polynôme est en
effet déjà irréductible modulo 5 !
> Berl(5,P) ;
[X 10 + 6 X 9 + 3 X 8 + 6 X 7 + X 6 + 6 X 5 + 2 X 4 + 2 X 3 + 5 X 2 + 2 X + 3]
• Un polynôme aléatoire est presque toujours irréductible. Forçons le choix d’un polynôme exercice
certainement réductible.
> _seed := 940 :
> P1, P2 := rndP(4), rndP(6) :
> P := sort(expand(P1 * P2)) ;
P := X 10 + 4 X 9 + 7 X 8 + 16 X 7 + 30 X 6 + 34 X 5 + 49 X 4 + 51 X 3 + 28 X 2 + 30 X + 20
> RootsSup(P) ;
8.
> nextprime(2*5*8) ;
83
> Berl(83, P) ;
[X + 9, X + 74, X + 68, X + 2, X + 1, X 2 + 37 X + 64, X 3 + 62 X 2 + 40 X + 67]
• On doit donc examiner si -1 et -2 sont racines.

> eval(P, X=-1) ;
0
> eval(P, X=-2) ;
• Le reste est un peu confus. Divisons et réexaminons la question.

> P2 := quo(P, (X+1)*(X+2), X) ;
P2 := X 8 + X 7 + 2 X 6 + 8 X 5 + 2 X 4 + 12 X 3 + 9 X 2 + 10
> RootsSup(P2) ;
107
4.000000000
> Berl(37, P2) ;
[X 2 + 2, X 6 + X 5 + 6 X 3 + 2 X 2 + 5]
• Essai.
> rem(P2, X^2+2, X) ;
• D’où la Q-factorisation définitive. Vérification.

> factor(P) ;
(X + 1) (X + 2) (X 6 + X 5 + 6 X 3 + 2 X 2 + 5) (X 2 + 2)
• En «bricolant» de la sorte, on arrive en général à factoriser les polynômes pas trop compliqués, mais
programmer une méthode générale est autrement complexe. Il serait confortable de savoir faire la
factorisation modulo un grand nombre premier, mais la méthode de Berlekamp, telle qu’elle a été
programmée précédemment, échoue alors, parce que l’équation de Berlekamp V p − V = 0 devient
trop difficile à résoudre, à cause de la taille de p.
> # Ne pas effectuer sous Maple 6.
> # Berl(nextprime(10^6), P) ;
• Beaucoup d’améliorations peuvent être intégrées à la procédure Berl, mais elle n’ira jamais très
loin pour une factorisation par rapport à de grands nombres premiers. Le corps «fini» Z p est bien
trop grand pour mener les calculs bien loin. Penser en particulier à la factorisation qu’il faut utiliser
V p − V = V (V − 1) ... V − p − 1, où le nombre de facteurs est justement p ! ! Une autre solution
devient alors beaucoup plus intéressante, basée sur le lemme de Hensel.
B5. Lemme de Hensel.
• Le lemme de Hensel est une méthode largement utilisée en algèbre commutative consistant à
résoudre un problème d’abord «approximativement» modulo un idéal m puis à affiner en travaillant
modulo les puissances de cet idéal, puissances de plus en plus petites. Le problème de la factorisation
des polynômes est justement un cadre parfait pour comprendre le mécanisme.
• L’outil essentiel pour démontrer le lemme de Hensel consiste à utiliser judicieusement une relation
à la Bezout pour exprimer un élément quelconque, et pas seulement 1, en fonction de deux éléments
u et v premiers entre eux dans un anneau principal.
• Commençons pour comprendre le principe par le cas entier.

Proposition B1 Si u et v sont deux entiers positifs premiers entre eux, alors tout entier x ε [0,
uv [ s’exprime d’une façon et d’une seule sous la forme :
x = α u + β v mod (u v)
avec α ∈ [0, v[ et β ∈ [0, u[.

Démonstration. Soit 1 = a u + b v une relation de Bezout entre u et v. Par multiplication par
x, on obtient x = x a u + x b v, mais x a et x b sont en général trop grands ; on les divise donc
respectivement par v et u, pour obtenir x = α u + β v + γ u v où on peut choisir α et β dans
les intervalles requis. Si un autre choix était possible, on trouverait par différences une relation
108
α u + β v = 0 mod ( u v) avec α non nul et de module < v ; mais ceci contredit la divisibilité de α
par v.
• Programme conséquent.
> Bezout2 := proc(x::nonnegint, u::posint, v::posint)
> local a, b, gcd ;
> gcd := igcdex(u, v, ’a’, ’b’) ;
> sprintf("les nombres %a et %a
> u, v))
> fi ;
> RETURN(x*a mod v, x*b mod u)
> end :
> Bezout2(4, 6, 15) ;
Error, (in Bezout2) les nombres 6 et 15

ne sont pas premiers entre eux.
> Bezout2(4, 3, 5) ;
3, 2
> evalb(4 = 3 * 3 + 2 * 5 mod (3*5)) ;
true
• Le même résultat est valide pour les polynômes à coefficients dans un corps, sous une forme encore
plus confortable.
Proposition B2 Si U et V sont deux polynômes de degrés respectifs m et n, premiers entre eux,
alors pour tout polynôme P de degré < m + n, il existe un unique polynôme A (resp. B) de degré
< n (resp. < m) tel que P = A U + B V .
• La démonstration est la même mais un examen de degrés montre qu’on peut même se dispenser de
l’imprécision «modulo U V ». Le programme conséquent suit.
> Bezout3 := proc(P::polynom(rational, X),
> U::polynom(rational, X),
> V::polynom(rational, X))
> local gcd, A, B ;
> gcd := gcdex(U, V, X, ’A’, ’B’) ;
> U, V))
> fi ;
> RETURN(rem(P*A, V, X), rem(P*B, U, X))
> end :
> _seed := 1925 :
> P, U, V := rndP(5), rndP(3), rndP(3) ;
P, U, V := X 5 + 5 X 4 + 6 X 3 + 2 X 2 + 6 X + 2, X 3 + X 2 + X + 6, X 3 + 2 X 2 + 3
> A, B := Bezout3(P, U, V) ;
1 7 2 2 25 2 59 1
A, B := − X − X, X + X+
6 18 3 18 18 3
> expand(P - A*U - B*V) ;
0
• Ceci est valable quel que soit le corps, par exemple Z7 , mais il faut adapter la procédure.
109
> ‘type/Z7‘ := proc(obj::anything)
> RETURN(type(obj, And(integer, Range(-1, 7))))
> end :
> type(3, Z7), type(-3, Z7) ;
true, false
> Bezout4 := proc(P::polynom(Z7, X),
> U::polynom(Z7, X),
> V::polynom(Z7, X))
> local gcd, A, B ;
> gcd := Gcdex(U, V, X, ’A’, ’B’) mod 7 ;
> ### WARNING: %x or %X format should be %y or %Y if used with
> floating point arguments
> ### WARNING: incomplete string; use " to end the string
> U, V))
> fi ;
> RETURN(Rem(P*A, V, X) mod 7, Rem(P*B, U, X) mod 7)
> end :
• On prend les mêmes polynômes, mais l’interprétation est différente.

> A, B := Bezout4(P, U, V) ;
A, B := 4 X + 6, X 2 + 6 X + 5
> Expand(P - A*U - B*V) mod 7 ;
0
• Un énoncé équivalent est obtenu pour des polynômes à coefficients entiers, à condition de faire
intervenir une égalité «modulo p» pour un premier p. Cet énoncé va pouvoir être généralisé au cas
pk où le quotient Z/ pk n’est plus un corps.
Proposition B3 : soient U et V des polynômes unitaires à coefficients entiers dans [0, p[, p-
premiers entre eux, de degrés respectifs m et n > 0. Alors pour tout polynôme P de degré < m + n,
il existe des polynômes uniques A et B , à coefficients entiers dans [0, p[, de degrés respectifs < n
et < m, et un polynôme R de degré < m + n, tels que P = A U + B V + p R.
Il suffit en effet d’appliquer le résultat précédent, mais quand on finit le calcul, il n’est exact que
modulo p. Il n’y a rien à changer à la procédure Bezout4, seule la fin de la vérification est différente.
> R := expand(P - A*U - B*V) / 7 ;
R := −X 4 − 3 X 3 − 3 X 2 − 6 X − 7
• On énonce maintenant un résultat analogue modulo pk . Cette fois l’anneau des polynômes à coef-
ficients modulo pk n’est plus principal, car il n’est même pas intègre. On se place donc dans une
situation où on suppose donnée une relation de Bezout entre U et V .
Proposition B4 Soient U et V deux polynômes unitaires à coefficients entiers dans [0, p k [, de
degrés respectifs m et n. On suppose donnée une relation de Bezout : 1 = A U + B V + p k C où
le degré de A (resp. B, C) est < n (resp. < m, < m + n). Alors, pour tout polynôme P à coef-
ficients entiers de degré < m + n, il existe des polynômes uniques E (resp. F , G), de degré < n
(resp. < m, < m + n), à coefficients entiers dans [0, pk [, (resp. dans [0, pk [, entiers), tels que
P = E U + F V + pk G.
Démonstration. Analogue avec les adaptations évidentes. Prendre E = P A et F = P B est ten-
tant, mais les degrés sont trop grands. Comme V est unitaire, on peut diviser P A par V pour obtenir
un reste à coefficients entiers E qu’on réduit modulo pk : P A = Q V + E + pk R, et de même on di-
110
vise P B par U pour obtenir P B = S U + F + pk T . En reportant dans P = P A U + P B V + pk P C,
il vient P = E U + F V + (Q + S) U V + pk (P C + R U + T V ). La réduction modulo pk de tous
les termes laisse un polynôme U V unitaire de degré m + n. Comme P − E U − F V est de de-
gré < m + n, il en résulte que le polynôme Q + S est nul modulo pk ; on peut donc «glisser» le
terme (Q + S) U V dans le facteur de pk et finalement le degré résultant est nécessairement <
m + n. Si on avait deux solutions différentes, on déduirait une relation E U + F V = pk R ; en
multipliant par A, il vient E A U + F A V = pk A R ou, compte tenu de la relation presque-Bezout,
E − E B V + F A V = pk (A R + E C). Mais si on réduit modulo pk , E devient divisible par V , ce
qui est incompatible avec V unitaire et degré de E < degré de V , à moins que E soit nul. CQFD.
> Bezout5 := proc
> (p::posint, k::posint, P::polynom(integer, X),
> U::polynom(integer, X), V::polynom(integer, X),
> A::polynom(integer, X), B::polynom(integer, X))
> RETURN(Rem(P*A, V, X) mod p^k, Rem(P*B, U, X) mod p^k)
> end :
• On redéfinit rndP pour que l’entier modulaire soit libre.

> rndP := proc(p::posint, d::posint)
> local rnd ;
> rnd := rand(0..(p-1)) ;
> RETURN(sort(X^d + add(rnd()*Xî, i=0..(d-1))))
> end :
> _seed := 2210 :
> p, k := 7,2 ; U,V := seq(rndP(49,3), i=1..2) ;
p, k := 7, 2
U, V := X + 43 X + 28 X + 48, X 3 + 18 X 2 + 12 X + 24
3 2
> Gcdex(U, V, X, ’A’, ’B’) mod 49 ;

1
> sort(expand(1-A*U-B*V)/49) ;
−X 5 − 38 X 4 − 63 X 3 − 85 X 2 − 56 X − 23
> P := rndP(49, 5) ;
P := X 5 + 22 X 4 + 26 X 3 + 11 X 2 + 39 X + 4
> E, F := Bezout5(7, 2, P, U, V, A, B) ;
E, F := 43 X 2 + 22 X + 19, 7 X 2 + 34 X + 3
> expand(P-E*U-F*V)/49 ;
−X 5 − 41 X 4 − 58 X 3 − 84 X 2 − 49 X − 20
• Nous pouvons maintenant énoncer le lemme de Hensel pour les polynômes modulo une puissance
de nombre premier.
Proposition B5 (lemme de Hensel) : On suppose qu’on dispose de deux relations :
P = U V + pk R; 1 = A U + B V + pk S;
où les degrés de U (resp. V , P , R, A, B, S) sont m (resp. n, m + n, < m + n, < n, < m, <

m + n). Par ailleurs P , U et V sont supposés unitaires, et les coefficients de A, U , B et V sont des
entiers dans [0, pk [. Alors il existe U0 , V0 , R0 , A0 , U0 , B0 , V0 et S0 vérifiant les mêmes conditions
à ceci près que pk doit être remplacé par p(2 k) . De plus U0 , V0 , A0 et B0 sont uniques. Il en résulte
la même propriété pour R0 et S0 .
111
Démonstration. On pose U0 = U + pk U1 et de même pour V , A et B. En reportant dans les
équations à satisfaire et en réduisant modulo p(2 k) , il vient les équations suivantes.
R = (V1 U + U1 V ) mod pk
;
S − A U1 − B V1 = (A1 U + B1 V ) mod pk
. On va donc trouver les correctifs d’indice 1 par application de Bezout5. CQFD.
> Hensel := proc
> (p::posint, k::posint, P::polynom(integer, X),
> U::polynom(integer, X), V::polynom(integer, X),
> A::polynom(integer, X), B::polynom(integer, X))
> local R, S, U1, V1, A1, B1 ;
> R := expand(P - U*V)/p^k ;
> S := expand(1 - A*U - B*V)/p^k ;
> if not type(R, polynom(integer, X)) then
> ERROR("P, U, V not coherent for Hensel.")
> fi ;
> if not type(S, polynom(integer, X)) then
> ERROR("A, U, B, V not coherent for Hensel.")
> fi ;
> V1, U1 := Bezout5(p, k, R, U, V, A, B) ;
> A1, B1 := Bezout5(p, k, S-A*U1-B*V1, U, V, A, B) ;
> RETURN(p, 2*k, P, sort(U+p^k*U1), sort(V+p^k*V1),
> sort(A+p^k*A1), sort(B+p^k*B1))
> end :
• On a maintenant l’outil ad hoc pour augmenter très vite l’entier modulaire par rapport auquel
on effectue une factorisation de polynômes à coefficients entiers. On trouve ainsi assez vite une
factorisation éventuelle pour un polynôme à coefficients entiers, ou au contraire son irréductibilité.
> _seed := 1713 ;
> P := rndP(10, 10) ;
> RootsSup(P) ;
_seed := 1713
P := X 10 + 4 X 9 + 8 X 8 + 2 X 7 + 9 X 6 + 3 X 5 + 4 X 4 + X 3 + 9 X 2 + 5
8.
> fs := Berl(11, P) ;
fs := [X 2 + 4 X + 2, X 8 + 6 X 6 + 8 X 4 + 4 X 3 + 5 X 2 + 6 X + 8]
• Deux facteurs, c’est la situation idéale pour Hensel. Il faut préparer les données.
> U, V := op(fs) ;
U, V := X 2 + 4 X + 2, X 8 + 6 X 6 + 8 X 4 + 4 X 3 + 5 X 2 + 6 X + 8
> Gcdex(U, V, X, ’A’, ’B’) mod 11 ;
1
> p,k,P,U,V,A,B := Hensel(11,1,P,U,V,A,B) : U ; V ;
X 2 + 92 X + 68
X + 33 X + 50 X + 55 X 5 + 19 X 4 + 81 X 3 + 93 X 2 + 94 X + 41
8 7 6
• Le facteur de degré 2 n’est pas possible, car il devrait être X 2 − 29 X + ... mais ceci est incompatible
avec la majoration par 8 des racines. Vérification.
> irreduc(P) ;
true
112
• Considérons comme plus haut un cas certainement factorisable.
> _seed := 16 :
> P := sort(expand(rndP(5,4)*rndP(5,6))) ;
> RootsSup(P) ;
P := X 10 + 2 X 8 + 4 X 7 + 2 X 6 + 12 X 5 + 4 X 4 + 16 X 3 + 8 X 2 + 8 X + 8
3.287503660
> fs := Berl(11, P) ;
fs := [X + 4, X 4 + 2 X 2 + 2, X 5 + 7 X 4 + 5 X 3 + 6 X 2 + 9 X + 1]
• Une racine est majorée par 3.3 et X + 4 ne peut pas venir d’un Z-facteur. Regroupons les deux
premiers facteurs.
> U := Expand(fs[1]*fs[2]) mod 11 ; V := fs[3] ;
U := X 5 + 2 X 3 + 2 X + 4 X 4 + 8 X 2 + 8
V := X 5 + 7 X 4 + 5 X 3 + 6 X 2 + 9 X + 1
> Gcdex(U, V, X, ’A’, ’B’) mod 11;
1
X 5 + 70 X 4 + 2 X 3 + 19 X 2 + 2 X + 19
X 5 + 51 X 4 + 60 X 3 + 39 X 2 + 53 X + 45
• Mais les coefficients de X 4 sont impossibles. On essaie l’autre combinaison.

> U := Expand(fs[1]*fs[3]) mod 11 ; V := fs[2] ;
U := X 6 + 4 X 3 + 4 X + 4
V := X 4 + 2 X 2 + 2
> Gcdex(U, V, X, ’A’, ’B’) mod 11;
1
X6 + 4 X3 + 4 X + 4
X4 + 2 X2 + 2
• Cette fois les facteurs potentiels restent curieusement constants. Continuons.

X6 + 4 X3 + 4 X + 4
X4 + 2 X2 + 2
X6 + 4 X3 + 4 X + 4
X4 + 2 X2 + 2
• Cette fois il s’agit d’une factorisation certaine modulo :

> 11^8 ;
214358881
113
• On est donc certain d’avoir une vraie factorisation entière, qu’on aurait pu essayer plus vite. Véri-
fication.
> factor(P) ;
(X 4 + 2 X 2 + 2) (X 6 + 4 X 3 + 4 X + 4)
• Jouons à trouver ainsi des factorisations élevées de X 4 + 1 ;

> P := X^4+1 ;
P := X 4 + 1
> Berl(3, P) ;
[X 2 + 2 X + 2, X 2 + X + 2]
> U,V := op(%) ;
> Gcdex(U,V,X,’A’,’B’) mod 3 ;
> p,k := 3, 1 ;
U, V := X 2 + 2 X + 2, X 2 + X + 2
1
p, k := 3, 1
> p,k,P,U,V,A,B := Hensel(p,k,P,U,V,A,B)
> od :
> k, p^k ; U ; V ;
64, 3433683820292512484657849089281
X 2 + 1352955588233944339554610415792 X + 3433683820292512484657849089280
X 2 + 2080728232058568145103238673489 X + 3433683820292512484657849089280
114
C Annexe : Bornes sur codes
restart;
>
> q:=7;
q := 7
> H[q](delta):=delta*log(q-1)/log(q)-
> delta*log(delta)/log(q)-(1-delta)*log(1-delta)/log(q);
> ’H[q](delta)=delta*log(q-1)/log(q)-
> delta*log(delta)/log(q)-(1-delta)*log(1-delta)/log(q)’;
δ ln(24) δ ln(δ) (1 − δ) ln(1 − δ)
H25 (δ) := − −
ln(25) ln(25) ln(25)
Hq (δ) = − −
> plot([H[q](delta)], delta = 0..1, R = 0..1,discont=true);

> ’R=H[q](delta)’;
0.8
0.6
R
0.4
0.2
0 0.2 0.4 0.6 0.8 1

delta
R = Hq (δ)
BORNE DE PLOTKIN ASYMPTOTIQUE

> R=1-q*delta/(q-1);plot([1-q*delta/(q-1)],delta=0..1, R=0..1, discont
> = true);
115
7
R=1− δ
6
0.8
0.6
R
0.4
0.2
0 0.2 0.4 0.6 0.8 1

delta
BORNE DE GILBERT-VARSHAMOV
> R=1-H[q](delta);plot([1-H[q](delta)],delta=0..1, R=0..1);
δ ln(6) δ ln(δ) (1 − δ) ln(1 − δ)

R =1− + +
ln(7) ln(7) ln(7)
116
1
0.8
0.6
R
0.4
0.2
0 0.2 0.4 0.6 0.8 1

delta
BORNE DE SINGLETON ASYMPTOTIQUE

> R=1-delta;plot([1-delta],delta=0..1, R=0..1);
R =1−δ
117
1
0.8
0.6
R
0.4
0.2
0 0.2 0.4 0.6 0.8 1

delta
BORNE DE HAMMING (D’EMPILEMENT DE SPHÈRES) ASYMPTOTIQUE

> f:=H[q](delta);
δ ln(6) δ ln(δ) (1 − δ) ln(1 − δ)

f := − −
ln(7) ln(7) ln(7)
> g1:=delta/2;g:=algsubs(delta=g1,f);
> ’g=H[q](delta/2)’;
1
g1 := δ
2
1 1 1 1
ln(1 − δ) (1 − δ) δ (−ln( δ) + ln(6))
g := − 2 2 + 2 2
ln(7) ln(7)
1
g = Hq ( δ)
2
> plot([1-g(delta),1-f], delta=0..2,R=0..2);
> ’R=1-H[q](delta/2) ,1-H[q](delta)’;
118
2
1.8
1.6
1.4
1.2
R 1
0.8
0.6
0.4
0.2
0 0.2 0.4 0.6 0.8 1 1.2 1.4 1.6 1.8 2

delta
1
R = 1 − Hq ( δ), 1 − Hq (δ)
2
BORNE DE BASSALYGO-ELIAS ASYMPTOTIQUE
> h:=(q-1)/q-((q-1)/q)*(1-(q*delta/(q-1)))^(1/2);
> R[BE]:=1-algsubs(delta=h,f);
> ’R[BE]= 1-H[q]((q-1)/q-((q-1)/q)*((1-(q*delta/(q-1)))^(1/2)))’;
r
6 6 7
h := − 1− δ
7 7 6
1 1 1 1 1 6 1
ln( + %1) ( + %1) (−6 + %1) (−ln( − %1) + ln(6))
RBE := 1 + 7 7 7 7 + 7 7 7
ln(7) ln(7)
√
%1 := 36 − 42 δ
 r 
qδ
q − 1 (q − 1) 1 − q − 1 
 q −
RBE = 1 − Hq  
q 
> plot([R[BE]],delta=0..1,R=0..1);
> ’R=R[BE](delta)’;
119
1
0.8
0.6
R
0.4
0.2
0 0.2 0.4 0.6 0.8 1

delta
R = RBE (δ)
BORNE DE LA GEOMETRIE ALGEBRIQUE
> R[GA]:=1-delta-(sqrt(q)-1)^(-1);
> ’R[GA]=1-delta-(sqrt(q)-1)^(-1)’;
1
RGA := 1 − δ − √
7−1
1
RGA =1−δ− √
q−1
TOUTES LES BORNES

> plot([1-f,1-g,R[BE],1-q*delta/(q-1),
> 1-delta,R[GA]],delta=0..2,R=0..1);
> ’R=1-H[q](delta),1-H[q](delta/2),R[BE](delta),
> 1-q*delta/(q-1), 1-delta, R[GA](delta)’;
120
1
0.8
0.6
R
0.4
0.2
0 0.2 0.4 0.6 0.8 1 1.2 1.4 1.6 1.8 2

delta
1 qδ
R = 1 − Hq (δ), 1 − Hq ( δ), RBE (δ), 1 − , 1 − δ, RGA (δ)
2 q−1
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
> restart;
> q:=49;
q := 49
δ ln(48) δ ln(δ) (1 − δ) ln(1 − δ)
H49 (δ) := − −
ln(49) ln(49) ln(49)
Hq (δ) = − −

> plot([1-q*delta/(q-1)],delta=0..1, R=0..1, discont = true);
> ’R=1-q*delta/(q-1)’;
121
1
0.8
0.6
R
0.4
0.2
0 0.2 0.4 0.6 0.8 1

delta
qδ
R =1−
q−1
> ’R=1-H[q](delta)’;
> plot([1-H[q](delta)],delta=0..1, R=0..1, discont = true);
R = 1 − Hq (δ)
122
1
0.8
0.6
R
0.4
0.2
0 0.2 0.4 0.6 0.8 1

delta
\mapleinline{active}{1d}{h:=(q-1)/q-((q-1)/q)*(1-(q*delta/(q-1)))^(1/2);}{%
}
r
48 48 49
h := − 1− δ
49 49 48
> f:=H[q](delta);
> ’f=H[q](delta)’;
δ ln(48) δ ln(δ) (1 − δ) ln(1 − δ)
f := − −
ln(49) ln(49) ln(49)
f = Hq (δ)
1
g1 := δ
2
1 1 1
ln(1 − δ) (1 − δ) 1 δ (ln( δ) − ln(48))
g := − 2 2 − 2
ln(49) 2 ln(49)
1
g = Hq ( δ)
2
123
2
1.8
1.6
1.4
1.2
R 1
0.8
0.6
0.4
0.2
0 0.2 0.4 0.6 0.8 1 1.2 1.4 1.6 1.8 2

delta
2
1.8
1.6
1.4
1.2
R 1
0.8
0.6
0.4
0.2
0 0.2 0.4 0.6 0.8 1 1.2 1.4 1.6 1.8 2

delta
124
1
R = 1 − Hq ( δ), 1 − Hq (δ)
2
> h ;R[BE]:=1-algsubs(delta=h,f);
> ’R[BE]= 1-H[q]((q-1)/q-((q-1)/q)*(1-(q*delta/(q-1)))^(1/2))’;
r
48 48 49
− 1− δ
49 49 48
1 4 1 4 4 48 4
ln( + %1) ( + %1) (−12 + %1) (−ln( − %1) + ln(48))
RBE := 1 + 49 49 49 49 + 49 49 49
ln(49) ln(49)
√
%1 := 144 − 147 δ
 r 
qδ
q − 1 (q − 1) 1−
q − 1
 q −
RBE = 1 − Hq  
q 

> plot([R[BE](delta)],delta=0..1,R=0..1);
0.8
0.6
R
0.4
0.2
0 0.2 0.4 0.6 0.8 1

delta
R = RBE (δ)
> R[GA]:=1-delta-(sqrt(q)-1)^(-1);
> ’R[GA]=1-delta-(sqrt(q)-1)^(-1)’;
125
5
RGA := −δ
6
1
RGA = 1 − δ − √
q−1
TOUTES LES BORNES

> 1-delta,R[GA]],delta=0..2,R=0..1);
0.8
0.6
R
0.4
0.2
0 0.2 0.4 0.6 0.8 1 1.2 1.4 1.6 1.8 2

delta
> restart;
> q:=25;
q := 25
δ ln(24) δ ln(δ) (1 − δ) ln(1 − δ)
H25 (δ) := − −
ln(25) ln(25) ln(25)
Hq (δ) = − −
126
> plot([1-q*delta/(q-1)],delta=0..1, R=0..1, discont = true);
> ’R=1-q*delta/(q-1)’;
0.8
0.6
R
0.4
0.2
0 0.2 0.4 0.6 0.8 1

delta
qδ
R =1−
q−1
> ’R=1-H[q](delta)’;
> plot([1-H[q](delta)],delta=0..1, R=0..1, discont = true);
R = 1 − Hq (δ)
127
1
0.8
0.6
R
0.4
0.2
0 0.2 0.4 0.6 0.8 1

delta
\mapleinline{active}{1d}{h:=(q-1)/q-((q-1)/q)*(1-(q*delta/(q-1)))^(1/2);}{%
}
r
24 24 25
h := − 1− δ
25 25 24
> f:=H[q](delta);
> ’f=H[q](delta)’;
δ ln(24) δ ln(δ) (1 − δ) ln(1 − δ)
f := − −
ln(25) ln(25) ln(25)
f = Hq (δ)
1
g1 := δ
2
1 1 1
ln(1 − δ) (1 − δ) 1 δ (ln( δ) − ln(24))
g := − 2 2 − 2
ln(25) 2 ln(25)
1
g = Hq ( δ)
2
128
2
1.8
1.6
1.4
1.2
R 1
0.8
0.6
0.4
0.2
0 0.2 0.4 0.6 0.8 1 1.2 1.4 1.6 1.8 2

delta
2
1.8
1.6
1.4
1.2
R 1
0.8
0.6
0.4
0.2
0 0.2 0.4 0.6 0.8 1 1.2 1.4 1.6 1.8 2

delta
129
1
R = 1 − Hq ( δ), 1 − Hq (δ)
2
> h ;R[BE]:=1-algsubs(delta=h,f);
> ’R[BE]= 1-H[q]((q-1)/q-((q-1)/q)*(1-(q*delta/(q-1)))^(1/2))’;
r
24 24 25
− 1− δ
25 25 24
1 2 1 2 2 24 2
ln( + %1) ( + %1) (−12 + %1) (−ln( − %1) + ln(24))
RBE := 1 + 25 25 25 25 + 25 25 25
ln(25) ln(25)
√
%1 := 144 − 150 δ
 r 
qδ
q − 1 (q − 1) 1−
q − 1
 q −
RBE = 1 − Hq  
q 

> plot([R[BE](delta)],delta=0..1,R=0..1);
0.8
0.6
R
0.4
0.2
0 0.2 0.4 0.6 0.8 1

delta
R = RBE (δ)
> R[GA]:=1-delta-(sqrt(q)-1)^(-1);
> ’R[GA]=1-delta-(sqrt(q)-1)^(-1)’;
130
3
RGA := −δ
4
1
RGA = 1 − δ − √
q−1
TOUTES LES BORNES

> 1-delta,R[GA]],delta=0..2,R=0..1);
0.8
0.6
R
0.4
0.2
0 0.2 0.4 0.6 0.8 1 1.2 1.4 1.6 1.8 2

delta
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
131
D Annexe : Codes cycliques. Codes de Golay
D1. Exemple de correction de deux erreurs par un code cyclique
.
> restart;
> restart ;
> with(linalg) :
unprotected
> q:=2;
q := 2
> g1:= x^4+x^3+1;
g1 := x4 + x3 + 1
> g:= x^4+x+1;
g := x4 + x + 1
> g2:=x^4+x^3+x^2+x+1;
g2 := x4 + x3 + x2 + x + 1
• Pour travailler sous Maple dans des extensions de Zp , on procède comme pour les extensions de Q,
mais il n’y a aucune différence dans l’usage initial de RootOf, c’est seulement en fin de calcul
qu’on précise qu’on veut travailler dans Zp et ses extensions, en suffixant par «mod p».
• Le quotient Z2 [ X]/(g) est un espace vectoriel de degré 4 sur Z2 , dont les éléments sont tous de la
forme i + j α + k α2 + l α3 pour i, j, k et l parcourant Z2 .
> Factor(g, alpha) mod 2 ;
(x + α2 ) (x + α + 1) (x + α2 + 1) (x + α)
> s:=1+(alpha^2+alpha^3)*x+(1+alpha+alpha^3)*x^2;
s := 1 + (α2 + α3 ) x + (1 + α + α3 ) x2
> Factor(s, alpha) mod 2 ;
(1 + α + α3 ) (x + α3 + α + 1) (x + α)
> Expand(alpha^7) mod 2;
1 + α + α3
> if Eval(s, x=alphaî) mod 2 = 0 then print(i) fi
> od ;
1
7
132
D2. Codes de Golay
> restart ;
> with(linalg) :
unprotected
(x + 1) (x11 + x10 + x6 + x5 + x4 + x2 + 1) (x11 + x9 + x7 + x6 + x5 + x + 1)
> g:=x^11+x^10+x^6+x^5+x^4+x^2+1;irreduc(g) mod 2;
g := x11 + x10 + x6 + x5 + x4 + x2 + 1
true
α
(x + α9 ) (x + α6 ) (x + α9 + α8 + α6 + α5 + α2 + α) (x + α4 )
(x + α8 + α7 + α6 + α5 + α3 + α2 + 1) (x + α10 + α8 + α6 + α3 + α + 1)
(x + α10 + α7 + α4 + α3 + α2 + α + 1) (x + α) (x + α2 ) (x + α8 ) (x + α3 )
> od ;
i = 1, α = α, g(α) = 0
i = 2, α2 = α2 , g(α2 ) = 0
i = 3, α3 = α3 , g(α3 ) = 0
i = 4, α4 = α4 , g(α4 ) = 0
i = 6, α6 = α6 , g(α6 ) = 0
i = 8, α8 = α8 , g(α8 ) = 0
i = 9, α9 = α9 , g(α9 ) = 0
i = 12, α12 = α10 + α7 + α4 + α3 + α2 + α + 1, g(α12 ) = 0
i = 13, α13 = α10 + α8 + α6 + α3 + α + 1, g(α13 ) = 0
i = 16, α16 = α9 + α8 + α6 + α5 + α2 + α, g(α16 ) = 0
i = 18, α18 = α8 + α7 + α6 + α5 + α3 + α2 + 1, g(α18 ) = 0

> od ;
1
i = 5, α5 = α5 , g( 5 ) = 0
α
1
i = 7, α7 = α7 , g( 7 ) = 0
α
1
i = 10, α10 = α10 , g( 10 ) = 0
α
133
1
i = 11, α11 = α10 + α6 + α5 + α4 + α2 + 1, g( )=0
α11
1
i = 14, α14 = α10 + α9 + α7 + α6 + α5 + α + 1, g( 14 ) = 0
α
1
i = 15, α15 = α8 + α7 + α5 + α4 + α + 1, g( 15 ) = 0
α
1
i = 17, α17 = α10 + α9 + α7 + α6 + α3 + α2 , g( 17 ) = 0
α
1
i = 19, α19 = α9 + α8 + α7 + α6 + α4 + α3 + α, g( 19 ) = 0
α
1
i = 20, α20 = α10 + α9 + α8 + α7 + α5 + α4 + α2 , g( 20 ) = 0
α
1
i = 21, α21 = α9 + α8 + α4 + α3 + α2 + 1, g( 21 ) = 0
α
1
i = 22, α22 = α10 + α9 + α5 + α4 + α3 + α, g( 22 ) = 0
α
> g[1]:=x^11+x^9+x^7+x^6+x^5+x+1;Factor(g[1],alpha) mod 2;
g1 := x11 + x9 + x7 + x6 + x5 + x + 1
(x + α10 + α9 + α7 + α6 + α3 + α2 ) (x + α10 + α6 + α5 + α4 + α2 + 1) (x + α7 )
(x + α8 + α7 + α5 + α4 + α + 1) (x + α10 ) (x + α5 ) (x + α10 + α9 + α5 + α4 + α3 + α)
(x + α9 + α8 + α7 + α6 + α4 + α3 + α) (x + α9 + α8 + α4 + α3 + α2 + 1)
(x + α10 + α9 + α7 + α6 + α5 + α + 1) (x + α10 + α9 + α8 + α7 + α5 + α4 + α2 )
générateur
g := x11 + x10 + x6 + x5 + x4 + x2 + 1
et avec le polynome de contrôle h = (x + 1) (x11 + x9 + x7 + x6 + x5 + x + 1) ,
h = x12 + x11 + x10 + x9 + x8 + x5 + x2 + 1.
C’est un [23,12, 7 ] _ 2-code.
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%%

> if Eval(g[1], x=alphaî) mod 2 = 0 then Expand (alphaî) mod 2;
> print(’i’=i, alphaî=Expand (alphaî) mod 2, ’g[1]’(alphaî)=0) fi
> od ;
i = 5, α5 = α5 , g1 (α5 ) = 0
i = 7, α7 = α7 , g1 (α7 ) = 0
i = 10, α10 = α10 , g1 (α10 ) = 0
i = 11, α11 = α10 + α6 + α5 + α4 + α2 + 1, g1 (α11 ) = 0
i = 14, α14 = α10 + α9 + α7 + α6 + α5 + α + 1, g1 (α14 ) = 0
i = 15, α15 = α8 + α7 + α5 + α4 + α + 1, g1 (α15 ) = 0
i = 17, α17 = α10 + α9 + α7 + α6 + α3 + α2 , g1 (α17 ) = 0
134
i = 19, α19 = α9 + α8 + α7 + α6 + α4 + α3 + α, g1 (α19 ) = 0
i = 20, α20 = α10 + α9 + α8 + α7 + α5 + α4 + α2 , g1 (α20 ) = 0
i = 21, α21 = α9 + α8 + α4 + α3 + α2 + 1, g1 (α21 ) = 0
i = 22, α22 = α10 + α9 + α5 + α4 + α3 + α, g1 (α22 ) = 0
> (x^11+x^10+x^6+x^5+x^4+x^2+1)*(x+1)*(x^11+x^9+x^7+x^6+x^5+x+1);g:=x^1
> 1+x^10+x^6+x^5+x^4+x^2+1;
(x11 + x10 + x6 + x5 + x4 + x2 + 1) (x + 1) (x11 + x9 + x7 + x6 + x5 + x + 1)
g := x11 + x10 + x6 + x5 + x4 + x2 + 1
> G:= matrix(12, 23,
> [[1,0,1,0,1,1,1,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0],
> [0,1,0,1,0,1,1,1,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0],
> [0,0,1,0,1,0,1,1,1,0,0,0,1,1,0,0,0,0,0,0,0,0,0],
> [0,0,0,1,0,1,0,1,1,1,0,0,0,1,1,0,0,0,0,0,0,0,0],
> [0,0,0,0,1,0,1,0,1,1,1,0,0,0,1,1,0,0,0,0,0,0,0],
> [0,0,0,0,0,1,0,1,0,1,1,1,0,0,0,1,1,0,0,0,0,0,0],
> [0,0,0,0,0,0,1,0,1,0,1,1,1,0,0,0,1,1,0,0,0,0,0],
> [0,0,0,0,0,0,0,1,0,1,0,1,1,1,0,0,0,1,1,0,0,0,0],
> [0,0,0,0,0,0,0,0,1,0,1,0,1,1,1,0,0,0,1,1,0,0,0],
> [0,0,0,0,0,0,0,0,0,1,0,1,0,1,1,1,0,0,0,1,1,0,0],
> [0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,1,1,0,0,0,1,1,0],
> [0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,1,1,0,0,0,1,1]]) ;
 
1 0 1 0 1 1 1 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0
 0 1 0 1 0 1 1 1 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 
 
 0 0 1 0 1 0 1 1 1 0 0 0 1 1 0 0 0 0 0 0 0 0 0 
 
 0 0 0 1 0 1 0 1 1 1 0 0 0 1 1 0 0 0 0 0 0 0 0 
 
 0 0 0 0 1 0 1 0 1 1 1 0 0 0 1 1 0 0 0 0 0 0 0 
 
 0 0 0 0 0 1 0 1 0 1 1 1 0 0 0 1 1 0 0 0 0 0 0 
G := 
 0 0 0 0 0 0 1 0 1 0 1 1 1 0 0

 0 1 1 0 0 0 0 0 

 0 0 0 0 0 0 0 1 0 1 0 1 1 1 0 0 0 1 1 0 0 0 0 
 
 0 0 0 0 0 0 0 0 1 0 1 0 1 1 1 0 0 0 1 1 0 0 0 
 
 0 0 0 0 0 0 0 0 0 1 0 1 0 1 1 1 0 0 0 1 1 0 0 
 
 0 0 0 0 0 0 0 0 0 0 1 0 1 0 1 1 1 0 0 0 1 1 0 
0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 1 1 1 0 0 0 1 1
> transpose(G);
135
 
1 0 0 0 0 0 0 0 0 0 0 0

 0 1 0 0 0 0 0 0 0 0 0 0 


 1 0 1 0 0 0 0 0 0 0 0 0 


 0 1 0 1 0 0 0 0 0 0 0 0 


 1 0 1 0 1 0 0 0 0 0 0 0 


 1 1 0 1 0 1 0 0 0 0 0 0 


 1 1 1 0 1 0 1 0 0 0 0 0 


 0 1 1 1 0 1 0 1 0 0 0 0 


 0 0 1 1 1 0 1 0 1 0 0 0 


 0 0 0 1 1 1 0 1 0 1 0 0 


 1 0 0 0 1 1 1 0 1 0 1 0 


 1 1 0 0 0 1 1 1 0 1 0 1 


 0 1 1 0 0 0 1 1 1 0 1 0 


 0 0 1 1 0 0 0 1 1 1 0 1 


 0 0 0 1 1 0 0 0 1 1 1 0 


 0 0 0 0 1 1 0 0 0 1 1 1 


 0 0 0 0 0 1 1 0 0 0 1 1 


 0 0 0 0 0 0 1 1 0 0 0 1 


 0 0 0 0 0 0 0 1 1 0 0 0 


 0 0 0 0 0 0 0 0 1 1 0 0 


 0 0 0 0 0 0 0 0 0 1 1 0 

 0 0 0 0 0 0 0 0 0 0 1 1 
0 0 0 0 0 0 0 0 0 0 0 1
> (x^11+x^10+x^6+x^5+x^4+x^2+1)*(x+1)*(x^11+x^9+x^7+x^6+x^5+x+1);
(x11 + x10 + x6 + x5 + x4 + x2 + 1) (x + 1) (x11 + x9 + x7 + x6 + x5 + x + 1)
> ’h’=(x+1)*(x^11+x^9+x^7+x^6+x^5+x+1);
> h:=Expand((x+1)*(x^11+x^9+x^7+x^6+x^5+x+1)) mod 2;
h = (x + 1) (x11 + x9 + x7 + x6 + x5 + x + 1)
h := x12 + x11 + x10 + x9 + x8 + x5 + x2 + 1
> ’h’=(x+1)*(x^11+x^9+x^7+x^6+x^5+x+1);’h’=sort(h,x);
h = (x + 1) (x11 + x9 + x7 + x6 + x5 + x + 1)
h = x12 + x11 + x10 + x9 + x8 + x5 + x2 + 1
> Expand(h*g) mod 2;

1 + x23
136
> H:= matrix(11, 23,
> [[0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,1,0,0,1,0,1],
> [0,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,1,0,0,1,0,1,0],
> [0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,1,0,0,1,0,1,0,0],
> [0,0,0,0,0,0,0,1,1,1,1,1,0,0,1,0,0,1,0,1,0,0,0],
> [0,0,0,0,0,0,1,1,1,1,1,0,0,1,0,0,1,0,1,0,0,0,0],
> [0,0,0,0,0,1,1,1,1,1,0,0,1,0,0,1,0,1,0,0,0,0,0],
> [0,0,0,0,1,1,1,1,1,0,0,1,0,0,1,0,1,0,0,0,0,0,0],
> [0,0,0,1,1,1,1,1,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0],
> [0,0,1,1,1,1,1,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0],
> [0,1,1,1,1,1,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0],
> [1,1,1,1,1,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0]]) ;
 
0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 0 0 1 0 0 1 0 1
 0 0 0 0 0 0 0 0 0 1 1 1 1 1 0 0 1 0 0 1 0 1 0 
 
 0 0 0 0 0 0 0 0 1 1 1 1 1 0 0 1 0 0 1 0 1 0 0 
 
 0 0 0 0 0 0 0 1 1 1 1 1 0 0 1 0 0 1 0 1 0 0 0 
 
 0 0 0 0 0 0 1 1 1 1 1 0 0 1 0 0 1 0 1 0 0 0 0 
 
 0 0 0 0 0 1 1 1 1 1 0 0 1 0 0 1 0 1
H :=  0 0 0 0 0 

 0 0 0 0 1 1 1 1 1 0 0 1 0 0 1 0 1 0 0 0 0 0 0 
 
 0 0 0 1 1 1 1 1 0 0 1 0 0 1 0 1 0 0 0 0 0 0 0 
 
 0 0 1 1 1 1 1 0 0 1 0 0 1 0 1 0 0 0 0 0 0 0 0 
 
 0 1 1 1 1 1 0 0 1 0 0 1 0 1 0 0 0 0 0 0 0 0 0 
1 1 1 1 1 0 0 1 0 0 1 0 1 0 0 0 0 0 0 0 0 0 0
 
2 2 2 2 2 2 4 4 4 4 4 4
 2 2 2 2 2 4 4 4 4 4 4 4 
 
 2 2 2 2 4 4 4 4 4 4 4 2 
 
 2 2 2 4 4 4 4 4 4 4 2 2 
 
 2 2 4 4 4 4 4 4 4 2 2 2 
 
 2 4 4 4 4 4 4 4 2 2 2 2 
K :=  
 4 4 4 4 4 4 4 2 2 2 2 2 
 
 4 4 4 4 4 4 2 2 2 2 2 2 
 
 4 4 4 4 4 2 2 2 2 2 2 0 
 
 4 4 4 4 2 2 2 2 2 2 0 2 
4 4 4 2 2 2 2 2 2 0 2 0
137
 
0 0 0 0 0 0 0 0 0 0 0 0

 0 0 0 0 0 0 0 0 0 0 0 0 


 0 0 0 0 0 0 0 0 0 0 0 0 


 0 0 0 0 0 0 0 0 0 0 0 0 


 0 0 0 0 0 0 0 0 0 0 0 0 


 0 0 0 0 0 0 0 0 0 0 0 0 


 0 0 0 0 0 0 0 0 0 0 0 0 


 0 0 0 0 0 0 0 0 0 0 0 0 


 0 0 0 0 0 0 0 0 0 0 0 0 

 0 0 0 0 0 0 0 0 0 0 0 0 
0 0 0 0 0 0 0 0 0 0 0 0
%1 := [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
Une autre matrice de contrôle :

on considère la matrice dont la j-me colonne est formée par les coordonnées de α j−1 (j = 1, 2, ..., 23)
dans la base
h1, α, α2 , . . . , α10 i
GF(211 ) = F2 [α].
> for j from 1 to 23 do print(alpha^(j-1)=Expand(alpha^(j-1)) mod 2) ;
> od;
1=1
α=α
α2 = α 2
α3 = α 3
α4 = α 4
α5 = α 5
α6 = α 6
α7 = α 7
α8 = α 8
α9 = α 9
α10 = α10
α11 = α10 + α6 + α5 + α4 + α2 + 1
α12 = α10 + α7 + α4 + α3 + α2 + α + 1
α13 = α10 + α8 + α6 + α3 + α + 1
α14 = α10 + α9 + α7 + α6 + α5 + α + 1
α15 = α8 + α7 + α5 + α4 + α + 1
α16 = α9 + α8 + α6 + α5 + α2 + α
α17 = α10 + α9 + α7 + α6 + α3 + α2
α18 = α8 + α7 + α6 + α5 + α3 + α2 + 1
α19 = α9 + α8 + α7 + α6 + α4 + α3 + α
α20 = α10 + α9 + α8 + α7 + α5 + α4 + α2
α21 = α9 + α8 + α4 + α3 + α2 + 1
α22 = α10 + α9 + α5 + α4 + α3 + α
138
> H1:= matrix(11, 23,
> [[1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,1,0,0,1,0],
> [0,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,1,0,0,1],
> [0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,1,1,1,0,1,1,0],
> [0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,1,1,1,0,1,1],
> [0,0,0,0,1,0,0,0,0,0,0,1,1,0,0,1,0,0,0,1,1,1,1],
> [0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,1,1,0,1,0,1,0,1],
> [0,0,0,0,0,0,1,0,0,0,0,1,0,1,1,0,1,1,1,1,0,0,0],
> [0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,1,0,1,1,1,1,0,0],
> [0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,1,0,1,1,1,1,0],
> [0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,1,0,1,1,1,1],
> [0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,1,0,0,1,0,1]]) ;
 
1 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 0 0 1 0 0 1 0
 0 1 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 0 0 1 0 0 1 
 
 0 0 1 0 0 0 0 0 0 0 0 1 1 0 0 0 1 1 1 0 1 1 0 
 
 0 0 0 1 0 0 0 0 0 0 0 0 1 1 0 0 0 1 1 1 0 1 1 
 
 0 0 0 0 1 0 0 0 0 0 0 1 1 0 0 1 0 0 0 1 1 1 1 
 
 0 0 0 0 0 1 0 0 0 0 0 1 0 0 1
H1 :=  1 1 0 1 0 1 0 1 

 0 0 0 0 0 0 1 0 0 0 0 1 0 1 1 0 1 1 1 1 0 0 0 
 
 0 0 0 0 0 0 0 1 0 0 0 0 1 0 1 1 0 1 1 1 1 0 0 
 
 0 0 0 0 0 0 0 0 1 0 0 0 0 1 0 1 1 0 1 1 1 1 0 
 
 0 0 0 0 0 0 0 0 0 1 0 0 0 0 1 0 1 1 0 1 1 1 1 
0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 0 0 1 0 0 1 0 1
> K1:=multiply(H1,transpose(G)) ;
 
2 2 2 2 2 2 2 4 4 4 4 4

 0 2 2 2 2 2 2 2 4 4 4 4 


 2 2 2 0 0 2 4 4 2 2 4 4 


 0 2 2 2 0 0 2 4 4 2 2 4 


 2 2 2 0 2 2 2 2 2 4 4 4 

K1 := 
 2 2 0 2 2 4 2 2 2 4 4 4 


 2 2 2 2 2 2 4 4 4 4 2 4 


 0 2 2 2 2 2 2 4 4 4 4 2 


 0 0 2 2 2 2 2 2 4 4 4 4 

 0 0 0 2 2 2 2 2 2 4 4 4 
2 2 2 2 2 2 4 4 4 4 4 4
> map(item -> Expand(item) mod 2, K1) ;
139
 
0 0 0 0 0 0 0 0 0 0 0 0

 0 0 0 0 0 0 0 0 0 0 0 0 


 0 0 0 0 0 0 0 0 0 0 0 0 


 0 0 0 0 0 0 0 0 0 0 0 0 


 0 0 0 0 0 0 0 0 0 0 0 0 


 0 0 0 0 0 0 0 0 0 0 0 0 


 0 0 0 0 0 0 0 0 0 0 0 0 


 0 0 0 0 0 0 0 0 0 0 0 0 


 0 0 0 0 0 0 0 0 0 0 0 0 

 0 0 0 0 0 0 0 0 0 0 0 0 
0 0 0 0 0 0 0 0 0 0 0 0
%1 := [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%
> q:=3;
q := 3
> restart ;
> with(linalg) :
unprotected
> Factor(x^11-1) mod 3;

(x + 2) (x5 + 2 x3 + x2 + 2 x + 2) (x5 + x4 + 2 x3 + x2 + 2)
> g:=x^5+2*x^3+x^2+2*x+2;irreduc(g) mod 3;

g := x5 + 2 x3 + x2 + 2 x + 2
true

α

(x + 2 α) (x + 2 α3 + α2 + 2 α + 2) (x + 2 α4 ) (x + α4 + 2 α3 + 2 α2 + 2 α + 1) (x + 2 α3 )
> od ;
i = 1, α = α, g(α) = 0
i = 3, α3 = α3 , g(α3 ) = 0
i = 4, α4 = α4 , g(α4 ) = 0
i = 5, α5 = α3 + 2 α2 + α + 1, g(α5 ) = 0
140
i = 9, α9 = 2 α4 + α3 + α2 + α + 2, g(α9 ) = 0
> od ;
1
i = 2, α2 = α2 , g( 2 ) = 0
α
6 4 3 2 1
i = 6, α = α + 2 α + α + α, g( 6 ) = 0
α
1
i = 7, α7 = 2 α4 + 2 α3 + α + 1, g( 7 ) = 0
α
8 4 3 2 1
i = 8, α = 2 α + 2 α + 2 α + 2, g( 8 ) = 0
α
1
i = 10, α10 = α4 + 2 α2 + α + 2, g( 10 ) = 0
α
> (x+2)*(x^5+2*x^3+x^2+2*x+2)*(x^5+x^4+2*x^3+x^2+2);
> ’h’=(x+2)*(x^5+x^4+2*x^3+x^2+2);
> h:= sort(Expand((x+2)*(x^5+x^4+2*x^3+x^2+2)) mod 3,x);
(x + 2) (x5 + 2 x3 + x2 + 2 x + 2) (x5 + x4 + 2 x3 + x2 + 2)
h = (x + 2) (x5 + x4 + 2 x3 + x2 + 2)
h := x6 + x4 + 2 x3 + 2 x2 + 2 x + 1
générateur
g := x5 + 2 x3 + x2 + 2 x + 2
et avec le polynome de contrôle h = (x + 2) (x5 + x4 + 2 x3 + x2 + 2) ,
h := x6 + x4 + 2 x3 + 2 x2 + 2 x + 1.
C’est un [12,6, 5 ] _ 3-code.
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%%
> G:= matrix(6, 11,

> [[2,2,1,2,0,1,0,0,0,0,0],
> [0,2,2,1,2,0,1,0,0,0,0],
> [0,0,2,2,1,2,0,1,0,0,0],
> [0,0,0,2,2,1,2,0,1,0,0],
> [0,0,0,0,2,2,1,2,0,1,0],
> [0,0,0,0,0,2,2,1,2,0,1]]);
 
2 2 1 2 0 1 0 0 0 0 0
 0 2 2 1 2 0 1 0 0 0 0 
 
 0 0 2 2 1 2 0 1 0 0 0 
G := 
 0

 0 0 2 2 1 2 0 1 0 0 

 0 0 0 0 2 2 1 2 0 1 0 
0 0 0 0 0 2 2 1 2 0 1
> ’h’= x^6+x^4+2*x^3+2*x^2+2*x+1;
141
h = x6 + x4 + 2 x 3 + 2 x 2 + 2 x + 1
> H:= matrix(5, 11,

> [[0,0,0,0,1,0,1,2,2,2,1],
> [0,0,0,1,0,1,2,2,2,1,0],
> [0,0,1,0,1,2,2,2,1,0,0],
> [0,1,0,1,2,2,2,1,0,0,0],
> [1,0,1,2,2,2,1,0,0,0,0]]);
 
0 0 0 0 1 0 1 2 2 2 1
 0 0 0 1 0 1 2 2 2 1 0 
 
 0
H :=  0 1 0 1 2 2 2 1 0 0 

 0 1 0 1 2 2 2 1 0 0 0 
1 0 1 2 2 2 1 0 0 0 0
> sort(Expand(h*g) mod 3,x);
x11 + 2
 
0 3 3 6 9 9

 3 3 6 9 9 12 
K := 
 3 6 9 9 12 12 

 6 9 9 12 12 9 
9 9 12 12 9 6
 
0 0 0 0 0 0

 0 0 0 0 0 0 


 0 0 0 0 0 0 

 0 0 0 0 0 0 
0 0 0 0 0 0
142
E Annexe : Points des courbes algébriques sur les corps finis
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

> restart ;
> with(linalg) :
unprotected
> g:=x^2+x+1 mod 2;
g := x2 + x + 1
α
> f:=(x,y,z)->x^3+y^3+z^3;
f := (x, y, z) → x3 + y 3 + z 3
> h:=(i,j)->x[i-1,j-1]: X:=Matrix(3,2,h);
 
x0, 0 x0, 1
X :=  x1, 0 x1, 1 
x2, 0 x2, 1

1
U :=
α
 
x0, 0 + x0, 1 α
Y :=  x1, 0 + x1, 1 α 
x2, 0 + x2, 1 α
> v[1]:=f(0, 1, x[2]);
v1 := 1 + x2 3
> v[2]:=f(1, x[1], x[2]);
v2 := 1 + x1 3 + x2 3
> vv[1]:=subs(x[0]=Y[1,1],x[1]=Y[2,1], x[2]=Y[3,1],v[1]) ;

vv 1 := 1 + (x2, 0 + x2, 1 α)3
> vv[2]:= subs(x[0]=Y[1,1],x[1]=Y[2,1], x[2]=Y[3,1],v[2]) ;
vv 2 := 1 + (x1, 0 + x1, 1 α)3 + (x2, 0 + x2, 1 α)3
143
> c:=0;
> if f(0,0,1) mod 2 =0 then c:=c+1;
> print (c, [0, 0, 1]) fi;
> print (c,[0, 1, i+j*alpha]) fi ;od ;od;
> if Eval(vv[2],{x[2,0]=i2,x[2,1]=j2, x[1,0]=i1,x[1,1]=j1}) mod 2
> =0 then c:=c+1;
> print (c,[1, (i1+j1*alpha)mod 2,
> (i2+j2*alpha)mod 2]) fi od; od ;od ;od;
c := 0
1, [0, 1, α]
2, [0, 1, 1]
3, [0, 1, 1 + α]
4, [1, α, 0]
5, [1, 1, 0]
6, [1, 1 + α, 0]
7, [1, 0, α]
8, [1, 0, 1]
9, [1, 0, 1 + α]
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

> restart ;
> with(linalg) :
unprotected
> g:=x^4+x+1 mod 2;
g := x4 + x + 1
α
> f:=(x,y,z)->x^3+y^3+z^3;
f := (x, y, z) → x3 + y 3 + z 3
> h:=(i,j)->x[i-1,j-1]: X:=Matrix(3,4,h);
 
x0, 0 x0, 1 x0, 2 x0, 3
X :=  x1, 0 x1, 1 x1, 2 x1, 3 
x2, 0 x2, 1 x2, 2 x2, 3
144
 
1
 α 
U :=  
 α2 
α3
 
x0, 0 + x0, 1 α + x0, 2 α2 + x0, 3 α3
Y :=  x1, 0 + x1, 1 α + x1, 2 α2 + x1, 3 α3 
x2, 0 + x2, 1 α + x2, 2 α2 + x2, 3 α3
> v[1]:=f(0, 1, x[2]);
v1 := 1 + x2 3
> v[2]:=f(1, x[1], x[2]);
v2 := 1 + x1 3 + x2 3
> vv[1]:=subs(x[0]=Y[1,1],x[1]=Y[2,1], x[2]=Y[3,1],v[1]) ;

vv 1 := 1 + (x2, 0 + x2, 1 α + x2, 2 α2 + x2, 3 α3 )3
> vv[2]:= subs(x[0]=Y[1,1],x[1]=Y[2,1], x[2]=Y[3,1],v[2]) ;
vv 2 := 1 + (x1, 0 + x1, 1 α + x1, 2 α2 + x1, 3 α3 )3 + (x2, 0 + x2, 1 α + x2, 2 α2 + x2, 3 α3 )3
> c:=0;
> if f(0,0,1) mod 2 =0 then c:=c+1;
> print (c, [0, 0, 1]) fi;
> for k from 0 to 1 do
> for l from 0 to 1 do
> if Eval(vv[1],{x[2,0]=i,x[2,1]=j,x[2,2]=k,x[2,3]=l}) mod 2 =0
> then c:=c+1;
> print (c,[0, 1,
> i+j*alpha+k*alpha^2+l*alpha^3]) fi; od; od ;od ;od;
> for k2 from 0 to 1 do
> for l2 from 0 to 1 do
> if Eval(vv[2],{x[2,0]=i2,x[2,1]=j2,x[2,2]=k2,x[2,3]=l2,
> x[1,0]=i1,x[1,1]=j1,x[1,2]=k1,x[1,3]=l1}) mod 2 =0 then c:=c+1;
> print (c,[1,
> i1+j1*alpha+k1*alpha^2+l1*alpha^3, i2+j2*alpha+k2*alpha^2+l2*alpha^3])
> fi; od; od ;od ;od;odd;od;od;od; od;
c := 0
1, [0, 1, α + α2 ]
2, [0, 1, 1]
3, [0, 1, 1 + α + α2 ]
4, [1, α + α2 , 0]
145
5, [1, 1, 0]
6, [1, α + α2 + 1, 0]
7, [1, 0, α2 + α]
8, [1, 0, 1]
9, [1, 0, α + 1 + α2 ]
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
COURBE de KLEIN sur GF(16)

> fk:=(x,y,z)->x^3*y+y^3*z+z^3*x;
fk := (x, y, z) → x3 y + y 3 z + z 3 x
> vk[1]:=fk(0, 1, x[2]);
vk 1 := x2
> vk[2]:=fk(1, x[1], x[2]);
vk 2 := x1 + x1 3 x2 + x2 3
> vvk[1]:=subs(x[0]=Y[1,1],x[1]=Y[2,1], x[2]=Y[3,1],vk[1]) ;

vvk 1 := x2, 0 + x2, 1 α + x2, 2 α2 + x2, 3 α3
> vvk[2]:= subs(x[0]=Y[1,1],x[1]=Y[2,1], x[2]=Y[3,1],vk[2]) ;
vvk 2 := x1, 0 + x1, 1 α + x1, 2 α2 + x1, 3 α3

+ (x1, 0 + x1, 1 α + x1, 2 α2 + x1, 3 α3 )3 (x2, 0 + x2, 1 α + x2, 2 α2 + x2, 3 α3 )
+ (x2, 0 + x2, 1 α + x2, 2 α2 + x2, 3 α3 )3
> c:=0;
> if fk(0,0,1) mod 2 =0 then c:=c+1;
> print (c, [0, 0, 1]) fi;
> for l from 0 to 1 do
> if Eval(vvk[1],{x[2,0]=i,x[2,1]=j,x[2,2]=k,x[2,3]=l}) mod 2 =0
> then c:=c+1;
> print (c,[0, 1,
> i+j*alpha+k*alpha^2+l*alpha^3]) fi; od; od ;od ;od;
> if Eval(vvk[2],{x[2,0]=i2,x[2,1]=j2,x[2,2]=k2,x[2,3]=l2,
> x[1,0]=i1,x[1,1]=j1,x[1,2]=k1,x[1,3]=l1}) mod 2 =0 then c:=c+1;
> print (c,[1,
> i1+j1*alpha+k1*alpha^2+l1*alpha^3, i2+j2*alpha+k2*alpha^2+l2*alpha^3])
> fi; od; od ;od ;od;odd;od;od;od; od;
c := 0
146
c := 1
1, [0, 0, 1]
2, [0, 1, 0]
3, [1, 0, 0]
4, [1, 1 + α2 , α3 ]
5, [1, α, α3 + α2 ]
6, [1, α + 1, α + α3 ]
7, [1, α3 , α + α2 ]
8, [1, 1 + α2 + α, α + α2 ]
9, [1, 1 + α + α2 + α3 , α + α2 ]
10, [1, α + α2 , α3 + α + α2 ]
11, [1, α2 + α, α3 + 1]
12, [1, 1 + α + α2 , α3 + 1 + α2 ]
13, [1, α + α2 + 1, 1 + α3 + α]
14, [1, α3 + α2 , α + α2 + 1]
15, [1, α + α3 , α + α2 + 1]
16, [1, α + α2 , α + α2 + 1]
17, [1, α2 , 1 + α + α2 + α3 ]
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%%%%%
COURBE
de KLEIN sur GF(8)

> restart ;
> with(linalg) :
unprotected
> g:=x^3+x+1 mod 2;
g := x3 + x + 1
α
> fk:=(x,y,z)->x^3*y+y^3*z+z^3*x;
fk := (x, y, z) → x3 y + y 3 z + z 3 x
> h:=(i,j)->x[i-1,j-1]: X:=Matrix(3,3,h);
 
x0, 0 x0, 1 x0, 2
X :=  x1, 0 x1, 1 x1, 2 
x2, 0 x2, 1 x2, 2
147
 
1
U :=  α 
α2
 
x0, 0 + x0, 1 α + x0, 2 α2
Y :=  x1, 0 + x1, 1 α + x1, 2 α2 
x2, 0 + x2, 1 α + x2, 2 α2
> vk[1]:=fk(0, 1, x[2]);
vk 1 := x2
> vk[2]:=fk(1, x[1], x[2]);
vk 2 := x1 + x1 3 x2 + x2 3
> vvk[1]:=subs(x[0]=Y[1,1],x[1]=Y[2,1], x[2]=Y[3,1],vk[1]) ;
vvk 1 := x2, 0 + x2, 1 α + x2, 2 α2
> vvk[2]:= subs(x[0]=Y[1,1],x[1]=Y[2,1], x[2]=Y[3,1],vk[2]) ;
vvk 2 := x1, 0 + x1, 1 α + x1, 2 α2 + (x1, 0 + x1, 1 α + x1, 2 α2 )3 (x2, 0 + x2, 1 α + x2, 2 α2 )
+ (x2, 0 + x2, 1 α + x2, 2 α2 )3
> c:=0;
> if fk(0,0,1) mod 2 = 0 then c:=c+1;
> print (c, [0, 0, 1]) fi;
> if Eval(vvk[1],{x[2,0]=i,x[2,1]=j,x[2,2]=k}) mod 2 =0 then
> c:=c+1;
> print (c, [0, 1, i+j*alpha+k*alpha^2])
> fi; od; od ;od ;
> if Eval(vvk[2],{x[2,0]=i2,x[2,1]=j2,x[2,2]=k2,
> x[1,0]=i1,x[1,1]=j1,x[1,2]=k1}) mod 2 =0 then c:=c+1;
> print (c, [1, i1+j1*alpha+k1*alpha^2,
> i2+j2*alpha+k2*alpha^2]) fi; od; od ;od ;od;od;od;
c := 0
c := 1
1, [0, 0, 1]
2, [0, 1, 0]
3, [1, 0, 0]
4, [1, α, α2 ]
5, [1, 1, α2 ]
6, [1, 1 + α, α2 ]
148
7, [1, α2 + α, α]
8, [1, 1, α]
9, [1, 1 + α + α2 , α]
10, [1, α2 , α2 + α]
11, [1, 1, α2 + α]
12, [1, 1 + α2 , α2 + α]
13, [1, α2 , 1]
14, [1, α, 1]
15, [1, α2 + α, 1]
16, [1, α, 1 + α2 ]
17, [1, 1 + α2 , 1 + α2 ]
18, [1, 1 + α + α2 , 1 + α2 ]
19, [1, α2 + α, 1 + α]
20, [1, 1 + α2 , 1 + α]
21, [1, 1 + α, 1 + α]
22, [1, α2 , 1 + α + α2 ]
23, [1, 1 + α, 1 + α + α2 ]
24, [1, 1 + α + α2 , 1 + α + α2 ]
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%%%%%%%%%%%%%%%

> restart ;
> with(linalg) :
unprotected
> g:=x^3+x+1 mod 2;
g := x3 + x + 1
α
> f:=(x,y,z)->x^3+y^3+z^3;
f := (x, y, z) → x3 + y 3 + z 3
> h:=(i,j)->x[i-1,j-1]: X:=Matrix(3,3,h);
 
x0, 0 x0, 1 x0, 2
X :=  x1, 0 x1, 1 x1, 2 
x2, 0 x2, 1 x2, 2
 
1
U :=  α 
α2
149
 
x0, 0 + x0, 1 α + x0, 2 α2
Y :=  x1, 0 + x1, 1 α + x1, 2 α2 
x2, 0 + x2, 1 α + x2, 2 α2
> v[1]:=f(0, 1, x[2]);
v1 := 1 + x2 3
> v[2]:=f(1, x[1], x[2]);
v2 := 1 + x1 3 + x2 3
> vv[1]:=subs(x[0]=Y[1,1],x[1]=Y[2,1], x[2]=Y[3,1],v[1]) ;
vv 1 := 1 + (x2, 0 + x2, 1 α + x2, 2 α2 )3
> vv[2]:= subs(x[0]=Y[1,1],x[1]=Y[2,1], x[2]=Y[3,1],v[2]) ;
vv 2 := 1 + (x1, 0 + x1, 1 α + x1, 2 α2 )3 + (x2, 0 + x2, 1 α + x2, 2 α2 )3
> c:=0;
> if Eval(vv[1],{x[2,0]=i,x[2,1]=j,x[2,2]=k}) mod 2 =0 then
> c:=c+1;
> print (c,[0, 1, i+j*alpha+k*alpha^2])
> fi; od; od ;od ;
> if Eval(vv[2],{x[2,0]=i,x[2,1]=j,x[2,2]=k,
> x[1,0]=i1,x[1,1]=j1,x[1,2]=k1}) mod 2 =0 then c:=c+1;
> print (c,[1, (i1+j1*alpha+k1*alpha^2)
> mod 2 ,(i+j*alpha+k*alpha^2) mod 2]) fi; od; od ;od ;od;odd;od;od;
c := 0
1, [0, 1, 1]
2, [1, 1, 0]
3, [1, 1 + α, α2 ]
4, [1, α2 + α + 1, α]
5, [1, α2 + 1, α + α2 ]
6, [1, 0, 1]
7, [1, α + α2 , 1 + α2 ]
8, [1, α2 , α + 1]
9, [1, α, 1 + α + α2 ]
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%%%%%%%%%%%%%%%
COURBE de HERMITE sur GF(9)
150
> restart ;
> with(linalg) :
> g:=x^2+1 mod 3;
unprotected
g := x2 + 1
α
> f:=(x,y,z)->x^4+y^4+z^4;
f := (x, y, z) → x4 + y 4 + z 4
> h:=(i,j)->x[i-1,j-1]: X:=Matrix(3,2,h);
 
x0, 0 x0, 1
X :=  x1, 0 x1, 1 
x2, 0 x2, 1

1
U :=
α
 
x0, 0 + x0, 1 α
Y :=  x1, 0 + x1, 1 α 
x2, 0 + x2, 1 α
> v[1]:=f(0, 1, x[2]);
v1 := 1 + x2 4
> v[2]:=f(1, x[1], x[2]);
v2 := 1 + x1 4 + x2 4
> vv[1]:=subs(x[0]=Y[1,1],x[1]=Y[2,1], x[2]=Y[3,1],v[1]) ;
vv 1 := 1 + (x2, 0 + x2, 1 α)4
> vv[2]:= subs(x[0]=Y[1,1],x[1]=Y[2,1], x[2]=Y[3,1],v[2]) ;
vv 2 := 1 + (x1, 0 + x1, 1 α)4 + (x2, 0 + x2, 1 α)4
> c:=0;
> print (c,[0, 1, i+j*alpha]) fi; od; od
> ;for i2 from 0 to 2 do
> if Eval(vv[2],{x[2,0]=i2,x[2,1]=j2,x[1,0]=i1,x[1,1]=j1})
> mod 3 =0 then c:=c+1;
> print (c,[1, (i1+j1*alpha)mod 3
> ,(i2+j2*alpha) mod 3]) fi; od; od ;od ;od;
c := 0
1, [0, 1, 1 + α]
151
2, [0, 1, 1 + 2 α]
3, [0, 1, 2 + α]
4, [0, 1, 2 + 2 α]
5, [1, 1 + α, 0]
6, [1, 1 + 2 α, 0]
7, [1, 2 + α, 0]
8, [1, 2 + 2 α, 0]
9, [1, α, α]
10, [1, 2 α, α]
11, [1, 1, α]
12, [1, 2, α]
13, [1, α, 2 α]
14, [1, 2 α, 2 α]
15, [1, 1, 2 α]
16, [1, 2, 2 α]
17, [1, α, 1]
18, [1, 2 α, 1]
19, [1, 1, 1]
20, [1, 2, 1]
21, [1, 0, 1 + α]
22, [1, 0, 1 + 2 α]
23, [1, α, 2]
24, [1, 2 α, 2]
25, [1, 1, 2]
26, [1, 2, 2]
27, [1, 0, 2 + α]
28, [1, 0, 2 + 2 α]
152
F Annexe : Systèmes linéaires dans GF(pd )
(F. Sergeraert)
> restart :
• Exemple dans GF( 34 ).
• On prend un polynôme irréductible de degré 4 dans F3 , affecté à irr34.

> irr34 := op(1, select(has, Factor(x^81-x) mod 3, 4)) ;
irr34 := x4 + 2 x3 + 2 x2 + x + 2
• Le polynôme irréductible obtenu par ce procédé n’est pas forcément le même d’une session à l’autre.
• On aliasse α à une racine de ce polynôme dans une extension de F3 , de sorte que GF(34 ) = F3 [ α].
> alias(alpha = RootOf(irr34) mod 3) ;
• La procédure rnd3 génére un entier modulo 3 pseudo-aléatoire.

> rnd3 := rand(0..2) :
> seq(rnd3(), i = 1..5) ;
0, 2, 0, 2, 1
• La procédure rnd34 génère un élément pseudo-aléatoire de GF( 34 ).

> rnd34 := () -> add(rnd3()*alphaî, i=0..3) :
> seq(rnd34(), i = 1..5) ;
2 + 2 α + 2 α2 + α3 , 1 + α, 2 + 2 α + α2 , 2 α2 , α2
• La matrice A est une matrice 3x3 pseudo-aléatoire à coefficients dans GF( 3 4 ).

> A := matrix(3, 3, rnd34) ;
 
1 + 2 α 2 + 2 α3 2 + 2 α + 2 α 3 2 + 2 α 2 + 2 α3
A :=  2 α2 2 + α + α2 1 + α3 
3 2
2+2α+α 1+α α + 2 α2
• Idem pour un vecteur second membre.
> b := vector(3, rnd34) ;

b := α3 , α3 , 2 + 2 α2
• Linsolve(...) mod 3 permet de résoudre dans GF( 34 ).

> x := Linsolve(A,b) mod 3 ;

x := α3 + 2 α2 + 2, α + α2 , 2
• Vérification. Calcul de A x − b.
> zerov := evalm(A &* x - b) ;
153
h
zerov := (1 + 2 α2 + 2 α3 ) (α3 + 2 α2 + 2) + (2 + 2 α + 2 α3 ) (α + α2 ) + 4 + 4 α2 + 3 α3 ,
2 α2 (α3 + 2 α2 + 2) + (2 + α + α2 ) (α + α2 ) + α3 + 2,
i
(2 + 2 α + α3 ) (α3 + 2 α2 + 2) + (1 + α2 ) (α + α2 ) + 2 α + 2 α2 − 2
• Les termes du vecteur obtenu ne sont pas « réduits » à leur forme canonique dans GF(3 4 ) = F3 [
> map(item -> Expand(item) mod 3, zerov) ;
[0, 0, 0]
154
Références
[Dem] Demazure, Michel Cours d’algèbre. Primalité. Divisibilité. Codes., Nouvelle Bibliothèque
Mathématique [New Mathematics Library], 1. Cassini, Paris, 1997. xviii+302 pp.
[vLi] J.H. van Lint, Introduction to coding theory. Springer-Verlag, New-York
[vLi-vdG] J.H. van Lint, G. van der Geer, Introduction to coding theory and algebraic geometry.
Springer-Verlag, New-York
[Li-Ni] Rudolf Lidl et Harald Niederreiter, Introduction to finite fields and their applications.
Addison–Wesley : Reading, 1983
[MW-S] McWilliams F.J., Sloane N.J.A., The theory of error–correcting codes, North – Holland,
Amsterdam, 1977
[Pa-Wo] Papini, O., et Wolfman, J., Algèbre discrète et codes correcteurs, Collection Math. et
Applications, Springer-Verlag, 1995
[Pey] Emmanuel Peyre, Corps finis et courbes elliptiques. DESS Cryptologie, sécurité et codage
d’information, Modules A1A et A1B, Grenoble, 2002, pp. 1-128
[Ste] S. A. Stepanov, Codes on algebraic curves. Kluwer Academic Publishers. vii, 350 p., 1999
[Ts-V] Tsfasman, M.A. et Vladut, S.G. , Algebraic-geometric codes. Kluwer Academic Publishers.
xxiv, 667 p., 1991
Institut Fourier,
B.P.74, 38402 St.–Martin d’Hères,
FRANCE
155

2 CC

Transféré par

Droits d'auteur :

Formats disponibles

2 CC

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

2 CC

Transféré par

Droits d'auteur :

Formats disponibles

Mathématiques des codes correcteurs d’erreurs

Institut Fourier, B.P.74, 38402 St.–Martin d’Hères, FRANCE

C1A, préparé avec la participation de J.-B.Werner

2. Distance de Hamming, rendement et vitesse de transmission 11

3. Codes linéaires et codes cycliques. Matrice génératrice et syndrome 18

4. Polynômes locateurs d’erreurs. Application au décodage 27

5. Codes BCH et codes de Reed-Solomon. Codage et décodage 44

6. Bornes de Plotkin et de Gilbert-Varshamov 56

8. Exercices de préparation à l’exemen 85

A Annexe : Rappels sur les corps finis 92

B Annexe : Restes chinois, suite : Factorisation des Polynômes (F. Sergeraert) 94

C Annexe : Bornes sur codes 114

D Annexe : Codes cycliques. Codes de Golay 131

F Annexe : Systèmes linéaires dans GF(pd )(F. Sergeraert) 152

Cette transmission a la redondance = 32-6=26, le coefficient de redondance= 32/6.

j = 1 ↔ (0, 0, 0, 0, 0), j = 2 ↔ (0, 0, 0, 0, 1), . . . , j = 32 ↔ (1, 1, 1, 1, 1)

(on considère l’écriture binaire du nombre j − 1) :

j − 1 = x5 + 2x4 + 4x3 + 8x2 + 16x1 , xi = 0 ou 1,

(1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1) ↔ {(∗, ∗, ∗, ∗, ∗) ∈ F 52 } = F52

(l’espace F52 tout entier) ,

f (x1 , x2 , x3 , x5 ) = 1 de l’espace affine F52

la ligne A2 représente la fonction f (x1 , x2 , x3 , x5 ) = x1

A2 ←→ f ≡ 1, f (x1 , x2 , x3 , x5 ) = x1 "le premier chiffre" de j − 1 mod 2 ∈ F2 ,

(la fonction indicatrice de la partie

f (x1 , x2 , x3 , x5 ) = 1 de l’espace affine F52 ).

y(x1 , x2 , x3 , x4 , x5 ) − (β1 + β2 x1 + β3 x2 + β4 x3 + β5 x4 + β6 x5 ), (0.2)

et on obtient le décodage u0 du mot d’information u :

1.1. Principe de transmission d’information

1.2. Hypothèses sur un canal bruité

1.3. Généralités sur les codes

a 7→ d(a, 0) = Card {i ∈ {0, 1, . . . , n} | ai 6= 0}

est le poids de Hamming.

d(a, b) = d(b, a) pour tous a, b pour tous E n

d(a, c) ≤ d(a, b) + d(b, c) pour tous a, b, c pour tous E n .

Définition 1.4 Soit C ⊂ F n un code (a) On appelle écart ou "distance" de C le nombre

d = d(C) = min d(C(x), C(y))

(pour la distance de Hamming) sont deux-à-deux disjointes.

1.4. Codage et decodage optimal sur un canal bruité

Exercice. Soit p = ps la probabilité des perturbations de symboles au cours de la transmission. On

1.5. Théorème de Shannon (1948)

(voir [vLi], p.27) pour la preuve détaillée.

> plot([1-H(p)], p = 0..1, R = 0..1,discont=true);

0 0.2 0.4 0.6 0.8 1

Card (Cn ) = Mn = 2[Rn] → ∞

δ log(q − 1) δ log(δ) (1 − δ) log(1 − δ)

2.1. Capacité de correction et rayon de recouvrement

Proposition 2.2 Pour tout entier r ≤ n, et tout x ∈ F n

Card (S(x, i)) = Card {y ∈ F n | d(x, y) = d}

l’ensemble des mots

Corollaire 2.4 Soit C ⊂ F n un code sur l’alphabet F de Card (F ) = q de distance d = d(C) et la

max(Card (C)) ≤ q n /Vq (n, t)

Optimisation des paramètres : on considère les codes C ⊂ F n sur l’alphabet F de Card (F ) = q de

2.3. Bonnes familles des codes et problèmes asymptotiques.

Preuve : Pour toute i, on pose Ri = ki /ni , δi = di /ni , alors Ri ≤ 1 − δi + 1/ni . Lorsque i → ∞, on

δ log(q − 1) δ log(δ) (1 − δ) log(1 − δ)

Puis, on utilise l’inégalité : pour tout z ∈]0, 1],

Pour trouver le minimum de g(z) on calcule la dérivée g 0 (z) :

z (−r) r (1 + (q − 1) z)n z (−r) (1 + (q − 1) z)n n (q − 1)

0 0.2 0.4 0.6 0.8 1

Il reste à rapeller que r

> Hq(x):=xlog(q-1)/log(q)- xlog(x)/log(q)-(1-x)*log(1-x)/log(q);

> g:=x^5+2x^3+x^2+2x+2;irreduc(g) mod 3;