THEORIE ALG EBRIQUE DU CODAGE

HANS BHERER

THEORIE ALGEBRIQUE DU CODAGE

Memoire

presente

a la Faculte des etudes superieures

de l’Universite Laval

pour l’obtention

du grade de maıtre es Sciences (M.Sc.)

Departement de mathematiques et statistique

FACULTE DES SCIENCES ET DE GENIE

UNIVERSITE LAVAL

Septembre 2000

c©Hans Bherer, 2000

Resume

La theorie du codage est l’etude des methodes permettant le transfert d’informations de

facon efficace et precise. Cette theorie est utilisee dans de multiples champs d’applications. On

la retrouve dans l’enregistrement des disques compacts, dans la transmission d’information

sur les reseaux ou encore dans les communications par satellites pour n’en nommer que

quelques-uns.

Le present memoire consiste a presenter et a analyser les differents concepts mathema-

tiques et les differentes structures algebriques associes aux codes lineaires. Les principaux

codes lineaires seront consideres, et on trouvera en annexe quelques programmes MAPLE

illustrant quelques-uns de ces codes.

Claude Levesque Hans Bherer

directeur de recherche etudiant

i

Avant-propos

J’aimerais remercier mon directeur de recherche, le professeur Claude Levesque, pour son

excellente supervision et son soutien pedagogique. Je tiens aussi a remercier mon collegue

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 particulierement celui de

Nathalie et de Anne car c’est aussi grace a eux si j’ai pu poursuivre plus avant mes etudes.

Je dedie ce memoire a Michele.

ii

Table des matieres

Resume i

Avant-propos ii

1 Introduction 1

2 Remarques generales en theorie du codage 4

2.1 Definitions generales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4

2.2 Probabilites associees a la detection d’erreur . . . . . . . . . . . . . . . . . . 6

2.3 Probabilites associees a la correction d’erreurs . . . . . . . . . . . . . . . . . 6

2.4 Principe de la distance minimale pour le decodage . . . . . . . . . . . . . . . 8

2.5 Distance versus la detection et la correction d’erreurs . . . . . . . . . . . . . 10

2.6 Codes equivalents . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11

3 Le probleme central en theorie du codage 12

3.1 Le probleme central : Aq(n, d) . . . . . . . . . . . . . . . . . . . . . . . . . 12

3.2 Quelques bornes superieures sur Aq(n, d) . . . . . . . . . . . . . . . . . . . . 13

4 Codes lineaires 15

iii

TABLE DES MATIERES iv

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

4.2 Decodage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18

4.3 Distribution de poids et enumerateur de poids . . . . . . . . . . . . . . . . . 20

4.3.1 Distribution de poids et enumerateur de poids . . . . . . . . . . . . . 20

4.3.2 Une propriete de la distribution des poids d’un code lineaire binaire . 23

4.3.3 MacWilliams et l’existence de codes lineaires . . . . . . . . . . . . . . 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 lineaires cycliques 36

5.1 Structure . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36

5.2 Codage-decodage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43

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

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

5.5 Codes Residus Quadratiques . . . . . . . . . . . . . . . . . . . . . . . . . . . 53

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

6 Conclusion 61

A Programmes MAPLE 62

A.1 Enumerateur de poids . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62

TABLE DES MATIERES v

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

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

B Programmes MAPLE avec sorties 71

B.1 Enumerateur de poids . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71

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

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

Bibliographie 94

Table des figures

2.1 Le canal symetrique binaire . . . . . . . . . . . . . . . . . . . . . . . . . . . 5

vi

Liste des tableaux

1.1 Repetition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1

3.1 A2(n, d) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13

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

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

5.1 Syndromes de H2(3) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46

5.2 Syndrome necessaire de H2(3) . . . . . . . . . . . . . . . . . . . . . . . . . . 47

5.3 F24 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50

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

5.5 F23 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59

vii

Chapitre 1

Introduction

Le transfert d’informations prend de plus en plus d’importance dans notre societe. Que ce

soit pour la transmission de photographies de planetes eloignees, 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

eliminer les erreurs mais plutot pour les detecter et si possible les corriger. Afin d’illustrer

sommairement un code, exploitons une idee intuitive qui consiste a repeter 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 resister au bruit du canal, on peut coder

l’information en la repetant 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: Repetition

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 decodage 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 repondre a cette question que nous doterons nos codes de structures mathematiques

permettant de les analyser et meme de les creer. Nous voudrons alors obtenir des codes

permettant de coder le maximum de mots, de detecter et de corriger le maximum d’erreurs

tout en ayant la longueur la plus petite possible (rapidite de transmission). Plusieurs de ces

caracteristiques sont en conflit et l’elaboration de bons modeles mathematiques permet de

maximiser la satisfaction globale. Peut-on vraiment ameliorer la fiabilite des communications

a l’aide d’un code ? Afin de repondre a cette question, nous preferons presenter un exemple

qui, nous l’esperons, 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 detecte aucune erreur. Supposons

que la probabilite qu’un bit soit transmis sans erreur soit de 1 − 1108 et supposons que la

transmission se fasse a un taux de 107 bits par seconde. Alors la probabilite qu’un mot soit

transmis de facon incorrecte est

1 − P (0 erreur) = 1 −(

1 − 1

108

)11

≈ 11

108.

Cela implique qu’il y aura approximativement

11

108× 107

11= 0.1

mot par seconde qui sera transmis incorrectement sans etre detecte. Cela represente 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 egaux a 1 est impair, sinon il

vaut 0). On doit avoir au moins 2 erreurs dans notre mot afin que celui-ci soit mal interprete.

Cette probabilite est

1 − P (0 erreur) − P (1 erreur) = 1 −(

1 − 1

108

)12

−(

12

1

) (1 − 1

108

)11 (1

108

)1

≈ 66

1016.

Cela implique qu’il y aura approximativement

66

1016× 107

12= 5.5 × 10−9

mot par seconde qui sera transmis incorrectement sans etre detecte. Cela represente donc

une seule erreur a tous les 2000 jours !

CHAPITRE 1. INTRODUCTION 3

Dans ce memoire, nous presenterons les differentes structures algebriques utilisees en

theorie du codage pour les codes lineaires. Nous nous proposons de balayer la theorie en

largeur. Nous entendons par la de presenter l’ensemble des principaux codes ainsi que des

principales methodes de codage et de decodage. Nous optons pour un memoire qui ne se

specialise pas sur un code en particulier. Voulant etablir un lien direct entre la theorie et la

pratique, nous preferons opter pour des exemples de codes binaires plutot que sur un autre

corps. Cela n’est en aucun cas restrictif puisque nous presenterons notre theorie pour les

codes definis sur un corps fini quelconque.

Chapitre 2

Remarques generales en theorie du

codage

2.1 Definitions generales

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 appelee 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 appelee la longueur du code. Un code de longueur

n contenant M mots sera appele un (n, M)−code. Le corps fini a q elements sera note Fq .

L’espace vectoriel de dimension n sur Fq sera note Vn(Fq ).

Le taux d’un code sera defini par :

R =logq M

n.

Un canal discret sans memoire (C.D.S.M.) consiste en un alphabet A = {a1, ..., aq}d’entrees, un alphabet de sorties O = {b1, ..., bt} ou A ⊂ O, et un ensemble de probabilites

de canal P (bj|ai) satisfaisantt∑

j=1

P (bj|ai) = 1.

4

CHAPITRE 2. REMARQUES GENERALES EN THEORIE DU CODAGE 5

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

P (d|c) =

n∏i=1

P (di|ci).

A titre d’exemple, citons un des plus importants C.D.S.M., le canal symetrique binaire :

0

1

0

1

1-p

p

p

1-p

Fig. 2.1: Le canal symetrique binaire

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

Notations : La variable aleatoire X representera la distribution d’entrees alors que la

variable aleatoire Y representera la distribution de sorties. Le mot c sera le mot fourni en

entree et d representera la chaıne en sortie. Les probabilites seront notees de la facon 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 schema de decision est une fonction partielle f

f : On −→ 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 ete envoye, nous dirons qu’une erreur de decision a ete commise.


2.2 Probabilites associees a la detection d’erreur

Si des erreurs se produisent dans la transmission, elles seront detectees si et seulement si

le mot recu ne fait pas partie du code. Ainsi,

P (erreur non detectee|c est transmis) =∑d∈Cd6=c

P (d|c).

Ainsi, la probabilite de ne pas detecter une erreur est :

Perr non det =∑c∈C

∑d∈Cd6=c

P (d|c)P (c).

2.3 Probabilites associees a la correction d’erreurs

Pour tout schema de decisions, un mot c etant envoye, la probabilite d’une erreur de

decision est

P (erreur|c) =∑

d6∈f−1(c)

p(d|c);

ainsi la probabilite conditionnelle Pe d’une erreur de decision est

Pe =∑c

P (erreur|c)p(c) =∑c

∑d6∈f−1(c)

p(d|c)p(c).

On remarque que Pe est fonction du schema de decisions f de meme que de la distribution

d’entrees p(c). Dans le but de trouver un schema de decisions qui minimise Pe, calculons

cette erreur en conditionnant sur la sortie. Soit d la sortie du canal ; alors une bonne decision

sera effectuee si et seulement si f(d) est le mot d’entree, c’est-a-dire

P (erreur|d) = 1 − p(f(d)|d).

Pour toutes les sorties nous obtenons

Pe =∑d

p(erreur|d)p(d) = 1 −∑d

p(f(d)|d)p(d).

Comme p(d) ne depend pas du schema de decision f , Pe sera minimum en maximisant

p(f(d)|d) pour tout d ∈ On. Cela nous guidera donc dans la selection d’un schema de


decisions. Pour une distribution d’entrees donnee, tout schema de decisions f pour lequel

p(f(d)|d) = maxc∈C

p(c|d) ∀d ∈ On

est appele un schema de decisions d’observateur ideal et tout schema de decisions f

pour lequel

p(d|f(d)) = maxc∈C

p(d|c) ∀d ∈ On

est appele un schema de decisions de maximum de vraisemblance

Avant d’enoncer le theoreme de Shannon, qui est a la base meme de la theorie du codage,

nous avons besoin de deux theoremes ainsi que d’une definition appartenant a la theorie de

l’information et dont le lecteur trouvera demonstration dans [9].

