Td corrigé 1. Introduction sur les codes correcteurs - Infoscience - EPFL pdf

Finite fields And

Error-correcting codes

Etudiante : Nelly Burrin

Master en systèmes de communication Projet de semestre, été 2006

Prof. Amin Shokrollahi

Assistant: Andrew Brown

Laboratoire d'algorithmique

SOMMAIRE

SOMMAIRE...3

1. Introduction sur les codes correcteurs :...5

1.1. Intérêt :...5

1.2. Définition mathématique des codes:...5

1.3. Caractéristiques d'un code :...6

1.4. Exemples de codes simples :...7

1.4.1. Code répétitif :...7

1.4.2. Parity Check code :...7

2. Notions d'algèbre :...8

2.1. Théorie des anneaux et des corps :...8

2.1.1. Les anneaux :...8

2.1.2. Les corps :...9

2.1.3. Les idéaux :...10

2.2. Les corps finis :...10

2.2.1. Construction d'un corps fini :...10

2.2.2. Exemple:...11

3. Codes linéaires :...13

3.1. Définition :...13

3.1.1. Définition générale des q-ary codes:...13

3.1.2. Cas particulier des codes binaires :...13

3.2. Matrice génératrice (generator matrix) :...14

3.3. Matrice de vérification (parity-check matrix) :...14

3.4. Distance minimum:...15

3.4.1. Définition :...15

3.4.2. Calcul de la distance minimale d'un code :...16

3.5. Détection et correction des erreurs :...17

3.5.1. Mécanisme de décodage d'un mot :...17

3.5.2. Distance minimale et capacité de détection et correction d'erreurs :...18

3.6. Bornes caractérisant les codes :...19

3.6.1. Singleton Bound:...19

3.6.2. Sphere Packing Bound:...20

3.7. Exemple : les codes de Hamming :...21

3.7.1. Cas général des q-ary codes de Hamming:...21

3.7.2. Cas particulier des codes de Hamming binaires:...23

4. Les codes cycliques:...26

4.1. Description:...26

4.1.1. Définition:...26

4.1.2. Représentation polynomiale des mots de code:...26

413. Définition des codes avec les représentations polynomiales:...27

4.2. Construction du code:...28

4.2.1. Polynôme générateur:...28

4.2.2. Propriétés importantes de g(x):...29

4.2.3. Exemple:...30

4.3. Matrices génératrice et de vérification:...31

4.3.1. Matrice génératrice :...31

4.3.2. Matrice de vérification :...32

4.4. Codage et détection des erreurs:...32

4.4.1. Code non systématique:...33

4.4.2. Code systématique:...33

4.4.3. Exemple:...33

4.4.4. Détection des erreurs:...34

4.5. Racines d'un code cyclique et distance minimum :...35

4.5.1. Racines du polynôme générateur:...35

4.5.2. Distance minimale d'un code cyclique:...36

4.5.3. Exemple:...37

5. Les codes BCH :...40

5.1. Historique :...40

5.2. Description et construction des codes :...40

5.2.1. Caractéristiques générales de ces codes:...40

5.2.2. Définition:...40

5.2.3. Construction:...41

5.2.4. 524. Exemple:...41

5.3. Décodage des codes BCH binaires:...42

5.3.1. Décodage de 2 erreurs:...43

5.3.2. Exemple du décodage de 2 erreurs d'un code [15, 7, 5]2 :...44

5.3.3. Décodage de t erreurs avec les relations de Newton:...46

5.3.4. Décodage de t erreurs avec les équations matricielles:...48

5.3.5. Exemple d'un décodage de 2 erreurs avec les équations matricielles:...50

6. Les codes Reed-Solomon (R-S codes):...51

6.1. Introduction:...51

6.2. Utilisation:...51

6.3. Construction et caractéristique:...51

6.3.1. Définition:...51

6.3.2. Construction du code:...52

6.3.3. Distance minimale:...52

7. Bibliographie:...54

1. Introduction sur les codes correcteurs :

Pour commencer, il nous semble important d'introduire quelques concepts basiques concernant les codes correcteurs d'erreurs, qui seront utilisés dans les paragraphes suivants.

Nous illustrerons ensuite le concept de code correcteur par des exemples très simples.

1.1. ^{Intérêt :}

En communication, une fonction d'encodage est une règle qui permet de convertir de l'information sous une autre forme de représentation, appelée code. Dans le domaine de la théorie de l'information, les codes sont utilisés pour détecter et corriger les erreurs de transmission. En effet, lorsqu'une source souhaite transmettre un message à un destinataire, elle envoie ce message au travers d'un canal dans lequel peuvent apparaître des erreurs dues à des bruits. Ainsi le message que le destinataire reçoit peut avoir été modifié. Afin de protéger l'information de ce genre d'erreurs, on ajoute au message de la redondance avant de le transmettre dans le canal. A la réception, le décodeur tente de récupérer le message originel à partir du message reçu.

Le schéma suivant illustre la chaîne d'actions qui permet à une source de transmettre de l'information à un destinataire :

Un message m = (m1,m2,…mk) constitué de k symboles est généré par la source et envoyé au codeur. Celui-ci va l'encoder en mots de code x de longueur n, avec n > k. On envoie donc des mots de la forme x = (x1x2…xn) au travers du canal.

A la sortie du canal, on obtient un mot qui contient un certain nombre d'erreurs qui sera noté y

= (y1y2…yn). Le décodeur récupère le message m à partir de y en appliquant une règle de décodage, qui peut être, par exemple, le principe du maximum de vraisemblance. On peut donc retrouver le message de départ, à condition que le nombre d'erreurs ne soit pas trop grand. En outre, plus on a ajouté de symboles redondants, plus on peut corriger d'erreurs.

