These Theorie de Codage

HANS BHERER
THÉORIE ALGÉBRIQUE DU CODAGE
Mémoire
présenté
à la Faculté des études supérieures
de l’Université Laval
pour l’obtention
du grade de maı̂tre ès Sciences (M.Sc.)
Département de mathématiques et statistique

FACULTÉ DES SCIENCES ET DE GÉNIE
UNIVERSITÉ LAVAL
Septembre 2000
Hans
c Bherer, 2000
Résumé
La théorie du codage est l’étude des méthodes permettant le transfert d’informations de

façon efficace et précise. Cette théorie est utilisée dans de multiples champs d’applications. On
la retrouve dans l’enregistrement des disques compacts, dans la transmission d’information
sur les réseaux ou encore dans les communications par satellites pour n’en nommer que
quelques-uns.
Le présent mémoire consiste à présenter et à analyser les différents concepts mathéma-

tiques et les différentes structures algébriques associés aux codes linéaires. Les principaux
codes linéaires seront considérés, et on trouvera en annexe quelques programmes MAPLE
illustrant quelques-uns de ces codes.
Claude Levesque Hans Bherer

directeur de recherche étudiant
i
Avant-propos
J’aimerais remercier mon directeur de recherche, le professeur Claude Levesque, pour son
excellente supervision et son soutien pédagogique. Je tiens aussi à remercier mon collègue
Jean-Norbert, non seulement pour son aide mais aussi pour son amitié. Enfin je veux sou-
ligner le grand soutien de mon entourage et de ma famille et plus particulièrement celui de
Nathalie et de Anne car c’est aussi grâce à eux si j’ai pu poursuivre plus avant mes études.
Je dédie ce mémoire à Michèle.
ii
Table des matières
Résumé i
Avant-propos ii
1 Introduction 1
2 Remarques générales en théorie du codage 4
2.1 Définitions générales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
2.2 Probabilités associées à la détection d’erreur . . . . . . . . . . . . . . . . . . 6
2.3 Probabilités associées à la correction d’erreurs . . . . . . . . . . . . . . . . . 6
2.4 Principe de la distance minimale pour le décodage . . . . . . . . . . . . . . . 8
2.5 Distance versus la détection et la correction d’erreurs . . . . . . . . . . . . . 10
2.6 Codes équivalents . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
3 Le problème central en théorie du codage 12
3.1 Le problème central : Aq (n, d) . . . . . . . . . . . . . . . . . . . . . . . . . 12
3.2 Quelques bornes supérieures sur Aq (n, d) . . . . . . . . . . . . . . . . . . . . 13
4 Codes linéaires 15
iii
TABLE DES MATIÈRES iv
4.1 Structure et codage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
4.2 Décodage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
4.3 Distribution de poids et énumérateur de poids . . . . . . . . . . . . . . . . . 20
4.3.1 Distribution de poids et énumérateur de poids . . . . . . . . . . . . . 20
4.3.2 Une propriété de la distribution des poids d’un code linéaire binaire . 23
4.3.3 MacWilliams et l’existence de codes linéaires . . . . . . . . . . . . . . 24
4.3.4 L’identité de MacWilliams et Aq [n, d] . . . . . . . . . . . . . . . . . . 25
4.3.5 L’identité de MacWilliams et la distribution de poids . . . . . . . . . 26
4.4 Codes de Hamming . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
4.5 Codes de Golay . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
4.6 Codes de Reed-Muller . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
5 Codes linéaires cycliques 36
5.1 Structure . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
5.2 Codage-décodage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
5.3 Codes BCH . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
5.4 Codes de Reed-Solomon . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
5.5 Codes Résidus Quadratiques . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
5.6 Codes de Goppa . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
6 Conclusion 61
A Programmes MAPLE 62
A.1 Énumérateur de poids . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62

TABLE DES MATIÈRES v
A.2 Codes de Hamming . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66
A.3 Codes BCH . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69
B Programmes MAPLE avec sorties 71
B.1 Énumérateur de poids . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71
B.2 Codes de Hamming . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85
B.3 Codes BCH . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90
Bibliographie 94
Table des figures
2.1 Le canal symétrique binaire . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
vi
Liste des tableaux
1.1 Répétition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
3.1 A2 (n, d) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
4.1 Distributions pour un [n, k, d]−code sur F 2 . . . . . . . . . . . . . . . . . . . 26
4.2 Code [7,3, ?] . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
5.1 Syndrômes de H2 (3) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
5.2 Syndrôme nécessaire de H2 (3) . . . . . . . . . . . . . . . . . . . . . . . . . . 47
5.3 F 24 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
5.4 Reed − Solomon . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
5.5 F 23 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
vii
Chapitre 1
Introduction
Le transfert d’informations prend de plus en plus d’importance dans notre société. Que ce
soit pour la transmission de photographies de planètes éloignées, pour des communications
entre ordinateurs ou encore pour la lecture de nos disques lasers, le besoin de communi-
cations efficaces et sans erreurs est plus important que jamais. Nous savons tous que des
communications sans erreurs sont physiquement impossibles. Les codes ne sont pas là pour
éliminer les erreurs mais plutôt pour les détecter et si possible les corriger. Afin d’illustrer
sommairement un code, exploitons une idée intuitive qui consiste à répéter l’information un
certain nombre de fois.
Supposons que l’on ait quatre messages à envoyer, soit 00, 01, 10 et 11, dans un canal
qui produit une erreur de temps en temps. Pour résister au bruit du canal, on peut coder
l’information en la répétant trois fois comme le montre le tableau 1.1.
Information Mot du code

00 00 00 00
01 01 01 01
10 10 10 10
11 11 11 11
Tab. 1.1: Répétition
S’il survient une erreur dans la transmission, elle n’affectera que l’un des trois couples
1
CHAPITRE 1. INTRODUCTION 2
formant le mot du code. Le décodage pourra alors se faire par vote majoritaire sur ces trois
couples de bits. Une question naturelle nous vient à l’esprit : Peut-on faire mieux ? C’est dans
le but de répondre à cette question que nous doterons nos codes de structures mathématiques
permettant de les analyser et même de les créer. Nous voudrons alors obtenir des codes
permettant de coder le maximum de mots, de détecter et de corriger le maximum d’erreurs
tout en ayant la longueur la plus petite possible (rapidité de transmission). Plusieurs de ces
caractéristiques sont en conflit et l’élaboration de bons modèles mathématiques permet de
maximiser la satisfaction globale. Peut-on vraiment améliorer la fiabilité des communications
à l’aide d’un code ? Afin de répondre à cette question, nous préférons présenter un exemple
qui, nous l’espérons, saura convaincre le lecteur de l’utilité du codage de l’information.
Supposons que nous ayons un code binaire de longueur 11 ayant 211 = 2048 mots. Comme
notre code contient toutes les chaı̂nes de longueur 11, il ne détecte aucune erreur. Supposons
que la probabilité qu’un bit soit transmis sans erreur soit de 1 − 1
108
et supposons que la
transmission se fasse à un taux de 107 bits par seconde. Alors la probabilité qu’un mot soit
transmis de façon incorrecte est
11
1 11
1 − P (0 erreur) = 1 − 1 − 8 ≈ .
10 108
Cela implique qu’il y aura approximativement
11 107
× = 0.1
108 11
mot par seconde qui sera transmis incorrectement sans être détecté. Cela représente donc
8640 mots incorrects par jour. Supposons maintenant que l’on ajoute à chaque mot un bit
dit bit de parité (le bit de parité vaut 1 si le nombre de bits égaux à 1 est impair, sinon il
vaut 0). On doit avoir au moins 2 erreurs dans notre mot afin que celui-ci soit mal interprété.
Cette probabilité est
12 11 1
1 12 1 1 66
1 − P (0 erreur) − P (1 erreur) = 1 − 1 − 8 − 1− 8 ≈ .
10 1 10 108 1016
Cela implique qu’il y aura approximativement
66 107
16
× = 5.5 × 10−9
10 12
mot par seconde qui sera transmis incorrectement sans être détecté. Cela représente donc
une seule erreur à tous les 2000 jours !
CHAPITRE 1. INTRODUCTION 3
Dans ce mémoire, nous présenterons les différentes structures algébriques utilisées en

théorie du codage pour les codes linéaires. Nous nous proposons de balayer la théorie en
largeur. Nous entendons par là de présenter l’ensemble des principaux codes ainsi que des
principales méthodes de codage et de décodage. Nous optons pour un mémoire qui ne se
spécialise pas sur un code en particulier. Voulant établir un lien direct entre la théorie et la
pratique, nous préférons opter pour des exemples de codes binaires plutôt que sur un autre
corps. Cela n’est en aucun cas restrictif puisque nous présenterons notre théorie pour les
codes définis sur un corps fini quelconque.
Chapitre 2
Remarques générales en théorie du

codage
2.1 Définitions générales
Soit A = {a1 , ..., aq } un ensemble fini que nous appellerons un alphabet de code et soit
An l’ensemble de toutes les chaı̂nes de longueur n sur A.
Nous dirons que chaque sous-ensemble C ⊂ An s’appelle un code. Chacune des chaı̂nes
c de C est appelée mot du code. De plus, nous dirons qu’un code C ⊂ An est de cardinalité
M si M = |C|. La dimension n de An est appelée la longueur du code. Un code de longueur
n contenant M mots sera appelé un (n, M)−code. Le corps fini à q éléments sera noté F.q
L’espace vectoriel de dimension n sur F q F

sera noté Vn ( q ).
Le taux d’un code sera défini par :

logq M
R= .
n
Un canal discret sans mémoire (C.D.S.M.) consiste en un alphabet A = {a1 , ..., aq }

d’entrées, un alphabet de sorties O = {b1 , ..., bt } où A ⊂ O, et un ensemble de probabilités
de canal P (bj |ai ) satisfaisant
X
t
P (bj |ai ) = 1.
j=1
4
CHAPITRE 2. REMARQUES GÉNÉRALES EN THÉORIE DU CODAGE 5
De plus, si c = c1 ...cn et d = d1 ...dn sont des mots, alors

Y
n
P (d|c) = P (di|ci ).
i=1
À titre d’exemple, citons un des plus importants C.D.S.M., le canal symétrique binaire :
0 1-p
p
0
p
1 1-p 1
Fig. 2.1: Le canal symétrique binaire
où P (1|0) = P (0|1) = p et P (1|1) = P (0|0) = 1 − p.
Notations : La variable aléatoire X représentera la distribution d’entrées alors que la

variable aléatoire Y représentera la distribution de sorties. Le mot c sera le mot fourni en
entrée et d représentera la chaı̂ne en sortie. Les probabilités seront notées de la façon suivate :
P (c) = P (X = c),
P (d) = P (Y = d),
P (c|d) = P (X = c|Y = d),
P (d|c) = P (Y = d|X = c),
P (c, d) = P (X = c, Y = d).
Un schéma de décision est une fonction partielle f
f : O n −→ C
de l’ensemble des chaı̂nes de sortie vers l’ensemble des mots du code. Ainsi, l’ensemble
f −1 (c) = {d|f (d) = c}
sera l’ensemble des chaı̂nes de sortie que nous associerons au mot c du code. De plus, si f (d)
n’est pas le mot qui avait été envoyé, nous dirons qu’une erreur de décision a été commise.
2.2 Probabilités associées à la détection d’erreur
Si des erreurs se produisent dans la transmission, elles seront détectées si et seulement si

le mot reçu ne fait pas partie du code. Ainsi,
X
P (erreur non détectée|c est transmis) = P (d|c).
d∈C
d6=c
Ainsi, la probabilité de ne pas détecter une erreur est :

XX
Perr non dét = P (d|c)P (c).
c∈C d∈C
d6=c
2.3 Probabilités associées à la correction d’erreurs
Pour tout schéma de décisions, un mot c étant envoyé, la probabilité d’une erreur de
décision est
X
P (erreur|c) = p(d|c);
d6∈f −1 (c)
ainsi la probabilité conditionnelle Pe d’une erreur de décision est

X X X
Pe = P (erreur|c)p(c) = p(d|c)p(c).
c c d6∈f −1 (c)
On remarque que Pe est fonction du schéma de décisions f de même que de la distribution

d’entrées p(c). Dans le but de trouver un schéma de décisions qui minimise Pe , calculons
cette erreur en conditionnant sur la sortie. Soit d la sortie du canal ; alors une bonne décision
sera effectuée si et seulement si f (d) est le mot d’entrée, c’est-à-dire
P (erreur|d) = 1 − p(f (d)|d).
Pour toutes les sorties nous obtenons

X X
Pe = p(erreur|d)p(d) = 1 − p(f (d)|d)p(d).
d d
Comme p(d) ne dépend pas du schéma de décision f , Pe sera minimum en maximisant

p(f (d)|d) pour tout d ∈ On . Cela nous guidera donc dans la sélection d’un schéma de
décisions. Pour une distribution d’entrées donnée, tout schéma de décisions f pour lequel
p(f (d)|d) = max p(c|d) ∀d ∈ On

c∈C
est appelé un schéma de décisions d’observateur idéal et tout schéma de décisions f

pour lequel
p(d|f (d)) = max p(d|c) ∀d ∈ On
c∈C
est appelé un schéma de décisions de maximum de vraisemblance
Avant d’énoncer le théorème de Shannon, qui est à la base même de la théorie du codage,
nous avons besoin de deux théorèmes ainsi que d’une définition appartenant à la théorie de
l’information et dont le lecteur trouvera démonstration dans [9].
Théorème 2.1 Pour toutes les distributions d’entrées et parmi tous les schémas de
décisions, un schéma de décisions d’observateur idéal minimise Pe .
Théorème 2.2 Pour la distribution uniforme d’entrées, un schéma de décisions d’ob-

servateur idéal est équivalent à un schéma de décisions de maximum de vraisemblance.
Pour la suite, nous assumerons que la distribution d’entrées de notre canal est uniforme.
Définition 2.1 La capacité d’un canal binaire symétrique avec probabilité d’erreur p
est
C(p) = 1 + p log2 p + (1 − p) log2 (1 − p).
Nous sommes maintenant en mesure d’énoncer le théorème qui donna naissance à la

théorie du codage.
Théorème 2.3 (Shannon Noisy Coding Theorem) ∀ε > 0, si R < C(p) et pour
un n assez grand, il existe un code binaire de longeur n de taux k/n ≥ R avec Pe < ε.
Bien entendu nous avons des résultats similaires pour les codes non binaires mais dans
ces cas, la définition de la capacité diffère. Nous sommes donc assurés de l’existence de bons
codes dans la mesure où nous sommes prêts à diminuer le taux.
2.4 Principe de la distance minimale pour le décodage
Nous aimerions adopter un schéma de décisions qui serait en accord avec un schéma
décisionnel de maximum de vraisemblance. En effet, en supposant une distribution uniforme
d’entrées, on obtiendrait ainsi un schéma équivalent à celui d’un observateur idéal et Pe serait
donc minimisé. Nous allons montrer que c’est précisement ce que nous fournit le principe de
la distance minimale.
Définition 2.2 Soient x et y deux chaı̂nes de même longueur définies sur le même
alphabet. La distance de Hamming d(x, y) est le nombre de positions où x et y diffèrent.
Montrons que la distance de Hamming
d : An × An → N
est bien une métrique et qu’ainsi (An , d) devient un espace métrique. Montrons que ∀ x,y,z
∈ An nous avons :
(1) d(x, y) ≥ 0 et d(x, y) = 0 ⇐⇒ x = y,
(2) d(x, y) = d(y, x),
(3) d(x, z) ≤ d(x, y) + d(y, z).
Les points 1 et 2 sont immédiats. Prouvons le point 3. Soient
x = x1 x2 . . . xn ,
y = y 1 y2 . . . yn ,
z = z1 z2 . . . zn ,
U = {i|xi 6= zi },
S = {i|xi 6= zi ∧ xi = yi },
T = {i|xi 6= zi ∧ xi 6= yi }.
On voit alors facilement que
S ∪ T = U,
S ∩ T = ∅;
ceci implique alors que d(x, z) = |U| = |T | + |S|. De plus, comme |T | ≤ d(x, y) et que
|S| ≤ d(y, z) le résultat est immédiat.
Définition 2.3 Le poids wt(x) d’une chaı̂ne x ∈ Vn (q) est le nombre de symboles
différents de 0 que contient x. Le poids minimal wt(C) est min wt(c).
c∈C
c6=0
Il est immédiat de vérifier que d(x, y) = wt(x − y).
Définition 2.4 La distance minimale d d’un code C est donnée par :
d(C) = min d(x, y).

x,y∈C
x6=y
Un (n, M)−code avec distance minimale d sera appelé un (n, M, d)−code. Considérons
maintenant un canal binaire symétrique avec p < 12 . Si le mot x est envoyé et que la chaı̂ne
y est reçue, alors
p(y|x) = pd(x,y) (1 − p)n−d(x,y) .
Comme p < 12 , cette probabilité sera maximale lorsque d(x, y) sera minimale. Ainsi, décoder
en utilisant un schéma de maximum de vraisemblance revient à choisir le mot x du code qui
est le plus près de y. C’est ce que nous appelons le principe du décodage à distance
minimale. C’est le principe qui nous guidera dans nos procédures de décodages.
Enfin, la distance de Hamming nous permet de définir la notion de boule et de volume

sur l’espace An .
Définition 2.5 Soit x une chaı̂ne de An , où |A| = q et soit r un entier non négatif. La
boule de rayon r centrée en x notée Sq (x, r) est l’ensemble
Sq (x, r) = {y ∈ An | d(x, y) ≤ r}.
Définition 2.6 Le volume de la boule Sq (x, r) noté Vq (n, r) est le nombre d’éléments
de Sq (x, r). Le volume est indépendent de x et est donné par
r
X n
Vq (n, r) = (q − 1)k .
k=0
k
2.5 Distance versus la détection et la correction d’er-