Theoreme 2.1 Pour toutes les distributions d’entrees et parmi tous les schemas de

decisions, un schema de decisions d’observateur ideal minimise Pe.

Theoreme 2.2 Pour la distribution uniforme d’entrees, un schema de decisions d’ob-

servateur ideal est equivalent a un schema de decisions de maximum de vraisemblance.

Pour la suite, nous assumerons que la distribution d’entrees de notre canal est uniforme.

Definition 2.1 La capacite d’un canal binaire symetrique avec probabilite d’erreur p

est

C(p) = 1 + p log2 p + (1 − p) log2(1 − p).

Nous sommes maintenant en mesure d’enoncer le theoreme qui donna naissance a la

theorie du codage.

Theoreme 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 resultats similaires pour les codes non binaires mais dans

ces cas, la definition de la capacite differe. Nous sommes donc assures de l’existence de bons

codes dans la mesure ou nous sommes prets a diminuer le taux.


2.4 Principe de la distance minimale pour le decodage

Nous aimerions adopter un schema de decisions qui serait en accord avec un schema

decisionnel de maximum de vraisemblance. En effet, en supposant une distribution uniforme

d’entrees, on obtiendrait ainsi un schema equivalent a celui d’un observateur ideal et Pe serait

donc minimise. Nous allons montrer que c’est precisement ce que nous fournit le principe de

la distance minimale.

Definition 2.2 Soient x et y deux chaınes de meme longueur definies sur le meme

alphabet. La distance de Hamming d(x,y) est le nombre de positions ou x et y different.

Montrons que la distance de Hamming

d : An ×An → N

est bien une metrique et qu’ainsi (An, d) devient un espace metrique. 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 immediats. Prouvons le point 3. Soient

x = x1x2 . . . xn,

y = y1y2 . . . yn,

z = z1z2 . . . 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 resultat est immediat. �

Definition 2.3 Le poids wt(x) d’une chaıne x ∈ Vn(q) est le nombre de symboles

differents de 0 que contient x. Le poids minimal wt(C) est minc∈Cc6=0

wt(c).

Il est immediat de verifier que d(x,y) = wt(x − y).

Definition 2.4 La distance minimale d d’un code C est donnee par :

d(C) = minx,y∈Cx6=y

d(x,y).

Un (n, M)−code avec distance minimale d sera appele un (n, M, d)−code. Considerons

maintenant un canal binaire symetrique avec p < 12. Si le mot x est envoye et que la chaıne

y est recue, 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, decoder

en utilisant un schema de maximum de vraisemblance revient a choisir le mot x du code qui

est le plus pres de y. C’est ce que nous appelons le principe du decodage a distance

minimale. C’est le principe qui nous guidera dans nos procedures de decodages.

Enfin, la distance de Hamming nous permet de definir la notion de boule et de volume

sur l’espace An.

Definition 2.5 Soit x une chaıne de An, ou |A| = q et soit r un entier non negatif. La

boule de rayon r centree en x notee Sq(x, r) est l’ensemble

Sq(x, r) = {y ∈ An | d(x,y) ≤ r}.

Definition 2.6 Le volume de la boule Sq(x, r) note Vq(n, r) est le nombre d’elements

de Sq(x, r). Le volume est independent de x et est donne par

Vq(n, r) =

r∑k=0

(n

k

)(q − 1)k.


2.5 Distance versus la detection et la correction d’er-

reurs

Le but du codage est evidemment la detection et surtout la correction d’erreurs. Il nous

faut cependent definir ce que l’on entend par detection et correction d’erreurs dans le cadre

de la theorie du codage. Pour ce faire, nous utiliserons les definitions de distance de Hamming

et de distance minimale.

Definition 2.7 Soit t ≥ 1. Nous dirons qu’un code C detecte t erreurs si pour x ∈ C,

les chaınes y ∈ An verifiant x 6= y et d(x,y) ≤ t ne sont pas dans C.

Definition 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 detection, il est clair qu’un code C detectera t erreurs si et seulement

si t < d. Pour ce qui est de la correction, le resultat est moins evident et fera l’objet du

prochain theoreme.

Theoreme 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 equivalents

En theorie du codage on retrouve plusieurs definitions de codes equivalents. Nous adop-

terons la definition suivante :

Definition 2.9 Deux (n, M)−codes q-aires C1 et C2 sont equivalents s’il existe une

permutation σ des n coordonnees de chaque mot et des permutations π1, π2, . . . , πn de l’alpha-

bet telles que

c1c2c3 · · · cn ∈ C1 ⇐⇒ π1(cσ(1))π2(cσ(2))π3(cσ(3)) · · ·πn(cσ(n)) ∈ C2.

Autrement dit, deux codes C1 et C2 sont equivalents si nous pouvons obtenir l’un a

partir de l’autre en permutant les coordonnees de chacun des mots ou encore les symboles

de l’alphabet dans chacunes des positions de chacun des mots. Deux codes equivalents ont

evidemment les meme parametres.

Chapitre 3

Le probleme central en theorie du

codage

3.1 Le probleme 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

evidemment en conflit. On note Aq(n, d) la plus grande cardinalite M pour laquelle un

(n, M, d)−code sur Fq existe. Un code pour lequel M = Aq(n, d) sera dit optimal. Determi-

ner Aq(n, d) est appele le probleme central en theorie du codage. A titre indicatif, on

a quelques resultats connus pour A2(n, d) dans le tableau 3.1.

Afin d’etudier Aq(n, d), nous presentons ici les quatres principales bornes utilisees en

theorie du codage. L’utilisation de certaines bornes de concert avec l’identite de MacWilliams

nous permettra d’etudier l’existence ou la non-existence de certains codes lineaires de pa-

rametres donnes.

12

CHAPITRE 3. LE PROBLEME CENTRAL EN THEORIE 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 superieures sur Aq(n, d)

Dans le but de resoudre (pour certains parametres) le probleme central de la theorie

du codage, l’utilisation de certaines bornes pour Aq(n, d) s’avere tres utile. Nous presentons

ici quatre des bornes les plus utilisees et connues en theorie du codage. Nous fournirons la

demonstration pour les deux premieres et referons le lecteur a [7] pour les demonstrations

des deux autres.

Theoreme 3.1 (La borne de Singleton)

Aq(n, d) ≤ qn−d+1.

Preuve

Soit C un (n, M, d)−code. Si on enleve les d − 1 dernieres positions de chaque mot, on

obtient des mots de longueur n − d + 1. Ces mots sont tous differents car sinon la distance

minimale ne serait pas d. Ainsi, on obtient immediatement que M ≤ qn−d+1. �

Sachant que dans le cas d’un code lineaire nous avons que M = qk, nous obtenons alors

la tres importante relation : d ≤ n− k +1. Un code lineaire C pour lequel nous avons egalite

dans la borne de Singleton est appele un code separable de distance maximale.

Theoreme 3.2 (La borne de l’empilement des spheres)

Aq(n, d) ≤ qn∑tk=0

(nk

)(q − 1)k

, t =

⌊d − 1

2

⌋.

CHAPITRE 3. LE PROBLEME CENTRAL EN THEORIE DU CODAGE 14

Preuve

Soit C un (n, M, d)−code. Il est clair que M ·Vn(q, t) ≤ qn. Le resultat est alors immediat.�

Un code C pour lequel nous avons egalite dans la borne de l’empilement des spheres est

appele un code parfait.

Theoreme 3.3 (La borne de Plotkin) Soit θ = q−1q

. Si d > θn. Alors

Aq(n, d) ≤ d

d − θn.

Theoreme 3.4 (La borne d’Elias) Soit θ = q−1q

. Si r est un entier positif satisfaisant

r < θn et r2 − 2θnr + θnd > 0, alors

Aq(n, d) ≤ θnd · qn

r2 − 2θnr + θnd · Vq(n, r).

Chapitre 4

Codes lineaires

4.1 Structure et codage

Nous nous proposons maintenant de presenter la plus importante classe de codes : la

classe des codes lineaires.

Rappelons que notre alphabet de code A ne possede aucune structure particuliere. Si nous

voulons doter nos codes d’une certaine structure nous devons prealablement 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 considerer les mots du code comme des vecteurs de l’espace

vectoriel Vn(Fq ). 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

interesserons aux codes qui sont en fait des sous-espaces vectoriels de Vn(Fq ). Cela nous

conduit a la definition suivante.

Definition 4.1 Un code C ⊂ Vn(Fq ) est un code lineaire si C est un sous-espace vec-

toriel de Vn(Fq ). 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 lineaire alors qu’on utilise les parentheses pour un code en general).

15

CHAPITRE 4. CODES LINEAIRES 16

Montrons maintenant que pour un code lineaire C nous avons d(C)=wt(C) :

d(C) = minc,d∈Cc6=d

d(c,d) = minc,d∈Cc6=d

wt(c− d) = min06=c∈C

wt(c). �

Comme un code lineaire est en fait un espace vectoriel, il devient naturel de le representer

par une base. En theorie du codage on presente habituellement la base comme des vecteurs

lignes d’une matrice. Nous respecterons cette convention.

Definition 4.2 Soit C un [n, k]−code. Une matrice G de dimension k × n ayant pour

lignes une base de C est appelee la matrice generatrice du code (bien que nous disions

la matrice de generatrice, il faut comprendre qu’elle est unique a equivalence pres).

Il est immediat de verifier que le code C peut etre represente de la facon suivante :

C = {xG|x ∈ Vk(Fq )}.

La procedure de codage est alors triviale. Il suffit de coder le vecteur x de longueur k par le

mot xG du code.

Il peut s’averer utile d’avoir une matrice generatrice sous une forme speciale. Nous dirons

que G est sous la forme standard si G = (Ik|A). On peut aisement montrer que toute

matrice G peut etre transformee sous la forme standard sans changer le code (a equivalence

pres).

L’espace vectoriel Vn(Fq ) peut etre muni d’un produit scalaire de la facon suivante. Soient

x = x1 · · ·xn et y = y1 · · · yn, alors le produit scalaire de x et y nous est donne par :

〈x,y〉 = x1y1 + · · ·+ xnyn.

A l’aide de ce produit scalaire nous allons definir l’un des concepts fondamentaux de la

theorie du codage, soit le concept de code dual.