Nous nous intéresserons donc aux mécanismes par lesquels l'information va être codée puis décodée, ainsi qu'aux outils mathématiques qui ont été développés pour ce fait.

1.2. Définition mathématique des codes:

On considère que les mots sont constitués d'éléments appartenant tous à un alphabet  contenant q éléments. Le mécanisme de codage fournit des mots de code de n éléments appartenant tous à

.

Source Codeur Canal

Décodeur Destinataire

msg m

m₁m₂…m_k

msg m x₁x₂…x_n y₁y₂…y_n

Existence de bruits:

Certains bits de x sont changés

Si on appelle Vn() l'ensemble de toutes les séquences de taille n, on a donc :

|V

n

()| = q

ⁿ

Un code serait donc un sous-ensemble de Vn(). Donnons une définition plus précise de ce terme ainsi que de la fonction d'encodage :

Définition : Un code C défini sur un alphabet est un sous-ensemble de ⁿ. Le code ainsi obtenu est appelé un q-ary code de longueur n.

Définition : Une fonction d'encodage f est une fonction injective qui, à chaque élément de l'espace du message, associe un mot de code. On a donc:

^{espace dumessage}^



ⁿ

f :

Un code est donc l'image obtenue par cette fonction : C = Im{f}

Dans le cas où q=2, le code est dit binaire. On a alors . Le code C est donc un sous- ensemble de {0,1}ⁿ et |Vn()| = 2ⁿ.

Notation : On note (n, M, d), un code qui transforme des blocs de message en mots de code de n éléments, avec une distance minimale égale à d. M représente le nombre de mots de codes.

1.3. Caractéristiques d'un code :

Les codes correcteurs sont caractérisés par quatre données importantes : 1. La longueur des mots de code n.

Dans les codes par blocs, on code le message en mots de longueur n. On souhaite envoyer des blocs de messages relativement grands car dans ce cas, le nombre d'erreurs se rapproche de son espérance, ce qui implique que la probabilité d'erreurs est meilleure. Cependant, au niveau du décodeur, si la complexité de l'algorithme de décodage est en O(n²), on souhaitera que n soit petit afin que le décodage ne soit pas trop long.

2. Le rendement ou taux de codage (= « rate » en anglais) correspondant au nombre d'de symboles d'information des blocs du message divisé par le nombre d'éléments des mots de code, c'est-à-dire k/n. Si ce taux est très petit, cela signifie que pour envoyer un petit bloc de message, il va être nécessaire de transmettre un mot de code très grand. Or ceci n'est pas souhaitable car la vitesse de transmission va être fortement réduite, et il faudra beaucoup de temps pour envoyer un court message. Le but étant d'optimiser cette vitesse de transmission, on cherchera à avoir le meilleur rendement possible.

3. La probabilité d'erreurs du code.

Cette probabilité va dépendre de la distance minimale entre les mots de code (ce terme sera défini plus clairement plus loin). Il est en effet évident que plus les mots seront différents les uns des autres, plus la capacité à retrouver le message originel va augmenter.

4. La complexité de l'algorithme d'encodage et de décodage.

La complexité de ces algorithmes est une donnée importante car elle décidera du temps de calcul et des ressources nécessaires pour l'exécution des fonctions de codage et de décodage.

Il s'agit donc d'une donnée à prendre en compte lors du choix d'un type de code.

1.4. Exemples de codes simples :

Pour ces exemples de codes, nous considérerons des codes binaires. Les blocs de messages seront des éléments de {0,1}^k, et les mots de code générés seront des éléments de {0,1}ⁿ.

Pour illustrer ces codes, nous utiliserons le bloc de message : 1011001.

1.4.1.

Code répétitif :

Il s'agit d'un code très simple dans lequel on répète n fois chaque bit du message à envoyer.

On a alors C = {(00…0); (11…1)}.

Illustration : Considérons le cas où n = 5, on obtiendrait alors le mot de code : 11111 00000 11111 11111 00000 00000 11111

On remarque qu'il n'y a que deux mots de code possibles qui sont {(00…0); (11…1)}, où les bits sont répétés n fois. On déduit donc que la distance minimale de ce code est de n, c'est-à-dire que les mots diffèrent de n bits au minimum.

De plus, on code des blocs de 1 bit en mots de n bits. Nous verrons plus loin que l'on note ce code [n, 1, n], pour signifier un code de dimension 1, de longueur n et de distance minimale n.

Nous verrons également que le fait que ces mots soient distants de n bits implique que l'on pourra détecter n-1 erreurs et corriger (n-1)/2erreurs.

Illustration : Le code répétitif où λ = 5 peut donc détecter jusqu'à 4 erreurs et corriger 2 erreurs.

En effet, si le décodeur applique la règle du maximum de vraisemblance, si un mot a 3 erreurs, le décodeur va retourner le mauvais bit. En revanche, il ne pourra pas retrouver le mot originel car le mot reçu sera plus proche d'un autre mot de code.

Remarque : Si on analyse ce code, on se rend compte qu'il s'agit d'un code qui a un rendement faible puisque pour transmettre un bit il faut le répéter λ fois.

1.4.2.

Parity Check code :

Dans ce code, on ajoute un bit correcteur à la fin du bloc de message pour indiquer si le nombre de 1 est pair ou impair. Il faut que le mot de code possède un nombre pair de 1.

Le codage s'effectue donc de la façon suivante :

Si le nombre de bits 1 dans le bloc est pair, on ajoute 0.

Si le nombre de bits 1 dans le bloc est impair, on ajoute 1.

On a donc C = {(c1,…, cn) / ci = 0}.

Illustration : Etant donné que dans notre exemple, le nombre de bits 1 est égal à 4, on ajoute un 0 à la fin du mot. Le mot de code ainsi généré serait donc : 10110010.