reurs
Le but du codage est évidemment la détection et surtout la correction d’erreurs. Il nous

faut cependent définir ce que l’on entend par détection et correction d’erreurs dans le cadre
de la théorie du codage. Pour ce faire, nous utiliserons les définitions de distance de Hamming
et de distance minimale.
Définition 2.7 Soit t ≥ 1. Nous dirons qu’un code C détecte t erreurs si pour x ∈ C,
les chaı̂nes y ∈ An vérifiant x 6= y et d(x, y) ≤ t ne sont pas dans C.
Définition 2.8 Soit t ≥ 1. Nous dirons qu’un code C corrige t erreurs si pour tout
y ∈ An , il existe au plus un x ∈ C tel que x 6= y et d(x, y) ≤ t.
Pour ce qui est de la détection, il est clair qu’un code C détectera t erreurs si et seulement
si t < d. Pour ce qui est de la correction, le résultat est moins évident et fera l’objet du
prochain théorème.
Théorème 2.4 Un code C avec distance minimale d corrige t erreurs si et seulement

si d ≥ 2t + 1.
Preuve
⇐
Soit d ≥ 2t + 1. Soit y ∈ An . Nous aimerions montrer qu’il existe au plus un mot x ∈ C tel
que x 6= y et d(x, y) ≤ t. Soit z ∈ C où z 6= x, d(x, y) ≤ t et d(y, z) ≤ t. Alors nous avons
que d(x, z) ≤ 2t. Ce qui contredit le fait que d ≥ 2t + 1.
⇒
Soit d ≤ 2t. Soit x, z ∈ C où x 6= z et où d(x, z) ≤ 2t. On peut alors choisir un y ∈ An tel
que d(x, y) ≤ t et d(z, y) ≤ t. Nous avons donc deux mots du code dont la distance à y est
≤ t. Ceci implique que le code ne corrige pas t erreurs.
2.6 Codes équivalents
En théorie du codage on retrouve plusieurs définitions de codes équivalents. Nous adop-

terons la définition suivante :
Définition 2.9 Deux (n, M)−codes q-aires C1 et C2 sont équivalents s’il existe une
permutation σ des n coordonnées de chaque mot et des permutations π1 , π2 , . . . , πn de l’alpha-
bet telles que
c1 c2 c3 · · · cn ∈ C1 ⇐⇒ π1 (cσ(1) )π2 (cσ(2) )π3 (cσ(3) ) · · · πn (cσ(n) ) ∈ C2 .
Autrement dit, deux codes C1 et C2 sont équivalents si nous pouvons obtenir l’un à
partir de l’autre en permutant les coordonnées de chacun des mots ou encore les symboles
de l’alphabet dans chacunes des positions de chacun des mots. Deux codes équivalents ont
évidemment les même paramètres.
Chapitre 3
Le problème central en théorie du

codage
3.1 Le problème central : Aq (n, d)
Pour un (n, m, d)−code donné, nous aimerions que sa distance minimale d soit aussi
grande que possible tout en ayant une cardinalité M maximale. Ces deux exigences sont
évidemment en conflit. On note Aq (n, d) la plus grande cardinalité M pour laquelle un
(n, M, d)−code sur F q existe. Un code pour lequel M = Aq (n, d) sera dit optimal. Détermi-
ner Aq (n, d) est appelé le problème central en théorie du codage. À titre indicatif, on
a quelques résultats connus pour A2 (n, d) dans le tableau 3.1.
Afin d’étudier Aq (n, d), nous présentons ici les quatres principales bornes utilisées en
théorie du codage. L’utilisation de certaines bornes de concert avec l’identité de MacWilliams
nous permettra d’étudier l’existence ou la non-existence de certains codes linéaires de pa-
ramètres donnés.
12
CHAPITRE 3. LE PROBLÈME CENTRAL EN THÉORIE DU CODAGE 13
A2 (n, d)
n d=3 d=5 d=7 n d=3 d=5 d=7
5 4 2 - 11 144-158 24 4
6 8 2 - 12 256 32 4
7 16 2 2 13 512 64 8
8 20 4 2 14 1024 128 16
9 40 6 2 15 2048 256 32
10 72-79 12 2 16 2560-3276 256-340 36-37
Tab. 3.1: A2 (n, d)
3.2 Quelques bornes supérieures sur Aq (n, d)
Dans le but de résoudre (pour certains paramètres) le problème central de la théorie

du codage, l’utilisation de certaines bornes pour Aq (n, d) s’avère très utile. Nous présentons
ici quatre des bornes les plus utilisées et connues en théorie du codage. Nous fournirons la
démonstration pour les deux premières et référons le lecteur à [7] pour les démonstrations
des deux autres.
Théorème 3.1 (La borne de Singleton)
Aq (n, d) ≤ q n−d+1 .
Preuve
Soit C un (n, M, d)−code. Si on enlève les d − 1 dernières positions de chaque mot, on

obtient des mots de longueur n − d + 1. Ces mots sont tous différents car sinon la distance
minimale ne serait pas d. Ainsi, on obtient immédiatement que M ≤ q n−d+1 .
Sachant que dans le cas d’un code linéaire nous avons que M = q k , nous obtenons alors
la très importante relation : d ≤ n − k + 1. Un code linéaire C pour lequel nous avons égalité
dans la borne de Singleton est appelé un code séparable de distance maximale.
Théorème 3.2 (La borne de l’empilement des sphères)

qn d−1
Aq (n, d) ≤ Pt , t= .
k=0 k (q − 1)
n k 2
CHAPITRE 3. LE PROBLÈME CENTRAL EN THÉORIE DU CODAGE 14
Preuve
Soit C un (n, M, d)−code. Il est clair que M ·Vn (q, t) ≤ q n . Le résultat est alors immédiat.
Un code C pour lequel nous avons égalité dans la borne de l’empilement des sphères est
appelé un code parfait.
q−1
Théorème 3.3 (La borne de Plotkin) Soit θ = q
. Si d > θn. Alors
d
Aq (n, d) ≤ .
d − θn
q−1
Théorème 3.4 (La borne d’Élias) Soit θ = q
. Si r est un entier positif satisfaisant
r < θn et r 2 − 2θnr + θnd > 0, alors
θnd · q n
Aq (n, d) ≤ .
r 2 − 2θnr + θnd · Vq (n, r)
Chapitre 4
Codes linéaires
4.1 Structure et codage
Nous nous proposons maintenant de présenter la plus importante classe de codes : la

classe des codes linéaires.
Rappelons que notre alphabet de code A ne possède aucune structure particulière. Si nous
voulons doter nos codes d’une certaine structure nous devons préalablement doter A d’une
structure. Nous imposerons à A la structure de corps fini. Le but d’une telle imposition
est qu’alors nous pourrons considérer les mots du code comme des vecteurs de l’espace
F
vectoriel Vn ( q ). On remarque alors que la longueur du code est en fait la dimension de
l’espace vectoriel qui lui est associé. Comme il est primordial que la somme de deux mots
ou encore la multiplication d’un mot par un scalaire soit encore un mot du code, nous nous
F
intéresserons aux codes qui sont en fait des sous-espaces vectoriels de Vn ( q ). Cela nous
conduit à la définition suivante.
F
Définition 4.1 Un code C ⊂ Vn ( q ) est un code linéaire si C est un sous-espace vec-
F
toriel de Vn ( q ). Si la dimension de C est k on dit que C est un [n, k]−code. De plus, si la
distance minimale du code C est d on dit alors que C est un [n, k, d]−code (on utilise les
crochets pour un code linéaire alors qu’on utilise les parenthèses pour un code en général).
15
CHAPITRE 4. CODES LINÉAIRES 16
Montrons maintenant que pour un code linéaire C nous avons d(C)=wt(C) :
d(C) = min d(c, d) = min wt(c − d) = min wt(c).

c,d∈C c,d∈C 06=c∈C

c6=d c6=d
Comme un code linéaire est en fait un espace vectoriel, il devient naturel de le représenter
par une base. En théorie du codage on présente habituellement la base comme des vecteurs
lignes d’une matrice. Nous respecterons cette convention.
Définition 4.2 Soit C un [n, k]−code. Une matrice G de dimension k × n ayant pour
lignes une base de C est appelée la matrice génératrice du code (bien que nous disions
la matrice de génératrice, il faut comprendre qu’elle est unique à équivalence près).
Il est immédiat de vérifier que le code C peut être représenté de la façon suivante :
F
C = {xG|x ∈ Vk ( q )}.
La procédure de codage est alors triviale. Il suffit de coder le vecteur x de longueur k par le
mot xG du code.
Il peut s’avérer utile d’avoir une matrice génératrice sous une forme spéciale. Nous dirons
que G est sous la forme standard si G = (Ik |A). On peut aisément montrer que toute
matrice G peut être transformée sous la forme standard sans changer le code (à équivalence
près).
F
L’espace vectoriel Vn ( q ) peut être muni d’un produit scalaire de la façon suivante. Soient
x = x1 · · · xn et y = y1 · · · yn , alors le produit scalaire de x et y nous est donné par :
hx, yi = x1 y1 + · · · + xn yn .
À l’aide de ce produit scalaire nous allons définir l’un des concepts fondamentaux de la
théorie du codage, soit le concept de code dual.
Définition 4.3 Soit C un [n, k]−code. Le code C ⊥ défini par
C ⊥ = {x ∈ Vn (q)|hx, ci = 0 ∀c ∈ C}
est appelé le code dual du code C.

Le théorème suivant caractérise le code dual C ⊥ associé au code C.
Théorème 4.1 (Dual)

F
(1) Soit G une matrice génératrice de C. Alors C ⊥ = {x ∈ Vn ( q )|xGt = 0}.
(2) Si C est un [n, k]−code alors C ⊥ est un [n, n − k]−code.
(3) C ⊥⊥ = C.
Preuve
(1) Découle du fait que x ⊥ C ⇐⇒ x est perpendiculaire à tous les vecteurs d’une base
de C.
(2) Découle de (1).
(3) Comme dim(C) = dim(C ⊥⊥ ) et que C ⊂ C ⊥⊥ , alors C ⊥⊥ = C.

Nous avons montré que si C est un code linéaire alors C ⊥ est aussi un code linéaire. Il
est naturel de nous demander si les deux matrices génératrices ne seraient pas reliées entre
elles. Nous verrons que oui et nous allons de plus montrer comment obtenir l’une connaissant
l’autre.
Soit G = (Ik |A) une matrice génératrice du code C sous sa forme standard. Définissons
la matrice H = (−At |In−k ) et montrons que H est la matrice génératrice de C ⊥ .
On vérifie facilement que

−A
GH = (Ik |A)
t
= −A + A = 0.
In−k
C’est donc dire que les lignes de H sont orthogonales aux lignes de G. De plus, comme
rang(H) = n − k = dim(C ⊥ ), on en déduit que H est en fait une matrice génératrice du code
C ⊥ . La matrice H est aussi appelé la matrice de contrôle du code C. Cette dénomination
découle du fait suivant :
(4.1) x ∈ C ⇐⇒ xH t = 0.
Il est à noter que la notion de matrice de contrôle et la propriété 4.1 s’avèreront fondamentales
dans le processus de décodage.
On sait que la distance minimale d d’un code C est un paramètre fondamental afin
de caractériser un code. De plus, comme la capacité d’un code à corriger les erreurs est
directement reliée à d, il est intéressant de remarquer qu’il est possible de déterminer d si on
connaı̂t la matrice de contrôle H du code. C’est le but du prochain théorème.
Théorème 4.2 Soient C un [n, k, d]−code et H une matrice de contrôle du code C. La

distance d est le plus petit entier r pour lequel la matrice H contient r colonnes linéairement
dépendantes.
Preuve
F
Soit x = x1 . . . xn ∈ Vn ( q ) et soit Hj la j-ième colonne de H. Alors
x∈C ⇐⇒ xH t = 0
⇐⇒ x1 H1 + x2 H2 + · · · + xn Hn = 0.
Ainsi pour chaque mot de poids d, il existe un ensemble de d colonnes linéairement dépendan-
tes. D’un autre coté, s’il existait un ensemble de d − 1 colonnes linéairement dépendantes,
il existerait un mot de poids = d − 1 < d dans notre code. Cela contredirait le fait que
d = wt(C).
4.2 Décodage
Une méthode efficace de décodage peut être construite à l’aide de la matrice de contrôle.
Cette méthode s’appelle le décodage avec syndrômes.
Définition 4.4 Soit C un [n, k]−code ayant H comme matrice de contrôle. Alors pour
F
tout x ∈ Vn ( q ) on définit le syndrôme de x, noté syn(x), par
syn(x) = xH t .
On vérifie immédiatement que
syn(x) = 0 ⇐⇒ x ∈ C.
Voyons cette méthode en détails. Rappelons tout d’abord que l’espace quotient Vn ( q )/C F
est aussi un espace vectoriel sur Fq . Nous savons aussi que x + C = y + C ⇐⇒ x − y ∈ C.
Nous pouvons alors établir un lien entre les classes modulo C et les syndrômes de la façon
suivante.
Théorème 4.3 Soit C un [n, k]−code ayant H comme matrice de contrôle. Alors
syn(x) = syn(y) ⇐⇒ x et y appartiennent à la même classe de Vn ( q )/C. F

Preuve
x + C = y + C ⇐⇒ x − y ∈ C ⇐⇒ (x − y)H t = 0 ⇐⇒ xH t = yH t .
Nous allons maintenant utiliser l’ensemble de nos résultats précédents afin d’établir une
méthode de décodage en accord avec le principe de la distance minimale.
Supposons qu’un vecteur x (pas nécessairement un mot du code) soit reçu. Le principe
de la distance minimale nous demande de décoder x par c ∈ C où c est le mot du code
C le plus près (au sens de notre métrique) de x. Si e représente l’erreur de transmission,
nous obtenons alors que e = x − c. Chercher la distance minimale est alors équivalent à
minimiser wt(e). Comme syn(e) = syn(x − c) = syn(x) − syn(c) = syn(x), on en déduit
alors que e et x appartiennent à la même classe modulo C. Si nous choisissons le mot de
poids minimal comme représentant de chaque classe, e est alors le représentant de la classe
de x. Nous pouvons alors décoder x comme le mot c du code où c = x + e . Il suffit donc de
garder en mémoire une table des représentants de chaque classe modulo C ainsi que de leur
syndrôme respectif.
Bien que cette méthode puisse s’appliquer à tous les codes linéaires, il est souvent sou-
haitable de la modifier pour certains codes en particulier. On devine déjà que plus le taux
R d’un code sera faible, plus le nombre de classes sera élevé. Maintenir une table de chaque
représentant et de son syndrôme peut ne s’avérer d’aucune utilité en pratique. Pensons sim-
plement à un code de dimension k = 12 sur V24 ( F ). Le nombre de classes serait alors de
2
224 12
212
=2 = 4096 ce qui ne serait d’aucune efficacité (nous verrons qu’un tel code existe ; c’est
le code de Golay). Dans la pratique on s’intéressera non seulement aux codes ayant certains
paramètres donnés mais aussi et surtout aux codes admettant des procédures de décodage
simples et rapides.
4.3 Distribution de poids et énumérateur de poids
4.3.1 Distribution de poids et énumérateur de poids
Soit C un [n, M]−code et soit Ai le nombre de mots de poids i. Le vecteur (A0 , . . . , An )

est appelé la distribution des poids du code C ou encore le vecteur de distribution
de poids.
Définition 4.5 Soit C un [n, k]−code de distribution (A0 , . . . , An ). Alors l’énumérateur

de poids est le polynôme à deux inconnues
X
n
WC (x, y) = Ai xn−i y i.
i=0
F
De plus, pour u ∈ Vn ( q ), on définit
P (u) = xn−wt(u) y wt(u) .
Nous obtenons ainsi

X X
n
(4.2) P (u) = Ai xn−i y i = WC (x, y).
u∈C i=0
Il est important de noter que si on connaı̂t (A0 , . . . , An ) pour un certain code linéaire,
alors la distance devient facile à trouver car A0 = 1, Ai = 0 pour 1 ≤ i ≤ d − 1 et Ad ≥ 1.
Un des plus intéressants résultats en regard de l’énumérateur de poids est certes l’identité
de MacWilliams qui relie l’énumérateur de poids d’un code linéaire C à l’énumérateur de poids
de son code dual C ⊥ .
Bien que l’identité de MacWilliams s’applique aux codes linéaires définis sur F , nous
q
ne nous intéresserons ici qu’au cas où le code linéaire est défini sur F . Afin de démontrer
2
l’identité de MacWilliams dans le cas binaire, deux lemmes seront nécessaires.
Définition 4.6 Soit Vn = Vn ( F ) un espace vectoriel binaire de dimension n. Pour

2
u ∈ Vn , définissons
X
gn (u) = (−1)hu,vi P (v).
v∈Vn
Lemme 4.1 Soit C un [n, k]−code binaire. Alors