Definition 4.3 Soit C un [n, k]−code. Le code C⊥ defini par

C⊥ = {x ∈ Vn(q)|〈x, c〉 = 0 ∀c ∈ C}

est appele le code dual du code C.


Le theoreme suivant caracterise le code dual C⊥ associe au code C.

Theoreme 4.1 (Dual)

(1) Soit G une matrice generatrice de C. Alors C⊥ = {x ∈ Vn(Fq )|xGt = 0}.(2) Si C est un [n, k]−code alors C⊥ est un [n, n − k]−code.

(3) C⊥⊥ = C.

Preuve

(1) Decoule du fait que x ⊥ C ⇐⇒ x est perpendiculaire a tous les vecteurs d’une base

de C.

(2) Decoule de (1).

(3) Comme dim(C) = dim(C⊥⊥) et que C ⊂ C⊥⊥, alors C⊥⊥ = C. �

Nous avons montre que si C est un code lineaire alors C⊥ est aussi un code lineaire. Il

est naturel de nous demander si les deux matrices generatrices ne seraient pas reliees 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 generatrice du code C sous sa forme standard. Definissons

la matrice H = (−At|In−k) et montrons que H est la matrice generatrice de C⊥.

On verifie facilement que

GH t = (Ik|A)

( −A

In−k

)= −A + A = 0.

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 deduit que H est en fait une matrice generatrice du code

C⊥. La matrice H est aussi appele la matrice de controle du code C. Cette denomination

decoule du fait suivant :

x ∈ C ⇐⇒ xH t = 0.(4.1)

Il est a noter que la notion de matrice de controle et la propriete 4.1 s’avereront fondamentales

dans le processus de decodage.


On sait que la distance minimale d d’un code C est un parametre fondamental afin

de caracteriser un code. De plus, comme la capacite d’un code a corriger les erreurs est

directement reliee a d, il est interessant de remarquer qu’il est possible de determiner d si on

connaıt la matrice de controle H du code. C’est le but du prochain theoreme.

Theoreme 4.2 Soient C un [n, k, d]−code et H une matrice de controle du code C. La

distance d est le plus petit entier r pour lequel la matrice H contient r colonnes lineairement

dependantes.

Preuve

Soit x = x1 . . . xn ∈ Vn(Fq ) et soit Hj la j-ieme colonne de H. Alors

x ∈ C ⇐⇒ xH t = 0

⇐⇒ x1H1 + x2H2 + · · ·+ xnHn = 0.

Ainsi pour chaque mot de poids d, il existe un ensemble de d colonnes lineairement dependan-

tes. D’un autre cote, s’il existait un ensemble de d − 1 colonnes lineairement dependantes,

il existerait un mot de poids = d − 1 < d dans notre code. Cela contredirait le fait que

d = wt(C).�

4.2 Decodage

Une methode efficace de decodage peut etre construite a l’aide de la matrice de controle.

Cette methode s’appelle le decodage avec syndromes.

Definition 4.4 Soit C un [n, k]−code ayant H comme matrice de controle. Alors pour

tout x ∈ Vn(Fq ) on definit le syndrome de x, note syn(x), par

syn(x) = xH t.

On verifie immediatement que

syn(x) = 0 ⇐⇒ x ∈ C.


Voyons cette methode en details. Rappelons tout d’abord que l’espace quotient Vn(Fq )/Cest aussi un espace vectoriel sur Fq. Nous savons aussi que x + C = y + C ⇐⇒ x − y ∈ C.

Nous pouvons alors etablir un lien entre les classes modulo C et les syndromes de la facon

suivante.

Theoreme 4.3 Soit C un [n, k]−code ayant H comme matrice de controle. Alors

syn(x) = syn(y) ⇐⇒ x et y appartiennent a la meme classe de Vn(Fq )/C.

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 resultats precedents afin d’etablir une

methode de decodage en accord avec le principe de la distance minimale.

Supposons qu’un vecteur x (pas necessairement un mot du code) soit recu. Le principe

de la distance minimale nous demande de decoder x par c ∈ C ou c est le mot du code

C le plus pres (au sens de notre metrique) de x. Si e represente l’erreur de transmission,

nous obtenons alors que e = x − c. Chercher la distance minimale est alors equivalent a

minimiser wt(e). Comme syn(e) = syn(x − c) = syn(x) − syn(c) = syn(x), on en deduit

alors que e et x appartiennent a la meme classe modulo C. Si nous choisissons le mot de

poids minimal comme representant de chaque classe, e est alors le representant de la classe

de x. Nous pouvons alors decoder x comme le mot c du code ou c = x + e . Il suffit donc de

garder en memoire une table des representants de chaque classe modulo C ainsi que de leur

syndrome respectif.

Bien que cette methode puisse s’appliquer a tous les codes lineaires, il est souvent sou-

haitable de la modifier pour certains codes en particulier. On devine deja que plus le taux

R d’un code sera faible, plus le nombre de classes sera eleve. Maintenir une table de chaque

representant et de son syndrome peut ne s’averer d’aucune utilite en pratique. Pensons sim-

plement a un code de dimension k = 12 sur V24(F2). Le nombre de classes serait alors de224

212 = 212 = 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’interessera non seulement aux codes ayant certains

parametres donnes mais aussi et surtout aux codes admettant des procedures de decodage

simples et rapides.


4.3 Distribution de poids et enumerateur de poids

4.3.1 Distribution de poids et enumerateur 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.

Definition 4.5 Soit C un [n, k]−code de distribution (A0, . . . , An). Alors l’enumerateur

de poids est le polynome a deux inconnues

WC(x, y) =n∑

i=0

Aixn−iyi.

De plus, pour u ∈ Vn(Fq ), on definit

P (u) = xn−wt(u)ywt(u).

Nous obtenons ainsi

∑u∈C

P (u) =

n∑i=0

Aixn−iyi = WC(x, y).(4.2)

Il est important de noter que si on connaıt (A0, . . . , An) pour un certain code lineaire,

alors la distance devient facile a trouver car A0 = 1, Ai = 0 pour 1 ≤ i ≤ d − 1 et Ad ≥ 1.

Un des plus interessants resultats en regard de l’enumerateur de poids est certes l’identite

de MacWilliams qui relie l’enumerateur de poids d’un code lineaire C a l’enumerateur de poids

de son code dual C⊥.

Bien que l’identite de MacWilliams s’applique aux codes lineaires definis sur Fq , nous

ne nous interesserons ici qu’au cas ou le code lineaire est defini sur F2 . Afin de demontrer

l’identite de MacWilliams dans le cas binaire, deux lemmes seront necessaires.

Definition 4.6 Soit Vn = Vn (F2) un espace vectoriel binaire de dimension n. Pour

u ∈ Vn, definissons

gn(u) =∑v∈Vn

(−1)〈u,v〉P (v).


Lemme 4.1 Soit C un [n, k]−code binaire. Alors∑u∈C⊥

P (u) =1

|C|∑u∈C

gn(u).

Preuve

Nous avons ∑u∈C

gn(u) =∑u∈C

∑v∈Vn

(−1)〈u,v〉P (v)

=∑v∈Vn

P (v)S(v)

ou S(v) =∑

u∈C(−1)〈u,v〉, pour v ∈ Vn. Montrons que S(v) =