Si l'on code des blocs de k bits, on obtient donc des mots de code de k+1 bits.

De plus, si on prend deux blocs qui ne diffèrent que d'un seul bit, on obtient deux mots de code

On va donc noter ce code comme étant [k+1, k, 2]. Si on pose n = k + 1, on peut également écrire cette définition de la façon [n, n-1, 2].

Ce code peut détecter 1 erreur, mais ne peut pas la corriger.

2. Notions d'algèbre :

Les corps finis sont à la base de beaucoup de codes correcteurs d'erreurs. Il est donc essentiel de comprendre la théorie des corps finis afin de pouvoir comprendre par la suite le fonctionnement des codes linéaires et des codes cycliques. Nous allons rappeler brièvement les concepts importants qui seront utiles pour la compréhension des mécanismes de codage qui seront développés par la suite.

2.1. Théorie des anneaux et des corps :

2.1.1.

Les anneaux :

Afin de pouvoir définir simplement un corps, nous allons tout d'abord introduire le concept d'anneau.

Définition : Un anneau est un ensemble R muni de deux opérations internes + et · et de deux éléments particuliers distincts 0 et 1 satisfaisant les propriétés suivantes :

a. L'associativité de l'addition : (a + b) + c = a + (b + c) pour tout a, b, c



R b. La commutativité de l'addition : a + b = b + a pour tout a, b



R

c. L'existence d'un élément neutre 0 pour l'addition : a + 0 = 0 + a = a pour tout a



R d. L'existence de l'opposé : pour tout a Є R, il existe un élément –a tel que a + (-a)=0 e. L'associativité de la multiplication : (a · b) · c = a · (b · c) pour tout a, b, c



R f. L'existence d'un élément identité 1 : a · 1 = 1 · a = a pour tout a



R

g. La distributivité de l'addition par rapport à la multiplication : a · (b+c) = a · b + a · c pour tout a, b, c



R

On le note en général (R, +, ·, 0, 1) afin de spécifier les deux opérations ainsi que les éléments particuliers. Cependant, dans le cas où il n'y aurait aucune ambiguïté, on le notera simplement R.

Exemple : L'ensemble Z/mZ est l'ensemble des classes de congruences modulo m, où la classe de congruence d'un nombre a modulo m, notée [a]m est définie comme étant l'ensemble des entiers congrus à a modulo m.

Cet ensemble Z/mZ muni de l'addition et de la multiplication est un anneau. L'élément neutre est [0] m et l'élément identité est [1] m.

Définition : Un ensemble S R est un sous-anneau de R s'il satisfait les propriétés suivantes : a. 1R



S

b. a



S implique que –a



S

c. a, b S implique que a + b



S et que a · b



S

L'ensemble S ainsi obtenu, muni des mêmes opérations que R est un anneau.

Définition : Un anneau R est dit commutatif si pour tout a, b dans R, on a a · b = b · a.

Définition : Un anneau commutatif R est dit intègre si le produit de deux éléments non nuls est non nul. Ainsi pour tout a, b dans R, on a : a · b = 0 implique que a = 0 ou b = 0.

Exemple : L'anneau défini plus haut Z/mZ n'est pas toujours intègre. En effet Z/8Z n'est pas intègre car on peut trouver deux éléments non nuls dont le produit est nul. Ainsi, [4]8 et [2] 8 sont tous les deux non nuls, mais on a [4] 8 · [2] 8 = [8] 8 = [0] 8.

En revanche, Z/5Z est intègre, car on ne peut pas trouver d'éléments non nuls dont le produit soit nul.

Définition : Un diviseur de zéro d'un anneau R est un élément a  0 tel qu'il existe b  0 et ab = 0.

D'après les deux définitions précédentes, on peut déduire qu'un anneau intègre ne possède aucun diviseur de zéros.

Définition : Une unité d'un anneau R est un élément a tel qu'il existe b



R tel que ab = ba = 1.

Unités et diviseurs de zéros dans Z/mZ :

Dans cet anneau, tout élément non nul est soit un diviseur de zéro, soit une unité. Le théorème suivant permet de distinguer rapidement quels sont les unités et quels sont les diviseurs de zéro d'un tel anneau :

Théorème : Soit a



Zet m



N. On a a. Si m | a alors [a]m = [0] m



Z/mZ

b. Si (m, a) = 1, alors [a]m est une unité dans Z/mZ.

c. Si 1 < (a, m) < m, alors [a]m est un diviseur de zéro modulo m.

On peut donc déduire de ce théorème que si m est un nombre premier noté p, alors Z/pZ ne contiendra que des unités.

2.1.2.

Les corps :

Nous pouvons à présent donner la définition d'un corps.

Définition : Un corps est un anneau commutatif dont tous les éléments non nuls sont des unités.

On déduit de cette définition que l'anneau Z/pZ avec p premier est un corps. Plus généralement, on a la proposition suivante :

Proposition : Un anneau Z/pZ est un corps si et seulement si p est premier.

On note alors ce corps Fp. Celui-ci contient p éléments.

Très simplement, on peut dire qu'un corps est un ensemble d'éléments dans lequel on peut réaliser l'addition, la soustraction, la multiplication et la division, tout en restant dans cet ensemble.

Le nombre d'éléments d'un corps est appelé l'ordre du corps. Si le corps contient un nombre fini d'éléments, on dit que le corps est un corps fini.

Etant donné qu'un corps est un anneau particulier, les propriétés des anneaux s'appliquent toutes aux corps. Résumons ici quelques propriétés propres aux corps qui découlent des propriétés des anneaux vus ci-dessus.

Propriétés : Soit un corps K, on a :

a. Pour tout élément a