X 1 X
P (u) = gn (u).
⊥
|C| u∈C
u∈C
Preuve
Nous avons
X XX
gn (u) = (−1)hu,vi P (v)
u∈C u∈C v∈Vn
X
= P (v)S(v)
v∈Vn
(
P hu,vi
|C| si v ∈ C ⊥ ,
où S(v) = u∈C (−1) , pour v ∈ Vn . Montrons que S(v) =
0 si v 6∈ C ⊥ .
Pour v ∈ Vn , soit C0 (v) = {u ∈ C : hu, vi = 0}. Alors C0 (v) est un sous-groupe de C

(et même un sous-espace vectoriel). Si w1 , w2 ∈ C, hw1 , vi = 1 et hw2 , vi = 1, alors nous
avons que hw1 − w2 , vi = 0 et par conséquent, w1 − w2 ∈ C0 . Cela implique que C1 (v) défini
par C1 (v) = {u ∈ C : hu, vi = 1} est soit l’ensemble vide ou une classe de C modulo C0 (v) ;
de plus, nous avons que C1 (v) = ∅ ⇐⇒ v ∈ C ⊥ . Si v ∈ C ⊥ , alors
X
S(v) = (−1)0 = |C|.
u∈C0 (v)
S
Pour v 6∈ C ⊥ , nous avons |C0 (v)| = |C1 (v)| et comme C = C0 (v) C1 (v), nous avons
X X
S(v) = (−1)hu,vi + (−1)hu,vi = 0.
u∈C0 (v) u∈C1 (v)
Ainsi
X X X
gn (u) = P (v)S(v) + P (v)S(v)
u∈C v∈C ⊥ v6∈C ⊥
X
= |C| P (v).
v∈C ⊥
Lemme 4.2 Soit u ∈ Vn = Vn ( F ). Alors

2
gn (u) = (x + y)n−w(u)(x − y)w(u) .

Preuve
Nous allons procéder par induction. Par définition, lorsque nous avons u ∈ Vn , nous avons
X
gn (u) = (−1)hu,vi P (v).
v∈Vn
Montrons que c’est vrai pour n = 1. En effet, pour u ∈ V1 ,
g1 (u) = (−1)hu,0i P ((0)) + (−1)hu,1i P ((1))

(
x + y si u = 0
=
x − y si u = 1
(
(x + y)1−w(0) (x − y)w(0) si u = 0
=
(x + y)1−w(1) (x − y)w(1) si u = 1
= (x + y)1−w(u) · (x − y)w(u) .
Supposons que c’est vrai pour n = k. Montrons alors que cela est vrai pour n = k + 1. Soient
u = (u1 , . . . , uk+1), v = (v1 , . . . , vk+1 ), u0 = (u1 , . . . , uk ), v0 = (v1 , . . . , vk ). Alors nous avons
X X
gk+1 (u) = (−1)hu,vi P (v) + (−1)hu,vi P (v)
v∈Vk+1 v∈Vk+1
vk+1 =0 vk+1 =1
X 0 0 0 0
X 0 0 0 0
= (−1)hu ,v i xk+1−w(v ) y w(v ) + (−1)hu ,v i+uk+1 xk−w(v ) y w(v )+1
v0 ∈Vk v0 ∈Vk
= xgk (u0 ) + y(−1)uk+1 gk (u0 )

= gk (u0 )(x + y(−1)uk+1 )
0 0
= (x + y)k−w(u ) (x − y)w(u ) (x + y(−1)uk+1 ) (d’après l’hypothèse d’induction)
= (x + y)k+1−w(u) (x − y)w(u)
en considérant uk+1 = 0, uk+1 = 1.

Nous sommes maintenant prêts à démontrer l’identité de MacWilliams sur F.
2
Théorème 4.4 (Identité de MacWilliams sur F ) Soit C un [n, k]−code binaire.

2
Alors
1
WC ⊥ (x, y) = WC (x + y, x − y).
2k
Preuve
Soit (A0 , A1 , . . . , An ) la distribution des poids de C. Comme
X 1 X
P (u) = gn (u) (d’après le lemme 4.1)
|C| u∈C
u∈C ⊥
1 X
= (x + y)n−w(u)(x − y)w(u) (d’après le lemme 4.2)
|C| u∈C
1 X
n
= Ai (x + y)n−i (x − y)i
|C| i=1
1
= WC (x + y, x − y) (d’après l’équation 4.2)
|C|
et comme d’après l’équation 4.2,
X
P (u) = WC⊥ (x, y),
u∈C ⊥
nous avons le résultat voulu.
4.3.2 Une propriété de la distribution des poids d’un code linéaire

binaire
Nous allons montrer une propriété intéressante des codes linéaires binaires. Pour ce faire,
nous utiliserons le théorème suivant.
Théorème 4.5 Soit (G, +) un groupe abélien contenant un sous-ensemble A non vide
tel que
(1) a1 , a2 ∈ A ⇒ a1 − a2 ∈ A,
(2) b1 , b2 ∈
/ A ⇒ b1 − b2 ∈ A.
Alors ou bien A = G ou bien A < G et [G : A] = 2.
Preuve
L’implication (1) nous dit que A est un sous-groupe. L’implication (2) nous dit que
[G : A] = 2.
Ainsi nous sommes en mesure d’énoncer le théorème suivant.
Théorème 4.6 Les mots d’un code linéaire binaire sont soit tous de poids pair ou soit
en nombre égal de poids pair et impair.
Preuve
Appliquer le théorème précédent avec A = {mots de poids pairs}.
4.3.3 MacWilliams et l’existence de codes linéaires
En théorie du codage on s’intéresse souvent à l’existence d’un code de paramètres donnés.

Nous allons montrer comment l’identité de MacWilliams peut nous servir à montrer la non-
existence d’un code.
Question : Existe-t-il un [7, 2, 5]−code binaire ?
La borne de Singleton nous donne k ≤ 7 − 5 + 1 = 3. Ainsi k = 2 est possible. Maintenant

en utilisant le théorème 4.6 nous obtenons seulement deux possibilités pour la distribution
de poids d’un tel code, à savoir :
(1, 0, 0, 0, 0, 1, 1, 1),
(1, 0, 0, 0, 0, 2, 1, 0),
ce qui nous donne respectivement les deux polynômes de distribution de poids suivants :
Wc (x, y) = x7 + x2 y 5 + xy 6 + y 7,
Wc (x, y) = x7 + 2x2 y 5 + xy 6 .
En appliquant l’identité de MacWilliams afin d’obtenir le polynôme de distribution de

poids du code dual nous obtenons respectivement :
Wc⊥ (x, y) = 2x2 y 5 + 3xy 6 + x7 − 2x6 y + 13x5 y 2 + 15x3 y 4,
Wc⊥ (x, y) = x7 − x6 y + 8x5 y 2 + 10x4 y 3 + 5x4 y 4 + 7x2 y 5 + 2xy 6 .
Comme on sait que le dual d’un code linéaire est aussi un code linéaire, on en déduit la
non-existence de notre [7, 2, 5]−code simplement en remarquant que les coefficients de Wc⊥
ne sont pas tous positifs.
On peut enfin remarquer que ce résultat est en accord avec la valeur de A2 (7, 5). Si un
tel code avait existé, il aurait contenu 4 mots ce qui impliquerait A2 (7, 5) ≥ 4 alors que nous
savons que A2 (7, 5) = 2.
4.3.4 L’identité de MacWilliams et Aq [n, d]
Le problème central en théorie du codage est de déterminer Aq (n, d). Si nous nous
intéressons à Aq [n, d], nous disons alors que c’est le problème central en théorie du co-
dage linéaire. Nous avons évidemment que Aq [n, d] ≤ Aq (n, d). De plus, nous savons que
Aq [n, d] = q k où k est le plus grand entier pour lequel il existe un [n, k, d]−code sur F . C’est
q
donc dans le but de déterminer Aq [n, d] que l’identité de MacWilliams peut nous venir en
aide. En effet, pour chacune des distributions possibles d’un code linéaire nous savons que
la distribution de son dual, qui nous est donnée par l’identité de MacWilliams, doit être
la distribution d’un code linéaire. Si, étant donnée une distribution initiale, la distribution
du dual que nous donne MacWilliams n’est pas valide, on en déduit alors qu’il n’existe pas
de code linéaire ayant comme distribution la distribution initiale. En utilisant l’ordinateur
(voir le programme MAPLE en annexe) nous avons donc, pour un k donné, généré toutes
les distributions valides et pour chacune d’elles, nous avons obtenu la distribution du dual.
En rejetant toutes les distributions pour lesquelles la distribution du dual n’était pas valide,
nous avons obtenu une borne supérieure pour k. Nos résultats sont présentés au tableau
4.1. En plus de nous aider à déterminer Aq [n, d], notre méthode nous donne aussi l’ensemble
des seules distributions possibles pour un [n, k, d]−code. Concrètement, nous avons dans un
premier temps calculer une borne supérieure pour k en nous basant sur les théorèmes du
chapitre 3. Nous avons amélioré ces bornes dans quelques cas comme le montre le tableau
4.1. Nous avons même fait quelques tests en forçant une valeur de k supérieure aux bornes
théoriques et notre méthode s’est encore avérée efficace. Soulignons enfin que notre méthode
ne nous garantit pas l’existence d’un code même si elle nous permet éventuellement de sup-
poser son existence. Il serait intéressant dans un travail futur d’explorer les liens entre une
distribution valide et l’existence concrète d’un code ayant cette distribution.
n d k (min. bornes théoriques) 2k A2 (n, d) Distributions possibles

9 7 1 2 2 (1, 0, 0, 0, 0, 0, 0, 1, 0, 0)
9 5 3 8 6 aucune
9 5 2 4 6 (1, 0, 0, 0, 0, 1, 1, 1, 0, 0)
(1, 0, 0, 0, 0, 2, 0, 0, 1, 0)
(1, 0, 0, 0, 0, 2, 1, 0, 0, 0)
10 5 4 16 12 aucune
10 5 3 8 12 (1, 0, 0, 0, 0, 3, 3, 1, 0, 0, 0)
(1, 0, 0, 0, 0, 4, 2, 0, 1, 0, 0)
11 5 4 16 24 (1, 0, 0, 0, 0, 6, 6, 2, 1, 0, 0, 0)
(1, 0, 0, 0, 0, 7, 6, 0, 1, 1, 0, 0)
Tab. 4.1: Distributions pour un [n, k, d]−code sur F 2
4.3.5 L’identité de MacWilliams et la distribution de poids
Il est justifié de nous demander comment MacWilliams peut nous aider dans la recherche
de distribution de poids (qui nous donne immédiatement la distance minimale) d’un code
linéaire. L’idée est la suivante. Si le taux R d’un code est bas, il devient facile de faire la
liste des codes et ainsi obtenir la distribution de poids. Si par contre le taux R d’un code est
élevé (c’est d’ailleurs ce que nous recherchons), alors la dimension de son dual est petite. Il
devient alors facile d’énumérer les mots du dual et ainsi facilement obtenir le polynôme de
distribution de poids du code dual. Comme C ⊥⊥ = C, on applique l’identité de MacWilliams
à WC ⊥ afin d’obtenir WC . Si le taux R est près de 12 , notre méthode sera sans succès car les
dimensions du code et de son dual sont alors sensiblement les mêmes. Comme notre intention
est de trouver des codes pour lesquels le taux R est élevé, notre méthode mérite l’attention.
Appliquons notre méthode à un exemple simple mais qui en illustre bien la philosophie.
Supposons que l’on s’intéresse à la distribution de poids et à la distance minimale d’un

code ayant la matrice de contrôle suivante :
 
1 0 1 0 1 0 1
 

C= 0 1 1 0 0 1 1 
.
0 0 0 1 1 1 1
Il est facile de faire la liste des mots ainsi que leur poids respectif. Le tableau 4.2 présente
cette liste. Ainsi on obtient facilement que C = (1, 0, 0, 0, 7, 0, 0, 0).
Code [7,3, ?]
MOT POIDS
0000000 0
1010101 4
0110011 4
0001111 4
1100110 4
1011010 4
0111100 4
1101001 4
Tab. 4.2: Code [7,3, ?]
Il est alors immédiat de calculer Wc pour ce code.
Wc (x, y) = x7 + 7x3 y 4.
En appliquant l’identité de MacWillams on obtient :

1
Wc⊥ (x, y) = Wc (x + y, x − y) = x7 + 7x4 y 3 + 7x3 y 4 + y 7.
8
⊥
On obtient alors que C = (1, 0, 0, 7, 7, 0, 1) et que sa distance minimale est 3.
4.4 Codes de Hamming
Les codes de Hamming sont des codes linéaires qui corrigent une seule erreur. Bien qu’ils
peuvent être définis sur F , nous ne présenterons ici que la version binaire (q = 2). La façon
q
traditionnelle de les présenter est de le faire via la matrice de contrôle ; c’est la façon que
nous allons utiliser. Le lecteur trouvera en annexe un programme MAPLE pour les codes de
Hamming.
Définition 4.7 Soir r un entier positif et soit H une matrice dont les colonnes sont les
vecteurs différents de zéro de Vr ( F ). Alors le code ayant H comme matrice de contrôle est
2
appelé un code de Hamming binaire et est noté H2 (r).

Exemple.
Pour r = 3 nous obtenons (à équivalence près)

 
0 0 0 1 1 1 1
 
H=  0 1 1 0 0 1 1 .

1 0 1 0 1 0 1
Ce n’est pas par hasard que nous avons placé les colonnes dans l’ordre naturel (la colonne
i est la représentation dyadique du nombre i). Nous justifierons ce choix un peu plus tard
lorsque nous parlerons du décodage des codes H2 (r). Si nous avions voulu exhiber la matrice
génératrice du code, il est évident que nous aurions opté pour la représentation sous forme
standard de H. Le théorème suivant rend explicite les propriétés de H2 (r).
Théorème 4.7 Soit C le code de Hamming H2 (r) où r ≥ 2. Alors

(1) C est un [2r − 1, 2r − 1 − r]−code ;
(2) la distance minimale de C est égale à 3 ;
(3) C est un code parfait.
Preuve
(1) Comme nous avons que H2 (r)⊥ est un [2r − 1, r]−code, le résultat suit.
(2) Comme H ne contient pas de colonne égale à zéro et qu’il n’y a pas deux colonnes
identiques, on en déduit que d ≥ 3. Si on additionne les colonnes qui représentent les nombres
1,2 et 3 en binaire, on obtient 0 ce qui implique que d = 3.
(3) Montrons que nous avons égalité pour la borne de l’empilement des sphères. Comme
nous avons que t = 1, n = 2r − 1 et que M = 2n−r , on obtient

n
2 n−r
1+ = 2n−r (1 + n) = 2n−r (1 + 2r − 1) = 2n .
1
Ainsi, C est bien un code parfait.
En ordonnant les colonnes de la matrice de contrôle H selon l’ordre naturel et en suppo-
sant qu’au plus une seule erreur de transmission s’est produite, on obtient une méthode de
décodage très élégante. En effet, si d est reçu alors son syndrôme dH t sera évidemment la
représentation binaire de la position où l’erreur s’est produite ; (on sait que si dH t = 0 alors
aucune erreur ne s’est produite). Illustrons le tout par un exemple.
Exemple. Soit C le code H2 (4) ayant pour matrice de contrôle la matrice

 
0 0 0 0 0 0 0 1 1 1 1 1 1 1 1
 
 0 0 0 1 1 1 1 0 0 0 0 1 1 1 1 
H =

.

 0 1 1 0 0 1 1 0 0 1 1 0 0 1 1 
1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
Supposons maintenant que nous transmettons le mot c = 000000011111111. Introduisons

maintenant une erreur et soit d = 001000011111111 le vecteur reçu. Comme syn(d) =
dH t = 0011 et que 0011 représente la position 3, on en déduit que le mot envoyé était
c = 000000011111111, ce qui est bien le cas.
4.5 Codes de Golay
En 1948, Marcel Golay a introduit quatre codes linéaires notés G23 , G24 , G11 et G12 qui
sont maintenant appelés des codes de Golay. Nous nous intéresserons, pour le moment,
seulement à G24 . C’est le code qui a été utilisé pour la mission Voyager afin de transmettre des
photographies couleurs de Jupiter et de Saturne. Nous le définirons de la manière classique en
donnant sa matrice génératrice. Notre but n’est pas de démontrer les propriétés de G24 mais
plutôt de présenter le code ainsi qu’une méthode de décodage tirant profit de la structure
du code. Comme nous l’avons mentionné précédemment, le principe de décodage nécessitant
le calcul du syndrôme de chaque classe modulo G24 s’avère souvent inutilisable en pratique.
Nous verrons que l’on peut décoder G24 d’une façon élégante, et ce, avec un nombre réduit de
calculs de syndrômes. Pour la justification des paramètres de G24 nous renvoyons le lecteur
à [7] et pour la justification de la méthode de décodage, nous renvoyons le lecteur à [11].
Définition 4.8 Un code linéaire C est un code auto-dual si C = C ⊥ .
Définition 4.9 Le code de Golay G24 est un code binaire ayant comme matrice géné-
ratrice G = [I12 B] où

 
0 1 1 1 1 1 1 1 1 1 1 1
 

 1 1 1 0 1 1 1 0 0 0 1 0 

 
 1 1 0 1 1 1 0 0 0 1 0 1 
 

 1 0 1 1 1 0 0 0 1 0 1 1 

 
 1 1 1 1 0 0 0 1 0 1 1 0 
 

 1 1 1 0 0 0 1 0 1 1 0 1 

B= .

 1 1 0 0 0 1 0 1 1 0 1 1 

 
 1 0 0 0 1 0 1 1 0 1 1 1 
 

 1 0 0 1 0 1 1 0 1 1 1 0 

 

 1 0 1 0 1 1 0 1 1 1 0 0 


 1 1 0 1 1 0 1 1 1 0 0 0 

1 0 1 1 0 1 1 1 0 0 0 1
On obtient alors que le code de Golay G24 est un [24, 12, 8]−code binaire auto-dual.
La famille des codes de Golay n’est pas aussi vaste que la famille des codes de Hamming,
mais son intérêt vient surtout du fait que les codes de Golay se prêtent bien au décodage.
Comme nous l’avons déjà mentionné, le décodage classique de G24 nécessiterait une table
contenant 212 lignes. Voici maintenant un algorithme de décodage n’utilisant pas une telle
table. Nous allons bien entendu illustrer notre méthode à l’aide de quelques exemples.
Voici la notation que nous utiliserons. La matrice génératrice est notée G et G = [I12 B].
La colonne i de B sera notée ci et la ligne i de B sera notée ri . Un 12-uplet binaire où la
seule composante différente de zéro est la composante i sera noté x(i) ou y(i) . Le mot envoyé
sera noté c et r sera le vecteur reçu. Le vecteur nul de longueur 12 sera noté 0 et la notation
(x, y) représentera le vecteur de longueur 24 obtenu par la concaténation de x et y.
Algorithme de décodage (code G24 ).
(1) Calculer s = GrT .

(2) Si wt(s) ≤ 3, alors e = (sT , 0) et aller à (8).
(3) Si wt(s + ci ) ≤ 2 pour un certain i (1 ≤ i ≤ 12), alors e = ((s + ci )T , y(i) ) et aller à
(8).
(4) Calculer B T s.
(5) Si wt(B T s) ≤ 3, alors e = (0, (B T s)T ) et aller à (8).
(6) Si wt(B T s + rTi ) ≤ 2 pour un certain ri (1 ≤ i ≤ 12), alors e = (x(i) , (B T s)T + ri ) et
aller à (8).
(7) Imprimer <Au moins 4 erreurs se sont produites> et fin.
(8) Décoder r comme r − e = c et fin.
Comme on le remarque facilement, avec cette méthode, nous avons un maximum de 24

syndrômes à calculer ce qui est nettement plus efficace que si nous décodions sans tirer profit
de la structure de G24 . Illustrons le tout par deux exemples.
Exemple 1.
Soit c = 110000000000100100011101 le mot du code formé par la première rangée plus

la seconde rangée de G. Introduisons 2 erreurs. Supposons alors que le vecteur reçu est
r = 10001000000010011101. On calcule s = GrT = (010010000000)T . Comme wt(s) ≤ 3,
on prend e = (sT , 0) = 010010000000000000000000 et on décode simplement par r − e =
110000000000100100011101, qui est bien le mot c envoyé. Remarquons qu’un seul calcul de
syndrôme a été nécessaire.
Exemple 2.
Soit c = 001100010000111011111001 le mot du code formé par la somme des rangées 3,4
et 8 de G. Supposons alors que le vecteur reçu est r = 101100010000110011110001 (3 erreurs).
On calcule s = GrT = (110010101011)T . Comme wt(s) > 3 et qu’il n’y a aucune colonne ci de
B telle que wt(s+ci ) ≤ 2, on calcule alors B T s = (010111110111)T . Comme wt(B T s) > 3, on
cherche alors une rangée ri de B telle que wt(B T s+rTi ) ≤ 2. Pour i = 1 on obtient B T s+rT1 =
(001000001000)T = yT . Ainsi, on choisit e = (x(1) , y) = 100000000000001000001000 et on
décode simplement par r − e = 001100010000111011111001, qui est bien le mot c envoyé.
Remarquons que nous avons eu besoin de seulement 15 calculs de syndrômes ce qui est encore
loin de 212 .
4.6 Codes de Reed-Muller
Les codes de Reed-Muller sont habituellement définis à l’aide de la matrice génératrice du

code et nous respecterons cette convention. Nous allons, dans un premier temps, présenter
les codes de Reed-Muller comme des extensions des codes de Hamming. Ce seront les codes
de Reed-Muller du premier ordre. Dans un deuxième temps nous présenterons une définition
récursive des codes de Reed-Muller d’ordre m. Nous faisons volontairement ce choix afin de
montrer que certains codes sont des généralisations d’autres codes ou encore que la façon
de définir un code n’est pas unique. Dans le cas des codes de Reed-Muller du premier ordre
nous exhiberons explicitement leurs paramètres alors que pour les code Reed-Muller d’ordre
m nous renvoyons le lecteur à [7] pour les démonstrations. Notons enfin que c’est un code de
Reed-Muller du premier ordre que Mariner 9 a utilisé afin de transmettre des photographies
de la planète Mars en 1972.
Soit Hr la matrice de contrôle du [2r − 1, 2r − 1 − r]−code binaire de Hamming H2 (r).

Soit maintenant Br = [Hr 0] la matrice Hr auquelle nous avons ajouté une colonne de zéros.
Soient v1 , v2 , . . . , vr les rangées de Br et soit enfin 1 le vecteur ligne de longueur 2r dont
toutes les composantes sont égales à 1. Nous pouvons alors définir les codes de Reed-Muller
du premier ordre de la façon suivante.
Définition 4.10 Le code de Reed-Muller du premier ordre, noté RM(1, r), est le
sous-espace vectoriel engendré par les vecteurs 1, v1 , v2 , . . . , vr . La matrice génératrice de
RM(1, r) est alors

1 1
G= = .
Br Hr 0
Exemple 1.
Construisons la matrice génératrice de RM(1, 3). Comme

 
0 0 0 1 1 1 1
 
H3 =   0 1 1 0 0 1 1 
,
1 0 1 0 1 0 1
nous avons alors  

0 0 0 1 1 1 1 0
 
B3 = [H3 0] = 
 0 1 1 0 0 1 1 0 .

1 0 1 0 1 0 1 0
Nous en déduisons donc que
 
1 1 1 1 1 1 1 1
 
1 1  0 0 0 1 1 1 1 0 
G= = =
 0 1 1 0 0 1 1 0
.

Br Hr 0  
1 0 1 0 1 0 1 0
Nous pouvons alors facilement vérifier que RM(1, 3) est un [8, 4, 4]−code.
Nous aimerions maintenant montrer que le paramètre r détermine tous les autres pa-
ramètres du code. C’est l’objet du prochain théorème.
Théorème 4.8 RM(1, r) est un [2r , r + 1, 2r−1]−code.
Preuve
Comme la matrice G possède 2r colonnes, la longueur du code est évidemment 2r . Comme

les vecteurs 1, v1 , v2 , . . . , vr sont linéairement indépendants, on en déduit que la dimension
est égale à r + 1. Il nous reste alors à montrer que la distance d du code est égale à 2r−1 .
Pour cela, nous montrerons que tous les mots du code (sauf 0 et 1) ont un poids égal à 2r−1 .
Tout mot c 6= 0 du code s’écrit
c = ri1 + ri2 + · · · + rih
où rij est la ij -ième rangée de G, 1 ≤ h ≤ r + 1. Supposons qu’aucun rij n’est égal à 1 et
considérons alors la matrice  
ri1
 
 
 ri2 
A= .. .
 . 
 
rih
Maintenant, la composante t de c sera 0 si la t-ième colonne de A possède un nombre pair
de 1 et sera 1 si cette colonne de A contient un nombre impair de 1. Remarquons que pour
chaque colonne distincte u∗ de A, le nombre de colonnes u de Br où la ij -ième composante,

1 ≤ j ≤ h, est la même que la composante j de u∗ est 2r−h car chacune des r −h composantes
restantes de u est libre de prendre les valeurs 1 ou 0 (par définition de Br ). On obtient donc
que chaque colonne distincte de A apparaı̂t précisément 2r−h fois dans A. Mais comme chaque
h-uplet binaire et distinct apparaı̂t comme colonne de A et que le nombre de ces h-uplets
de poids pairs est égal à celui de poids impairs, on obtient que exactement la moitié des
composantes de c sont égales à 1 et ainsi que wt(c) = 2r−1 .
Si par contre nous avons que rij = 1, alors il suffit de considérer c − 1. Ainsi le même
argument peut être appliqué (il s’applique à tout mot différent de 0) et on obtient alors
wt(c − 1) = 2r−1 (pour c 6= 1). On obtient alors que wt(c) = 2r−1 simplement en changeant
les 1 et les 0 dans c − 1.
Passons maintenant à la définition des codes de Reed-Muller d’ordre m.
Définition 4.11 Un code de Reed-Muller d’ordre m et de longueur 2r où 0 ≤

P r−m
m ≤ r, noté RM(m, r), est le [2r , m i
i=0 r , 2 ]−code défini récursivement de la façon
suivante :
RM(0, r) = {00 . . . 0, 11 . . . 1},
RM(r, r) = V2r ( F ),
2
RM(m, r) = {(x, x + y)|x ∈ RM(m, r − 1), y ∈ RM(m − 1, r − 1)}, (0 < m < r).
Plutôt que d’utiliser cette description du code, nous allons donner une méthode récursive
permettant de construire la matrice génératrice de RM(m, r). Nous noterons cette matrice
G(m, r). Pour 0 < m < r, on définit
" #
G(m, r − 1) G(m, r − 1)
G(m, r) = .
0 G(m − 1, r − 1)
Pour m = 0 on définit la matrice 1 × 2r suivante

h i
G(0, r) = 11 . . . 1
et pour m = r on définit la matrice 2r × 2r suivante

" #
G(r − 1, r)
G(r, r) = .
0 . . . 01
Exemple 2.
Utilisons cette méthode afin de déterminer G(1, 3) (c’est la matrice G de l’exemple 1).
On obtient
" #
G(1, 2) G(1, 2)
G(1, 3) =
0 G(0, 2)
où " #
G(1, 1) G(1, 1) h i
G(1, 2) = et G(0, 2) = 1 1 1 1
0 G(0, 1)
avec " #
1 1 h i
G(1, 1) = et G(0, 1) = 1 1 .
0 1
On obtient alors  
1 1 1 1 1 1 1 1
 
 0 1 0 1 0 1 0 1 
G(1, 3) = 



 0 0 1 1 0 0 1 1 
0 0 0 0 1 1 1 1
qui est bien (à équivalence près) la matrice G de l’exemple 1.
Chapitre 5
Codes linéaires cycliques
5.1 Structure
Une des classes de codes linéaires les plus importantes est la classe des codes cycliques.
Afin de bien les définir, le concept de sous-espace cyclique nous sera nécessaire.
F
Définition 5.1 Un sous-espace S de Vn ( q ) est un sous-espace cyclique si
(a1 , a2 , . . . , an ) ∈ S ⇒ (an , a1 , . . . , an−1 ) ∈ S.
Ainsi, on obtient la définition suivante pour un code linéaire cyclique.
Définition 5.2 Un code linéaire C est cyclique s’il est un sous-espace cyclique.
La construction et l’existence de codes cycliques se ramène donc à la construction et l’exis-

tence de sous-espaces vectoriels cycliques. Voyons comment contruire de tels sous-espaces.
Nous nous permettons de rappeler au lecteur que F [x] et F

q
q [x]
<f (x)> sont des anneaux
principaux. De plus, nous savons qu’il y a un isomorphisme entre Vn ( q ) et l’anneau des F
polynômes de degré inférieur à n sur F q noté F (n)
q [x] := Fq [x]

<f (x)> , où f (x) est un polynôme
de degré n. Cet isomorphisme nous permet de considérer indifférement un mot de C comme
F
un vecteur de Vn ( q ) ou comme un polynôme de F (n)
q [x] de la façon suivante :
F
v = a1 a2 . . . an ∈ Vn ( q ) 7−→ v(x) = a1 + a2 x + · + an xn−1 ∈ F (n)
q [x],
36
CHAPITRE 5. CODES LINÉAIRES CYCLIQUES 37
Lorsque f (x) = xn − 1, on notera Fq [x]

<xn −1> par Rn .
F
Théorème 5.1 Un sous-ensemble non-vide S de Vn ( q ) est un sous-espace cyclique si
et seulement si l’ensemble des polynômes I associés à S est un idéal dans l’anneau des
polynômes F (n)
q [x] F
associé à Vn ( q ).
Preuve
Par hypothèse, S est cyclique. Le fait que (I, +) est un groupe abélien découle du fait
que S est un sous-espace.
Montrons que I est fermé sous la multiplication. Soit v = (a0 , . . . , an−1 ) ∈ S. Alors
v(x) ∈ I implique (an−1 , a0 , . . . , an−2 ) ∈ S car S est cyclique. Alors xv(x) ∈ I.
Comme S est un espace vectoriel, si v ∈ S alors λv ∈ S pour tout λ ∈ q . Ainsi λxi v(x) ∈
Pn−1
F
F
I pour tout λ ∈ q , pour 0 ≤ i ≤ n − 1. Ainsi a(x)v(x) ∈ I où a(x) = j=0
(n)
λj xj ∈ q [x]. F
⇐
Par hypothèse, I est un idéal dans F (n)

q [x]. De plus, (I, +) est un groupe et la multipli-
cation par un scalaire n’est en fait que la multiplication par un polynôme constant. Donc S
est un sous-espace. Comme la multiplication par x revient à un décalage cyclique et que I
est un idéal, on déduit directement que S est cyclique.
Théorème 5.2 Soit I 6= (0) un idéal de Rn où f (x) = xn − 1. Soit g(x) un polynôme
unitaire de plus petit degré tel que [g(x)] représente une classe modulo I. Alors [g(x)] (que
nous pourrons noter g(x) par abus d’écriture) génère I et de plus g(x)|xn − 1.
Preuve
Le fait que I =< g(x) > découle du fait que F (n)
q [x] est un anneau principal. Montrons
que g(x)|xn − 1. Soit f (x) = h(x)g(x) + r(x) où deg(r(x)) < deg(g(x)) ou r(x) = 0. Alors
[f (x)] = [h(x)g(x) + r(x)] = [h(x)][g(x)] + [r(x)]. Comme [f (x)] = [0], nous obtenons
[r(x)] = [−h(x)][g(x)] ∈ I.
Ainsi r(x) = 0 (à cause du choix de g(x)). Donc g(x)|f (x) = xn − 1.

Montrons maintenant que ce polynôme est unique.
Théorème 5.3 Il y a un unique polynôme unitaire g(x) de plus petit degré (≤ n − 1)

qui engendre tout idéal 6= (0) de F (n)
q [x].
Preuve
Soit g(x) et h(x) ∈ F [x] de plus petit degré et unitaires tels que
q
< [g(x)] >=< [h(x)] >= I ⊂ F [x]. (n)

q
Alors [h(x)] = [a(x)g(x)] pour un certain a(x). Comme deg h(x) = deg g(x) et que h(x) et
g(x) sont unitaires le résultat suit.
Ainsi nous parlerons maintenant du polynôme unitaire g(x) de plus petit degré qui
engendre I.
Définition 5.3 g(x) est appelé le polynôme générateur de l’idéal I de Rn .
Théorème 5.4 Soit h(x) un polynôme unitaire diviseur de f (x) = xn − 1. Alors h(x)
est le générateur de l’idéal I = {a(x)h(x) : a(x) ∈ Rn } .
Preuve
Soit g(x) le générateur de I. Nous savons que g(x)|f (x). De plus, comme g(x) ∈ I, il
existe un polynôme a(x) tel que
[g(x)] = [a(x)h(x)].
Nous avons g(x) = a(x)h(x) + l(x)f (x) pour un certain polynôme l(x) ; comme h(x)|f (x),
cela implique que h(x)|g(x). De plus, g(x)|h(x) car g(x) est le générateur. Comme les deux
sont unitaires, on conclut que g(x) = h(x).
Comme on sait qu’un code C peut être engendré par un polynôme différent de son po-
lynôme générateur, la notation C =< g(x) > n’impose pas que g(x) soit l’unique polynôme
unitaire de degré minimal qui génère C. Nous introduisons alors la notation C = g(x) qui
signifie que dans ce cas on impose à g(x) d’être l’unique polynôme unitaire de degré minimal
qui génère C. Il est clair que g(x) et < g(x) > représentent en fait le même code C.
Ainsi en combinant nos résultats précédents, nous obtenons notre résultat principal à
savoir :
Il y a une bijection entre les sous-espace cycliques de Vn ( q ) F

et les polynômes unitaires g(x) ∈ F (n)
q [x] qui divisent f (x) = xn − 1.
Comme nous l’avons fait pour les codes linéaires, nous aimerions exhiber une base de
chacun de nos sous-espaces vectoriels cycliques et ainsi obtenir la matrice génératrice du
code associé. Le théorème suivant répond à cette attente.
Théorème 5.5 Soit g(x) un polynôme unitaire qui divise xn −1 sur F q et où deg g(x) =
n − k. Alors g(x) est le polynôme générateur d’un sous-espace vectoriel cyclique de Vn ( q ) F
de dimension k.
Preuve
F
Soit S un sous-espace vectoriel de Vn ( q ) généré par g(x). Soit

B = g(x), xg(x), . . . , xk−1 g(x) .
Afin d’obtenir notre résultat nous allons montrer que B est une base.
Premièrement, on suppose que
X
k−1
λi xi g(x) = 0, λi ∈ F.
q
i=0
De cette équation, on voit facilement que le seul terme pouvant avoir xn−1 est λk−1 xk−1 g(x)
et comme le degré de xk−1 g(x) est inférieur à n, cela implique que λk−1 = 0. On en déduit
que λi = 0, 0 ≤ i ≤ k − 1. Donc B est linéairement indépendant.
Deuxièmement. Soit h(x) ∈ S. Alors h(x) = a(x)g(x) où sans perte de généralité
deg a(x) < k. Alors
X
k−1 X
k−1
a(x) = λi xi et h(x) = λi xi g(x),
i=0 i=0
de sorte que B engendre S.

Maintenant que nous sommes en mesure de construire la matrice génératrice associée à

un code linéaire cyclique. Nous aimerions exhiber la matrice de contrôle du même code. Pour
cela, il nous faut définir le polynôme de contrôle d’un code linéaire cyclique.
Soit g(x) le polynôme générateur de degré r d’un code linéaire cyclique de paramètres
[n, n − r]. Aussi, nous savons que xn − 1 = g(x)h(x) où h(x) est un polynôme de degré n − r.
Le polynôme h(x) est appelé le polynôme de contrôle du code C ayant comme générateur
g(x). Le théorème suivant montre comment à l’aide de h(x) nous pouvons obtenir la matrice
de contrôle.
Théorème 5.6 Soit h(x) le polynôme de contrôle d’un code linéaire cyclique C dans
Rn .
(1) Le code C peut être représenté par
C = {p(x) ∈ Rn |p(x)h(x) ≡ 0}.
(2) Soit h(x) = h0 + h1 x + · · · + hn−r xn−r . Alors une matrice de contrôle du code C est
donnée par
 
hn−r ··· h0 0 0 ··· 0
 
 0 hn−r ··· h0 0 ··· 0 
 
 .. 
H= 0 0 hn−r · · · h0 ··· . .
 
 .. .. .. .. ..
. 0 
 . . . . ··· 
0 0 ··· 0 hn−r · · · h0
(3) Le code dual C ⊥ est un code cyclique de dimension r et son polynôme générateur est
donné par
h⊥ (x) = h−1
0 x
n−r
h(x−1 ) = h−1
0 (h0 x
n−r
+ h1 xn−r−1 + . . . + hn−r ).
Preuve
(1) Soit g(x) le polynôme générateur de C. Si p(x) ∈ C, alors p(x) = f (x)g(x) pour un
certain f (x) ∈ Rn . Ainsi
p(x)h(x) = f (x)g(x)h(x) = f (x)(xn − 1) ≡ 0.
De plus, si p(x) ∈ Rn et que p(x)h(x) ≡ 0, alors nous pouvons écrire que p(x) =
q(x)g(x) + r(x) où deg(r(x)) < r. Nous obtenons alors
p(x)h(x) = q(x)g(x)h(x) + r(x)h(x),

ce qui implique que r(x)h(x) ≡ 0. Cependant, comme deg(r(x)h(x)) < r + (n − r) = n,

cela implique que r(x)h(x) = 0. Ainsi r(x) = 0 et p(x) = q(x)g(x) ∈ C.
(2) Si c(x) ∈ C alors c(x)h(x) ≡ 0. Comme deg(c(x)h(x)) < 2n−r et qu’ainsi les coefficients
de xn−r , xn−r+1 , . . . , xn−1 , que nous retrouvons dans le produit c(x)h(x) doivent être
nuls, nous obtenons :


 c0 hn−r + c1 hn−r−1 + · · · + cn−r h0 = 0



 ch
1 n−r + c2 hn−r−1 + · · · + cn−r+1 h0 = 0
 .
.. .. .. ..

 . . .


 c h
r−1 n−r + cr hn−r−1 + · · · + cn−1 h0 = 0
Ce système est équivalent à (c0 , c1 , . . . , cn−1)H ⊥ = 0. On en déduit alors que H est

la matrice génératrice d’un code C ∗ qui est orthogonal à C. Ainsi C ∗ ⊂ C ⊥ . Comme
hn−r 6= 0, nous déduisont que dim(C ∗ ) = r et qu’alors C ∗ = C ⊥ .
(3) Ici, il suffit de montrer que h⊥ (x)|xn − 1. Ainsi h⊥ (x) sera le générateur d’un code
cyclique C =< h⊥ (x) > ayant H comme matrice génératrice et alors < h⊥ (x) >= C ⊥ .
Comme h(x)g(x) = xn − 1 implique h(x−1 )g(x−1 ) = x−n − 1, i.e.
xn−r h(x−1 )xr g(x−1 ) = 1 − xn ,
ceci montre alors que h⊥ (x)|xn − 1.

Comme nous venons de le voir, une fois le polynôme xn −1 factorisé en polynômes unitaires
irréductibles, la construction d’un code linéaire cyclique est chose relativement aisée.
Avant d’aborder le codage et le décodage des codes linéaires cycliques ainsi que les codes
eux-mêmes, il nous faut voir une autre façon de représenter un code linéaire cyclique, soit à
travers la notion de zéros d’un code.
Définition 5.4 Les zéros d’un code linéaire cyclique sont les racines de son polynôme
générateur.
Comme la factorisation de xn − 1 sur F q joue un rôle important dans l’élaboration de

la théorie des codes linéaires cycliques, nous nous permettons de rappeler certains faits
concernant cette factorisation. Nous savons que
Y
xn − 1 = mi (x)
i
où les mi (x) sont des polynômes irréductibles sur F . Si ω est une racine primitive n-ième
q
de l’unité sur F , nous savons que les racines du polynôme m (x) sont conjuguées. Elles sont
q i
iq d−1
de la forme {ω , ω , . . . , ω
i iq
} où d est le plus petit entier positif tel que iq d ≡ i mod n.
L’ensemble Ci = {i, iq, . . . , iq d−1 } est alors appelé la i-ième classe cyclotomique de q
modulo p. On obtient alors
Y
mi (x) = (x − ω j ).
j∈Ci
Voyons maintenant comment définir un code à l’aide de la notion de zéros.

Q
Soit xn −1 = i mi (x) où les mi (x) sont des polynômes unitaires irréductibles sur F . Soit
q
α une racine de mi (x) dans un corps de décomposition de F . Ainsi m (x) est le polynôme
q i
minimal de α sur F . Si f (x) ∈ F [x] et que f (α) = 0 alors f (x) = a(x)m (x) pour un certain
q q i
a(x). En particulier, si f (x) ∈ Rn , alors f (α) = 0 ⇐⇒ f (x) ∈ mi (x) .
Voyons comment appliquer cela aux codes linéaires cycliques. Soit g(x) = q1 (x) · · · qt (x)
(où les qi (x) sont des facteurs irréductibles de xn − 1). Soient {α1 , . . . , αu } l’ensemble des
racines de g(x). Alors
g(x) = {f (x) ∈ Rn |f (α1 ) = f (α2 ) = . . . = f (αu ) = 0}.
De plus, il suffit de prendre une seule racine pour chacun des qi (x). Soit βi une racine de
qi (x). Alors
g(x) = {f (x) ∈ Rn |f (β1) = f (β2 ) = . . . = f (βt ) = 0}.
Il faut souligner que si {α1 , . . . , αn } est un ensemble quelconque de racines de xn − 1, alors le

polynôme générateur g(x) sera évidemment le ppcm des polynômes minimaux associés aux
αi . À l’aide de cette représentation, il est très facile d’obtenir la matrice de contrôle. Voyons
comment la construire.
Soit {α1 , . . . , αn } un ensemble de racines de xn −1 appartenant au corps de décomposition

P P
F q d . Soit f (x) = aj xj ∈ Rn . Alors f (αi ) = 0 si et seulement si j aj αij = 0. Voyons
maintenant F qd F
comme l’espace vectoriel Vd ( q ) de dimension d sur F . Notons [α ] le vecteur
q
j
i
colonne de longueur d sur F . De plus, comme a ∈ F
q j q nous obtenons
[aj αij ] = aj [αij ]

et ainsi " #
X X
aj [xji ] = aj αij = 0.
j j
Définissons alors la matrice H de dimension ud × n de la façon suivante :

 
[α10 ] [α11 ] . . . α1n−1
 
 [α0 ] [α1 ] . . . αn−1 
 2 2 2 
H= . .. .. ,
 .. . . 
 
0 1 n−1
[αu ] [αu ] . . . [αu ]
et définissons f = (a0 , . . . , an−1 ). Nous obtenons alors
f (αi ) = 0 pour i = 1, . . . , u ⇐⇒ f H T = 0.
En supprimant les lignes linéairements dépendantes, nous obtenons ainsi une matrice de
contrôle pour le code ayant {α1 , . . . , αu } comme zéros.
Cette représentation nous sera fort utile lors de la définition des codes BCH, RS et des
codes de Goppa.
Avant de passer à un exemple illustrant toute la théorie développée jusqu’ici pour les
codes liéaires cycliques, nous allons voir comment coder et décoder avec un code cyclique.
5.2 Codage-décodage
Soit C = g(x) un [n, n − r]−code q-aire cyclique (le degré de g(x) est alors égal
à r). Ainsi, nous pouvons coder des messages de longueur n − r auxquels seront ajoutés
r symboles de vérification. Soit le message a0 a1 · · · an−r−1 auquel on associe le polynôme
ā(x) = a0 xn−1 + a1 xn−2 + . . . + an−r−1 xr . Ensuite on calcule r(x) où ā(x) = q(x)g(x) + r(x).
Enfin, on envoie c(x) = ā(x) − r(x).
On voit facilement que deg(r(x)) < r et comme ā(x) et r(x) n’ont pas de terme de même
degré, le codage est alors systématique. Par codage systématique on entend qu’en lisant le
mot en partant de la plus grande puissance de r, on vérifie facilement que les n − r premières
positions contiennent l’information alors que les r dernières contiennent les symboles de
vérification.
Comme un code cyclique est un code linéaire, nous pouvons utiliser la même procédure
de décodage que celle utilisée pour nos codes linéaires à savoir la méthode du syndrôme.
Ainsi si c(x) ∈ C est le mot envoyé et que u(x) est reçu, err(x) = u(x) − c(x) est le
polynôme erreur. Nous définirons le poids d’un polynôme comme le nombre de coefficients
différents de zéro. Il nous reste maintenant à voir ce que l’on entend par le syndrôme d’un
polynôme.
Définition 5.5 Soit C = g(x) un [n, n − r]−code q-aire cyclique. Le syndrôme

d’un polynôme u(x), noté syn(u(x)), est le reste de la divison de u(x) par g(x) :
u(x) = q(x)g(x) + syn(u(x)) où deg syn(u(x)) < r.
Il est clair que u(x) ∈ C ⇐⇒ syn(u(x)) = 0 et que syn(u(x)) = syn(u∗ (x)) ⇐⇒

u(x) − u∗ (x) ∈ C. Ainsi cette définition de syndrôme est équivalente à celle présentée pour
nos codes linéaires.
Passons maintenant à un exemple permettant d’illustrer tout ce qui précède.
Exemple
Nous voulons contruire un code cyclique de paramètres [7, 4] = [7, 7 − 3] sur F 2 (si c’est
possible !). (On reconnaı̂t ici les paramètres du code de Hamming H2 (3)). Ce code linéaire
est-il cyclique ? Oui !
Il faut d’abord factoriser x7 − 1 sur F . Nous obtenons

2
(x7 − 1) = (x + 1)(x3 + x + 1)(x3 + x2 + 1).
Pour obtenir un code de paramètres [7, 4], il nous faut donc un facteur irréductible de degré 3
qui divise x7 − 1. Nous avons alors deux choix pour le polynôme générateur. Choisissons
g(x) = x3 + x + 1. Nous obtenons alors un code cyclique C = g(x) de dimension
7 − 3 = 4 et ayant pour matrice génératrice la
matrice suivante
 
1 1 0 1 0 0 0
 
 0 1 1 0 1 0 0 
G= 
.

 0 0 1 1 0 1 0 
0 0 0 1 1 0 1
Afin d’obtenir notre matrice de contrôle, calculons h⊥ (x). (Nous savons que dim(C ⊥ ) = 3.)
Il nous faut alors le polynôme h(x) satisfaisant x7 − 1 = g(x)h(x). Ainsi h(x) = (x + 1)(x3 +
x2 + 1) = x4 + x2 + x + 1. On en déduit alors que h⊥ (x) = x4 + x3 + x2 + 1. Nous obtenons
ainsi la matrice de contrôle H suivante
 
1 0 1 1 1 0 0
 

H= 0 1 0 1 1 1 0 .

0 0 1 0 1 1 1
On vérifie alors facilement que GH T = 0. Comme nous pouvons le constater, la matrice

H comporte tous les vecteurs non nuls de F 3
2 comme colonnes. Ainsi c’est bien la matrice de
contrôle du code H2 (3). Essayons maintenant d’obtenir H avec la méthode des zéros.
Pour ce faire, il nous suffit d’obtenir une racine de x3 + x + 1 et ainsi obtenir H =

[α0 α1 α2 α3 α4 α5 α6 ] comme matrice de contrôle. Faisons quelques observations.
Le polynôme x3 + x + 1 étant primitif, il possède donc β comme racine où β est un

générateur de F . Ainsi H devient
∗
q

H = β0 β1 β2 β3 β4 β5 β6 .
Comme β est un élément primitif, on obtient facilement que

 
1 0 0 1 0 1 1
 
H= 0 1 0 1 1 1 0 

,
0 0 1 0 1 1 1
qui est équivalente à celle calculée avec notre autre méthode. Le code H2 (3) est donc cyclique !
Montrons explicitement comment coder avec ce code. Supposons que l’on désire envoyer
le mot 1001. Ce mot correspond au polynôme 1 + x3 = a(x). Formons ā(x) = x6 + x3 .
Maintenant
x6 + x3 = (x3 + x)(x3 + x + 1) + (x2 + x).
Ainsi
c(x) = ā(x) − r(x) = x6 + x3 − x2 − x

= x6 + x3 + x2 + x
= 0111001 ∈ C
Ainsi nous avons codé :
1001 7−→ 0111001,

1 + x3 7−→ x + x2 + x3 + x6 .
Maintenant comme nous savons que H2 (3) corrige seulement une erreur, introduisons une
erreur et vérifions notre méthode de décodage. Pour cela, formons une table de syndrômes
et de représentants de classes. Comme H2 (3) corrige une seule erreur, il corrige les err(x)
de poids égaux à 1. Le tableau 4.1 présente cette table.
représentants de classes syndrômes

0 0
1 1
x x
x2 x2
x3 x+1
4
x x2 + x
x5 x2 + x + 1
x6 x2 + 1
Tab. 5.1: Syndrômes de H2 (3)
Supposons alors que ayant transmis c(x) = x + x2 + x3 + x6 , nous ayons reçu u(x) =
x + x3 + x6 . Calculons son syndrôme. Or
x6 + x3 + x = (x3 + x)(x3 + x + 1) + x2 .
Donc syn(u(x)) = x2 . Le représentant de la classe de x2 étant x2 , on décode u(x) de la façon

suivante :
c(x) = u(x) − x2 = x + x2 + x3 + x6
= 0111001,
qui est bien le mot qui avait été envoyé.
Tel que nous l’avions mentionné avec les codes linéaires, un tel principe de décodage
nécessite la tenue d’une table de représentants de classes qui peut devenir très longue. Ainsi
nous sommes en droit de nous demander si une méthode de décodage tirant profit de la
structure cyclique du code n’aurait pas pour effet d’améliorer le décodage. La réponse est
évidemment oui. Explicitons cette méthode que nous appliquerons à notre exemple.
Voici le principe de cette nouvelle méthode. Supposons que l’on est capable de décoder
le coefficient de xn − 1. On pourrait, décoder ce coefficient, puis effectuer une permutation
circulaire, et décoder à nouveau le coefficient dominant qui serait en fait le coefficient de xn−1
de u(x). Ainsi, nous n’avons besoin que des lignes de la table pour lesquelles le représentant
de la classe est de degré égal à n − 1.
Appliquons cette méthode à notre exemple. La table en devient alors une qui ne compte
représentant de classe syndrôme

x6 x2 + 1
Tab. 5.2: Syndrôme nécessaire de H2 (3)
qu’une seule ligne.
Soit maintenant notre u(x) = x6 + x3 + x. Comme syn(u(x)) = x2 n’est pas dans la

table, on en déduit que le coefficient de x6 est correct. Calculons syn(xu(x)). Comme
syn(xu(x)) = ( syn(x7 + x4 + x2 ) mod x7 − 1) = syn(x4 + x2 + 1)
et comme (x4 + x2 + 1) = (x)(x3 + x + 1) + (1 + x), on obtient alors que syn(xu(x)) = 1 + x.

Puisque que ce dernier n’est pas dans la table, alors le coefficient de x5 est correct.
Calculons x2 u(x) = x5 + x3 + x où x5 + x3 + x = x2 (x7 + x + 1) + x + x2 . Ainsi

syn(x2 u(x)) = x + x2 ; alors le coefficient de x4 est correct.
Calculons x3 u(x) = x6 + x4 + x2 où x6 + x4 + x2 = x3 (x3 + x + 1) + x3 + x2 . Ainsi

syn(x3 u(x)) = x3 + x2 ; alors le coefficient de x3 est correct.
Calculons x4 u(x) = x7 + x5 + x3 = x5 + x3 + 1 où x5 + x3 + x = x2 (x3 + x + 1) + x2 + 1.

Ainsi syn(x4 u(x)) = x2 + 1 ; alors le coefficient de x2 est inexact.
Ainsi, on décode u(x) = x6 + x3 + x comme u(x) − x2 = x6 + x3 + x2 + x. Qui est bien

notre mot de départ !
La théorie portant sur les codes linéaires cycliques ayant été exposée et illustrée par un
exemple, passons maintenant à la descriptions des cinq principaux codes linéaires cycliques.
5.3 Codes BCH
Les codes BCH (Bose, Ray-Chaudhuri, Hocquenghem 1960) forment une très importante
classe de codes linéaires cycliques. Leur distance est facile à minorer, les mots peuvent être
encodés et les vecteurs, décodés de façon relativement simple. Le lecteur trouvera en annexe
un programme MAPLE pour les codes BCH.
Définition 5.6 Soit ω une racine n-ième primitive de l’unité sur F q et soit g(x) le
polynôme unitaire de plus petit degré sur F q ayant les δ − 1 nombres
ω b , ω b+1, . . . , ω b+δ−2
parmi ses racines (où b ≥ 0 et δ ≥ 1). Un code cyclique C = g(x) de longueur n noté
Bq (n, δ, ω, b) est appelé un code BCH avec distance planifiée δ. De plus, lorsque b = 1
nous dirons que nous avons un code BCH strict et nous le noterons par Bq (n, δ, ω). Si
n = q s − 1 pour un certain s ≥ 1 nous dirons alors que le code BCH est un code BCH
primitif (car ω est alors un élément primitif de F q s ).
Nous allons maintenant montrer que le choix de δ nous donne une borne inférieure pour
la distance d du code.
Théorème 5.7 (La borne BCH) Soit ω une racine n-ième primitive de l’unité sur
F . Soit C un code cyclique et soit g(x) son polynôme générateur. Si pour un certain b ≥ 0
q
et un certain δ ≥ 1 nous avons
g(ω b) = g(ω b+1) = · · · = g(ω b+δ−2) = 0,
alors la distance minimale du code C est supérieure ou égale à δ.
Preuve
Si c = c0 c1 . . . cn−1 ∈ C, alors pour c(x) = c0 + c1 x + · · · + cn−1 xn−1 , on a
c(ω b ) = c(ω b+1 ) = · · · = c(ω b+δ−2 ) = 0,

et ainsi on obtient que H ∗ ct = 0 où

 
1 ωb ω 2b ··· ω (n−1)b
 
 1 ω b+1 ω 2(b+1) · · · ω (n−1)(b+1) 
∗  
H = . .. .. .. .
 .. . . . 
 
1 ω b+δ−2
ω 2(b+δ−2)
··· ω (n−1)(b+δ−2)
Nous aimerions maintenant montrer que si on choisit au plus δ − 1 colonnes de H ∗ , alors

ces colonnes seront linéairement indépendantes sur F qm . Supposons que w = wt(c) ≤ δ − 1.
Cela signifie que ci 6= 0 si et seulement si i ∈ {a1 , a2 , . . . , aw }. Alors H ∗ ct = 0 implique
  
ω a1 b ω a2 b ··· ω aw b ca1
  
 ω a1 (b+1) ω a2 (b+1) ··· ω aw (b+1)   ca 
  2 
 .. .. ..   .  = 0.
 . . .   .. 
  
ω a1 (b+w−1 ω a2 (b+w−1 ··· ω aw (b+w−1)
caw
Le déterminant de la matrice de gauche doit alors être nul. Ce déterminant est cependant
égal à ω (a1 +···+aw )b multiplié par le déterminant de la matrice,
 
1 1 ··· 1
 
 ω a1 ω a2 ··· ω aw 
 
 .. .. .. ,
 . . . 
 
ω a1 (w−1
ω a2 (w−1
· · · ω aw (w−1)
qui est une matrice de Vandermonde. Il est facile de voir que le déterminant de cette matrice
n’est pas nul et qu’ainsi le résultat suit.
La construction d’un code BCH revient à exhiber son polynôme générateur g(x). Nous
devons être en mesure de trouver g(x) à partir des racines n-ièmes de l’unité utilisées pour
le définir. Nous expliciterons la démarche par deux exemples de construction de codes BCH.
Nous avons choisi nos exemples de façon à ce que le corps de décomposition soit F 24 . Nous
avons alors construit F 24 avec le polynôme primitif f (x) = x4 + x + 1 où α est une racine de
f (x). Le tabeau 5.3 présente ce corps.
Exemple 1.
Nous voulons construire un code BCH strict de longueur égale à 15 et de distance planifiée
égale à 7 sur F . Remarquons que nous sommes en présence d’un code BCH primitif car
2
α, racine de x4 + x + 1 F 24
0 0
0
α 1
1
α α
α2 α2
α3 α3
α4 α+1
α5 α2 + α
α6 α3 + α2
α7 α3 + α + 1
α8 α2 + 1
α9 α3 + α
α10 α2 + α + 1
α11 α3 + α2 + α
α12 α3 + α2 + α + 1
α13 α3 + α2 + 1
α14 α3 + 1
Tab. 5.3: F 24
15 = 24 − 1. Calculons en premier lieu les classes cyclotomiques de 2 modulo 15. Nous

obtenons :
C0 = {0}
C1 = {1, 2, 4, 8}
C3 = {3, 6, 9, 12}
C5 = {5, 10}
C7 = {7, 11, 13, 14}.
Notre choix de δ = 7 nous force à inclure les ω j où j ∈ C1 , C3 et C5 . On obtient alors
g(x) = (x − ω)(x − ω 2 )(x − ω 4 )(x − ω 8 )(x − ω 3 )(x − ω 6 )(x − ω 9 )(x − ω 12 )(x − ω 5 )(x − ω 10 ),
où ω est une racine primitive 15-ième de l’unité. Comme notre code est primitif, nous pouvons
prendre ω = α où α est un élément primitif de F 24 . On obtient alors
g(x) = (x − α)(x − α2 )(x − α4 )(x − α8 )(x − α3 )(x − α6 )(x − α9 )(x − α12 )(x − α5 )(x − α10 ).
En utilisant notre construction de F 24 , nous obtenons
g(x) = (1 + x + x4 )(1 + x + x2 + x3 + x4 )(1 + x + x2 )

= 1 + x + x2 + x4 + x5 + x8 + x10 .
Comme wt(g(x)) = 7, on en déduit que la distance d est égale à 7 (égale à la distance

planifiée). De plus, comme le degré de g(x) est égale à 10, la dimension de notre code est 5.
Nous avons donc construit un code BCH qui est un [15, 5, 7]−code.
Exemple 2.
Nous voulons construire un code BCH strict de longueur égale à 5 et de distance planifiée
égale à 3 sur F . Remarquons que nous sommes en présence d’un code BCH qui n’est pas
2
primitif. Calculons en premier lieu les classes cyclotomiques de 2 modulo 5. Nous obtenons :
C0 = {0}
C1 = {1, 2, 3, 4}.
Notre choix de δ = 3 nous donne alors que
g(x) = (x − ω)(x − ω 2 )(x − ω 3 )(x − ω 4 ),
où ω est une racine primitive 5-ième de l’unité. Comme le plus petit entier r satisfaisant
5|2r − 1 est 4, on en déduit que ω ∈ F 24 . De plus, comme 24 −1
= 3, on en déduit que l’on
F
5
peut prendre ω = α3 où α est un élément primitif de 24 . On obtient alors
g(x) = (x − α3 )(x − α6 )(x − α9 )(x − α12 ).
En utilisant notre construction de F 24 , nous obtenons
g(x) = 1 + x + x2 + x3 + x4 .
Il est intéressant de remarquer que nous avions δ = 3 mais que δ = 5 produit le même
code. Comme wt(g(x)) = 5, on en déduit que la distance d est égale à 5. Nous avons alors
construit un code BCH qui est un [5, 1, 5]−code (bien entendu tout cela était prévisible en
regardant la factorisation de x5 − 1 en facteurs irréductibles sur F ).
2
5.4 Codes de Reed-Solomon
Les codes de Reed-Solomon (RS) forment une classe particulière des codes BCH. La
NASA les utilise depuis 1977 dans différentes missions spatiales. Ils ont, par exemple, été
utilisés dans les missions de Galilée, Magellan et Ulysse. La sonde Voyager II les a utilisés
en janvier 1986 afin de transmettre des photographies de Uranus. Sony et Philips utilisent
les code RS depuis 1980 pour l’enregistrement des disques compacts. Nous verrons aussi
comment les codes RS peuvent être utilisés afin de corriger un éclat d’erreurs (ce qui explique
leur choix pour l’enregistrement des disques compacts).
Définition 5.7 Soit q ≥ 3. Un code Reed-Solomon q-aire noté R(n, δ, ω, b) est un

code BCH Bq (q − 1, δ, ω, b) où n = q − 1.
Comme n = q − 1, on obtient alors la factorisation suivante pour xn − 1.

Y
xn − 1 = xq−1 − 1 = (x − α)
α∈F∗q
Ainsi, si ω est une racine (q − 1)-ième primitive de l’unité, on obtient alors que le code RS
de distance planifiée δ admet comme polynôme générateur le polynôme
g(x) = (x − ω b)(x − ω b+1 ) · · · (x − ω b+δ−1 )
où b ≥ 0.
Dans le cas des codes RS, la distance planifiée présente une caractéristique intéressante.
Cette caractéristique fait l’objet du prochain théorème.
Théorème 5.8 La distance minimale d d’un code RS est égale à sa distance planifiée δ.
Preuve
Soit g(x) le polynôme générateur d’un code RS de distance planifiée δ. Nous avons alors
que deg(g(x))= δ − 1 et donc que la dimension k du code est égale à n−deg(g(x))= n − δ + 1.
La borne BCH nous dit que d ≥ δ = n − k + 1 et la borne de Singleton nous dit que
d ≤ n − k + 1 = δ d’où d = δ.
Corollaire 5.1 Les codes RS sont des codes séparables de distance maximale.
Preuve
(d = δ = n − k + 1).
La principale caractéristique des codes RS est qu’ils permettent de corriger un éclat
d’erreurs. Nous n’avons qu’à penser à une égratignure sur un disque compact afin de nous
convaincre que dans ces cas, les éclats d’erreurs sont fréquents. Voyons comment utiliser un
code RS afin de corriger un éclat d’erreurs.
Les codes RS pour lesquels q = 2m sont des codes C définis sur F 2m . Ce sont donc des
[n, k]−codes q-aires. Voyons maintenant F 2m comme F m
2 . Le même code C devient alors un
[mn, mk]−code binaire C + . Dans le premier cas, le code C est un espace vectoriel de dimension
k sur F 2m alors que dans le deuxième cas, le code C + est un espace vectoriel de dimension
mk sur F 2 (notons que C + peut ne plus être cyclique). En résumé, si C est un [n, m, d]−code
2m -aire alors C + est un [mn, mk, ≥ d]−code binaire. Illustrons nos propos par un exemple.
Exemple.
Soient q = 4, n = 3 et k = 2. Soit ω une racine du polynôme primitif (pour F )x

4
4
+x+1
sur F . Nous avons alors que F
2 4 = {0, 1, ω, ω 2}. Soit alors un code C = g(x) = R(3, 2, ω, 1)
où g(x) = x − ω. On obtient alors que
C = {p(x)(x − ω)|deg(p(x)) ≤ 1}.
Considérons maintenant {1, ω} comme une base ordonnée de F 4 sur F . On obtient alors que
2
0 = 0(1)+0(ω) = 00, 1 = 1(1)+0(ω) = 10, ω = 0(1)+1(ω) = 01, et que ω 2 = 1(1)+1(ω) = 11.

Nous obtenons ainsi les C et C + illustrés au tableau 5.4.
Il est alors évident que si le code original C corrige t erreurs alors le code C + corrigera
des éclats d’erreurs pouvant atteindre une longueur b = (t − 1)m + 1.
5.5 Codes Résidus Quadratiques
Comme nous l’avons vu, les codes cycliques peuvent être définis avec la notion de zéros
d’un code. En choisissant les zéros d’une façon particulière nous avons obtenu, par exemple,
les codes BCH. Les codes Résidus Quadratiques sont des codes linéaires cycliques pour
C (sur F)
4 C + (sur F)
2
000 000000
ω10 011000
2
ω ω0 110100
1ω 20 101100
0ω1 000110
2
0ω ω 001101
01ω 2 001011
ωω 21 011110
2
ω 01 110010
111 101010
ωωω 010101
2
ω 1ω 111001
10ω 100001
ωωω 2 010111
2 2 2
ω ω ω 111111
2
ω ω0 110100
1ωω 2 100111
Tab. 5.4: Reed − Solomon
lesquels un choix particulier de zéros est imposé. Comme son nom l’indique, ce choix reposera
sur la notion de résidu quadratique.
Définition 5.8 Soit p un nombre premier impair. Si (a, p) = 1 alors a est un résidu
quadratique modulo p s’il existe un x tel que x2 ≡ a mod p. Si aucun x ne satisfait cette
congruence alors on dira que a est un non-résidu quadratique modulo p.
Par la suite, nous noterons RQ l’ensemble des résidus quadratiques modulo p de l’en-
semble ZZ∗p = {1, . . . , p − 1} et l’ensemble des non-résidus quadratiques de ZZ∗p sera noté
NRQ. Nous nous permettons de rappeler au lecteur les propriétés suivantes des résidus
quadratiques :

p−1 2
(1) RQ = {12 , 22 , . . . , 2
};
(2) RQ ∪ NRQ = ZZ∗p ;
(3) |RQ| = |NRQ| = p−1

2
;
(4) a, b ∈ RQ ⇒ ab ∈ RQ;
(5) a, b ∈ NRQ ⇒ ab ∈ RQ;
(6) a ∈ RQ, b ∈ NRQ ⇒ ab ∈ NRQ;
(7) 2 ∈ RQ ⇐⇒ p ≡ ±1 mod 8;
(8) −1 ∈ RQ ⇐⇒ p ≡ 1 mod 4.
Passons maintenant à des considérations qui nous conduiront à la définition des code RQ.
Soit ω une racine primitive p-ième de l’unité. Nous aimerions alors que les zéros de notre
code soient l’ensemble
Z = {ω i|i ∈ RQ}.
Pour ce faire, il faut que
i ∈ RQ ⇒ Ci = {i, iq, . . . , iq d−1 } ⊂ RQ.
Cette condition impose donc à q d’être un résidu quadratique modulo p. Ainsi, pour un tel
q, nous obtenons des polynômes q(x) et n(x) à coefficients dans F q où
xp − 1 = (x − 1)q(x)n(x)
avec
Y Y
q(x) = (x − ω r ) et n(x) = (x − ω u ).
r∈RQ u∈N RQ
Nous sommes maintenant en mesure de définir un code RQ.
Définition 5.9 Soit p un nombre premier impair et soit q un premier qui est un résidu
quadratique modulo p. Alors, les codes cycliques q-aires
Q(p) =q(x), Q∗ (p) = (x − 1)q(x) ,
N (p) = n(x) , N ∗ (p) = (x − 1)n(x)
de longueur p dans Rp = F [x]/ < x −1 > sont appelés des codes Résidus Quadratiques.
q
p
Avant de présenter un code Résidu Quadratique, nous allons nous intéresser à sa distance
minimale. A cet égard nous avons le théorème suivant.
Théorème 5.9 (Borne de la racine carrée) La distance minimale d des codes Ré-
sidus Quadratiques Q(p) et N (p) satisfait
d2 ≥ p.
De plus, si p = 4k − 1 alors on obtient
d2 − d + 1 ≥ p.
Preuve
Soit a(x) 6= 0 un mot de poids minimal d dans Q(p). Si n ∈ NRQ, alors a∗ (x) = a(xn ) est
un mot de poids minimal dans N (p). Ainsi le mot a(x)a∗ (x) doit appartenir à Q(p) ∩ N (p).
Alors a(x)a∗ (x) est alors un multiple de
Y Y Y
p−1
Y
p−1
(x − ω )
r
(x − ω ) =
n
(x − ω ) =
i
xi .
r∈RQ n∈N RQ i=1 i=0
Nous obtenons donc que wt(a(x)a∗ (x)) = p. Comme wt(a(x)) = d alors le nombre maximum
de coefficients différents de zéro dans a(x)a∗ (x) est d2 , d’où d2 ≥ p.
Si p = 4k − 1, on peut prendre n = −1. De plus, comme a(x)a(x−1 ) possède d termes

égaux à 1 on en déduit que le poids maximal du produit est d2 − d + 1.
Passons maintenant à un exemple de codes Résidus Quadratiques.
Exemple.
Comme nous voulons travailler sur F , nous aimerions que 2 soit un résidu quadratique.
2
Pour ce faire, nous allons choisir p = 8m − 1 où m = 1. Pour p = 7 on obtient alors les deux
ensembles suivants :
RQ = {1, 2, 4};
NRQ = {3, 5, 6}.
Nous avons alors que

q(x) = (x − ω)(x − ω 2)(x − ω 4)
et
n(x) = (x − ω 3 )(x − ω 5 )(c − ω 6 )
où ω est une racine primitive septième de l’unité. Comme p = 23 − 1 nous pouvons prendre
ω = α où α est un élément primitif de F 8 (tel que présenté au tableau 5.5). Cette remarque
nous permet d’exprimer q(x) (par exemple) comme un polynôme irréductible sur F 2 de la
façon suivante :
q(x) = (x − ω)(x − ω 2 )(x − ω 4)

= (x − α)(x − α2 )(x − α4 )
= x3 − x2 (α + α2 + α2 + α) + x(α3 + α5 + α6 ) − α7
= x3 + x + 1.
Ainsi notre code RQ est le code q(x) = x3 + x + 1 . Comme nous savons que le
code H2 (3) est aussi un code cyclique BCH avec ω comme zéro, notre code est en fait le code
H2 (3). Autrement dit, nous avons vu que le code de Hamming H2 (3) était un code linéaire,
puis nous avons vu qu’il était un code cyclique BCH et maintenant nous venons de montrer
qu’il peut aussi être vu comme un code RQ.
5.6 Codes de Goppa
Bien que les codes de Goppa ne sont pas en général des codes cycliques, ils sont néanmoins
une généralisation des codes BCH. C’est pourquoi nous les présentons ici. Leur construction
et l’établissement de leurs paramètres étant plutôt longs, nous nous contenterons de bien les
définir et d’exhiber la forme générale de la matrice de contrôle. Enfin, nous fournirons un
exemple détaillé de construction d’un code de Goppa. Pour ce qui est de la justification de
la construction de la matrice de contrôle, nous référons le lecteur à [9].
Soit G(x) un polynôme à coefficients dans F qm et soit
Sm =
F q m [x]
< G(x) >
l’anneau des polynômes à coefficients dans F qm modulo < G(x) >. Si G(α) 6= 0, alors le
polynôme x − α est inversible dans Sm . En effet, si on divise G(x) par x − α on obtient
G(x) = q(x)(x − α) + G(α).

On en déduit alors que q(x)(x − α) ≡ −G(α) mod < G(x) > et donc que
[−G(α)−1 q(x)](x − α) ≡ 1 mod < G(x) > .
Mais comme nous avons alors que
G(x) − G(α)
q(x) = ,
x−α
nous obtenons finalement que
1 G(x) − G(α)
=− G(α)−1.
x−α x−α
Avec cette définition de (x − α)−1 nous sommes en mesure de définir les codes de Goppa.
Définition 5.10 Soit G(x) un polynôme sur F qm et soit L = {α1 , . . . , αn } un ensemble

d’éléments de F qm où G(αi ) 6= 0 et où n > deg(G(x)). De plus, pour tout a = a1 · · · an avec
ai ∈ F , définissons
q
X
n
ai
Ra = ∈ Sm .
i=1
x − αi
Alors le code de Goppa noté Γ = Γ(L, G) est donné par :
Γ(L, G) = {a ∈ F q |Ra (x)

n
≡0 mod < G(x) >}.
La matrice de contrôle d’un code de Goppa est alors de la forme suivante :
 
G(α1 )−1 G(α2 )−1 ··· G(αn )−1
 
 α1 G(α1 )−1 α2 G(α2 )−1 · · · αn G(αn )−1 
 
 
H =  α12 G(α1 )−1 α22 G(α2 )−1 · · · αn2 G(αn )−1 
 
 .. .. .. 
 . . . 
α1r−1 G(α1 )−1 α2r−1 G(α2 )−1 · · · αnr−1 G(αn )−1
où r = deg(G(x)).
Notons enfin que pour la distance minimale d d’un code de Goppa nous avons d ≥ r+1. On
peut donc, seulement à partir du polynôme G(x) (appelé polynôme de Goppa), minorer
la distance minimale du code.
Montrons maintenant à l’aide d’un exemple comment construire explicitement la matrice

de contrôle d’un code de Goppa donné. Comme notre exemple utilisera le corps F , nous
8
3
l’avons construit avec le polynôme primitif p(x) = x + x + 1 et où p(α) = 0. Le tableau 5.5
présente ce corps ainsi construit.
α, racine de x3 + x + 1 F 23
0 0
α0 1
1
α α
α2 α2
α3 α+1
4
α α2 + α
α5 α2 + α + 1
α6 α2 + 1
Tab. 5.5: F 23
Exemple.
Soit G(x) = x2 + x + 1 un polynôme irréductible sur F 2 F.

et L = {0, 1, α, . . . , α6 } = 8
Dans ce cas nous obtenons q = 2, m = 3, r = 2, n = 8 et α est un élément primitif de F . 8
Comme G(x) ne possède aucun zéro dans F (son corps de décomposition étant F ), nous
8 22
obtenons alors la matrice
" #
G(0)−1 G(1)−1 G(α1 )−1 G(α2 )−1 ··· G(α5 )−1 G(α6 )−1
H=
0G(0)−1 1G(1)−1 αG(α1 )−1 α2 G(α2 )−1 · · · α5 G(α5 )−1 α6 G(α6 )−1
comme matrice de contrôle.

Construisons explicitement les éléments de la matrice. On obtient alors
G(0)−1 = 1−1 = 1,
G(1)−1 = (1 + 1 + 1)−1 = 1,
G(α)−1 = (α2 + α + 1)−1 = α−5 = α2 ,
G(α2 )−1 = (α4 + α2 + 1)−1 = (α + 1)−1 = α−3 = α4 ,
G(α3 )−1 = (α6 + α3 + 1)−1 = (α2 + α + 1)−1 α−5 = α2 ,
G(α4 )−1 = (α8 + α4 + 1)−1 = (α2 + 1)−1 α−6 = α,
G(α5 )−1 = (α10 + α5 + 1)−1 = (α2 + 1)−1 α−6 = α,
G(α6 )−1 = (α12 + α6 + 1)−1 = (α + 1)−1 α−3 = α4 .
En calculant de façon semblable les éléments de la deuxième ligne, on obtient

" #
1 1 α2 α4 α2 α α α4
H= .
0 1 α3 α6 α5 α5 α6 α3
Ce qui nous donne explicitement la matrice de contrôle suivante :
 
1 1 0 0 0 0 0 0
 

 0 0 0 1 0 1 1 1 

 
 0 0 1 1 1 0 0 1 
.
H=
 
 0 1 1 1 1 1 1 1 
 

 0 0 1 0 1 1 0 1 

0 0 0 1 1 1 1 0
Enfin, nous pourrions vérifier que le rang de la matrice H est égal à 6, ce qui implique donc
que la dimension de notre code est 8 − 6 = 2.
Chapitre 6
Conclusion
Les objectifs de ce mémoire ont été d’investiguer les structures algébriques associées
aux codes linéaires. Pour chacune des principales classes de codes, nous avons présenté les
principaux codes utilisés. Pour certains codes, nous avons abordé leur création de différentes
façons afin d’illustrer que la méthode de construction d’un code n’est, en général, pas unique.
L’important problème qui consiste à établir l’existence d’un code de paramètres donnés a
été abordé, nous le croyons, d’une façon originale sous l’angle de l’identité de MacWilliams.
A cet effet, nous avons montré comment utiliser l’identité de MacWilliams afin d’exhiber les
seules distributions possibles pour un code de paramètres donnés.
En termes de perspectives, on peut signaler que dans un travail futur, nous aimerions
établir des conditions nécessaires et suffisantes pour l’existence de certains codes linéaires
pour lesquels l’identité de MacWilliams nous permet de supposer leur existence. Afin de
combler l’écart entre Aq (n, d) et Aq [n, d], l’étude des codes de géométrie algébrique semble
être des plus prometteuses. Soulignons à cet effet que la façon la plus intéressante de définir
et d’analyser les codes de Goppa, c’est de les voir comme des codes de géométrie algébrique.
Toujours en termes de perspectives, notons enfin que le fait de supposer une distribution
uniforme en entrées nous a permis de justifier notre méthode de décodage basée sur un
schéma de maximum de vraisemblance, mais nous croyons fermement que la connaissance
pratique de la distribution d’entrées pourrait conduire à des méthodes de décodage encore
plus efficaces.
61
Annexe A
Programmes MAPLE
A.1 Énumérateur de poids
# ------------------
# Utilisation de
# l’identite de MacWilliams
# -----------------
# Programme permettant d’exhiber
# les seules possibilites pour les
# distributions d’un code lineaire
# de parametres [ n , k , d ].
#
> restart;
# Determination de q,n,d
>
> q:=2:
> n:=11:
> d:=5:
>
# Calculs des 3 bornes
62
ANNEXE A. PROGRAMMES MAPLE 63
# 1 - de Singleton
# 2 - empilement des spheres
# 3 - Elias
>
> k[1]:=evalf(floor(evalf(log[q](q^(n-d+1)))));:t:=floor((d-1)/2):
> k[2]:=evalf(floor(evalf(log[q](q^n/sum(’binomial(n,k)*(q-1)^k’,’k’=0..
> t)))));
>
> Theta:=(q-1)/q:
> if(d>Theta*n)
> then k[3]:=evalf(floor(evalf(log[q](d/(d-Theta*n)))));
> else k[3]:=999;
> fi;
>
>
> kmin:=min(k[1],k[2],k[3]):
>
>
> print(’DEBUT’);
>
> A[0]:=1:
> A[1]:=0:
> A[2]:=0:
> A[3]:=0:
> A[4]:=0:
> for k from kmin to 1 by -1 do : M:=q^k:print(’debut_k’=k);
>
> for A[5] from 1 to (M-1) do
>
> for A[6] from 0 to (M-1-A[5]) do
>
> for A[7] from 0 to (M-1-A[5]-A[6]) do
>
> for A[8] from 0 to (M-1-A[5]-A[6]-A[7]) do

>
> for A[9] from 0 to (M-1-A[5]-A[6]-A[7]-A[8]) do
>
> for A[10] from 0 to (M-1-A[5]-A[6]-A[7]-A[8]-A[9]) do
>
> A[11]:=M-1-A[5]-A[6]-A[7]-A[8]-A[9]-A[10];
> #
>
> if (
> (A[1]+A[3]+A[5]+A[7]+A[9]+A[11]=0)or
>
> (A[0]+A[2]+A[4]+A[6]+A[8]+A[10]=A[1]+A[3]+A[5]+A[7]+A[9]+A[11])
> )
>
> then
> P:=sum(A[j]*(x^(n-j))*(y^j),j=0..n);
> Q:=expand(subs(x=v+w, y=v-w,P));
> Q:=Q*(1/(q^k));
> LC := [coeffs(Q)];
> Entier := 0;
> for L from 1 to nops(LC) do
> if frac(LC[L]) <> 0
> then
> Entier :=1;
> fi;
> od;
>
> if ((min(coeffs(expand(Q)))>=0) and ( Entier = 0 ))
> then
> print(’n’=n,’k’=k,’d’=d,’q’=2);
> print(P);
> print(simplify(Q));
> fi;
> fi;
>
> od:od:od:od:od:od:
> print(’fin_k’=k):od:
> print(’FIN’);
>
A.2 Codes de Hamming
# CODES DE HAMMING
# ======================================================================
# But : (1) Construire la matrice de controle ainsi que la matrice
# generatrice d’un code de Hamming
# de longueur 15 (r = 4).
# (2) Illustrer la procedure de codage et de decodage
# ======================================================================
> restart:
> with(linalg):
> r:=4:
# -----------------------
# construction de la matrice de controle
# -----------------------
> H:=[]:
> for j from 1 to 2^r-1 do
> cb := convert(j,base,2):
> bv := vector(r,0):
> for i from 1 to vectdim(cb) do
> bv[r-i+1] := cb[i]:
> od:
> H := augment(op(H),bv):
> od:
>
> evalm(H);
> nH := Nullspace(H) mod 2;
# -----------------------------------
# Construction de la matrice generatrice
# -----------------------------------
> G:= []:
> for i from 1 to nops(nH) do
> G := stackmatrix(op(G), nH[i]):

> od:
>
> evalm(G);
>
# --------------------------------
# Codage et decodage
#
# w = vecteur a coder
# c = mot du code correspondant a wG
# vr = vecteur recu
# --------------------------------
> w:= vector([1,0,1,1,1,0,1,1,1,1,0]):
> c:= map(x -> x mod 2, evalm(w &* G));
>
# -----------------
# Introduisons une erreur
# -----------------
> vr:= vector ([0,0,1,1,1,1,1,1,0,1,1,1,1,1,0]):
# ---------------
# calcul du syndrome
# ---------------
#
> syn := map( x -> x mod 2, evalm(H &* vr));
> fc:=0:
> cn := 0:
> while (fc <> 1) and (cn < 2^r-1) do
> cn := cn +1:
> if equal(col(H,cn),syn) = true then
> fc := 1:
> fi:
> od:
> print(‘Erreur en position:‘,cn):
# -------------------
# correction de l’erreur en position "cn"
# e : vecteur erreur
> e:= vector ( 2^r-1,0):
> e[cn]:=1:
> vd:=map(x -> x mod 2, evalm (vr + e)):
>
> print(‘Le mot envoye est :‘,c):
> print(‘Le vecteur recu est :‘,vr):
> print(‘Le vecteur erreur est :‘,e):
> print(‘Le mot envoye etait :‘,vd):
A.3 Codes BCH
# CODES BCH
# ========================================================
# But : exhiber le polynome generateur pour un code BCH binaire de
# longueur 15
# ayant les 6 premieres puissances d’une racine primitive 15
# ieme de l’unite comme racines
# ========================================================
#
# ---------------------------
# Construction du corps a 16 elements
# ---------------------------
> restart:
> with(linalg):
> p:=x -> x^4+x+1:
> Primitive(p(x)) mod 2;
> fs:=2^(degree(p(x)));
> field := vector(fs);
> for i from 1 to fs-1 do
> field[i] := Powmod(alpha,i,p(alpha),alpha) mod 2:
> od:
> field[fs] :=0:
> evalm(field);
> ftable := table():
> ftable[ field[i] ] := alphaî:
> od:
> ftable [ field[fs] ] := 0:
>
# ----------------------------------
# construction du polynome generateur
# ----------------------------------
> f := x -> x^(fs-1) -1;

> factf := Factor (f(x)) mod 2;
# -------------------
# t est le nombre d’erreurs que notre code peut corriger
# -------------------
#
> t:=3:
> for i from 1 to 2*t do
> for j from 1 to nops(factf) do
> fj := op(j,factf):
> fj := unapply(fj,x):
> if Rem(fj(alphaî),p(alpha),alpha) mod 2 = 0 then
> print(omegaî,‘ est une racine de ‘, fj(x)):
> break:
> fi:
> od:
> od:
>
> m1:= x -> x^4 + x + 1:
> m2:= x -> x^4 + x^3 +x^2 +x + 1:
> m3:= x -> x^2 + x + 1:
> g:= m1(x)*m2(x)*m3(x);
> print(‘Le polynome generateur est :‘,expand(g) mod 2):
Annexe B
Programmes MAPLE avec sorties
B.1 Énumérateur de poids
# ------------------
# Utilisation de
# l’identite de MacWilliams
# -----------------
# Programme permettant d’exhiber
# les seules possibilites pour les
# distributions d’un code lineaire
# de parametres [ n , k , d ].
#
> restart;
# Determination de q,n,d
>
> q:=2:
> n:=11:
> d:=5:
>
71
ANNEXE B. PROGRAMMES MAPLE AVEC SORTIES 72
# Calculs des 3 bornes

# 1 - de Singleton
# 2 - empilement des spheres
# 3 - Elias
>
> k[1]:=evalf(floor(evalf(log[q](q^(n-d+1)))));:t:=floor((d-1)/2):
> k[2]:=evalf(floor(evalf(log[q](q^n/sum(’binomial(n,k)*(q-1)^k’,’k’=0..
> t)))));
>
> Theta:=(q-1)/q:
> if(d>Theta*n)
> then k[3]:=evalf(floor(evalf(log[q](d/(d-Theta*n)))));
> else k[3]:=999;
> fi;
>
>
> kmin:=min(k[1],k[2],k[3]):
k[1] := 7.
k[2] := 4.
k[3] := 999
>
>
> print(’DEBUT’);
>
> A[0]:=1:
> A[1]:=0:
> A[2]:=0:
> A[3]:=0:
> A[4]:=0:
> for k from kmin to 1 by -1 do : M:=q^k:print(’debut_k’=k);
>
> for A[5] from 1 to (M-1) do
>
> for A[6] from 0 to (M-1-A[5]) do
>
> for A[7] from 0 to (M-1-A[5]-A[6]) do
>
> for A[8] from 0 to (M-1-A[5]-A[6]-A[7]) do
>
> for A[9] from 0 to (M-1-A[5]-A[6]-A[7]-A[8]) do
>
> for A[10] from 0 to (M-1-A[5]-A[6]-A[7]-A[8]-A[9]) do
>
> A[11]:=M-1-A[5]-A[6]-A[7]-A[8]-A[9]-A[10];
> #
>
> if (
> (A[1]+A[3]+A[5]+A[7]+A[9]+A[11]=0)or
>
> (A[0]+A[2]+A[4]+A[6]+A[8]+A[10]=A[1]+A[3]+A[5]+A[7]+A[9]+A[11])
> )
>
> then
> P:=sum(A[j]*(x^(n-j))*(y^j),j=0..n);
> Q:=expand(subs(x=v+w, y=v-w,P));
> Q:=Q*(1/(q^k));
> LC := [coeffs(Q)];
> Entier := 0;
> for L from 1 to nops(LC) do
> if frac(LC[L]) <> 0

> then
> Entier :=1;
> fi;
> od;
>
> if ((min(coeffs(expand(Q)))>=0) and ( Entier = 0 ))
> then
> print(’n’=n,’k’=k,’d’=d,’q’=2);
> print(P);
> print(simplify(Q));
> fi;
> fi;
>
> od:od:od:od:od:od:
> print(’fin_k’=k):od:
> print(’FIN’);
>
>
>
>
DEBUT
debut_k = 4.
n = 11, k = 4., d = 5, q = 2
11 6 5 5 6 4 7 3 8
x + 6 x y + 6 x y + 2 x y + x y
11 4 7 6 5 7 4 9 2 8 3
v + 26. w v + 24. w v + 20. w v + 4. w v + 13. w v
3 8 5 6
+ 12. w v + 28. w v
n = 11, k = 4., d = 5, q = 2
11 6 5 5 6 3 8 2 9
x + 7 x y + 6 x y + x y + x y
11 2 9 4 7 6 5 7 4 9 2
v + w v + 27. w v + 19. w v + 19. w v + 3. w v
8 3 3 8 5 6
+ 16. w v + 9. w v + 33. w v
fin_k = 4.
debut_k = 3.
n = 11, k = 3., d = 5, q = 2
11 6 5 5 6 4 7
x + x y + 3 x y + 3 x y
11 2 9 4 7 6 5 7 4 9 2
v + 4. w v + 44. w v + 58. w v + 46. w v + 6. w v
10 8 3 3 8 5 6
+ 2. w v + 19. w v + 26. w v + 50. w v
n = 11, k = 3., d = 5, q = 2
11 6 5 5 6 4 7 3 8
x + 2 x y + 2 x y + 2 x y + x y
11 2 9 4 7 6 5 7 4 9 2
v + 5. w v + 42. w v + 58. w v + 40. w v + 8. w v
10 8 3 3 8 5 6
+ w v + 21. w v + 24. w v + 56. w v
n = 11, k = 3., d = 5, q = 2
11 6 5 5 6 4 7 2 9
x + 2 x y + 3 x y + x y + x y
11 2 9 4 7 6 5 7 4 9 2
v + 6. w v + 46. w v + 48. w v + 44. w v + 4. w v
10 8 3 3 8 5 6
+ 2. w v + 25. w v + 20. w v + 60. w v
n = 11, k = 3., d = 5, q = 2
11 6 5 5 6 4 7 3 8
x + 3 x y + x y + x y + 2 x y
11 2 9 4 7 6 5 7 4 9 2
v + 6. w v + 40. w v + 58. w v + 34. w v + 10. w v
8 3 3 8 5 6
+ 23. w v + 22. w v + 62. w v
n = 11, k = 3., d = 5, q = 2
11 6 5 5 6 3 8 2 9
x + 3 x y + 2 x y + x y + x y
11 2 9 4 7 6 5 7 4 9 2
v + 7. w v + 44. w v + 48. w v + 38. w v + 6. w v
8 3 3 8 10 5 6
+ 27. w v + 18. w v + w v + 66. w v
n = 11, k = 3., d = 5, q = 2
11 6 5 5 6 4 7 10
x + 3 x y + 2 x y + x y + x y
11 2 9 4 7 6 5 7 4 9 2
v + 8. w v + 58. w v + 48. w v + 52. w v + 12. w v
8 3 3 8 5 6
+ 13. w v + 12. w v + 52. w v
n = 11, k = 3., d = 5, q = 2
11 6 5 5 6 11
x + 3 x y + 3 x y + 1. y
11 2 9 4 7 6 5 8 3 10
v + 10. w v + 90. w v + 108. w v + 45. w v + 2. w v
n = 11, k = 3., d = 5, q = 2
11 6 5 5 6 4 7
x + 3 x y + 3 x y + x y
11 10 2 9 4 7 6 5 7 4
v + w v + 3. w v + 48. w v + 52. w v + 42. w v
9 2 8 3 3 8 10 5 6
+ 7. w v + 23. w v + 22. w v + w v + 56. w v
n = 11, k = 3., d = 5, q = 2
11 6 5 5 6 3 8
x + 4 x y + 2 x y + x y
11 10 2 9 4 7 6 5 7 4
v + w v + 4. w v + 46. w v + 52. w v + 36. w v
9 2 8 3 3 8 5 6
+ 9. w v + 25. w v + 20. w v + 62. w v
fin_k = 3.
debut_k = 2.
n = 11, k = 2., d = 5, q = 2
11 6 5 3 8 2 9
x + x y + x y + x y
11 2 9 4 7 6 5 7 4 9 2
v + 19. w v + 78. w v + 106. w v + 76. w v + 12. w v
8 3 3 8 10 5 6
+ 49. w v + 36. w v + 3. w v + 132. w v
n = 11, k = 2., d = 5, q = 2
11 6 5 4 7 10
x + x y + x y + x y
11 2 9 4 7 6 5 7 4 9 2
v + 21. w v + 106. w v + 106. w v + 104. w v + 24. w v
8 3 3 8 10 5 6
+ 21. w v + 24. w v + w v + 104. w v
n = 11, k = 2., d = 5, q = 2
11 6 5 4 7 3 8
x + x y + x y + x y
11 10 2 9 4 7 6 5 7 4
v + w v + 14. w v + 78. w v + 120. w v + 76. w v
9 2 8 3 3 8 10 5 6
+ 17. w v + 41. w v + 44. w v + 2. w v + 118. w v
n = 11, k = 2., d = 5, q = 2
11 6 5 5 6 11
x + x y + x y + 1. y
11 2 9 4 7 6 5 8 3 10
v + 25. w v + 170. w v + 226. w v + 85. w v + 5. w v
n = 11, k = 2., d = 5, q = 2
11 6 5 5 6 2 9
x + x y + x y + x y
11 10 2 9 4 7 6 5 7 4
v + w v + 16. w v + 86. w v + 100. w v + 84. w v
9 2 8 3 3 8 10 5 6
+ 9. w v + 49. w v + 36. w v + 4. w v + 126. w v
n = 11, k = 2., d = 5, q = 2
11 6 5 5 6 4 7
x + x y + x y + x y
11 10 2 9 4 7 6 5 7 4
v + 2. w v + 11. w v + 86. w v + 114. w v + 84. w v
9 2 8 3 3 8 10 5 6
+ 14. w v + 41. w v + 44. w v + 3. w v + 112. w v
n = 11, k = 2., d = 5, q = 2
11 6 5 10
x + 2 x y + x y
11 10 2 9 4 7 6 5 7 4
v + w v + 20. w v + 110. w v + 100. w v + 100. w v
9 2 8 3 3 8 5 6
+ 25. w v + 25. w v + 20. w v + 110. w v
n = 11, k = 2., d = 5, q = 2
11 6 5 3 8
x + 2 x y + x y
11 10 2 9 4 7 6 5 7 4
v + 2. w v + 13. w v + 82. w v + 114. w v + 72. w v
9 2 8 3 3 8 10 5 6
+ 18. w v + 45. w v + 40. w v + w v + 124. w v
n = 11, k = 2., d = 5, q = 2
11 6 5 5 6
x + 2 x y + x y
11 10 2 9 4 7 6 5 7 4
v + 3. w v + 10. w v + 90. w v + 108. w v + 80. w v
9 2 8 3 3 8 10 5 6
+ 15. w v + 45. w v + 40. w v + 2. w v + 118. w v
fin_k = 2.
debut_k = 1.
n = 11, k = 1., d = 5, q = 2
11 6 5
x + x y
11 10 2 9 3 8 4 7 5 6
v + 6. w v + 25. w v + 80. w v + 170. w v + 236. w v
6 5 7 4 8 3 9 2 10
+ 226. w v + 160. w v + 85. w v + 30. w v + 5. w v
fin_k = 1.
FIN
>
B.2 Codes de Hamming
# CODES DE HAMMING
# =====================================================================
# But : (1) Construire la matrice de controle ainsi que la matrice
# generatrice d’un code de Hamming
# de longueur 15 (r = 4).
# (2) Illustrer la procedure de codage et de decodage
# ======================================================================
> restart:
> with(linalg):
> r:=4:
# -----------------------
# construction de la matrice de controle
# -----------------------
> H:=[]:
> for j from 1 to 2^r-1 do
> cb := convert(j,base,2):
> bv := vector(r,0):
> for i from 1 to vectdim(cb) do
> bv[r-i+1] := cb[i]:
> od:
> H := augment(op(H),bv):
> od:
>
> evalm(H);
[0 , 0 , 0 , 0 , 0 , 0 , 0 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1]
[0 , 0 , 0 , 1 , 1 , 1 , 1 , 0 , 0 , 0 , 0 , 1 , 1 , 1 , 1]
[0 , 1 , 1 , 0 , 0 , 1 , 1 , 0 , 0 , 1 , 1 , 0 , 0 , 1 , 1]
[1 , 0 , 1 , 0 , 1 , 0 , 1 , 0 , 1 , 0 , 1 , 0 , 1 , 0 , 1]
> nH := Nullspace(H) mod 2;
nH := {[1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[1, 1, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0],
[1, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1],
[1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[1, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0],
[1, 1, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0],
[0, 1, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0],
[0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0],
[0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[1, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0]}
# -----------------------------------
# Construction de la matrice generatrice
# -----------------------------------
> G:= []:
> for i from 1 to nops(nH) do
> G := stackmatrix(op(G), nH[i]):
> od:
>
> evalm(G);
[1 , 0 , 0 , 0 , 0 , 0 , 0 , 1 , 1 , 0 , 0 , 0 , 0 , 0 , 0]
[0 , 0 , 0 , 1 , 0 , 0 , 0 , 1 , 0 , 0 , 0 , 1 , 0 , 0 , 0]
[1 , 1 , 0 , 1 , 0 , 0 , 0 , 1 , 0 , 0 , 0 , 0 , 0 , 0 , 1]
[1 , 1 , 1 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0]
[1 , 0 , 0 , 1 , 1 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0]
[1 , 1 , 0 , 1 , 0 , 0 , 1 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0]
[0 , 1 , 0 , 1 , 0 , 0 , 0 , 1 , 0 , 0 , 0 , 0 , 0 , 1 , 0]
[0 , 1 , 0 , 1 , 0 , 1 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0]
[1 , 0 , 0 , 1 , 0 , 0 , 0 , 1 , 0 , 0 , 0 , 0 , 1 , 0 , 0]
[1 , 1 , 0 , 0 , 0 , 0 , 0 , 1 , 0 , 0 , 1 , 0 , 0 , 0 , 0]
[0 , 1 , 0 , 0 , 0 , 0 , 0 , 1 , 0 , 1 , 0 , 0 , 0 , 0 , 0]
>
# --------------------------------
# Codage et decodage
#
# w = vecteur a coder
# c = mot du code correspondant a wG
# vr = vecteur recu
# --------------------------------
> w:= vector([1,0,1,1,1,0,1,1,1,1,0]):

> c:= map(x -> x mod 2, evalm(w &* G));
c := [0, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1]
>
# -----------------
# Introduisons une erreur
# -----------------
> vr:= vector ([0,0,1,1,1,1,1,1,0,1,1,1,1,1,0]):
# ---------------
# calcul du syndrome
# ---------------
#
> syn := map( x -> x mod 2, evalm(H &* vr));
syn := [0, 1, 0, 1]
> fc:=0:
> cn := 0:
> while (fc <> 1) and (cn < 2^r-1) do
> cn := cn +1:
> if equal(col(H,cn),syn) = true then
> fc := 1:
> fi:
> od:
> print(‘Erreur en position:‘,cn):
Erreur en position:, 5
# -------------------
# correction de l’erreur en position "cn"
# e : vecteur erreur
> e:= vector ( 2^r-1,0):

> e[cn]:=1:
> vd:=map(x -> x mod 2, evalm (vr + e)):
>
> print(‘Le mot envoye est :‘,c):
> print(‘Le vecteur recu est :‘,vr):
> print(‘Le vecteur erreur est :‘,e):
> print(‘Le mot envoye etait :‘,vd):
>
Le mot envoye est :,
[0, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1]
Le vecteur recu est :,
[0, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0]
Le vecteur erreur est :,
[0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
Le mot envoye etait :,
[0, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0]
>
B.3 Codes BCH
# CODES BCH
# ========================================================
# But : exhiber le polynome generateur pour un code BCH binaire de
# longueur 15
# ayant les 6 premieres puissances d’une racine primitive 15
# ieme de l’unite comme racines
# ========================================================
#
# ---------------------------
# Construction du corps a 16 elements
# ---------------------------
> restart:
> with(linalg):
> p:=x -> x^4+x+1:
> Primitive(p(x)) mod 2;
true
> fs:=2^(degree(p(x)));
fs := 16
> field := vector(fs);
field := array(1 .. 16, [])

> field[i] := Powmod(alpha,i,p(alpha),alpha) mod 2:
> od:
> field[fs] :=0:
> evalm(field);
[ 2 3 2 3 2
[alpha, alpha , alpha , alpha + 1, alpha + alpha, alpha + alpha ,
3 2 3
alpha + alpha + 1, alpha + 1, alpha + alpha,
2 3 2
alpha + alpha + 1, alpha + alpha + alpha,
3 2 3 2 3
alpha + alpha + alpha + 1, alpha + alpha + 1, alpha + 1,
]
1, 0]
> ftable := table():

> ftable[ field[i] ] := alphaî:
> od:
> ftable [ field[fs] ] := 0:
>
# ----------------------------------
# construction du polynome generateur
# ----------------------------------
> f := x -> x^(fs-1) -1;
(fs - 1)
f := x -> x - 1
> factf := Factor (f(x)) mod 2;

4 3 2 4 2
factf := (x + x + x + x + 1) (x + x + 1) (x + x + 1) (x + 1)
4 3
(x + x + 1)
# -------------------
# t est le nombre d’erreurs que notre code peut corriger
# -------------------
#
> t:=3:
> for i from 1 to 2*t do
> for j from 1 to nops(factf) do
> fj := op(j,factf):
> fj := unapply(fj,x):
> if Rem(fj(alphaî),p(alpha),alpha) mod 2 = 0 then
> print(omegaî,‘ est une racine de ‘, fj(x)):
> break:
> fi:
> od:
> od:
>
4
omega, est une racine de , x + x + 1
2 4
omega , est une racine de , x + x + 1
3 4 3 2
omega , est une racine de , x + x + x + x + 1
4 4
5 2
6 4 3 2
omega , est une racine de , x + x + x + x + 1
> m1:= x -> x^4 + x + 1:

> m2:= x -> x^4 + x^3 +x^2 +x + 1:
> m3:= x -> x^2 + x + 1:
> g:= m1(x)*m2(x)*m3(x);
> print(‘Le polynome generateur est :‘,expand(g) mod 2):
4 4 3 2 2
g := (x + x + 1) (x + x + x + x + 1) (x + x + 1)
2 8 5 10 4
Le polynome generateur est :, 1 + x + x + x + x + x + x
Bibliographie
[1] Courteau, B., Mathématiques d’hier et d’aujourd’hui : Les codes correcteurs d’erreurs,
Modulo,1999.
[2] Dummit, D.S. and Foote, R.M., Abstract Algebra, Prentice-Hall, 1999.
[3] Fraleigh, J.B. and Beauregard, R.A., Linear Algebra, Addison-Wesley, Reading, 1995.
[4] Hill, R., A First Course in Coding Theory, Oxford applied mathematics and computing
science series, Oxford, 1986.
[5] Hoffman, D.G., Leonard, D.A., Lindner, C.C., Phelps, K.T., Rodger, C.A. and Wall,
J.R., Coding Theory, Marcel Dekker, Inc., New York, 1991.
[6] Klima, R.E., Sigmon, N. and Stitzinger, E., Applications of Abstract Algebra with
MAPLE, CRC Press, 2000.
[7] MacWilliams, F.J. and Sloane, N.J.A., The Theory of Error-Correcting Codes, North-
Holland, Amsterdam, 1977.
[8] Pretzel, O., Error-Correcting Codes and Finite Fields, Oxford applied mathematics and
computing science series, London, 1992.
[9] Roman, S., Coding and Information Theory, Springer-Verlag, New-York, 1992.
[10] van Lint, J.H., Introduction to Coding Theory, Springer-Verlag, Berlin, 1992.
[11] Vanstone, S.A. and van Oorschot, P.C., An Introduction to Error Correcting Codes with
Applications, Kluwer Academic Publishers, Boston, 1989.
[12] Vermani, L.R., Elements of Algebraic Coding Theory, Chapman and Hall Mathematics
Series, London, 1996.
[13] Walker, J.L., Codes and Curves, American Mathematical Society, Volume 7, 2000.
94
BIBLIOGRAPHIE 95
[14] Wesley-Peterson, W. and Weldon, E.J., Error-Correcting Codes, The Massachusetts

Institute of Technology, 1972.

These Theorie de Codage

Transféré par

Droits d'auteur :

Formats disponibles

These Theorie de Codage

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

These Theorie de Codage

Transféré par

Droits d'auteur :

Formats disponibles

HANS BHERER

THÉORIE ALGÉBRIQUE DU CODAGE

Département de mathématiques et statistique

La théorie du codage est l’étude des méthodes permettant le transfert d’informations de

Le présent mémoire consiste à présenter et à analyser les différents concepts mathéma-

Claude Levesque Hans Bherer

Je dédie ce mémoire à Michèle.

2 Remarques générales en théorie du codage 4

2.1 Définitions générales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4

2.2 Probabilités associées à la détection d’erreur . . . . . . . . . . . . . . . . . . 6

2.3 Probabilités associées à la correction d’erreurs . . . . . . . . . . . . . . . . . 6

2.4 Principe de la distance minimale pour le décodage . . . . . . . . . . . . . . . 8

2.5 Distance versus la détection et la correction d’erreurs . . . . . . . . . . . . . 10

2.6 Codes équivalents . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11

3 Le problème central en théorie du codage 12

3.1 Le problème central : Aq (n, d) . . . . . . . . . . . . . . . . . . . . . . . . . 12

3.2 Quelques bornes supérieures sur Aq (n, d) . . . . . . . . . . . . . . . . . . . . 13

4.1 Structure et codage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15

4.3 Distribution de poids et énumérateur de poids . . . . . . . . . . . . . . . . . 20

4.3.1 Distribution de poids et énumérateur de poids . . . . . . . . . . . . . 20

4.3.3 MacWilliams et l’existence de codes linéaires . . . . . . . . . . . . . . 24

4.3.4 L’identité de MacWilliams et Aq [n, d] . . . . . . . . . . . . . . . . . . 25

4.3.5 L’identité de MacWilliams et la distribution de poids . . . . . . . . . 26

4.4 Codes de Hamming . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27

4.5 Codes de Golay . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29

4.6 Codes de Reed-Muller . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32

5 Codes linéaires cycliques 36

5.3 Codes BCH . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48

5.4 Codes de Reed-Solomon . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52

5.5 Codes Résidus Quadratiques . . . . . . . . . . . . . . . . . . . . . . . . . . . 53

5.6 Codes de Goppa . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57

A.1 Énumérateur de poids . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62

A.2 Codes de Hamming . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66

A.3 Codes BCH . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69

B Programmes MAPLE avec sorties 71

B.1 Énumérateur de poids . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71

B.2 Codes de Hamming . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85

B.3 Codes BCH . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90

2.1 Le canal symétrique binaire . . . . . . . . . . . . . . . . . . . . . . . . . . . 5

4.1 Distributions pour un [n, k, d]−code sur F 2 . . . . . . . . . . . . . . . . . . . 26

4.2 Code [7,3, ?] . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27

5.1 Syndrômes de H2 (3) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46

5.2 Syndrôme nécessaire de H2 (3) . . . . . . . . . . . . . . . . . . . . . . . . . . 47

5.4 Reed − Solomon . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54

Information Mot du code

Tab. 1.1: Répétition

Dans ce mémoire, nous présenterons les différentes structures algébriques utilisées en

Remarques générales en théorie du

2.1 Définitions générales

L’espace vectoriel de dimension n sur F q F

Le taux d’un code sera défini par :

Un canal discret sans mémoire (C.D.S.M.) consiste en un alphabet A = {a1 , ..., aq }

De plus, si c = c1 ...cn et d = d1 ...dn sont des mots, alors

où P (1|0) = P (0|1) = p et P (1|1) = P (0|0) = 1 − p.

Notations : La variable aléatoire X représentera la distribution d’entrées alors que la

Un schéma de décision est une fonction partielle f

f −1 (c) = {d|f (d) = c}

2.2 Probabilités associées à la détection d’erreur

Si des erreurs se produisent dans la transmission, elles seront détectées si et seulement si