{|C| si v ∈ C⊥,

0 si v 6∈ C⊥.

Pour v ∈ Vn, soit C0(v) = {u ∈ C : 〈u,v〉 = 0}. Alors C0(v) est un sous-groupe de C(et meme un sous-espace vectoriel). Si w1,w2 ∈ C, 〈w1,v〉 = 1 et 〈w2,v〉 = 1, alors nous

avons que 〈w1−w2,v〉 = 0 et par consequent, w1−w2 ∈ C0. Cela implique que C1(v) defini

par C1(v) = {u ∈ C : 〈u,v〉 = 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

S(v) =∑

u∈C0(v)

(−1)0 = |C|.

Pour v 6∈ C⊥, nous avons |C0(v)| = |C1(v)| et comme C = C0(v)⋃ C1(v), nous avons

S(v) =∑

u∈C0(v)

(−1)〈u,v〉 +∑

u∈C1(v)

(−1)〈u,v〉 = 0.

Ainsi ∑u∈C

gn(u) =∑v∈C⊥

P (v)S(v) +∑v 6∈C⊥

P (v)S(v)

= |C|∑v∈C⊥

P (v). �

Lemme 4.2 Soit u ∈ Vn = Vn (F2). Alors

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


Preuve

Nous allons proceder par induction. Par definition, lorsque nous avons u ∈ Vn, nous avons

gn(u) =∑v∈Vn

(−1)〈u,v〉P (v).

Montrons que c’est vrai pour n = 1. En effet, pour u ∈ V1,

g1(u) = (−1)〈u,0〉P ((0)) + (−1)〈u,1〉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), u′ = (u1, . . . , uk), v

′ = (v1, . . . , vk). Alors nous avons

gk+1(u) =∑

v∈Vk+1vk+1=0

(−1)〈u,v〉P (v) +∑

v∈Vk+1vk+1=1

(−1)〈u,v〉P (v)

=∑v′∈Vk

(−1)〈u′,v′〉xk+1−w(v′)yw(v′) +

∑v′∈Vk

(−1)〈u′,v′〉+uk+1xk−w(v′)yw(v′)+1

= xgk(u′) + y(−1)uk+1gk(u

′)

= gk(u′)(x + y(−1)uk+1)

= (x + y)k−w(u′)(x − y)w(u′)(x + y(−1)uk+1) (d’apres l’hypothese d’induction)

= (x + y)k+1−w(u)(x − y)w(u)

en considerant uk+1 = 0, uk+1 = 1. �

Nous sommes maintenant prets a demontrer l’identite de MacWilliams sur F2 .

Theoreme 4.4 (Identite de MacWilliams sur F2) Soit C un [n, k]−code binaire.

Alors

WC⊥(x, y) =1

2kWC(x + y, x − y).

Preuve


Soit (A0, A1, . . . , An) la distribution des poids de C. Comme

∑u∈C⊥

P (u) =1

|C|∑u∈C

gn(u) (d’apres le lemme 4.1)

=1

|C|∑u∈C

(x + y)n−w(u)(x − y)w(u) (d’apres le lemme 4.2)

=1

|C|n∑

i=1

Ai(x + y)n−i(x − y)i

=1

|C|WC(x + y, x − y) (d’apres l’equation 4.2)

et comme d’apres l’equation 4.2,

∑u∈C⊥

P (u) = W⊥C (x, y),

nous avons le resultat voulu. �

4.3.2 Une propriete de la distribution des poids d’un code lineaire

binaire

Nous allons montrer une propriete interessante des codes lineaires binaires. Pour ce faire,

nous utiliserons le theoreme suivant.

Theoreme 4.5 Soit (G, +) un groupe abelien 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’enoncer le theoreme suivant.


Theoreme 4.6 Les mots d’un code lineaire binaire sont soit tous de poids pair ou soit

en nombre egal de poids pair et impair.

Preuve

Appliquer le theoreme precedent avec A = {mots de poids pairs}. �

4.3.3 MacWilliams et l’existence de codes lineaires

En theorie du codage on s’interesse souvent a l’existence d’un code de parametres donnes.

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 theoreme 4.6 nous obtenons seulement deux possibilites 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 polynomes de distribution de poids suivants :

Wc(x, y) = x7 + x2y5 + xy6 + y7,

Wc(x, y) = x7 + 2x2y5 + xy6.

En appliquant l’identite de MacWilliams afin d’obtenir le polynome de distribution de

poids du code dual nous obtenons respectivement :

Wc⊥(x, y) = 2x2y5 + 3xy6 + x7 − 2x6y + 13x5y2 + 15x3y4,

Wc⊥(x, y) = x7 − x6y + 8x5y2 + 10x4y3 + 5x4y4 + 7x2y5 + 2xy6.

Comme on sait que le dual d’un code lineaire est aussi un code lineaire, on en deduit 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 resultat 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 probleme central en theorie du codage est de determiner Aq(n, d). Si nous nous

interessons a Aq[n, d], nous disons alors que c’est le probleme central en theorie du co-

dage lineaire. Nous avons evidemment que Aq[n, d] ≤ Aq(n, d). De plus, nous savons que

Aq[n, d] = qk ou k est le plus grand entier pour lequel il existe un [n, k, d]−code sur Fq . C’est

donc dans le but de determiner Aq[n, d] que l’identite de MacWilliams peut nous venir en

aide. En effet, pour chacune des distributions possibles d’un code lineaire nous savons que

la distribution de son dual, qui nous est donnee par l’identite de MacWilliams, doit etre

la distribution d’un code lineaire. Si, etant donnee une distribution initiale, la distribution

du dual que nous donne MacWilliams n’est pas valide, on en deduit alors qu’il n’existe pas

de code lineaire ayant comme distribution la distribution initiale. En utilisant l’ordinateur

(voir le programme MAPLE en annexe) nous avons donc, pour un k donne, genere 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’etait pas valide,

nous avons obtenu une borne superieure pour k. Nos resultats sont presentes au tableau

4.1. En plus de nous aider a determiner Aq[n, d], notre methode nous donne aussi l’ensemble

des seules distributions possibles pour un [n, k, d]−code. Concretement, nous avons dans un

premier temps calculer une borne superieure pour k en nous basant sur les theoremes du

chapitre 3. Nous avons ameliore ces bornes dans quelques cas comme le montre le tableau

4.1. Nous avons meme fait quelques tests en forcant une valeur de k superieure aux bornes

theoriques et notre methode s’est encore averee efficace. Soulignons enfin que notre methode

ne nous garantit pas l’existence d’un code meme si elle nous permet eventuellement de sup-

poser son existence. Il serait interessant dans un travail futur d’explorer les liens entre une

distribution valide et l’existence concrete d’un code ayant cette distribution.


n d k (min. bornes theoriques) 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 F2

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 immediatement la distance minimale) d’un code

lineaire. L’idee 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

eleve (c’est d’ailleurs ce que nous recherchons), alors la dimension de son dual est petite. Il

devient alors facile d’enumerer les mots du dual et ainsi facilement obtenir le polynome 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 pres de 12, notre methode sera sans succes car les

dimensions du code et de son dual sont alors sensiblement les memes. Comme notre intention

est de trouver des codes pour lesquels le taux R est eleve, notre methode merite l’attention.

Appliquons notre methode a un exemple simple mais qui en illustre bien la philosophie.

Supposons que l’on s’interesse a la distribution de poids et a la distance minimale d’un

code ayant la matrice de controle suivante :

C =

1 0 1 0 1 0 1

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 presente

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 immediat de calculer Wc pour ce code.

Wc(x, y) = x7 + 7x3y4.

En appliquant l’identite de MacWillams on obtient :

Wc⊥(x, y) =1

8Wc(x + y, x− y) = x7 + 7x4y3 + 7x3y4 + y7.

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 lineaires qui corrigent une seule erreur. Bien qu’ils

peuvent etre definis sur Fq , nous ne presenterons ici que la version binaire (q = 2). La facon

traditionnelle de les presenter est de le faire via la matrice de controle ; c’est la facon que

nous allons utiliser. Le lecteur trouvera en annexe un programme MAPLE pour les codes de

Hamming.

Definition 4.7 Soir r un entier positif et soit H une matrice dont les colonnes sont les

vecteurs differents de zero de Vr(F2). Alors le code ayant H comme matrice de controle est

appele un code de Hamming binaire et est note H2(r).


Exemple.

Pour r = 3 nous obtenons (a equivalence pres)

H =

0 0 0 1 1 1 1

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 representation dyadique du nombre i). Nous justifierons ce choix un peu plus tard

lorsque nous parlerons du decodage des codes H2(r). Si nous avions voulu exhiber la matrice

generatrice du code, il est evident que nous aurions opte pour la representation sous forme

standard de H . Le theoreme suivant rend explicite les proprietes de H2(r).

Theoreme 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 egale a 3 ;

(3) C est un code parfait.

Preuve

(1) Comme nous avons que H2(r)⊥ est un [2r − 1, r]−code, le resultat suit.

(2) Comme H ne contient pas de colonne egale a zero et qu’il n’y a pas deux colonnes

identiques, on en deduit que d ≥ 3. Si on additionne les colonnes qui representent les nombres

1,2 et 3 en binaire, on obtient 0 ce qui implique que d = 3.

(3) Montrons que nous avons egalite pour la borne de l’empilement des spheres. Comme

nous avons que t = 1, n = 2r − 1 et que M = 2n−r, on obtient

2n−r

(1 +

(n

1

))= 2n−r(1 + n) = 2n−r(1 + 2r − 1) = 2n.

Ainsi, C est bien un code parfait. �

En ordonnant les colonnes de la matrice de controle H selon l’ordre naturel et en suppo-

sant qu’au plus une seule erreur de transmission s’est produite, on obtient une methode de

decodage tres elegante. En effet, si d est recu alors son syndrome dH t sera evidemment la


representation 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 controle la matrice

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

.

Supposons maintenant que nous transmettons le mot c = 000000011111111. Introduisons

maintenant une erreur et soit d = 001000011111111 le vecteur recu. Comme syn(d) =

dH t = 0011 et que 0011 represente la position 3, on en deduit que le mot envoye etait

c = 000000011111111, ce qui est bien le cas.

4.5 Codes de Golay

En 1948, Marcel Golay a introduit quatre codes lineaires notes G23,G24,G11 et G12 qui

sont maintenant appeles des codes de Golay. Nous nous interesserons, pour le moment,

seulement a G24. C’est le code qui a ete utilise pour la mission Voyager afin de transmettre des

photographies couleurs de Jupiter et de Saturne. Nous le definirons de la maniere classique en

donnant sa matrice generatrice. Notre but n’est pas de demontrer les proprietes de G24 mais

plutot de presenter le code ainsi qu’une methode de decodage tirant profit de la structure

du code. Comme nous l’avons mentionne precedemment, le principe de decodage necessitant

le calcul du syndrome de chaque classe modulo G24 s’avere souvent inutilisable en pratique.

Nous verrons que l’on peut decoder G24 d’une facon elegante, et ce, avec un nombre reduit de

calculs de syndromes. Pour la justification des parametres de G24 nous renvoyons le lecteur

a [7] et pour la justification de la methode de decodage, nous renvoyons le lecteur a [11].

Definition 4.8 Un code lineaire C est un code auto-dual si C = C⊥.

Definition 4.9 Le code de Golay G24 est un code binaire ayant comme matrice gene-


ratrice G = [I12 B] ou

B =

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

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 interet vient surtout du fait que les codes de Golay se pretent bien au decodage.

Comme nous l’avons deja mentionne, le decodage classique de G24 necessiterait une table

contenant 212 lignes. Voici maintenant un algorithme de decodage n’utilisant pas une telle

table. Nous allons bien entendu illustrer notre methode a l’aide de quelques exemples.

Voici la notation que nous utiliserons. La matrice generatrice est notee G et G = [I12 B].

La colonne i de B sera notee ci et la ligne i de B sera notee ri. Un 12-uplet binaire ou la

seule composante differente de zero est la composante i sera note x(i) ou y(i). Le mot envoye

sera note c et r sera le vecteur recu. Le vecteur nul de longueur 12 sera note 0 et la notation

(x,y) representera le vecteur de longueur 24 obtenu par la concatenation de x et y.