K, a · 0 = 0 · a = 0 b. Pour tout élément a et b non nuls de K, a · b ≠ 0 c. a · b = 0 et a ≠ 0 impliquent que b = 0

d. Pour tous a, b



K, – (a · b) = (-a) · b = a · (-b)

e. Pour tout a non nul de K, a · b = a · c implique que b = c.

2.1.3.

Les idéaux :

La notion d'idéal nous sera utile lors de la définition des codes cycliques. Dans ce paragraphe, nous ne ferons que donner une définition et une proposition essentielle pour la suite. Le concept sera en effet revu plus tard.

Définition : Un sous-ensemble I d'un anneau commutatif R est un idéal si on a : a. Pour tout x et x'



I, on a x + x'



I

b. Pour tout x



I et tout a



R, on a a · x



I

Proposition : Soit un anneau R et a



R. Le sous-ensemble {ax | x



R} est un idéal noté aR.

Définition: Un idéal I ≠ R d'un anneau R est dit principal s'il existe un r



R tel que : I = {r · x / x



R}

2.2. Les corps finis :

Nous avons vu au paragraphe précédent qu'un ensemble d'entiers modulo un nombre premier p (un anneau Z/pZ) forme un corps fini, noté Fp (pour "Field of order p") ou GF(p) (pour "Galois field of order p"). Plus généralement, on a le théorème suivant :

Théorème : Soit p un nombre premier et n un entier ≥1. Alors il existe un corps à pⁿ éléments.

Le nombre d'éléments d'un corps fini est donc toujours une puissance d'un nombre premier.

2.2.1.

Construction d'un corps fini :

Afin de construire un corps à pⁿ éléments, on introduit les notions d'anneau de polynômes et de congruence modulo un polynôme f. Le corps voulu sera construit en considérant des polynômes à coefficients pris dans un corps Fp .

Considérons un anneau R et le polynôme f(X) = anXⁿ + … + a1X + a0 tel que les ai, 0 ≤ i ≤ n, soient pris dans R.

L'anneau de polynôme R[X] est l'ensemble des polynômes à coefficients pris dans R, avec l'addition et la multiplication des polynômes comme opérations, le polynôme constant f(X) = 0 comme élément neutre 0, et le polynôme constant f(X) = 1 comme élément identité 1.

Restreignons nous maintenant au cas où R = K est un corps.

Définition : Soient f, g et m des polynômes de K[X] avec deg(m) > 0. On dit que les polynômes f et g sont congrus modulo m si le polynôme m divise le polynôme f – g. On note :

f ≡ g (mod m)

De même que pour les entiers, on regroupe les polynômes qui sont congrus modulo m en une classe de congruence, notée K[X]/(m). La classe de f (mod m) est alors notée [f]m.

Théorème : L'anneau K[X]/(m) est un corps si et seulement si le polynôme m(X) est irréductible.

Ainsi, si l'on choisit un nombre premier p, on a que Fp = Z/pZ est un corps. Si l'on choisit un polynôme g



Fp irréductible et de degré n, alors l'anneau Fp[X]/(g) est un corps qui contient pⁿ éléments.

En effet, étant donné qu'un élément de Fp[X]/(g) est une classe de polynômes modulo f , toute classe peut être représentée par un polynôme de degré < n. De plus, deux polynômes distincts de degré < n ne sont pas congrus modulo g. Ils représentent donc deux classes différentes. Ainsi, il y a autant d'éléments dans Fp[X]/(g) que de polynômes de degré < n à coefficients dans Fp. Ces polynômes possèdent donc n coefficients qui peuvent être choisis dans un ensemble de p éléments. Il y a donc pⁿ polynômes possibles et on en déduit que le corps construit contient pⁿ éléments, où n = deg(g).

2.2.2.

^Exemple:

Afin d'illustrer la théorie développée ci-dessus, nous allons donner un exemple de construction de corps fini à partir d'un nombre d'éléments donné.

Pour exemple, nous allons construire un corps fini de 9 éléments. Ayant 9 = 3², on a bien un nombre d'éléments qui est une puissance d'un nombre premier p = 3.

On part donc du corps fini F3 = {0, 1, 2} où les opération d'addition et de multiplication sont faites modulo 3, et on cherche une extension de degré 2 sur ce corps.

La première étape pour construire ce corps est donc de trouver un polynôme de degré 2 qui soit irréductible sur F3. Pour cela, on commence par lister tous les polynômes de degré 2 à coefficients dans F3 et on cherche ceux qui sont irréductibles.

Les polynômes unitaires de degré 2 existants sont :

x² ; x² + 1 ; x² + 2 ; x² + x ; x² + 2x ; x² + x + 1 ; x² + x + 2 ; x² + 2x + 1 ; x² + 2x + 2

Pour qu'un polynôme soit irréductible, il ne doit pas avoir de racine dans l'ensemble {0, 1, 2}.

Ainsi, tous les polynômes n'ayant pas de terme constant sont réductibles, car ils acceptent x = 0 comme racine. De fait, les polynômes x² ; x² + x ; x² + 2x sont réductibles.

De plus, si l'on fait la somme des coefficients, celle-ci doit être différente de 1 car dans ce cas, le polynôme accepterait x = 1 comme racine. De fait, les polynômes x² + 2 ; x² + x + 1 sont réductibles.

Pour finir, on teste la racine x = 2 sur les polynômes restants. On remarque alors que le polynôme x² + 2x + 1 est réductible.

Les polynômes suivant sont donc irréductibles sur F3 : x² + 1 ; x² + x + 2 ; x² + 2x + 2.

On choisit par exemple x² + 1, et on pose β une racine de ce polynôme. On a donc β² + 1 = 0.

Le corps fini obtenu par extension de F3 est donc F3 /[x² + 1]. Il s'agit bien d'un corps contenant 3² = 9 éléments, que l'on note F3[β].

Ce corps est formé des éléments suivants :

F3 /[x² + 1] = {a β + b / a, b Є F3} = {0, 1, 2, β, β + 1, β + 2, 2β, 2β + 1, 2β + 2}

3. Codes linéaires :

Dans la première section, nous avons introduit quelques généralités sur les codes. Les codes dont nous avons parlés étaient essentiellement des codes par blocs (blocks codes), c'est-à-dire des codes qui s'appliquent sur des blocs de symboles. On obtenait ainsi des mots de code qui étaient par la suite transmis dans le canal.

A partir de maintenant, nous allons nous restreindre à une sous-classe des codes par blocs, les codes linéaires. Nous étudierons le cas général des q-ary codes, ainsi que le cas plus particulier des codes binaires car ceux-ci sont très couramment utilisés pour la transmission d'informations.

Nous commencerons par en donner une définition, puis nous donnerons une description des matrices génératrices et de vérification, puis nous définirons plus précisément ce qu'est la distance minimum d'un code et nous expliquerons quel est son intérêt. Dans la section 3.6, nous définirons quelques bornes sur le nombre de mots par rapport à la distance minimale du code. Et pour finir, nous illustrerons les codes linéaires par un exemple de code connu, les codes de Hamming.

3.1. Définition :

A partir de maintenant, on considère que l'on code des blocs de symboles de k éléments. Le message émis par la source est donc tout d'abord découpé en blocs qui seront encodés séparément.

3.1.1.

Définition générale des q-ary codes:

Soit un alphabet Fq, avec q une puissance d’un nombre premier, i.e. q = p^r avec p premier.

Définition : Un code par blocs C est un code linéaire si et seulement si ses mots de codes de longueur n forment un sous-espace de dimension k de Fⁿq. Ce code est noté [n, k].

Ainsi, il existe k vecteurs g0, g1,…,gk-1 qui forment une base de ce sous-espace. Tout mot de code c appartenant à C peut s'écrire comme une combinaison linéaire de ces vecteurs :

c = u0 · g0 + u1 · g1 + … + uk-1 · gk-1

où les ui, 0 ≤ i ≤ k-1, sont des éléments de l'alphabet 

On déduit de cette notation qu'il existe q^k mots de code différents.

3.1.2.

Cas particulier des codes binaires : Soit F2 = {0, 1}.

Le code par blocs C est dit linéaire si et seulement si ses 2^k mots de code forment un sous-espace de dimension k de l'espace vectoriel de tous les vecteurs de longueur n.

Par conséquent C est défini comme étant un sous-espace vectoriel de dimension k de Fⁿ₂ . Plus simplement, un code binaire est linéaire si la somme modulo 2 de deux mots de code est aussi un mot de code.

De plus, on a :

c = u0 · g0 + u1 · g1 + … + uk-1 · gk-1

avec g0, g1,…,gk-1 les k vecteurs formant la base, et ui = {0, 1} pour 0 ≤ i ≤ k-1.

3.2. Matrice génératrice (generator matrix) :

Nous avons vu qu'un mot de code pouvait s'écrire comme la combinaison linéaire des k vecteurs de la base (g0, g1,…,gk-1).

c = u0 · g0 + u1 · g1 + … + uk-1 · gk-1

Ces vecteurs gi permettent donc de générer un mot de code. Ils peuvent être regroupés dans une matrice G, k



n, appelée matrice génératrice, formée de telle sorte que ses lignes soient composées des vecteurs de la base gi.

On obtient donc la matrice suivante :

G =















































 1,0 1,1 1, 1

1 , 1 1

, 1 0

, 1

1 , 0 1

, 0 0

, 0

1 1

n k k

k

n n

k o

g g

g

g g

g

g g

g

g g g

















Définition : Une matrice génératrice G d'un code linéaire C est une matrice k



n dont les lignes sont une base de C.

Si on considère le mot à encoder u



F2, avec u = (u0, u1, …, uk-1), le mot de code est obtenu en calculant :

 





























1 1 0

1 1

0

k k

g g g u

u u G u

c  

On a alors^C



^{uG uk}



.

Définition : On dit que G est dans une forme standard si G est de la forme (Ik P) ou (P Ik), où Ik est la matrice identité k



k.

Dans ce cas, les k premiers (ou derniers, suivant la façon dont est formée la matrice génératrice) symboles du mot de code sont appelés les symboles d'information ("information symbols" en anglais), ils peuvent être choisis de façon arbitraire. Les n-k autres symboles calculés par la fonction d'encodage à partir des symboles d'information sont appelés symboles de contrôle ("parity-check symbols" en anglais).

Dans le cas d'un code binaire, on dit bits d'information et bits de contrôle.

3.3. Matrice de vérification (parity-check matrix) :

Une autre matrice très utile est la matrice H, appelée matrice de vérification ("parity-check matrix" en anglais). On la définit de la façon suivante :

Définition : La matrice de vérification H est une matrice n-k



n, avec n-k lignes linéairement indépendantes, telle que chaque vecteur de l'espace des lignes de G est orthogonal

aux lignes de H, et que tout vecteur orthogonal aux lignes de H est dans l'espace des lignes de G.

On peut alors définir un code linéaire de la façon suivante :

Un n-tuple c est un mot du code C généré par G si et seulement si c · H^T = 0.

Remarque : Ayant c · H^T = 0 et sachant que c = u · G, avec c



C, on peut écrire : u · G · H^T = 0

Ayant u ≠ 0, on en déduit que : G · H^T = 0

Théorème : Si la matrice génératrice G de C est dans la forme standard (Ik ¦ P), alors une matrice de vérification pour C est H = (- P^T ¦ Ir), avec r = n – k.