Algorithme de decodage (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 BT s.

(5) Si wt(BTs) ≤ 3, alors e = (0, (BT s)T ) et aller a (8).

(6) Si wt(BT s + rTi ) ≤ 2 pour un certain ri (1 ≤ i ≤ 12), alors e = (x(i), (BT s)T + ri) et

aller a (8).

(7) Imprimer <Au moins 4 erreurs se sont produites> et fin.

(8) Decoder r comme r − e = c et fin.

Comme on le remarque facilement, avec cette methode, nous avons un maximum de 24

syndromes a calculer ce qui est nettement plus efficace que si nous decodions 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 premiere rangee plus

la seconde rangee de G. Introduisons 2 erreurs. Supposons alors que le vecteur recu est

r = 10001000000010011101. On calcule s = GrT = (010010000000)T . Comme wt(s) ≤ 3,

on prend e = (sT , 0) = 010010000000000000000000 et on decode simplement par r − e =

110000000000100100011101, qui est bien le mot c envoye. Remarquons qu’un seul calcul de

syndrome a ete necessaire.

Exemple 2.

Soit c = 001100010000111011111001 le mot du code forme par la somme des rangees 3,4

et 8 de G. Supposons alors que le vecteur recu 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 BT s = (010111110111)T . Comme wt(BT s) > 3, on

cherche alors une rangee ri de B telle que wt(BT s+rTi ) ≤ 2. Pour i = 1 on obtient BT s+rT

1 =

(001000001000)T = yT . Ainsi, on choisit e = (x(1),y) = 100000000000001000001000 et on

decode simplement par r − e = 001100010000111011111001, qui est bien le mot c envoye.

Remarquons que nous avons eu besoin de seulement 15 calculs de syndromes ce qui est encore

loin de 212.


4.6 Codes de Reed-Muller

Les codes de Reed-Muller sont habituellement definis a l’aide de la matrice generatrice du

code et nous respecterons cette convention. Nous allons, dans un premier temps, presenter

les codes de Reed-Muller comme des extensions des codes de Hamming. Ce seront les codes

de Reed-Muller du premier ordre. Dans un deuxieme temps nous presenterons une definition

recursive des codes de Reed-Muller d’ordre m. Nous faisons volontairement ce choix afin de

montrer que certains codes sont des generalisations d’autres codes ou encore que la facon

de definir un code n’est pas unique. Dans le cas des codes de Reed-Muller du premier ordre

nous exhiberons explicitement leurs parametres alors que pour les code Reed-Muller d’ordre

m nous renvoyons le lecteur a [7] pour les demonstrations. 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 planete Mars en 1972.

Soit Hr la matrice de controle 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 zeros.

Soient v1,v2, . . . ,vr les rangees de Br et soit enfin 1 le vecteur ligne de longueur 2r dont

toutes les composantes sont egales a 1. Nous pouvons alors definir les codes de Reed-Muller

du premier ordre de la facon suivante.

Definition 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 generatrice de

RM(1, r) est alors

G =

[1

Br

]=

[1

Hr 0

].

Exemple 1.

Construisons la matrice generatrice de RM(1, 3). Comme

H3 =

0 0 0 1 1 1 1

0 1 1 0 0 1 1

1 0 1 0 1 0 1

,


nous avons alors

B3 = [H3 0] =

0 0 0 1 1 1 1 0

0 1 1 0 0 1 1 0

1 0 1 0 1 0 1 0

.

Nous en deduisons donc que

G =

[1

Br

]=

[1

Hr 0

]=

1 1 1 1 1 1 1 1

0 0 0 1 1 1 1 0

0 1 1 0 0 1 1 0

1 0 1 0 1 0 1 0

.

Nous pouvons alors facilement verifier que RM(1, 3) est un [8, 4, 4]−code.

Nous aimerions maintenant montrer que le parametre r determine tous les autres pa-

rametres du code. C’est l’objet du prochain theoreme.

Theoreme 4.8 RM(1, r) est un [2r, r + 1, 2r−1]−code.

Preuve

Comme la matrice G possede 2r colonnes, la longueur du code est evidemment 2r. Comme

les vecteurs 1,v1,v2, . . . ,vr sont lineairement independants, on en deduit que la dimension

est egale a r + 1. Il nous reste alors a montrer que la distance d du code est egale a 2r−1.

Pour cela, nous montrerons que tous les mots du code (sauf 0 et 1) ont un poids egal a 2r−1.

Tout mot c 6= 0 du code s’ecrit

c = ri1 + ri2 + · · ·+ rih

ou rij est la ij-ieme rangee de G, 1 ≤ h ≤ r + 1. Supposons qu’aucun rij n’est egal a 1 et

considerons alors la matrice

A =

ri1

ri2...

rih

.

Maintenant, la composante t de c sera 0 si la t-ieme colonne de A possede 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-ieme composante,

1 ≤ j ≤ h, est la meme 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 definition de Br). On obtient donc

que chaque colonne distincte de A apparaıt precisement 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 egal a celui de poids impairs, on obtient que exactement la moitie des

composantes de c sont egales a 1 et ainsi que wt(c) = 2r−1.

Si par contre nous avons que rij = 1, alors il suffit de considerer c − 1. Ainsi le meme