Preuve : Pour cela, on vérifie que G · H^T = 0.

   

0

1 0

0

0 1

0

0 0

1 1

0 0

0 1

0

0 0

1

1 0

0

0 1

0

0 0

1

1 0

0

0 1

0

0 0

1

1 1

2 2 21

21

1 1 11

11

2 1

1 21

11

1

2 21

1 11

1

2 21

1 11

1

2 21

1 11



























































































































































kr kr k

k

r r

r r T

kr r

r

k

kr k

r r T

T

kr k

r r

kr k

r r T

T r T k

T

p p p

p

p p p

p

p p p

p H

G

p p

p

p p

p

p p

p p

p p

H G

p p

p p

p p

p p

p p

p p

H G

I P P I H G







































































































#

Ainsi, la forme standard de G est (-P^T ¦ In-k), avec In-k la matrice identité n-k



n-k, et P une matrice n-k



k.

3.4. Distance minimum:

Tout au long de ce paragraphe, nous considèrerons le code linéaire par blocs C ainsi que deux mots de ce code x et y.

3.4.1.

Définition :

Commençons par définir les notions de distance entre deux mots de code et le poids d'un mot.

Définition : La distance de Hamming entre deux mots x et y, notée d(x,y) est le nombre de symboles différents entre ces deux mots. En définissant les mots x = (x1x2…xn) et y = (y1y2…yn), on a :

d(x,y) = {i / x

i

≠ y

i

}

Exemple : Considérons les mots binaires x = (0 0 1 0 1 1 0) et y = (1 0 0 0 1 0 1).

On a alors : d(x,y) = 4

Définition : Le poids w(x) d'un bloc de symboles x est défini par :

w(x) := d(x, 0)

où 0 = (0, 0, …, 0)

Exemple : Si on reprend les exemples ci-dessus, on a : w(x) = 3 et w(y) = 3

Dans le cas d'un code binaire, si l'on réalise l'addition modulo 2 de deux mots x et y, les bits qui seront égaux à 1 seront placés aux endroits où x et y diffèrent. Ainsi, le poids de Hamming de cette somme sera égale à la distance de Hamming entre x et y, c'est-à-dire:

d(x, y) = w (x + y)

Exemple : Avec les mots x et y définis précédemment, on a :

w(x+y) = w(1 0 1 0 0 1 1) = 4 = d(x,y)

On peut alors définir la distance minimum du code, notée dmin, ou plus simplement d : Définition : La distance minimum du code C, notée d, est le minimum des distances de

Hamming entre les mots du code. On a donc:

d

min

= min {d(x,y) / x, y  C, x ≠ y}

Notation : Un code C ayant une distance minimale de d est noté [n, k, d]. Cette notation signifie que l’on code des mots de k symboles en mots de code de n symboles étant tous distants les uns des autres de d symboles au minimum.

3.4.2.

Calcul de la distance minimale d'un code : Dans le cas où C est un code linéaire binaire, on a :

dmin = min {d(x,y) / x, y



C, x ≠ y}

dmin = min {w(x + y) / x, y



C, x ≠ y}

dmin = min {w(x) / x



C, x ≠ 0} = wmin

On obtient donc le théorème suivant :

Théorème : La distance minimum d'un code linéaire par bloc est égale au poids minimum de ses mots de code non nuls.

Voyons à présent comment calculer la distance minimum d'un code à partir de sa matrice de vérification H.

Théorème : Soit C un code binaire [n, k], et H sa matrice de vérification. Pour chaque mot de code de poids w, il existe w colonnes de H telles que la somme de ces colonnes est nulle.

Inversement, s'il existe w colonnes de H dont la somme est nulle, alors il existe un vecteur de poids w.

Preuve : Pour plus de simplicité, on considère un code binaire C, ayant une matrice de vérification H = [h0, h1, …, hn-1] où hi est la i^ème colonne de H.

Soit r = (r0, r1, …, rn-1) un mot reçu au niveau du décodeur de poids w. r a donc w composantes non nulles égales à 1. On a donc ri1 = ri2 = … = riw = 1 avec 0 ≤ iw ≤ n-1.

r sera un mot de code si r · H^T = 0, ce qui équivaut à : r0 · h0 + r1 · h1 + … + rn-1 · hn-1 = 0 ri1 · hi1 + … + riw · hiw = 0

hi1 + … + hiw = 0

On a alors w colonnes de H dont la somme est nulle.

Pour montrer l'autre partie du théorème, on considère le n-tuple binaire x = (x0, x1, …, xn-1), de poids w, ayant les w composantes xi1, xi2, …, xiw non nulles. On a:

x · H^T = xi1 · hi1 + … + xiw · hiw = hi1 + … + hiw

Si hi1 + … + hiw = 0, on en déduit que x · H^T = 0.

Donc x est un mot du code C, de poids w.

#

De ce théorème, on déduit les deux corollaires suivants :

Corollaires : 1. Soient C un code linéaire et H sa matrice de vérification. Si on ne trouve pas d-1 ou moins colonnes telles que leur somme est nulle, alors dmin ≥ d.

2. Soit C un code linéaire et H sa matrice de vérification. Le poids minimum du code wmin est le plus petit nombre de colonnes telles que leur somme soit nulle.

Ainsi on pourra calculer la distance minimum du code C en trouvant le nombre minimum de colonnes dont la somme est nulle.

3.5. Détection et correction des erreurs :

3.5.1.

Mécanisme de décodage d'un mot :

L'encodage d'un mot u de k symboles s'effectue en calculant le vecteur c de longueur n tel que : c = u · G

Puis on transmet c dans le canal. A la sortie du canal, on reçoit un message r. Le but du décodeur va donc être de tenter de retrouver le message qui a été envoyé à partir de celui qu'il a reçu. Il