argument peut etre applique (il s’applique a tout mot different 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 definition des codes de Reed-Muller d’ordre m.

Definition 4.11 Un code de Reed-Muller d’ordre m et de longueur 2r ou 0 ≤m ≤ r, note RM(m, r), est le [2r,

∑mi=0

(ir

), 2r−m]−code defini recursivement de la facon

suivante :

RM(0, r) = {00 . . . 0, 11 . . . 1},RM(r, r) = V2r(F2),

RM(m, r) = {(x,x + y)|x ∈ RM(m, r − 1),y ∈ RM(m − 1, r − 1)}, (0 < m < r).

Plutot que d’utiliser cette description du code, nous allons donner une methode recursive

permettant de construire la matrice generatrice de RM(m, r). Nous noterons cette matrice

G(m, r). Pour 0 < m < r, on definit

G(m, r) =

[G(m, r − 1) G(m, r − 1)

0 G(m − 1, r − 1)

].

Pour m = 0 on definit la matrice 1 × 2r suivante

G(0, r) =[

11 . . . 1]

et pour m = r on definit la matrice 2r × 2r suivante

G(r, r) =

[G(r − 1, r)

0 . . . 01

].


Exemple 2.

Utilisons cette methode afin de determiner G(1, 3) (c’est la matrice G de l’exemple 1).

On obtient

G(1, 3) =

[G(1, 2) G(1, 2)

0 G(0, 2)

]

ou

G(1, 2) =

[G(1, 1) G(1, 1)

0 G(0, 1)

]et G(0, 2) =

[1 1 1 1

]avec

G(1, 1) =

[1 1

0 1

]et G(0, 1) =

[1 1

].

On obtient alors

G(1, 3) =

1 1 1 1 1 1 1 1

0 1 0 1 0 1 0 1

0 0 1 1 0 0 1 1

0 0 0 0 1 1 1 1

qui est bien (a equivalence pres) la matrice G de l’exemple 1.

Chapitre 5

Codes lineaires cycliques

5.1 Structure

Une des classes de codes lineaires les plus importantes est la classe des codes cycliques.

Afin de bien les definir, le concept de sous-espace cyclique nous sera necessaire.

Definition 5.1 Un sous-espace S de Vn(Fq ) est un sous-espace cyclique si

(a1, a2, . . . , an) ∈ S ⇒ (an, a1, . . . , an−1) ∈ S.

Ainsi, on obtient la definition suivante pour un code lineaire cyclique.

Definition 5.2 Un code lineaire C est cyclique s’il est un sous-espace cyclique.

La construction et l’existence de codes cycliques se ramene 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 Fq [x] et Fq [x]�<f(x)> sont des anneaux

principaux. De plus, nous savons qu’il y a un isomorphisme entre Vn(Fq ) et l’anneau des

polynomes de degre inferieur a n sur Fq note F(n)q [x] := Fq [x]�<f(x)>, ou f(x) est un polynome

de degre n. Cet isomorphisme nous permet de considerer indifferement un mot de C comme

un vecteur de Vn(Fq ) ou comme un polynome de F(n)q [x] de la facon suivante :

v = a1a2 . . . an ∈ Vn(Fq ) 7−→ v(x) = a1 + a2x + · + anxn−1 ∈ F(n)q [x],

36

CHAPITRE 5. CODES LINEAIRES CYCLIQUES 37

Lorsque f(x) = xn − 1, on notera Fq [x]�<xn−1> par Rn.

Theoreme 5.1 Un sous-ensemble non-vide S de Vn(Fq ) est un sous-espace cyclique si

et seulement si l’ensemble des polynomes I associes a S est un ideal dans l’anneau des

polynomes F(n)q [x] associe a Vn(Fq ).

Preuve

⇒

Par hypothese, S est cyclique. Le fait que (I, +) est un groupe abelien decoule 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 λ ∈ Fq . Ainsi λxiv(x) ∈I pour tout λ ∈ Fq , pour 0 ≤ i ≤ n − 1. Ainsi a(x)v(x) ∈ I ou a(x) =

∑n−1j=0 λjx

j ∈ F(n)q [x].

⇐

Par hypothese, I est un ideal 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 polynome constant. Donc S

est un sous-espace. Comme la multiplication par x revient a un decalage cyclique et que I

est un ideal, on deduit directement que S est cyclique. �

Theoreme 5.2 Soit I 6= (0) un ideal de Rn ou f(x) = xn − 1. Soit g(x) un polynome

unitaire de plus petit degre tel que [g(x)] represente une classe modulo I. Alors [g(x)] (que

nous pourrons noter g(x) par abus d’ecriture) genere I et de plus g(x)|xn − 1.

Preuve

Le fait que I =< g(x) > decoule 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 polynome est unique.

Theoreme 5.3 Il y a un unique polynome unitaire g(x) de plus petit degre (≤ n − 1)

qui engendre tout ideal 6= (0) de F(n)q [x].

Preuve

Soit g(x) et h(x) ∈ Fq [x] de plus petit degre et unitaires tels que

< [g(x)] >=< [h(x)] >= I ⊂ F(n)q [x].

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 resultat suit. �

Ainsi nous parlerons maintenant du polynome unitaire g(x) de plus petit degre qui

engendre I.

Definition 5.3 g(x) est appele le polynome generateur de l’ideal I de Rn.

Theoreme 5.4 Soit h(x) un polynome unitaire diviseur de f(x) = xn − 1. Alors h(x)

est le generateur de l’ideal I = {a(x)h(x) : a(x) ∈ Rn} .

Preuve

Soit g(x) le generateur de I. Nous savons que g(x)|f(x). De plus, comme g(x) ∈ I, il

existe un polynome 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 polynome 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 generateur. Comme les deux

sont unitaires, on conclut que g(x) = h(x). �

Comme on sait qu’un code C peut etre engendre par un polynome different de son po-

lynome generateur, la notation C =< g(x) > n’impose pas que g(x) soit l’unique polynome

unitaire de degre minimal qui genere C. Nous introduisons alors la notation C =�g(x)� qui

signifie que dans ce cas on impose a g(x) d’etre l’unique polynome unitaire de degre minimal

qui genere C. Il est clair que �g(x)� et < g(x) > representent en fait le meme code C.


Ainsi en combinant nos resultats precedents, nous obtenons notre resultat principal a

savoir :

Il y a une bijection entre les sous-espace cycliques de Vn(Fq )

et les polynomes unitaires g(x) ∈ F(n)q [x] qui divisent f(x) = xn − 1.

Comme nous l’avons fait pour les codes lineaires, nous aimerions exhiber une base de

chacun de nos sous-espaces vectoriels cycliques et ainsi obtenir la matrice generatrice du

code associe. Le theoreme suivant repond a cette attente.

Theoreme 5.5 Soit g(x) un polynome unitaire qui divise xn−1 sur Fq et ou deg g(x) =

n − k. Alors g(x) est le polynome generateur d’un sous-espace vectoriel cyclique de Vn(Fq )

de dimension k.

Preuve

Soit S un sous-espace vectoriel de Vn(Fq ) genere par g(x). Soit

B ={g(x), xg(x), . . . , xk−1g(x)

}.

Afin d’obtenir notre resultat nous allons montrer que B est une base.

Premierement, on suppose que

k−1∑i=0

λixig(x) = 0, λi ∈ Fq .

De cette equation, on voit facilement que le seul terme pouvant avoir xn−1 est λk−1xk−1g(x)

et comme le degre de xk−1g(x) est inferieur a n, cela implique que λk−1 = 0. On en deduit

que λi = 0, 0 ≤ i ≤ k − 1. Donc B est lineairement independant.

Deuxiemement. Soit h(x) ∈ S. Alors h(x) = a(x)g(x) ou sans perte de generalite

deg a(x) < k. Alors

a(x) =

k−1∑i=0

λixi et h(x) =

k−1∑i=0

λixig(x),

de sorte que B engendre S. �


Maintenant que nous sommes en mesure de construire la matrice generatrice associee a

un code lineaire cyclique. Nous aimerions exhiber la matrice de controle du meme code. Pour

cela, il nous faut definir le polynome de controle d’un code lineaire cyclique.

Soit g(x) le polynome generateur de degre r d’un code lineaire cyclique de parametres

[n, n− r]. Aussi, nous savons que xn −1 = g(x)h(x) ou h(x) est un polynome de degre n− r.

Le polynome h(x) est appele le polynome de controle du code C ayant comme generateur

g(x). Le theoreme suivant montre comment a l’aide de h(x) nous pouvons obtenir la matrice

de controle.

Theoreme 5.6 Soit h(x) le polynome de controle d’un code lineaire cyclique C dans

Rn.

(1) Le code C peut etre represente par

C = {p(x) ∈ Rn|p(x)h(x) ≡ 0}.

(2) Soit h(x) = h0 + h1x + · · · + hn−rxn−r. Alors une matrice de controle du code C est

donnee par

H =

hn−r · · · h0 0 0 · · · 0

0 hn−r · · · h0 0 · · · 0

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 polynome generateur est

donne par

h⊥(x) = h−10 xn−rh(x−1) = h−1

0 (h0xn−r + h1x

n−r−1 + . . . + hn−r).

Preuve

(1) Soit g(x) le polynome generateur 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 ecrire 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 etre

nuls, nous obtenons :

c0hn−r + c1hn−r−1 + · · · + cn−rh0 = 0

c1hn−r + c2hn−r−1 + · · · + cn−r+1h0 = 0...

......

...

cr−1hn−r + crhn−r−1 + · · · + cn−1h0 = 0

Ce systeme est equivalent a (c0, c1, . . . , cn−1)H⊥ = 0. On en deduit alors que H est

la matrice generatrice d’un code C∗ qui est orthogonal a C. Ainsi C∗ ⊂ C⊥. Comme

hn−r 6= 0, nous deduisont 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 generateur d’un code

cyclique C =< h⊥(x) > ayant H comme matrice generatrice 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−rh(x−1)xrg(x−1) = 1 − xn,

ceci montre alors que h⊥(x)|xn − 1. �

Comme nous venons de le voir, une fois le polynome xn−1 factorise en polynomes unitaires

irreductibles, la construction d’un code lineaire cyclique est chose relativement aisee.

Avant d’aborder le codage et le decodage des codes lineaires cycliques ainsi que les codes

eux-memes, il nous faut voir une autre facon de representer un code lineaire cyclique, soit a

travers la notion de zeros d’un code.

Definition 5.4 Les zeros d’un code lineaire cyclique sont les racines de son polynome

generateur.

Comme la factorisation de xn − 1 sur Fq joue un role important dans l’elaboration de

la theorie des codes lineaires cycliques, nous nous permettons de rappeler certains faits

concernant cette factorisation. Nous savons que

xn − 1 =∏

i

mi(x)


ou les mi(x) sont des polynomes irreductibles sur Fq . Si ω est une racine primitive n-ieme

de l’unite sur Fq , nous savons que les racines du polynome mi(x) sont conjuguees. Elles sont

de la forme {ωi, ωiq, . . . , ωiqd−1} ou d est le plus petit entier positif tel que iqd ≡ i mod n.

L’ensemble Ci = {i, iq, . . . , iqd−1} est alors appele la i-ieme classe cyclotomique de q

modulo p. On obtient alors

mi(x) =∏j∈Ci

(x − ωj).

Voyons maintenant comment definir un code a l’aide de la notion de zeros.

Soit xn−1 =∏

i mi(x) ou les mi(x) sont des polynomes unitaires irreductibles sur Fq . Soit

α une racine de mi(x) dans un corps de decomposition de Fq . Ainsi mi(x) est le polynome

minimal de α sur Fq . Si f(x) ∈ Fq [x] et que f(α) = 0 alors f(x) = a(x)mi(x) pour un certain

a(x). En particulier, si f(x) ∈ Rn, alors f(α) = 0 ⇐⇒ f(x) ∈�mi(x)�.

Voyons comment appliquer cela aux codes lineaires cycliques. Soit g(x) = q1(x) · · · qt(x)

(ou les qi(x) sont des facteurs irreductibles 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

polynome generateur g(x) sera evidemment le ppcm des polynomes minimaux associes aux

αi. A l’aide de cette representation, il est tres facile d’obtenir la matrice de controle. Voyons

comment la construire.

Soit {α1, . . . , αn} un ensemble de racines de xn−1 appartenant au corps de decomposition

Fqd . Soit f(x) =∑

ajxj ∈ Rn. Alors f(αi) = 0 si et seulement si

∑j ajα

ji = 0. Voyons

maintenant Fqd comme l’espace vectoriel Vd(Fq ) de dimension d sur Fq . Notons [αji ] le vecteur

colonne de longueur d sur Fq . De plus, comme aj ∈ Fq nous obtenons

[ajαji ] = aj[α

ji ]


et ainsi ∑j

aj [xji ] =

[∑j

ajαji

]= 0.

Definissons alors la matrice H de dimension ud × n de la facon suivante :

H =

[α01] [α1

1] . . .[αn−1

1

][α0

2] [α12] . . .

[αn−1

2

]...

......

[α0u] [α1

u] . . . [αn−1u ]

,

et definissons f = (a0, . . . , an−1). Nous obtenons alors

f(αi) = 0 pour i = 1, . . . , u ⇐⇒ fHT = 0.

En supprimant les lignes lineairements dependantes, nous obtenons ainsi une matrice de

controle pour le code ayant {α1, . . . , αu} comme zeros.

Cette representation nous sera fort utile lors de la definition des codes BCH, RS et des

codes de Goppa.

Avant de passer a un exemple illustrant toute la theorie developpee jusqu’ici pour les

codes lieaires cycliques, nous allons voir comment coder et decoder avec un code cyclique.

5.2 Codage-decodage

Soit C =� g(x) � un [n, n − r]−code q-aire cyclique (le degre de g(x) est alors egal

a r). Ainsi, nous pouvons coder des messages de longueur n − r auxquels seront ajoutes

r symboles de verification. Soit le message a0a1 · · ·an−r−1 auquel on associe le polynome

a(x) = a0xn−1 + a1x

n−2 + . . . + an−r−1xr. 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 meme

degre, le codage est alors systematique. Par codage systematique on entend qu’en lisant le

mot en partant de la plus grande puissance de r, on verifie facilement que les n−r premieres

positions contiennent l’information alors que les r dernieres contiennent les symboles de

verification.


Comme un code cyclique est un code lineaire, nous pouvons utiliser la meme procedure

de decodage que celle utilisee pour nos codes lineaires a savoir la methode du syndrome.

Ainsi si c(x) ∈ C est le mot envoye et que u(x) est recu, err(x) = u(x) − c(x) est le

polynome erreur. Nous definirons le poids d’un polynome comme le nombre de coefficients

differents de zero. Il nous reste maintenant a voir ce que l’on entend par le syndrome d’un

polynome.

Definition 5.5 Soit C =� g(x) � un [n, n − r]−code q-aire cyclique. Le syndrome

d’un polynome 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 definition de syndrome est equivalente a celle presentee pour

nos codes lineaires.

Passons maintenant a un exemple permettant d’illustrer tout ce qui precede.

Exemple

Nous voulons contruire un code cyclique de parametres [7, 4] = [7, 7 − 3] sur F2 (si c’est

possible !). (On reconnaıt ici les parametres du code de Hamming H2(3)). Ce code lineaire

est-il cyclique ? Oui !

Il faut d’abord factoriser x7 − 1 sur F2 . Nous obtenons

(x7 − 1) = (x + 1)(x3 + x + 1)(x3 + x2 + 1).

Pour obtenir un code de parametres [7, 4], il nous faut donc un facteur irreductible de degre 3

qui divise x7 − 1. Nous avons alors deux choix pour le polynome generateur. Choisissons

g(x) = x3 + x + 1. Nous obtenons alors un code cyclique C =� g(x) � de dimension

7 − 3 = 4 et ayant pour matrice generatrice la matrice suivante

G =

1 1 0 1 0 0 0

0 1 1 0 1 0 0

0 0 1 1 0 1 0

0 0 0 1 1 0 1

.


Afin d’obtenir notre matrice de controle, calculons h⊥(x). (Nous savons que dim(C⊥) = 3.)

Il nous faut alors le polynome h(x) satisfaisant x7 − 1 = g(x)h(x). Ainsi h(x) = (x+1)(x3 +

x2 + 1) = x4 + x2 + x + 1. On en deduit alors que h⊥(x) = x4 + x3 + x2 + 1. Nous obtenons

ainsi la matrice de controle H suivante

H =

1 0 1 1 1 0 0

0 1 0 1 1 1 0

0 0 1 0 1 1 1

.

On verifie alors facilement que GHT = 0. Comme nous pouvons le constater, la matrice

H comporte tous les vecteurs non nuls de F32 comme colonnes. Ainsi c’est bien la matrice de

controle du code H2(3). Essayons maintenant d’obtenir H avec la methode des zeros.

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 controle. Faisons quelques observations.

Le polynome x3 + x + 1 etant primitif, il possede donc β comme racine ou β est un

generateur de F∗q . Ainsi H devient

H =[β0 β1 β2 β3 β4 β5 β6

].

Comme β est un element primitif, on obtient facilement que

H =

1 0 0 1 0 1 1

0 1 0 1 1 1 0

0 0 1 0 1 1 1

,

qui est equivalente a celle calculee avec notre autre methode. Le code H2(3) est donc cyclique !

Montrons explicitement comment coder avec ce code. Supposons que l’on desire envoyer

le mot 1001. Ce mot correspond au polynome 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 verifions notre methode de decodage. Pour cela, formons une table de syndromes

et de representants de classes. Comme H2(3) corrige une seule erreur, il corrige les err(x)

de poids egaux a 1. Le tableau 4.1 presente cette table.

representants de classes syndromes

0 0

1 1

x x

x2 x2

x3 x + 1

x4 x2 + x

x5 x2 + x + 1

x6 x2 + 1

Tab. 5.1: Syndromes de H2(3)

Supposons alors que ayant transmis c(x) = x + x2 + x3 + x6, nous ayons recu u(x) =

x + x3 + x6. Calculons son syndrome. Or

x6 + x3 + x = (x3 + x)(x3 + x + 1) + x2.

Donc syn(u(x)) = x2. Le representant de la classe de x2 etant x2, on decode u(x) de la facon

suivante :

c(x) = u(x) − x2 = x + x2 + x3 + x6

= 0111001,

qui est bien le mot qui avait ete envoye.

Tel que nous l’avions mentionne avec les codes lineaires, un tel principe de decodage

necessite la tenue d’une table de representants de classes qui peut devenir tres longue. Ainsi


nous sommes en droit de nous demander si une methode de decodage tirant profit de la

structure cyclique du code n’aurait pas pour effet d’ameliorer le decodage. La reponse est

evidemment oui. Explicitons cette methode que nous appliquerons a notre exemple.

Voici le principe de cette nouvelle methode. Supposons que l’on est capable de decoder

le coefficient de xn − 1. On pourrait, decoder ce coefficient, puis effectuer une permutation

circulaire, et decoder 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 representant

de la classe est de degre egal a n − 1.

Appliquons cette methode a notre exemple. La table en devient alors une qui ne compte

representant de classe syndrome

x6 x2 + 1

Tab. 5.2: Syndrome necessaire 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 deduit 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 x2u(x) = x5 + x3 + x ou x5 + x3 + x = x2(x7 + x + 1) + x + x2. Ainsi

syn(x2u(x)) = x + x2 ; alors le coefficient de x4 est correct.

Calculons x3u(x) = x6 + x4 + x2 ou x6 + x4 + x2 = x3(x3 + x + 1) + x3 + x2. Ainsi

syn(x3u(x)) = x3 + x2 ; alors le coefficient de x3 est correct.

Calculons x4u(x) = x7 + x5 + x3 = x5 + x3 + 1 ou x5 + x3 + x = x2(x3 + x + 1) + x2 + 1.

Ainsi syn(x4u(x)) = x2 + 1 ; alors le coefficient de x2 est inexact.

Ainsi, on decode u(x) = x6 + x3 + x comme u(x) − x2 = x6 + x3 + x2 + x. Qui est bien

notre mot de depart !


La theorie portant sur les codes lineaires cycliques ayant ete exposee et illustree par un

exemple, passons maintenant a la descriptions des cinq principaux codes lineaires cycliques.

5.3 Codes BCH

Les codes BCH (Bose, Ray-Chaudhuri, Hocquenghem 1960) forment une tres importante

classe de codes lineaires cycliques. Leur distance est facile a minorer, les mots peuvent etre

encodes et les vecteurs, decodes de facon relativement simple. Le lecteur trouvera en annexe

un programme MAPLE pour les codes BCH.

Definition 5.6 Soit ω une racine n-ieme primitive de l’unite sur Fq et soit g(x) le

polynome unitaire de plus petit degre sur Fq 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 planifiee δ. De plus, lorsque b = 1

nous dirons que nous avons un code BCH strict et nous le noterons par Bq(n, δ, ω). Si

n = qs − 1 pour un certain s ≥ 1 nous dirons alors que le code BCH est un code BCH

primitif (car ω est alors un element primitif de Fqs ).

Nous allons maintenant montrer que le choix de δ nous donne une borne inferieure pour

la distance d du code.

Theoreme 5.7 (La borne BCH) Soit ω une racine n-ieme primitive de l’unite sur

Fq . Soit C un code cyclique et soit g(x) son polynome generateur. Si pour un certain b ≥ 0

et un certain δ ≥ 1 nous avons

g(ωb) = g(ωb+1) = · · · = g(ωb+δ−2) = 0,

alors la distance minimale du code C est superieure ou egale a δ.

Preuve

Si c = c0c1 . . . cn−1 ∈ C, alors pour c(x) = c0 + c1x + · · · + cn−1xn−1, on a

c(ωb) = c(ωb+1) = · · · = c(ωb+δ−2) = 0,


et ainsi on obtient que H∗ct = 0 ou

H∗ =

1 ωb ω2b · · · ω(n−1)b

1 ωb+1 ω2(b+1) · · · ω(n−1)(b+1)

......

......

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 lineairement independantes sur Fqm . 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

ωa1b ωa2b · · · ωawb

ωa1(b+1) ωa2(b+1) · · · ωaw(b+1)

......

...

ωa1(b+w−1 ωa2(b+w−1 · · · ωaw(b+w−1)

ca1

ca2

...

caw

= 0.

Le determinant de la matrice de gauche doit alors etre nul. Ce determinant est cependant

egal a ω(a1+···+aw)b multiplie par le determinant 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 determinant de cette matrice

n’est pas nul et qu’ainsi le resultat suit. �

La construction d’un code BCH revient a exhiber son polynome generateur g(x). Nous

devons etre en mesure de trouver g(x) a partir des racines n-iemes de l’unite utilisees pour

le definir. Nous expliciterons la demarche par deux exemples de construction de codes BCH.

Nous avons choisi nos exemples de facon a ce que le corps de decomposition soit F24 . Nous

avons alors construit F24 avec le polynome primitif f(x) = x4 + x + 1 ou α est une racine de

f(x). Le tabeau 5.3 presente ce corps.

Exemple 1.

Nous voulons construire un code BCH strict de longueur egale a 15 et de distance planifiee

egale a 7 sur F2 . Remarquons que nous sommes en presence d’un code BCH primitif car


α, racine de x4 + x + 1 F24

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: F24

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-ieme de l’unite. Comme notre code est primitif, nous pouvons

prendre ω = α ou α est un element primitif de F24 . 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 F24 , 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 deduit que la distance d est egale a 7 (egale a la distance

planifiee). De plus, comme le degre de g(x) est egale 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 egale a 5 et de distance planifiee

egale a 3 sur F2 . Remarquons que nous sommes en presence d’un code BCH qui n’est pas

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-ieme de l’unite. Comme le plus petit entier r satisfaisant

5|2r − 1 est 4, on en deduit que ω ∈ F24 . De plus, comme 24−15

= 3, on en deduit que l’on

peut prendre ω = α3 ou α est un element primitif de F24 . On obtient alors

g(x) = (x − α3)(x − α6)(x − α9)(x − α12).

En utilisant notre construction de F24 , nous obtenons

g(x) = 1 + x + x2 + x3 + x4.

Il est interessant de remarquer que nous avions δ = 3 mais que δ = 5 produit le meme

code. Comme wt(g(x)) = 5, on en deduit que la distance d est egale a 5. Nous avons alors

construit un code BCH qui est un [5, 1, 5]−code (bien entendu tout cela etait previsible en

regardant la factorisation de x5 − 1 en facteurs irreductibles sur F2).


5.4 Codes de Reed-Solomon

Les codes de Reed-Solomon (RS) forment une classe particuliere des codes BCH. La

NASA les utilise depuis 1977 dans differentes missions spatiales. Ils ont, par exemple, ete

utilises dans les missions de Galilee, Magellan et Ulysse. La sonde Voyager II les a utilises

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 etre utilises afin de corriger un eclat d’erreurs (ce qui explique

leur choix pour l’enregistrement des disques compacts).

Definition 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.

xn − 1 = xq−1 − 1 =∏α∈F∗q

(x − α)

Ainsi, si ω est une racine (q − 1)-ieme primitive de l’unite, on obtient alors que le code RS

de distance planifiee δ admet comme polynome generateur le polynome

g(x) = (x − ωb)(x − ωb+1) · · · (x − ωb+δ−1)

ou b ≥ 0.

Dans le cas des codes RS, la distance planifiee presente une caracteristique interessante.

Cette caracteristique fait l’objet du prochain theoreme.

Theoreme 5.8 La distance minimale d d’un code RS est egale a sa distance planifiee δ.

Preuve

Soit g(x) le polynome generateur d’un code RS de distance planifiee δ. Nous avons alors

que deg(g(x))= δ−1 et donc que la dimension k du code est egale 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 separables de distance maximale.


Preuve

(d = δ = n − k + 1). �

La principale caracteristique des codes RS est qu’ils permettent de corriger un eclat

d’erreurs. Nous n’avons qu’a penser a une egratignure sur un disque compact afin de nous

convaincre que dans ces cas, les eclats d’erreurs sont frequents. Voyons comment utiliser un

code RS afin de corriger un eclat d’erreurs.

Les codes RS pour lesquels q = 2m sont des codes C definis sur F2m . Ce sont donc des

[n, k]−codes q-aires. Voyons maintenant F2m comme Fm2 . Le meme 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 F2m alors que dans le deuxieme cas, le code C+ est un espace vectoriel de dimension

mk sur F2 (notons que C+ peut ne plus etre cyclique). En resume, 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 polynome primitif (pour F4) x4 +x+1

sur F2 . Nous avons alors que F4 = {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}.

Considerons maintenant {1, ω} comme une base ordonnee de F4 sur F2 . On obtient alors que

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+ illustres au tableau 5.4.

Il est alors evident que si le code original C corrige t erreurs alors le code C+ corrigera

des eclats d’erreurs pouvant atteindre une longueur b = (t − 1)m + 1.

5.5 Codes Residus Quadratiques

Comme nous l’avons vu, les codes cycliques peuvent etre definis avec la notion de zeros

d’un code. En choisissant les zeros d’une facon particuliere nous avons obtenu, par exemple,

les codes BCH. Les codes Residus Quadratiques sont des codes lineaires cycliques pour


C (sur F4) C+ (sur F2)

000 000000

ω10 011000

ω2ω0 110100

1ω20 101100

0ω1 000110

0ω2ω 001101

01ω2 001011

ωω21 011110

ω201 110010

111 101010

ωωω 010101

ω21ω 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 zeros est impose. Comme son nom l’indique, ce choix reposera

sur la notion de residu quadratique.

Definition 5.8 Soit p un nombre premier impair. Si (a, p) = 1 alors a est un residu

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-residu quadratique modulo p.

Par la suite, nous noterons RQ l’ensemble des residus quadratiques modulo p de l’en-

semble ZZ∗p = {1, . . . , p − 1} et l’ensemble des non-residus quadratiques de ZZ∗

p sera note

NRQ. Nous nous permettons de rappeler au lecteur les proprietes suivantes des residus

quadratiques :

(1) RQ = {12, 22, . . . ,(

p−12

)2};(2) RQ ∪ NRQ = ZZ∗

p;


(3) |RQ| = |NRQ| = p−12

;

(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 considerations qui nous conduiront a la definition des code RQ.

Soit ω une racine primitive p-ieme de l’unite. Nous aimerions alors que les zeros de notre

code soient l’ensemble

Z = {ωi|i ∈ RQ}.Pour ce faire, il faut que

i ∈ RQ ⇒ Ci = {i, iq, . . . , iqd−1} ⊂ RQ.

Cette condition impose donc a q d’etre un residu quadratique modulo p. Ainsi, pour un tel

q, nous obtenons des polynomes q(x) et n(x) a coefficients dans Fq ou

xp − 1 = (x − 1)q(x)n(x)

avec

q(x) =∏

r∈RQ

(x − ωr) et n(x) =∏

u∈NRQ

(x − ωu).

Nous sommes maintenant en mesure de definir un code RQ.

Definition 5.9 Soit p un nombre premier impair et soit q un premier qui est un residu

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 = Fq [x]/ < xp−1 > sont appeles des codes Residus Quadratiques.

Avant de presenter un code Residu Quadratique, nous allons nous interesser a sa distance

minimale. A cet egard nous avons le theoreme suivant.


Theoreme 5.9 (Borne de la racine carree) 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

∏r∈RQ

(x − ωr)∏

n∈NRQ

(x − ωn) =

p−1∏i=1

(x − ωi) =

p−1∏i=0

xi.

Nous obtenons donc que wt(a(x)a∗(x)) = p. Comme wt(a(x)) = d alors le nombre maximum

de coefficients differents de zero 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) possede d termes

egaux a 1 on en deduit que le poids maximal du produit est d2 − d + 1. �

Passons maintenant a un exemple de codes Residus Quadratiques.

Exemple.

Comme nous voulons travailler sur F2 , nous aimerions que 2 soit un residu quadratique.

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 septieme de l’unite. Comme p = 23 − 1 nous pouvons prendre

ω = α ou α est un element primitif de F8 (tel que presente au tableau 5.5). Cette remarque

nous permet d’exprimer q(x) (par exemple) comme un polynome irreductible sur F2 de la

facon 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 zero, notre code est en fait le code

H2(3). Autrement dit, nous avons vu que le code de Hamming H2(3) etait un code lineaire,

puis nous avons vu qu’il etait un code cyclique BCH et maintenant nous venons de montrer

qu’il peut aussi etre vu comme un code RQ.

5.6 Codes de Goppa

Bien que les codes de Goppa ne sont pas en general des codes cycliques, ils sont neanmoins

une generalisation des codes BCH. C’est pourquoi nous les presentons ici. Leur construction

et l’etablissement de leurs parametres etant plutot longs, nous nous contenterons de bien les

definir et d’exhiber la forme generale de la matrice de controle. Enfin, nous fournirons un

exemple detaille de construction d’un code de Goppa. Pour ce qui est de la justification de

la construction de la matrice de controle, nous referons le lecteur a [9].

Soit G(x) un polynome a coefficients dans Fqm et soit

Sm =Fqm [x]

< G(x) >

l’anneau des polynomes a coefficients dans Fqm modulo < G(x) >. Si G(α) 6= 0, alors le

polynome x − α est inversible dans Sm. En effet, si on divise G(x) par x − α on obtient

G(x) = q(x)(x − α) + G(α).


On en deduit alors que q(x)(x − α) ≡ −G(α) mod < G(x) > et donc que

[−G(α)−1q(x)](x − α) ≡ 1 mod < G(x) > .

Mais comme nous avons alors que

q(x) =G(x) − G(α)

x − α,

nous obtenons finalement que

1

x − α= −G(x) − G(α)

x − αG(α)−1.

Avec cette definition de (x−α)−1 nous sommes en mesure de definir les codes de Goppa.

Definition 5.10 Soit G(x) un polynome sur Fqm et soit L = {α1, . . . , αn} un ensemble

d’elements de Fqm ou G(αi) 6= 0 et ou n > deg(G(x)). De plus, pour tout a = a1 · · ·an avec

ai ∈ Fq , definissons

Ra =n∑

i=1

ai

x − αi

∈ Sm.

Alors le code de Goppa note Γ = Γ(L, G) est donne par :

Γ(L, G) = {a ∈ Fnq |Ra(x) ≡ 0 mod < G(x) >}.

La matrice de controle d’un code de Goppa est alors de la forme suivante :

H =

G(α1)−1 G(α2)

−1 · · · G(αn)−1

α1G(α1)−1 α2G(α2)

−1 · · · αnG(αn)−1

α21G(α1)

−1 α22G(α2)

−1 · · · α2nG(αn)−1

......

...

αr−11 G(α1)

−1 αr−12 G(α2)

−1 · · · αr−1n 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 polynome G(x) (appele polynome de Goppa), minorer

la distance minimale du code.


Montrons maintenant a l’aide d’un exemple comment construire explicitement la matrice

de controle d’un code de Goppa donne. Comme notre exemple utilisera le corps F8 , nous

l’avons construit avec le polynome primitif p(x) = x3 + x + 1 et ou p(α) = 0. Le tableau 5.5

presente ce corps ainsi construit.

α, racine de x3 + x + 1 F23

0 0

α0 1

α1 α

α2 α2

α3 α + 1

α4 α2 + α

α5 α2 + α + 1

α6 α2 + 1

Tab. 5.5: F23

Exemple.

Soit G(x) = x2 + x + 1 un polynome irreductible sur F2 et L = {0, 1, α, . . . , α6} = F8 .

Dans ce cas nous obtenons q = 2, m = 3, r = 2, n = 8 et α est un element primitif de F8 .

Comme G(x) ne possede aucun zero dans F8 (son corps de decomposition etant F22 ), nous

obtenons alors la matrice

H =

[G(0)−1 G(1)−1 G(α1)

−1 G(α2)−1 · · · G(α5)

−1 G(α6)−1

0G(0)−1 1G(1)−1 αG(α1)−1 α2G(α2)

−1 · · · α5G(α5)−1 α6G(α6)

−1

]

comme matrice de controle.


Construisons explicitement les elements 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 facon semblable les elements de la deuxieme ligne, on obtient

H =

[1 1 α2 α4 α2 α α α4

0 1 α3 α6 α5 α5 α6 α3

].

Ce qui nous donne explicitement la matrice de controle suivante :

H =

1 1 0 0 0 0 0 0

0 0 0 1 0 1 1 1

0 0 1 1 1 0 0 1

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 verifier que le rang de la matrice H est egal a 6, ce qui implique donc

que la dimension de notre code est 8 − 6 = 2.

Chapitre 6

Conclusion

Les objectifs de ce memoire ont ete d’investiguer les structures algebriques associees

aux codes lineaires. Pour chacune des principales classes de codes, nous avons presente les

principaux codes utilises. Pour certains codes, nous avons aborde leur creation de differentes

facons afin d’illustrer que la methode de construction d’un code n’est, en general, pas unique.

L’important probleme qui consiste a etablir l’existence d’un code de parametres donnes a

ete aborde, nous le croyons, d’une facon 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 parametres donnes.

En termes de perspectives, on peut signaler que dans un travail futur, nous aimerions

etablir des conditions necessaires et suffisantes pour l’existence de certains codes lineaires

pour lesquels l’identite de MacWilliams nous permet de supposer leur existence. Afin de

combler l’ecart entre Aq(n, d) et Aq[n, d], l’etude des codes de geometrie algebrique semble

etre des plus prometteuses. Soulignons a cet effet que la facon la plus interessante de definir

et d’analyser les codes de Goppa, c’est de les voir comme des codes de geometrie algebrique.

Toujours en termes de perspectives, notons enfin que le fait de supposer une distribution

uniforme en entrees nous a permis de justifier notre methode de decodage basee sur un

schema de maximum de vraisemblance, mais nous croyons fermement que la connaissance

pratique de la distribution d’entrees pourrait conduire a des methodes de decodage encore

plus efficaces.

61

Annexe A

Programmes MAPLE

A.1 Enumerateur 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^i:

> 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^i),p(alpha),alpha) mod 2 = 0 then

> print(omega^i,‘ 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 Enumerateur 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^i:

> 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^i),p(alpha),alpha) mod 2 = 0 then

> print(omega^i,‘ 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., Mathematiques 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.

THEORIE ALG EBRIQUE DU CODAGE

Documents

Transcript of THEORIE ALG EBRIQUE DU CODAGE