cherche donc à détecter s'il y a eu une erreur, puis dans un deuxième temps, il cherche à corriger cette ou ces erreurs.

Une méthode pour détecter la présence d'erreurs et de calculer le syndrome s = (s0, s1, …, sn-1), défini par :

s = r · H^T

Si le vecteur s obtenu est égal au vecteur nul, étant donné que le produit d'un des mots du code C avec la transposée de la matrice de vérification est nulle, on peut déduire que r est un mot appartenant au code C. Le récepteur va alors considérer qu'il n'y a pas d'erreur, et qu'il s'agit du message envoyé.

Si le syndrome est différent du vecteur nul, cela signifie que le mot reçu r n'est pas un mot appartenant au code C. Par conséquent, on est sûr qu'une erreur est apparue lors de la transmission. Le but du décodeur va donc être de trouver où se situe cette erreur et de la corriger.

Voyons plus précisément le cas des codes binaires :

On pose e = (e0, e1, …, en-1), le vecteur d'erreur, représentant les erreurs ayant été introduite par le canal. Ce vecteur a des zéros partout sauf aux positions où une erreur s'est produite.

On a alors :

r = c + e Le syndrome s est alors égal à :

s = (c + e) · H^T s = c · H^T + e · H^T Or c · H^T = 0, donc on a:

s = e · H^T

On peut donc calculer les syndromes possibles à partir des vecteurs d'erreurs et constituer une table associant à chaque erreur pouvant apparaître dans le canal le syndrome que l'on obtiendrait.

Ainsi lors du décodage, on pourra comparer s avec les entrées de la table et retrouver le vecteur erreur. Lorsque e est connu, on retrouve facilement c en calculant :

c = r + e

3.5.2.

Distance minimale et capacité de détection et correction d'erreurs :

Voyons à présent comment la distance minimale nous permet de savoir combien d'erreurs pourront être détectées et corrigées.

Afin de comprendre le principe, commençons par réaliser une illustration des mots d'un code binaire C. Les petites étoiles représentent les 2^k mots du code pris dans un ensemble de 2ⁿ éléments.

*

*

* * *

*

*

*

d

(d-1)/2

(d-1)/2

Un mot n'appartient pas au code C si celui-ci n'est pas un des 2^k mots représentés.

Instinctivement, on déduit de ce schéma qu'on pourra détecter qu'un mot n'appartient pas à C s'il a une distance avec un mot de code non nulle et strictement inférieure à d.

De plus, en admettant que l'on utilise une règle de maximum de vraisemblance pour le décodage, on pourra corriger correctement les erreurs et retrouver le mot originel si la distance entre le mot reçu et le mot envoyé est inférieure à _^{ d}₂¹_^.

On obtient donc la propriété suivante :

Propriété : Un code ayant une distance minimale de d peut détecter (d-1) erreurs et peut corriger



  2

1

d erreurs.

Ainsi, si l'on pose d = 2e + 1, on pourra détecter 2e erreurs et on pourra corriger e erreurs.

3.6. Bornes caractérisant les codes :

Nous avons vu que l'on caractérise un code par la longueur de ses mots de code n, son nombre de mots M (ou la longueur des blocs de message k), et la distance minimum d entre les mots de code. On dit alors qu'il s'agit d'un code (n, M, d).

Intuitivement, on comprend que les grandeurs M et d "jouent" l'une contre l'autre. En effet, si on a un très grand nombre de mots, ceux-ci auront une distance faible. Alors que si on a M petit, alors la distance entre les mots pourra être plus grande, permettant ainsi de détecter et de corriger plus d'erreurs.

Pour caractériser cette relation, on introduit la notation Aq(n, d) qui représente le nombre de mots M maximum tels qu'il existe un code q-ary (n, M, d).

Il va donc être nécessaire de trouver un compromis entre ces deux valeurs, afin d'avoir un nombre de mots suffisants et une distance minimale suffisamment grande pour pouvoir détecter et corriger un certain nombre d'erreurs. Pour cela, il existe des bornes qui caractérisent les grandeurs M et d. Nous allons étudier dans ce paragraphe deux bornes : le Singleton Bound et la Sphere Packing Bound, appelée également borne de Hamming.

3.6.1.

Singleton Bound:

Considérons un code C [n, k, d]. Cette borne permet de trouver une borne maximale sur la distance minimale d par rapport aux valeurs n et k.

Théorème : Soit un code [n, k, d]. On a l'inégalité suivante :

d ≤ n – k + 1

Preuve: Soient C le code [n, k, d]q,et x un mot de ce code.

Considérons le mot x' formé à partir de x auquel on enlèverait les (d-1) derniers symboles.

On obtient ainsi un nouveau code C' de taille n' = n – (d – 1) = n – d + 1.

Comme C avait une distance minimale de d, tous les mots de C avaient une distance entre eux supérieure ou égale à d, donc si on enlève (d – 1) symboles à ces mots, on obtient des mots qui sont tous différents d'au moins un symbole. Ainsi, tous les mots de C' sont différents les uns des autres, et on en déduit que C et C' ont le même nombre de mots de code.

On peut donc écrire que : q^k' = q^k ce qui implique :

k = k'.

C' est donc un code [n', k] avec n' = n – d + 1. On en déduit qu'il existe un code de dimension k et de distance d ≥1 et de longueur n.

Or, on sait que la longueur des mots de code est toujours supérieure ou égale à la dimension du code, et donc on a la relation suivante :

n' ≥ k  n – d + 1 ≥k d ≤ n – k + 1

#

3.6.2.

Sphere Packing Bound:

Il s'agit d'une borne sur la dimension du code k.

Pour commencer, définissons une "balle" de rayon r = (d-1)/2 autour de chaque mot de code . Celle-ci englobe tous les éléments de l'ensemble Fⁿq qui se trouvent à une distance inférieure ou égale à r d'un mot de code.

Illustrons ce concept pour le cas d'un code binaire, à l'aide d'un schéma. Le cercle bleu représente la balle de rayon r. Pour des raisons de clarté, nous ne représenterons cette balle que pour un seul mot de code, l'idée étant la même pour tous les autres mots de codes.

On s'intéresse alors au nombre de mots se situant dans cette balle, c'est-à-dire au nombre de mots se trouvant à une distance inférieure ou égale à r d'un mot de code c donné. On note :

Sr(c) = {x



Fⁿ2/ d(x, c) ≤ r } avec r = (d-1)/2

On calcule le cardinal de Sr(c). Pour cela, on compte le nombre de mots qui diffèrent d'un nombre de symbole de 0 à r du bloc c. On choisit donc i places (0 ≤ i ≤ r) dans le mot que l'on multiplie par le nombre de possibilités de changements d'un symbole. On obtient alors la formule suivante :





 



 



 ^r 

i

r q i

i C n

S

0

) 1 ( )

(

*

*

* * *

*

*

d

(d-1)/2

c

*

Pour finir, étant donné que les balles sont disjointes, le nombre de mots du code multipliés par le nombre d'éléments contenus dans cette balle doit donner un nombre inférieur ou égal au nombre total d'éléments de Fⁿq . On obtient donc la borne suivante :

n d

k S q

q  _ 

2 1

Théorème : Soit un code linéaire [n, k, d] défini sur un alphabet à q éléments. La borne de Hamming du code est la relation :

 

ⁿ

d

i

k q i q

i

q n  



 







^

 

 

 2 1

0

1

Dans le cas d'un code binaire, on a la relation :

n d

i k

i n 2

2 ²

1

0





 







^

 

 



Cette borne nous permet de définir la notion de code parfait.

Définition: Un code est dit parfait si la borne de Hamming est une égalité, c'est-à-dire si :

 

ⁿ

d

i

k q i q

i

q n  

 







^

 

 

 2 1

0

1

Plus simplement, un code est parfait si tous les éléments de Fⁿq sont inclus dans les balles de rayon r autour des mots du code.

3.7. Exemple : les codes de Hamming :

Ces codes ont été inventés par Richard Hamming, et sont utilisés dans le domaine des "digital communications" et des systèmes de sauvegarde de données.

Le codage d'un mot de k bits s'effectue en ajoutant m bits de façon à obtenir des mots de codes de n bits. On a donc m = n – k. Ces bits sont calculés à l'aide de la matrice génératrice.

Le code a une distance minimale de 3, il peut donc détecter 2 erreurs et en corriger 1.

3.7.1.

Cas général des q-ary codes de Hamming:

Voyons tout d'abord comment on forme de façon générale les codes de Hamming définis sur un alphabet contenant q éléments.

On part du "projective space" Pⁿ(Fq) de dimension n défini sur Fq. Cet ensemble est l'ensemble des classes d'équivalence de Fⁿq^1\{0}, où deux vecteurs x et y sont dit équivalents si y = λx, avec λ



Fq*. Par conséquent, dans une classe d'équivalence, tous les éléments dont des multiples les uns des autres. Le principe est comparable aux classes d'équivalence définies sur Z/mZ.

1) Montrons que le nombre d'éléments de Pⁿ(Fq) est

1

1 1



 ^  q N q

n

:

Le nombre d'éléments de Fⁿq^1\{0} est égal au nombre de vecteurs de longueur n+1 constitués d'éléments pris dans un ensemble de q éléments auquel on enlève le vecteur nul. On a alors :

| Fⁿq^1\{0} | = qⁿ⁺¹ – 1

Pour trouver le nombre d'élément de Pⁿ(Fq), on applique le principe suivant :

On regroupe tous les vecteurs de Fⁿq^1\{0} en classes d'équivalence et on cherche le nombre d'éléments contenus dans une classe d'équivalence. De là, on pourra déduire le nombre de classe d'équivalence, qui est le nombre recherché.

Sachant que y = λ · x, si l'on considère un vecteur x, on obtient tous les autres vecteurs de la classe représentée par x en multipliant x par un λ



Fq*. On a q - 1 possibilités pour choisir λ (Fq* contient q-1 éléments car on y a exclu l'élément 0), ce qui implique que l'on a q - 1 éléments dans une classe d'équivalence.

Par conséquent, on en déduit que :

|

Pⁿ(Fq)

|

^{ N  q}_q^n1_^₁¹

#

On considère maintenant la matrice H possédant n+1 lignes et N colonnes, où les colonnes de H sont les représentants de chaque classe d'équivalence qui sont les éléments de Pⁿ(Fq).

2) Montrons que le rang de H est égal à n+1 :

Ceci équivaut à montrer qu'il existe n+1 colonnes linéairement indépendantes.

Prenons les vecteurs e1, e2, …., en+1, définis de la façon suivante :





















 0 0 0 1

1



e ,





















 0 0 1 0

2



e , ….,





















  1 0 0 0

1 

en

On remarque que les ei sont tous dans des classes d'équivalence différentes, et que tout autre vecteur de n+1 composantes peut être défini par une combinaison linéaire de e1, e2, …., en+1. Par conséquent, (e1, e2, …., en+1) peut être considéré comme une base de l'espace des colonnes de H.

Le rang de H est donc de n+1.

#

3) Montrons que la distance minimale du code obtenu est égale à 3:

Ceci revient à montrer que le poids minimum des mots du code est de 3.

On sait que si x est un mot du code C défini par la matrice de vérification H, alors :

0

H^T x

Supposons que le poids minimum est strictement inférieur à 3, prenons le cas où il serait égal à 2.