Rapport de TER Transformation de la matrice génératrice d un code quasi-cyclique. NARDEAU Nicolas, BENMOUSSA Wafa 2006-2007

Rapport de TER Transformation de la matrice génératrice d un code quasi-cyclique NARDEAU Nicolas, BENMOUSSA Wafa 2006-2007 1

Table des matières 1 Codes Correcteurs 3 1.1 Préliminaires.................................. 3 1.2 Codes Cycliques................................. 7 1.3 Quelques lemmes................................ 11 1.4 Codes Quasi-Cycliques............................. 13 2 Transformation de la matrice génératrice d un code quasi-cyclique 15 2.1 Partie théorique................................. 15 2.1.1 Objectif et méthode.......................... 15 2.1.2 Théorème de transformation...................... 16 2.2 Partie programmation de la transformation d une matrice d un code quasicyclique en Magma............................... 21 2.2.1 Bibliothèque contenant les fonctions et procédures.......... 21 2.2.2 Algorithme de transformation de la matrice............. 25 2.2.3 Graphe de complexité temps...................... 27 2.3 Différents exemples obtenus avec le programme en magma......... 28 2.3.1 Exemple sur F 2 avec des mots de longueur 75............ 28 2.3.2 Exemple sur F 2 avec des mots de longueur 35............ 31 2.3.3 Exemple sur F 3 avec des mots de longueur 35............ 32 2.3.4 Différentes matrices obtenus dans K n avec K = F 2 5......... 33 2

1 Codes Correcteurs 1.1 Préliminaires K un ensemble fini, non vide, n un entier naturel non nul. K n l ensemble des x = (x 1,.., x n ) tels que x i K. Définition 1 (Distance de Hamming) Soient x et y deux éléments de K n, la distance de Hamming entre x et y est le nombre de composantes pour lesquelles ces éléments sont différents si x = (x 1,.., x n ) et y = (y 1,.., y n ) alors d(x, y) := card{i = 1, 2.., n/x i y i }. a) d(x, y) R + b) d(x, y) = 0 x = y c) d(x, y) = d(y, x) d) d(x, y) d(x, z) + d(z, y) Définition 2 (Définition d un code) Un code sur K de longueur n est un sous-ensemble de K n. n est appelé la longueur du code C et les éléments de C sont appelés les mots du code. Exemple 1 Le code C = {(0, 1, 1), (1, 1, 1), (1, 0, 1)} est un code de longueur 3 sur K = F 2. Code Linéaires Définition 3 Soit K un corps un fini, K n un K-espace vecoriel. C est un code linéaire si et seulement si c est un sous espace vectoriel de K n. Il est de dimension k s il est un sous-espace vectoriel de dimension k. Définition 4 (Support d un mot) Soit x = (x 1,.., x n ) un mot de C. Alors :. Supp(x) := {i/x i 0} Définition 5 (Poids de Hamming) Soit x = (x 1,.., x n ) un mot de C. Alors w(x) = card(supp(x)) Définition 6 (Distance minimale d un code linéaire C) Soit C un code linéaire, sa distance minimale est définie par d := Min x C w(x) Propriétés 1 Soit d la distance de Hamming et w la fonction poids. Alors : a) d(x, y) = w(x y) b) w(x) = d(x, 0) c) w(x) = 0 x = 0 d) λ K et λ 0, w(λx) = w(x) e) w(x + y) w(x) + w(y) Propriétés 2 (Nombre de mots d un code linéaire C) Si q est le cardinal de K et si C est un code linéaire de longueur n et de dimension k. Alors le nombre de mots de C est q k. Preuve 1 C K k en tant que K-espace vectoriel. 3

Nombre d erreurs commises lors d une transmission : si x = (x 1,.., x n ) est un mot envoyé et x = (x 1,.., x n) le mot reçu. Alors le nombre d erreurs commises est d(x, x ). On suppose par exemple que d(x, x ) e (e est le nombre maximum d erreurs). Condition de décodage d ordre e, et rayon de recouvrement : Définition 7 (Condition de décodage) Un code C vérifie la condition de décodage d ordre e si pour tout x K n, il existe au plus un mot x C tel que d(x, x ) e. c-à-d que les boules fermées (pour la distance de Hamming) de rayon e centrées sur les mots de C sont 2 à 2 disjointes. Définition 8 (Rayon de recouvrement) Soit C un code de K n, et soit r le plus petit rayon tel que les boules de rayon r centrées en chaque mot de C forment un recouvrement de K n, r est appelé rayon de recouvrement de C. Remarque 1 Soit d la distance minimale d un code C : d = min x C w(x). Si d 2e + 1 alors C vérifie la condition de décodage d ordre e. Code Parfait Définition 9 (capacité de correction d un code) Soit e un entier, un code dont la distance minimale est d, est dit e-correcteur si la partie entière de d 1 est égale à e, e 2 s appelle alors la capacité de correction du code. Définition 10 Un code est dit parfait si sa capacité de correction est égale à son rayon de recouvrement. Codes équivalents - Soient C et D deux codes de longueur n, ils sont équivalents s il existe une permutation σ de 1, 2,.., n telle que D soit l image de C par ϕ : (x 1,.., x n ) (x σ(1),.., x σ(n) ) - Deux codes équivalents ont la meme capacité de correction et aussi les mêmes distances entres les mots, la même longueur et le même cardinal. Matrice génératrice d un code linéaire Définition 11 Une matrice génératrice d un code linéaire C sur le corps K est une matrice sur K dont les lignes forment une base de C. Remarque 2 Un code possède en général plusieurs matrices génératrices. Exemple 2 M = 1 0 0 1 0 0 1 0 1 1 0 0 1 0 1 La matrice M est de rang 3, c est la matrice d un code C de longueur 5 et de dimension 3 sur F 2 (C est (5, 3)) dont les mots seront : (1, 0, 0, 1, 0), (0, 1, 0, 1, 1), (1, 1, 0, 0, 1), (1, 0, 1, 1, 1), (0, 1, 1, 1, 0), (1, 1, 1, 0, 0), (0, 0, 1, 0, 1), (0, 0, 0, 0, 0). 4

Propriétés 3 Si G est une matrice génératrice de C, un code linéaire(n, k), alors : a) Les autres matrices génératrices de C sont de la forme A G où A est une matrice carrée inversible k k. b) Le code C est l ensemble des mots de la forme : x k = (u 1,.., u k ) G où U = (u 1,.., u k ) K k c) Si c 1,, c k sont les vecteurs colonnes de G, les mots du code C sont tous obtenus sous la forme x k = (< c 1, u >,.., < c k, u >) avec u K k et <.,. > est le produit scalaire usuel sur K k. Remarque 3 Une matrice G obtenue par permutation des colonnes de G serait une matrice génératrice d un code C équivalent à C. Définition 12 (matrice génératrice normalisée) Une matrice génératrice d un code C (n, k) est normalisée si la matrice formée par les k premières colonnes est la matrice unité. Définition 13 (Codages des messages au moyen d un code linéaire) Le codage des messages au moyen d une matrice génératrice G d un code C se résume : Message u = (u 1,.., u k ) x k = (u 1,.., u k ) G la matrice G est choisie comme matrice génératice d un code e-correcteur, et e est choisi en fonction des statistiques d erreurs commmises lors de la transmission. Si G est normalisée, alors on trouve : u = (u 1,.., u k ) (u 1,.., u k, x k+1, x k+2,.., x n ) u 1,.., u k sont appelés symboles d information et x k+1, x k+2,.., x n symboles de controles. Définition 14 (Code Systématique) Un code possédant une matrice génératrice normalisée entraine un code systématique. Orthogonal d un code C Définition 15 Soit C un code (n, k), le code orthogonal de C est l espace vectoriel orthogonal à C pour le produit scalaire usuel de K n. (le code orthogonal de C est un code linéaire (n, n k)) Définition 16 (Matrice de Controle) On appelle matrice de controle de C, toute matrice génératrice de son orthogonal. Propriétés 4 Soit H une matrice de controle de C et x = (x 1,.., x n ). Le mot x C ssi H t x = 0. Codes de Hamming binaires Définition 17 On appelle code de Hamming (binaire) de longueur 2 k 1 tout code admettant comme matrice de controle H, une matrice dont les 2 k 1 colonnes sont tous les vecteurs de F k 2 \ {0}, il est appelé code Hamming de paramètre k. 5

Exemple 3 Matrice de controle du code de Hamming de longueur 7. 1 0 0 0 1 1 1 H = 0 1 0 1 0 1 1 0 0 1 1 1 0 1 6

1.2 Codes Cycliques Définition 18 Un code C est dit cyclique si : a) C est un code linéaire. b) Si (x 1,.., x n ) C, alors (x n, x 1,.., x n 1 ) C. Exemple 4 Soit C le code de matrice génératrice : 1 0 0 1 0 0 1 0 0 G = 0 1 0 0 1 0 0 1 0 0 0 1 0 0 1 0 0 1 Ce code possède 2 3 = 8 éléments. On peut vérifier que pour chacun de ses mots, un décalage à droite donne un autre mot du code C. Par exemple le mot (110110110) qui est égal à la somme des deux premières lignes de G donne (011011011) qui est égal à la somme de la 2 eme et 3 eme lignes de G. Représentation polynomiale des codes cycliques - Soit C un code linéaire de longueur n, pour chaque mot m de C, m := (a 0,.., a n 1 ) on lui associe le polynôme m(x) := a 0 + a 1 X +.. + a n 1 X n 1. Un décalage à droite correspond donc à faire : Xm(X) mod(x n 1). - C est donc cyclique Ssi m C xm(x) mod(x n 1) est un polynôme associé à un mot de C. Définition 19 Soit K un corps fini, et soit n N. a) On appelle représentation polynomiale de K n, l application Θ de K n dans K[X]/(X n 1) : Θ : K n K[X]/(X n 1) (a 0,.., a n 1 ) a 0 + a 1 x +.. + a n 1 x n 1 b) On appelle représentation polynomiale d un code C, l ensemble des représentations polynomiales des mots de C : Θ(C). Remarque 4 La représentation polynomiale Θ de K n, est un isomorphisme d espace vectoriel sur K. Théorème 1 Soit C un code linéaire sur K, le code C est cyclique ssi sa représentation polynomiale Θ(C) est un idéal de K[X]/(X n 1). Preuve 2 Si C est cyclique, Xm(X) est dans Θ(C) pour tout élément m(x) de Θ(C), il en est de même pour les X i m(x) et puisque C est linéaire les polynômes (d 0 + d 1 X +...)m(x) aussi et donc tous les multiples quelconques de m(x). 7

Inversement, si tous les multiples quelconques d un élément m(x) de Θ(C) sont dans Θ(C) alors en particulier pour Xm(X), le code C est donc invariant par shift, si de plus Θ(C) est un sous-espace vectoriel, alors C est un code cyclique. Remarque 5 Si K est un corps, n un entier non nul, alors tout idéal de K[X]/(X n 1) est principal (la preuve de ce résultat repose sur l existence de la division euclidienne). Théorème 2 Soit Θ(C) l idéal de K[X]/(X n 1) associé à un code linéaire cyclique C. Soit g(x) un polynôme unitaire de plus petit degré dans Θ(C). Soit r := deg(g(x)). Alors on a les propositions suivantes : a) g(x) est l unique polynôme unitaire de degré r dans Θ(C). b) g(x) génère Θ(C) comme idéal principal de K[X]/(X n 1). c) g(x) divise x n 1 d) {X i g(x), i = 0,.., n r 1} est une base de Θ(C), considérée comme sous-espace vectoriel, alors pour tout P (X) de Θ(C), on peut trouver un ensemble de coefficients {a i K, i = 0,.., n r 1} tels que P (X) = n r 1 i=0 a i X i g(x) c-à-d P (X) = a(x)g(x) avec a(x) = n r 1 i=0 a i X i. Preuve 3 1) Si on suppose qu il existe g (X), un autre polynôme unitaire de degré r dans Θ(C) alors g(x) g (X) Θ(C), ce qui est impossible car deg(g(x) g (X)) r 1. 2) Supposons que g(x) ne génère pas Θ(C), cela revient a dire qu il existe P (X) de Θ(C) tel que P (X) = q(x)g(x) + r(x) où deg(r(x)) r 1, Comme Θ(C) est un idéal donc q(x)g(x) Θ(C) et r(x) = P (X) q(x)g(x) Θ(C) ce qui est aussi en contradiction avec l hypothèse faite sur g(x). 3) Supposons que g(x) ne divise pas x n 1. Alors : X n 1 = q(x)g(x) + r(x) avec deg(r(x)) r 1 et de meme le fait que r(x) appartienne à Θ(C) est en contradiction avec l hypothèse sur le degré de g. 4) Comme g(x) est un générateur de Θ(C), alors tout polynôme de Θ(C) est de la forme a(x)g(x) avec deg(a) n 1. Les polynômes g(x), Xg(X),.., X n 1 g(x) forment donc une famille génératrice de Θ(C), on veut en extraire une base. Soit a(x)g(x) un élément de Θ(C) et soit h(x) tel que X n 1 = g(x)h(x) dans K[X] en divisant a(x) par h(x) dans K[X] on trouve : a(x) = h(x)q(x) + r(x) avec deg(r(x)) deg(g(x)) où r(x) = 0, le reste r(x) est donc de la forme r(x) = r 0 + r 1 X +.. + r n r 1 X n r 1 d où : a(x)g(x) = h(x)q(x)g(x) + r(x)g(x). Donc a(x)g(x) = (X n 1)q(X) + r(x)q(x), en passant à K[X]/(X n 1) on a : a(x)g(x) = r(x)g(x) = r 0 g(x) + r 1 Xg(X) +.. + r n r 1 X n r 1 g(x) La famille g(x), Xg(X),.., X n r 1 g(x) est donc aussi une famile génératrice de Θ(C). 8

Montrons maintenant qu elle est aussi libre : Dans K[X]/(X n 1), supposons λ 0 g(x) + λ 1 Xg(X) +.. + λ n r 1 X n r 1 g(x) = 0 ceci implique dans K[X] que (λ 0 + λ 1 X +.. + λ n r 1 X n r 1 )g(x) 0[X n 1]. Soit P (X) := λ 0 + λ 1 X +.. + λ n r 1 X n r 1. Le polynôme P est soit nul soit de degré inférieur à n 1 et en même temps divisible par X n 1, donc P (X)g(X) = 0 dans K[X] mais on sait que K[X] n a pas de diviseurs de 0 et on sait aussi que g(x) est non nul d où P (X) = 0 d où λ 0 = λ 1 = = λ n r 1 X n r 1 = 0, alors la famille en question est bien libre et donc c est bien une base. Remarque 6 On trouve bien que la dimension d un code cyclique de longueur n, dont le générateur est g(x), est k = n deg(g(x)). Théorème 3 Soit g(x) = g 0 + g 1 X +.. + g r X r le générateur d un code cyclique C de longueur n sur K, la matrice G à k lignes et n colonnes suivante où r = deg(g(x)) = n k, est une matrice génératrice de C. g 0 g 1 g 2... g r 0... 0 0 g 0 g 1 g 2... g r... 0 G =.................... 0... 0 g 0 g 1 g 2... g r Preuve 4 Une matrice génératrice est obtenue en choisissant comme lignes les n-uplets correspondants aux polynômes de la base précédente. Soit : g(x), Xg(X),.., X n r 1 g(x) Ce sont tous les décalages successifs du premier, d ou le résultat. Exemple 5 La décomposition de X 7 1 en diviseurs irréductibles de F 2 est : X 7 1 = (X 1)(X 3 + X + 1)(X 3 + X 2 + 1) Les codes cycliques de longueur 7 sur F 2 différents de {0} sont donc ceux générés comme suit : C 0 : g 0 (X) = X 7 1 = 0 C 0 = {0,.., 0} C 1 : g 1 (X) = X 1 C 2 : g 2 (X) = X 3 + X + 1 C 3 : g 3 (X) = X 3 + X 2 + 1 C 4 : g 4 (X) = (X 1)(X 3 + X + 1) = X 4 + X 3 + X 2 + 1 C 5 : g 5 (X) = (X 1)(X 3 + X 2 + 1) = X 4 + X 2 + X + 1 C 6 : g 6 (X) = (X 3 + X + 1)(X 3 + X 2 + 1) = X 6 + X 5 + X 4 + X 3 + X 2 + X + 1 Pour C 4, on a : G 4 est une matrice génératrice G 4 = 1 0 1 1 1 0 0 0 1 0 1 1 1 0 0 0 1 0 1 1 1 9

En appliquant le théorème sur la dimension de chaque code, on trouve effectivement que la dimension de C 4 est 3 Pour les autres on a : C 0 : 0, C 1 : 6, C 2 : 4, C 3 : 4, C 4 : 3, C 5 : 3, C 6 : 1. 10

1.3 Quelques lemmes Lemme 1 Soit C un code cyclique de longueur m, soit Θ(C) sa représentation polynomiale et M une matrice génératrice de C de taille m m. Alors, le pgcd de X m 1 et des polynômes L i (X) dont les coefficients sont respectivement les éléments des lignes de M est le polynôme g(x) générateur de l idéal Θ(C). Preuve 5 On pose d(x) = pcgd(l 1 (X), L 2 (X)..., L m (X), X m 1). D abord on a g(x) d(x), car g(x) L i (X) i = 1...m et g(x) X m 1. De plus g(x) Θ(C) et donc : m g(x) = y i (X)L i (X) car (L i (X) m i=1) est une base de Θ(C). i=1 m = y i (X)L i (X) + 0 (X m 1) i=1 m = ( y i (X)a i (X)) d(x). i=1 Alors d(x) g(x). Et on a bien : g(x) = d(x). Lemme 2 Soit l application ϕ : M r,m (F q ) M m,m (F q ) ; M M avec r m telle que : ( ) M r M = m r 0 L application ϕ ne change pas le code engendré par les lignes de la matrice. Preuve 6 Soient L i (X), i = 1...m, les polynômes correspondants aux lignes de M. m i=1 λ i(x)l i (X) = r i=1 λ i(x)l i (X) + m i=r+1 λ i(x)l i (X) Car m i=r+1 λ i(x)l i (X) = 0 car L i (X) = 0, i = r + 1...m Lemme 3 Soient C un code cyclique de longueur m, M une matrice génératrice normalisée de C, r le rang de M (c est aussi son nombre de lignes), et soit g(x) le polynôme générateur de l idéal Θ(C). Soit G = (g 0, g 1,..., g m r, 0,..., 0) M 1,m (F q ). Alors on a : G ϕ(m) = G Preuve 7 On a : M = ( I r A ) tel que I r matrice identité M r,r Alors G = G ϕ(m) = (g 0, g 1,..., g m r, 0,..., 0) ( M 0 ) 11

Et donc : ( ) G Ir A = (g 0, g 1,..., g m r, 0,..., 0) = (g 0 0 0, g 1,..., g r, g r+1,..., g m) On a G et G deux éléments de C. Or W = G G = (0, 0,..., 0, g r+1,..., g m ) C et W s écrit donc en combinaison linéaire des vecteurs de la base de C. Alors : W = r i=1 λ il i = (λ 1, λ 2,..., λ r, λ r+1,..., λ m) Or on sait que W = (0, 0,..., 0, g r+1,..., g m ) et donc λ i = 0, i = 1..r. Puisque W = r i=1 λ il i alors W = 0,d où G = G, et donc G ϕ(m) = G. 12

1.4 Codes Quasi-Cycliques Soit σ la permutation circulaire (l opérateur de décalage d un rang vers la droite) Un code linéaire C de longueur n, de dimension k et de distance d, est dit quasi-cyclique s il vérifie : l N /σ l C, c C. Le plus petit entier naturel vérifiant ceci est appelé l indice du code. On réordonne les éléments Soit C un code quasi-cyclique de longueur n, de dimension k, de distance d et d indice l sur F q, posons n = r l. C = (x 0,.., x l 1 x l,.., x 2l 1 x 2l,.., x 3l 1... x l(r 1),.., x lr 1 ) On réorganise les mots pour trouver : C = (x 0, x l, x 2l,.., x l(r 1) x l, x l+1,.., x l(r 1)+1... x l 1, x 2l 1,.., x lr 1 ) Et ceci moyennant l application suivante : où : Φ : (A 0, A 1,.., A j = ((x jl+i ) l 1 i=0 ),.., A r 1) (C 0, C 1,.., C j = ((x il+j ) r 1 i=0 ),.., C l) C 0 = (x 0, x l, x 2l,..., x l(r 1) ), C 1 = (x l, x l+1,..., x l(r 1)+1 ),..., C l = (x l 1, x 2l 1,.., x lr 1 ) Or le code C est quasi-cyclique d indice l donc par construction, les C i sont bien des codes cycliques. Dans toute la suite de notre travail, nous utiliserons des codes quasi-cycliques organisés comme présenté ci-dessus aprés le passage par l application Φ. Notation : Désormais, on notera :. l l indice du code quasi-cyclique.. m longueur des codes cycliques qui composent le code quasi-cyclique. On obtient alors un code dont la longueur des mots est égale à m l que l on notera n. si x est un mot du code alors il est de la forme : x = (x 1, x 2.., x m x m+1, x m+2.., x 2m... x (l 1)m+1,.., x lm ) Construction d une matrice génératrice d un code quasi-cyclique : espace vectoriel de dimension n = m l sur F q. Soit V un Soit v un élément de V tiré au hasard. V := {(x 1,.., x n )/x i F q pour x i = 1..n} v = (x 1, x 2.., x m x m+1, x m+2.., x 2m... x (l 1)m+1,.., x lm ) 13

Soit σ la permutation définie comme suit : σ : V V x := (x 1, x 2.., x m x m+1, x m+2.., x 2m... x (l 1)m+1,.., x lm ) (x m, x 1.., x m 1 x 2m, x m+1.., x 2m 1... x lm, x (l 1)m+1,.., x lm 1 ) La permutation σ que nous venons de définir va nous permettre de construire une matrice génératrice du code. Travaillons sur notre élément v, à partir de cet élément nous allons construire une famille de m vecteurs par application de σ. Notons cette famille B, on a alors B := {V, σ(v ), σ 2 (V ),.., σ m 1 (V )} Cette famille est la plus grande que l on puisse construire à partir de σ car (σ m = Id). On obtient donc une famille de m vecteurs. On vérifie alors que ces vecteurs soient libres (sinon on en extrait une famille libre) et par juxtaposition de ces vecteurs ont construit la matrice M suivante : 0 1 x 1 x 2... x m x m+1 x m+2... x 2m... x (l 1)m+1 x (l 1)m+2... x lm x m x 1... x m 1 x 2m x m+1... x 2m 1... x lm x (l 1)m+1... x lm 1 M = B C @..................... A x 2 x 3... x 1 x m+2 x m+3... x m+1... x (l 1)m+2 x (l 1)m+3... x (l 1)m+1 Cette matrice est la matrice génératrice d un code quasi-cyclique. 14

2 Transformation de la matrice génératrice d un code quasi-cyclique 2.1 Partie théorique 2.1.1 Objectif et méthode Notre objectif est de réaliser la transformation d une matrice génératrice d un code quasi-cyclique en une forme canonique unique. Supposons que l on possède la matrice M génératrice d un code quasi-cyclique. Cette matrice peut être vue en bloc sous la forme suivante. M := (M 1 M 2.. M l ) Les M i sont des matrices de taille m m auxquelles on peut associer un code cyclique que l on notera C i. Pour réaliser la transformation de cette matrice, nous effectuons les étapes suivantes : On applique à la matrice M un pivot de gauss. On obtient alors une nouvelle matrice M. Par suite, on travaille sur la matrice M1. On récupère le générateur g 1 du code C 1 et le rang r 1 de la matrice M1. On effectue la multiplication g 1 ϕ(m) (où ϕ est l application définie dans le lemme 2). On récupère alors le premier générateur G 1 de la matrice. Ce générateur engendrera les r 1 premières lignes. Puis on réitère le même procédé avec la matrice M 2 en enlevant les r 1 premières lignes (on note le rang de cette matrice r 2 ). On obtient ainsi le deuxième générateur G 2. On continue comme cela jusqu à ce que r i = m. A partir de maintenant, on travaille uniquement sur les générateurs G i. Nous allons effectuer une réduction. Pour réduire un générateur G i, on utilise les générateurs G j tels que j > i. Regardons les générateurs comme suit : G 1 = ( g 1 f 11 f 12... f 1l ) G 2 = ( 0 g 2 f 22... f 2l ) Chaque élément de G i est en faite un vecteur de longueur m qui selon sa position appartient à un des codes C i. Dans ce cas, on travaille dans le code C 2. En utilisant la représentation polynomiale, on effectue la division de f 11 par g 2. On a f 11 = g 2 q + r11 et donc r 11 = f 11 g 2 q. On remplace alors f 11 par r 11. Pour que le mot appartienne toujours au code quasi-cyclique, il faut reporter l opération sur le reste du mot en posant r 1i = f 1i f 2i q, i = 2... l et en remplaçant f 1i par r 1i. Puis on recommence cette opération sur G 1 avec les autres vecteurs G j tel que j > 2. Ensuite on effectue le même type d opération sur G 2 avec les G j tels que j > 2. Puis sur G 3, G 4,..., et ceux juqu à épuisement des G i. 15

On peut alors construire la nouvelle matrice à l aide de la permutation σ définie dans la construction d une matrice (section 1.4). Pour chaque G i, on effectue r i permutation, puis on juxtapose les vecteurs. On obtient alors la matrice : A 1 B 1...... M 0 A 2...... = 0 0...... 0 0 0 A k Tels que les A i sont de la forme en posant s i := m r i où r i est le rang de la matrice : g i,0 g i,1 g i,2... g i,si 0... 0 0 g i,0 g i,1 g i,2... g i,si... 0 A i =.................... 0... 0 g i,0 g i,1 g i,2... g i,si Les A i sont des matrices génératrices de codes cycliques et le générateur de ce code est le mot g i = (g i,0, g i,1, g i,2,..., g i,si, 0,..., 0). La matrice obtenu par ce procédé est unique et canonique. 2.1.2 Théorème de transformation Théorème 4 Soit C un code quasi-cyclique, alors il existe une unique matrice M génératrice de forme canonique (forme définie précédement) qui généralise les matrices canoniques des codes cycliques. Preuve 8 Soit C un code quasi-cyclique de longueur n = m l, et soit M une matrice génératrice de ce code de taille m n. On réalise un pivot de Gauss sur cette matrice et on obtient une autre matrice génératrice du code quasi-cyclique que l on note toujours M. Après cela, on procède aux opérations suivantes : Modification de la matrice : Regardons maintenant les blocs concaténés qui forment la matrice, ils sont tous de taille m m. Chacun d entre eux représente un code cyclique que l on notera C i pour i = 1... l et auxquels on associe la matrice M i. M := (M 1 M 2.. M l ) On commence par le code cyclique C 1 dans un premier temps on récupère le rang r 1 de la matrice M 1. Extraction du polynôme générateur de C 1 : On veut trouver le générateur du code cyclique C 1 que l on note g 1 (X). On connait maintenant le degré du polynôme recherché deg(g 1 (X)) = s 1 = m r 1 où r 1 est le rang de la matrice M 1. 16

On sait que g 1 (X) divise X m 1 ainsi que tout les polynômes L i (X) dont les coefficients sont les éléments de la i-ème ligne de la matrice M 1. On effectue donc un calcul de pgcd :. pgcd 1 = pgcd(l 1 (X), X m 1). pgcd 2 = pgcd(l 2 (X), pgcd 1 ).. pgcd i = pgcd(l i (X), pgcd i 1 ) tant que deg(pgcd i ) deg(g 1 (X)) On en déduit alors : 1 Le degré des pgcd diminue : On a pgcd i+1 = pgcd(l i+1 (X), pgcd i ). donc pgcd i+1 pgcd i. donc deg(pgcd i+1 ) deg(pgcd i ). 2 Si l algorithme va jusqu à la m ème étapes alors : pgcd m = pgcd(pgcd m 1, L m(x)) pgcd m = pgcd(pgcd(pgcd m 2, L m 1), L m (X)). pgcd m = pgcd(pgcd(... pgcd(pgcd(l 1 (X), X m 1)L 2 (X))L 3 (X)... L m (X)) En appliquant Bézout on trouve : pgcd(l 1 (X), X m 1) = U 1 (X)L 1 (X) + U 2 (X)(X m 1) Si on le réapplique à chaque fois que l on calcule un pgcd dans la formule de pgcd m trouve alors : on pgcd m =... U 3 (X)(U 1 (X)L 1 (X) + U 2 (X)(X m 1)) + U 4 (X)L 2 (X))... pgcd m = U 0(X)(X m 1) + U 1(X)L 1 (X) +... + U m (X)L m (X) Donc puisqu il existe U 0(X), U 1(X)... U m (X) tels que : pgcd m = U 0(X)(X m 1) + U 1(X)L 1 (X) +... + U m (X)L m (X). Alors pgcd m = pcgd(l 1 (X) + L 2 (X)... + L m (X), X m 1). D après le lemme 1 on sait que : g 1 (X) = pcgd(l 1 (X), L 2 (X)..., L m (X), X m 1) Donc on trouve bien que pgcd m = g 1 (X). Donc même au pire, si l agorithme va jusqu à la m ème étape on tombe sur le polynôme générateur g 1 (X). 17

Récupération des vecteurs générateurs G i : On effectue le produit de G = (g 0, g 1,..., g m r1, 0,..., 0) M 1,m (F q ) par ϕ(m) = (M 1 M 2... M l ) où M est la matrice du code quasi-cyclique, et ϕ est l application définie dans le Lemme 2 : On fait : (g 0, g 1,..., g m r1, 0,..., 0)(M 1 M 2... M l ) En tenant compte du Lemme 3, on trouve : G 1 = (g 1, g 2.., g m r1, 0,..., 0 f 1 1, f 1 2,.., f 1 m f 2 1, f 2 2,.., f 2 m... f l 1 1, f l 1 2,.., f l 1 m ) C est le premier vecteur générateur qu on récupère. Pour le 2ième vecteur générateur on réapplique la même chose à la matrice M constituée par les m r 1 dernières lignes de M (on a bien vu dans le Lemme 2 que l application ϕ ne change pas le code engendré par la matrice) On cherche par le même algorithme le polynôme générateur g 2 (X) du code cyclique C 2 dont la matrice génératrice est M 2 constituée par les m r 1 dernières lignes de M 2, on pose r 2 le rang de M 2. On effectue le produit de G = (g 2,0, g 2,1,..., g 2,m r2, 0,..., 0) M 1,m (F q ) par ϕ(m ), on trouve donc le vecteur suivant : G 2 := (0, 0,..., 0 g 2,0, g 2,1,..., g 2,m r2, 0,..., 0 P 1 1, P 1 2,.., P 1 m,.., P l 2 1, P l 2 2,.., P l 2 m ) On prendra donc comme second générateur le vecteur G 2. Et ainsi de suite on récupére tous les vecteurs générateurs on s arrête lorsque r i = m. Dorénavant, on va travailler exclusivement sur ces vecteurs générateurs. Réduction des G i : Le principe : On réduit chaque générateur G i par tous les G j qui le suivent (pour les j i + 1) Réduction de G 1 par G 2 : on a : et G 1 = (g 1, g 2.., g m r1, 0,..., 0 f 1 1, f 1 2,.., f 1 m f 2 1, f 2 2,.., f 2 m... f l 1 1, f l 1 2,.., f l 1 m ) G 2 := (0, 0,..., 0 g 2,0, g 2,1,..., g 2,m r2, 0,..., 0 P 1 1, P 1 2,.., P 1 m,.., P l 2 1, P l 2 2,.., P l 2 m ) On va réduire G 1 par G 2 : Soit f 1 (X) le polynôme dont les coefficients sont (f 1 1, f 1 2,.., f 1 m). On effectue la division euclidienne de f 1 (X) par g 2 (X) : On trouve : f 1 (X) = q 1 (X)g 2 (X) + r 1 (X) Donc, r 1 (X) = f 1 (X) q 1 (X)g 2 (X) Montrons que r 1 (X) Θ(C 2 ) (Θ(C 2 ) la représentation polynomiale du code cyclique C 2 ) On sait que f 1 (X) Θ(C 2 ) car : 18

G 1 = (g 1, g 2.., g m r1, 0,..., 0 f 1 1, f 1 2,.., f 1 m f 2 1, f 2 2,.., f 2 m... f l 1 1, f l 1 2,.., f l 1 m ) appartient au code quasi-cyclique C = (C 1 C 2... C l ) en tant que code quasi-cyclique constitué par des codes cycliques concaténés. On sait aussi que q 1 (X)g 2 (X) Θ(C 2) =< g 2 (X) > et puisque C 2 C 2 alors q 1 (X)g 2 (X) Θ(C 2 ) et donc r 1 (X) Θ(C 2 ) pour tout i = 2...l 1. On pose : r i (X) = f i (X) q 1 (X)P i 1 (X) Les r i (X) appartiennent bien à Θ(C i+1 ) car :. f i (X) Θ(C i+1 ). q 1 (X)P i 1 (X) Θ(C i+1 ) [car P i 1 (X) Θ(C i+1 ) et C i+1 est un code cyclique]. On récupère donc un vecteur : G 1 := (g 1, g 2.., g m r1, 0,..., 0 r 1 1, r 1 2,.., r 1 m r 2 1, r 2 2,.., r 2 m... r l 1 1, r l 1 2,.., r l 1 m ) qui appartient bien au code quasi-cyclique C = (C 1 C 2... C l ). On a donc effectué la réduction de G 1 par G 2, on aura alors à réduire G 1 par G 3 et ainsi de suite.. Ceci est en ce qui concerne la réduction du vecteur générateur G 1. On récupère à la fin le premier vecteur générateur réduit : G 1 = (g 1, g 2.., g m r1, 0,..., 0 R 1 1, R 1 2,.., R 1 m R 2 1, R 2 2,.., R 2 m... R l 1 1, R l 1 2,.., R l 1 m ) On passe alors à la réduction du vecteur générateur G 2 par tous les G j qui le suivent (pour les j 3), on commencera donc par le réduire par G 3, même démarche et ainsi de suite.. Lorsqu on sera arrivé au bout de la réduction de G 2, on récupèrera le 2 ième vecteur générateur réduit : G 2 = (0, 0,..., 0 g 2,0, g 2,1,..., g 2,m r2, 0,..., 0 S 1 1, S 1 2,.., S 1 m,.., S l 2 1, S l 2 2,.., S l 2 m ) On réduira de la même manière les autres vecteurs générateurs. Reconstruction d une matrice génératrice du code quasi-cyclique C à partir des vecteurs générateurs réduits : À l issue de l opération de réduction, on aura obtenu des vecteurs : G 1 = (g 1, g 2.., g m r1, 0,.., 0 R 1 1, R 1 2,..., R 1 m R 2 1, R 2 2,.., R 2 m... R l 1 1, R l 1 2,.., R l 1 m ) G 2 = (0, 0,..., 0 g 2,0, g 2,1,..., g 2,m r2, 0,..., 0 S1, 1 S2, 1..., Sm... S 1 1 l 2, S2 l 2,.., Sm l 2 ) G 3 = (0, 0,..., 0 0, 0,..., 0 g 3,0, g 3,1,..., g 3,m r3, 0,..., 0 T1 1, T2 1,.., Tm.. T 1 1 l 3, T2 l 3,.., Tm l 3 ). Soit σ la permutation qui correspond à un shift. On effectue sur chaque G i : r i shifts successifs. Et on récupère ainsi pour chaque G i, la matrice : G i σ(g i ) r i. σ r i (G i ) 19

Supposons qu on avait récupéré k vecteurs G i. La famille (G 1, σ(g 1 ),.., σ r 1 (G 1 ), G 2, σ(g 2 ),.., σ r 1 (G 2 ),.., G k, σ(g k ),.., σ r k (G k )) est une famille libre, car déja les G i pour (i = 1..k) sont libres entre eux par construction (voir leurs formes ci-dessus, l emplacement des zéros au début de chaque vecteur empeche le fait qu ils soient liés) Ensuite, en faisant des shifts, le même argument tient. C est donc une famille libre du code quasi-cyclique C qui est de cardinal k i=1 r i, Or par construction, on sait que k i=1 r i = m donc c est bien une base de C. Nous allons donc prendre pour nouvelle matrice P génératrice du code quasi-cyclique C la matrice : P = G 1 σ(g 1 ). σ r 1 (G 1 ) G 2 σ(g 2 ). σ r 2 (G 2 ). G k σ(g k ). σ r k (G k ) En forme plus détaillée peut être : A 1 B 1...... 0 A 2...... P =. 0 0..... 0 0... A k Tels que les A i sont de la forme (on pose s i := m r i ) : g i,0 g i,1 g i,2... g i,si 0... 0 0 g i,0 g i,1 g i,2... g i,si... 0 A i =.................... 0... 0 g i,0 g i,1 g i,2... g i,si La matrice P ainsi obtenu est unique car après l étape du pivot de Gauss, chaque étape effectuer entraine un résultat unique. En effet, lorsqu on l on cherche les générateurs g, il n en existe qu un à chaque fois. De plus lorsque l on effectue les réductions à l aide des différents vecteurs, l unicité découle directement de la division euclidienne. Les différentes étapes entrainent donc l unicité de la matrice obtenue et cette forme est canonique quelque soit le code quasi-cyclique sur lequel on travaille. 20

2.2 Partie programmation de la transformation d une matrice d un code quasi-cyclique en Magma 2.2.1 Bibliothèque contenant les fonctions et procédures /************************************************************************/ /*** procédure qui réalise la permutation dans un code quasi-cyclique ***/ /*** de longueur n, d indice l et ayant des codes cycliques engendrés ***/ /*** par des polyn^omes qui divise X^m-1 avec m=n/l ***/ /************************************************************************/ procedure sigma(~x,m,l) // x : élément sur lequel on effectue les permutations // m : longueur des cycles // l : indice du code quasi-cyclique for i:= 0 to l-1 do tmp:=x[m*i+m]; for j:=m-1 to 1 by -1 do x[m*i+j+1]:=x[m*i+j]; end for; x[m*i+1]:=tmp; end for; end procedure; /*******************************************************/ /*** fonction qui construit la liste contenant les ***/ /*** permutations de l élément tirer au hasard ***/ /*******************************************************/ procedure list(x,~l,k,l) // x : élément aléatoire // L : liste où l on stocke les permutations // k : nombres de permutations effectuées // l : indice du code tmp:=x; L[1]:=x; for i:= 2 to k do sigma(~tmp,m,l); L[i]:=tmp; end for; end procedure; 21

/***************************************************************/ /*** procédure de création de la matrice génératrice du code ***/ /***************************************************************/ function matrice_du_code(l,m,n,fq) // L: liste à partir de laquelle on genere la matrice du code M:=KMatrixSpace(Fq,m,n)![p:p in L]; C:=LinearCode(M);C; MAT:=GeneratorMatrix(C); return MAT; end function; /*****************************************************/ /*** fonction qui renvoie le polyn^ome generateur ***/ /*** d un code cyclique sous la forme d un vecteur ***/ /*****************************************************/ function generateur(a,m,fq) // A:matrice du code // m:longueur du code cyclique F<x>:=PolynomialRing(Fq); r:=rank(a); // récupere le rang de la matrice // initialisation des variables : f=polyn^ome,i=compteur f:=0;i:=1;ftmp:=x^m-1;g:=x^m-1; while (Degree(g) ne m-r) and (i le 7) do for j:=1 to m do f:=f+a[i][j]*x^(j-1); // construction du polyn^ome end for; g:=gcd(f,ftmp); // calcul du pgcd de f et de g ftmp:=g; i:=i+1; end while; v:=coefficients(g); // on récupere les coefficients du polyn^ome // on convertit au format qui nous convient gene:=[**]; for i:=1 to m do if (i le #v) then gene[i]:=v[i]; 22

else gene[i]:=0; end if; end for; gener:=vector([p:p in gene]); return gener; end function; /************************************************************************/ /*** fonction qui extrait la partie d un vecteur nécesssaire ***/ /*** à la multiplication pour recuperer la premiere ligne d un "bloc" ***/ /************************************************************************/ function extractvect(v,d) // v générateur d un code cyclique // d nombre de lignes restant dans la matrice génératrice du code u:=[**]; // initialisation chaine vide // on récupere les coordonnées du vecteur générateur dont on a besoin for i:= 1 to d do u[i]:=v[i]; end for; // on convertit la liste en vecteur u:=vector([p:p in u]); return u; end function; /*********************************************************************/ /*** procédure de construction d un polyn^ome à partir d un vecteur ***/ /*********************************************************************/ procedure polyn^ome(~f,v,m,a,fq) // f polyn^ome que l on renvoie // v vecteur dans lequel on récupère le polyn^ome // m longueur des codes cycliques // a variable qui permet de ce positionner dans le bon code cyclique F<x>:=PolynomialRing(Fq); f:=0; for i:= 1 to m do f:=f+v[a*m+i]*x^(i-1); 23

end for; end procedure; /**************************************************************************/ /*** procedure qui remplace un vecteur d un des codes quasi-cycliques ***/ /*** par le reste de la division ***/ /**************************************************************************/ procedure remplace(~v,m,r,a) // v vecteur que l on modifie // m longueur des codes cycliques // r polyn^ome reste avec lequel on effectue le remplacement // a variable qui permet de ce positionner dans le bon code cyclique c:=coefficients(r); // récupération des coefficients du polyn^ome // remplacement dans le vecteur par les coefficients du polyn^ome // puis par des zéro pour compléter for h:=1 to m do if (h le #c) then v[a*m+h]:=c[h]; else v[a*m+h]:=0; end if; end for; end procedure; /************************************************************************/ /*** procédure qui réalise la reduction du vecteur generateur de bloc ***/ /*** par division euclidienne ***/ /************************************************************************/ procedure reduct_ligne(~g,m,l,k,h,p,fq) // G liste qui contient les vecteurs générateur de la matrice // m longueur des codes cycliques // l indice du code quasi-cyclique // k élément de la liste que l on veut modifier // h élément de la liste gr^ace auquel on effectue la réduction // p variable qui permet de savoir dans quel bloc on travail F<x>:=PolynomialRing(Fq); // on trouve le quotient et le reste 24

fi:=0;g:=0; polyn^ome(~fi,g[k],m,p,fq); // on récupère le polyn^ome à modifier print"fi:=",fi; polyn^ome(~g,g[h],m,p,fq); // on récupère le polyn^ome par lequel on divise print"g:=",g; r:=fi mod g; // récupèration du reste de la division print"r:=",r; q:=fi div g; // récupèration du quotient de la division print"q:=",q; remplace(~g[k],m,r,p); // remplacement de f par le reste r // répércution et modification sur le reste de la ligne for e:=p+1 to l-1 do polyn^ome(~fi,g[k],m,e,fq); // on récupère le polyn^ome à modifier print"fi:=",fi; polyn^ome(~g,g[h],m,e,fq); // on récupère le polyn^ome qui sert à la modification print"g:=",g; r:=((fi-(g*q))mod (x^m+1)); // on répercute la modification print"g*q:=",g*q;print"r:=",r; remplace(~g[k],m,r,e); // remplacement de f par le r trouver end for; end procedure; 2.2.2 Algorithme de transformation de la matrice /**********************************************************/ /*** Mise en place des différentes valeurs nécessaires ***/ /**********************************************************/ // chargement de la bibliothèque qui contient les fonctions et les procédures load"bibliotheque_final.mag"; // déclartion des différentes constantes SetOutputFile("code_quasi_cyclique.txt":Overwrite); q:=2;l:=3;m:=7; n:=l*m; Fq:=GF(q); V:=VectorSpace(Fq,n); F<x>:=PolynomialRing(Fq); 25

print"q:=",q,"\tl:=",l,"\tm:=",m,"\tn:=",n; v:=random(v); print "\nelement aléatoire:\n"; print v,"\n"; // construction et réalisation de la mise sous forme canonique de la matrice du code L:=[**];list(v,~L,m,l); // on génère la liste contenant les permutations MAT:=matrice_du_code(L,m,n,Fq); // on construit la matrice du code m1:=rank(mat); // on récupère le rang de la matrice du code i:=1;r:=0;j:=0; // initialisation des compteurs // i : permet de se placer dans la bonne partie de la matrice // r : somme des différents rang // j : permet de connaitre le nombre de vecteur générateur G:=[**];RANG:=[**];pos:=[**]; // initialisation des listes // G : liste des générateurs // RANG : liste des différents rang // pos : liste permettant de se placer dans la matrice while(r lt m1) do j:=j+1; // récupération de la sous matrice sur laquelle on travaille A:=SubmatrixRange(MAT,r+1,m*(i-1)+1,m1,i*m); rang:=rank(a);print"rang du",j,"eme code cyclique:",rang; // rang de cette matrice if (rang eq 0) // si le rang est nul j incremente then i:=i+1; // et je passe à la boucle suivante j:=j-1; continue; end if; gene:=generateur(a,m,fq); // on récupère le générateur du code cyclique print"generateur:",j,"eme bloc:",gene; A:=SubmatrixRange(MAT,r+1,1,m1,n); // on recupere la sous matrice à modifier v:=extractvect(gene,m1-r); // on met le vecteur à taille pour la multiplication G[j]:=v*A;G[j]; // on récupère le vecteur generateur du j eme bloc RANG[j]:=rang; // on récupère le rang de ce bloc pos[j]:=i; // on recupère la position de ce bloc dans la matrice r:=rang + r ; // on fait la somme des rangs des différents blocs i:=i+1; end while; // Reduction des différents générateurs for k:=1 to j-1 do 26

for h:=k+1 to j do reduct_ligne(~g,m,l,k,h,pos[h]-1,fq); end for; end for; // on réalise l affichage des générateurs réduits for i:=1 to j do G[i]; end for; print "\n"; // on reconstruit la matrice qui a la forme canonique souhaitée H:=[**];i:=1; while (r ne 0) do L:=[**]; list(g[i],~l,rang[i],l); H:= H cat L; r:=r-rang[i]; i:=i+1; end while; M:=KMatrixSpace(Fq,m1,n)![p:p in H];M; UnsetOutputFile(); 2.2.3 Graphe de complexité temps 350 300 250 Temps en seconde 200 Temps de calul en fonction de la longueur des mots du code 450 complexite.txt using 1 :2 400 150 100 50 0 10 100 1000 10000 100000 Longueur des mots du code 27

2.3 Différents exemples obtenus avec le programme en magma 2.3.1 Exemple sur F 2 avec des mots de longueur 75 q := 2 l := 5 m := 15 n := 75 Element aléatoire : (1 1 1 0 1 0 1 1 0 0 1 0 0 0 1 0 0 1 1 0 1 0 0 0 1 1 0 1 1 1 1 0 0 1 0 1 0 0 1 1 1 1 1 0 0 0 0 0 1 1 1 0 1 0 0 0 0 0 1 0 0 0 0 0 1 0 1 1 0 0 0 0 1 1 1) Matrice générée à partir des permutations et de la fonction LinearCode() : [1 0 0 0 1 1 1 1 0 1 0 1 1 0 0 0 0 0 0 0 0 1 1 1 0 0 1 1 1 0 0 0 0 0 1 1 0 1 0 0 0 0 0 0 1 0 1 0 1 0 1 0 1 0 1 0 0 1 1 0 0 0 0 1 1 0 1 0 1 1 0 1 1 1 0] [0 1 0 0 0 1 1 1 1 0 1 0 1 1 0 0 0 0 0 0 0 0 1 1 1 0 0 1 1 1 0 0 0 0 1 0 1 0 1 1 1 0 0 0 1 0 1 1 0 1 0 0 0 1 0 1 1 0 1 1 1 0 1 1 0 0 0 0 1 0 0 0 0 0 0] [0 0 1 0 0 0 1 1 1 1 0 1 0 1 1 0 0 0 0 0 0 1 1 1 1 0 1 1 1 1 0 0 0 0 1 0 1 1 0 0 0 0 1 1 1 0 1 1 1 0 1 1 1 1 0 1 0 0 1 1 0 1 0 1 1 0 0 1 0 0 0 1 1 0 0] [0 0 0 1 1 1 1 0 1 0 1 1 0 0 1 0 0 0 0 0 0 0 1 0 1 0 0 1 0 1 0 0 0 0 0 1 1 0 1 1 1 1 1 0 1 0 0 1 0 1 1 0 1 0 1 1 0 0 0 1 0 0 1 1 0 1 1 1 0 0 0 0 1 0 0] [0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 1 0 0 1 1 1 0 0 0 0 0 0 0 0 1 0 0 0 0 1 1 1 0 0 1 1 1 1 1 1 0 0 0 0 1 0 0 1 1 0 1 1 1 1 0 0 1 0 1 1 0 1 1] [0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 1 0 0 1 1 1 0 0 0 0 0 0 0 0 1 0 0 0 0 1 1 1 0 1 0 0 0 0 0 0 1 1 1 1 0 1 1 1 1 0 1 1 1 1 0 0 1 0 1 1 0 1] [0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 1 0 0 1 1 1 0 0 0 0 1 1 0 0 1 1 1 0 0 1 0 0 0 0 1 1 1 0 1 1 0 0 1 0 1 0 0 1 0 1 0 0 1 0 1 1 0 0 0 0 1] [0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 1 0 1 0 1 1 1 1 0 0 0 0 0 1 0 0 0 1 1 0 1 1 1 0 1 1 1 0 0 0 0 1 1 0 1 1 0 0 0 0 0 1 0 1 0 1 1 1 0 1 0 1 1] [0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 1 0 0 1 0 1 1 0 0 0 0 1 1 0 0 0 1 0 0 1 0 0 0 0 0 0 0 1 0 0 0 1 1 0 1 1 1 1 0 0 0 1 0 1 1 1 0 1 1 0 0 1] [0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 1 1 1 0 0 1 0 0 0 0 0 1 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 1 1 1 1 0 1 1 0 1 0 1 1 1 1 0 0 1 0 1 1 0 1 1 1] [0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 1 1 0 0 0 1 1 0 0 0 1 0 1 0 0 0 0 1 0 0 0 0 1 0 0 0 1 0 1 1 1 1 0 1 1 1 1 0 1 1 1] [0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 0 1 0 0 1 0 1 0 0 1 0 1 1 0 0 0 1 1 0 0 0 1 1 0 0 0 1 1 0 0 0 1 1 0 0 0 1 1 0 0] [0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 0 1 0 1 0 0 1 0 1 0 1 1 1 0 0 1 1 1 0 0 1 1 1 0 1 0 0 0 1 1 0 0 0 1 1 0 0 0 1] [0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 1 1 0 0 0 1 1 0 1 1 1 1 0 1 1 1 1 0 1 1 1 1 0 1 1 1 1 0 1 1 1 1 0 1 1 1 1] [0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0] rang du premier bloc : 4 générateur de ce bloc : (1 1 1 1 0 1 0 1 1 0 0 1 0 0 0) générateur à la taille pour la multiplication : (1 1 1 1 0 1 0 1 1 0 0 1 0 0 0) G 1 (vecteur qui génére les 4 premières lignes de la matrice) : (1 1 1 1 0 1 0 1 1 0 0 1 0 0 0 0 1 0 1 1 0 0 0 1 0 0 1 0 0 1 0 1 0 0 1 0 0 1 0 1 1 0 1 1 1 0 0 1 1 0 0 0 0 0 1 1 0 0 1 1 1 1 1 0 0 1 1 1 0 1 1 0 1 0 1) rang du deuxième bloc : 6 générateur de ce bloc : (1 1 0 0 1 1 1 0 0 1 0 0 0 0 0) générateur à la taille pour la multiplication : (1 1 0 0 1 1 1 0 0 1 0) G 2 (vecteur qui génére les 6 lignes suivantes de la matrice) : (0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 1 1 1 0 0 1 0 0 0 0 0 1 0 0 1 1 1 1 1 1 1 0 0 0 1 1 0 0 0 0 0 0 0 0 1 0 0 1 1 1 1 0 1 0 1 0 1 1 0 0 0 0 0 0 0 0) rang du troisième bloc : 4 générateur de ce bloc : (1 1 0 0 0 1 1 0 0 0 1 1 0 0 0) générateur à la taille pour la multiplication : (1 1 0 0 0) G 3 (vecteur qui génére les 4 lignes suivantes de la matrice) : (0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 1 1 0 0 0 1 1 0 0 0 0 0 1 0 0 0 0 1 0 0 0 0 1 0 0 1 1 0 1 1 1 1 0 1 1 1 1 0 1 1) rang du quatrième bloc : 1 generateur de ce bloc : (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1) générateur à la taille pour la multiplication : (1) G 1 (vecteur qui génére la dernière ligne de la matrice) : (0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) réduction de la 1 ere à l aide de la 2 eme : Travaille sur le deuxième bloc : f i := x 14 + x 11 + x 8 + x 4 + x 3 + x g := x 9 + x 6 + x 5 + x 4 + x + 1 r := x 8 + x 7 + x 6 + x 5 + x 3 + x 2 + x + 1 28

q := x 5 + x + 1 On répercute la combinaison linéaire au reste de la ligne : f i := x 14 + x 13 + x 12 + x 10 + x 9 + x 7 + x 4 + x g := x 14 + x 13 + x 9 + x 8 + x 7 + x 6 + x 5 + x 4 + x 3 + 1 g q := x 19 + x 18 + x 15 + x 14 + x 12 + x 11 + x 9 + x 8 + x 5 + x 3 + x + 1 r := x 13 + x 11 + x 10 + x 8 + x 7 + x 5 f i := x 14 + x 13 + x 10 + x 9 + x 3 + x 2 g := x 14 + x 13 + x 12 + x 11 + x 8 g q := x 19 + x 18 + x 17 + x 16 + x 15 + x 13 + x 11 + x 9 + x 8 r := x 14 + x 11 + x 10 + x 8 + x 4 + x + 1 f i := x 14 + x 12 + x 10 + x 9 + x 7 + x 6 + x 5 + x 2 + x + 1 g := x 6 + x 5 + x 3 + x g q := x 11 + x 10 + x 8 + x 7 + x 6 + x 5 + x 4 + x 3 + x 2 + x r := x 14 + x 12 + x 11 + x 9 + x 8 + x 4 + x 3 + 1 réduction de la 1 ere à l aide de la 3 eme : f i := x 13 + x 11 + x 10 + x 8 + x 7 + x 5 g := x 11 + x 10 + x 6 + x 5 + x + 1 r := x 10 + x 7 + x 6 + x 5 + x 3 + x q := x 2 + x On répercute la combinaison linéaire au reste de la ligne : f i := x 14 + x 11 + x 10 + x 8 + x 4 + x + 1 g := x 12 + x 7 + x 2 g q := x 14 + x 13 + x 9 + x 8 + x 4 + x 3 r := x 13 + x 11 + x 10 + x 9 + x 3 + x + 1 f i := x 14 + x 12 + x 11 + x 9 + x 8 + x 4 + x 3 + 1 g := x 14 + x 13 + x 11 + x 10 + x 9 + x 8 + x 6 + x 5 + x 4 + x 3 + x + 1 g q := x 16 + x 14 + x 13 + x 9 + x 8 + x 4 + x 3 + x r := x 13 + x 12 + x 11 + 1 Et ainsi de suite : réduction : 1 4 f i := x 13 + x 11 + x 10 + x 9 + x 3 + x + 1 g := x 14 + x 13 + x 12 + x 11 + x 10 + x 9 + x 8 + x 7 + x 6 + x 5 + x 4 + x 3 + x 2 + x + 1 r := x 13 + x 11 + x 10 + x 9 + x 3 + x + 1 q := 0 29

f i := x 13 + x 12 + x 11 + 1 g := 0 g q := 0 r := x 13 + x 12 + x 11 + 1 réduction : 2 3 f i := x 14 + x 13 + x 9 + x 8 + x 7 + x 6 + x 5 + x 4 + x 3 + 1 g := x 11 + x 10 + x 6 + x 5 + x + 1 r := x 7 + x 6 + x 5 + 1 q := x 3 f i := x 14 + x 13 + x 12 + x 11 + x 8 g := x 12 + x 7 + x 2 g q := x 15 + x 10 + x 5 r := x 14 + x 13 + x 12 + x 11 + x 10 + x 8 + x 5 + 1 f i := x 6 + x 5 + x 3 + x g := x 14 + x 13 + x 11 + x 10 + x 9 + x 8 + x 6 + x 5 + x 4 + x 3 + x + 1 g q := x 17 + x 16 + x 14 + x 13 + x 12 + x 11 + x 9 + x 8 + x 7 + x 6 + x 4 + x 3 r := x 14 + x 13 + x 12 + x 11 + x 9 + x 8 + x 7 + x 5 + x 4 + x 2 réduction : 2 4 f i := x 14 + x 13 + x 12 + x 11 + x 10 + x 8 + x 5 + 1 g := x 14 + x 13 + x 12 + x 11 + x 10 + x 9 + x 8 + x 7 + x 6 + x 5 + x 4 + x 3 + x 2 + x + 1 r := x 9 + x 7 + x 6 + x 4 + x 3 + x 2 + x q := 1 f i := x 14 + x 13 + x 12 + x 11 + x 9 + x 8 + x 7 + x 5 + x 4 + x 2 g := 0 g q := 0 r := x 14 + x 13 + x 12 + x 11 + x 9 + x 8 + x 7 + x 5 + x 4 + x 2 réduction : 3 4 f i := x 12 + x 7 + x 2 g := x 14 + x 13 + x 12 + x 11 + x 10 + x 9 + x 8 + x 7 + x 6 + x 5 + x 4 + x 3 + x 2 + x + 1 r := x 12 + x 7 + x 2 q := 0 f i := x 14 + x 13 + x 11 + x 10 + x 9 + x 8 + x 6 + x 5 + x 4 + x 3 + x + 1 g := 0 30

g q := 0 r := x 14 + x 13 + x 11 + x 10 + x 9 + x 8 + x 6 + x 5 + x 4 + x 3 + x + 1 On obtient alors les vecteurs suivants après la réduction : (1 1 1 1 0 1 0 1 1 0 0 1 0 0 0 1 1 1 1 0 1 1 1 1 0 0 0 0 0 0 0 1 0 1 0 1 1 1 0 0 1 0 0 0 0 1 1 0 1 0 0 0 0 0 1 1 1 0 1 0 1 0 0 0 0 0 0 0 0 0 0 1 1 1 0), (0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 1 1 1 0 0 1 0 0 0 0 0 1 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 1 1 1 1 0 1 1 0 1 0 0 0 0 0 0 0 1 0 1 1 0 1 1 1 0 1 1 1 1), (0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 1 1 0 0 0 1 1 0 0 0 0 0 1 0 0 0 0 1 0 0 0 0 1 0 0 1 1 0 1 1 1 1 0 1 1 1 1 0 1 1), (0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) On reconstruit la matrice et on obtient : [1 1 1 1 0 1 0 1 1 0 0 1 0 0 0 1 1 1 1 0 1 1 1 1 0 0 0 0 0 0 0 1 0 1 0 1 1 1 0 0 1 0 0 0 0 1 1 0 1 0 0 0 0 0 1 1 1 0 1 0 1 0 0 0 0 0 0 0 0 0 0 1 1 1 0] [0 1 1 1 1 0 1 0 1 1 0 0 1 0 0 0 1 1 1 1 0 1 1 1 1 0 0 0 0 0 0 0 1 0 1 0 1 1 1 0 0 1 0 0 0 0 1 1 0 1 0 0 0 0 0 1 1 1 0 1 0 1 0 0 0 0 0 0 0 0 0 0 1 1 1] [0 0 1 1 1 1 0 1 0 1 1 0 0 1 0 0 0 1 1 1 1 0 1 1 1 1 0 0 0 0 0 0 0 1 0 1 0 1 1 1 0 0 1 0 0 1 0 1 1 0 1 0 0 0 0 0 1 1 1 0 1 0 1 0 0 0 0 0 0 0 0 0 0 1 1] [0 0 0 1 1 1 1 0 1 0 1 1 0 0 1 0 0 0 1 1 1 1 0 1 1 1 1 0 0 0 0 0 0 0 1 0 1 0 1 1 1 0 0 1 0 0 1 0 1 1 0 1 0 0 0 0 0 1 1 1 1 1 0 1 0 0 0 0 0 0 0 0 0 0 1] [0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 1 1 1 0 0 1 0 0 0 0 0 1 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 1 1 1 1 0 1 1 0 1 0 0 0 0 0 0 0 1 0 1 1 0 1 1 1 0 1 1 1 1] [0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 1 1 1 0 0 1 0 0 0 0 0 1 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 1 1 1 1 0 1 1 0 1 0 0 0 0 1 0 0 1 0 1 1 0 1 1 1 0 1 1 1] [0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 1 1 1 0 0 1 0 0 0 0 0 1 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 1 1 1 1 0 1 1 0 1 0 0 0 1 1 0 0 1 0 1 1 0 1 1 1 0 1 1] [0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 1 1 1 0 0 1 0 0 0 0 0 1 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 1 1 1 1 0 1 1 0 1 0 0 1 1 1 0 0 1 0 1 1 0 1 1 1 0 1] [0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 1 1 1 0 0 1 0 0 0 0 0 1 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 1 1 1 1 0 1 1 0 1 0 1 1 1 1 0 0 1 0 1 1 0 1 1 1 0] [0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 1 1 1 0 0 1 0 0 0 0 0 1 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 1 1 1 1 0 1 1 0 1 0 1 1 1 1 0 0 1 0 1 1 0 1 1 1] [0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 1 1 0 0 0 1 1 0 0 0 0 0 1 0 0 0 0 1 0 0 0 0 1 0 0 1 1 0 1 1 1 1 0 1 1 1 1 0 1 1] [0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 1 1 0 0 0 1 1 0 0 0 0 0 1 0 0 0 0 1 0 0 0 0 1 0 1 1 1 0 1 1 1 1 0 1 1 1 1 0 1] [0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 1 1 0 0 0 1 1 0 0 0 0 0 1 0 0 0 0 1 0 0 0 0 1 1 1 1 1 0 1 1 1 1 0 1 1 1 1 0] [0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 1 1 0 0 0 1 1 1 0 0 0 0 1 0 0 0 0 1 0 0 0 0 0 1 1 1 1 0 1 1 1 1 0 1 1 1 1] [0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0] 2.3.2 Exemple sur F 2 avec des mots de longueur 35 q:= 2 l:= 5 m:= 7 n:= 35 Elément aléatoire: (0 0 1 0 1 1 1 0 1 1 0 0 1 1 0 1 0 1 1 0 1 0 1 1 0 0 1 1 1 1 1 0 1 0 1) [35, 7, 7] Quasicyclic of degree 5 Linear Code over GF(2) Generator matrix:(obtenu avec LinearCode) [1 0 0 1 0 1 1 0 0 0 1 0 1 0 1 1 1 0 0 0 1 0 0 0 1 0 1 0 0 1 0 1 0 0 1] [0 1 0 1 1 1 0 0 0 0 1 1 1 1 0 0 0 1 0 0 1 0 0 0 1 1 1 1 0 0 0 0 0 1 0] [0 0 1 0 1 1 1 0 0 0 1 0 0 1 1 0 1 1 0 0 1 0 0 0 1 0 0 1 0 1 1 0 0 0 0] [0 0 0 0 0 0 0 1 0 0 1 1 1 0 0 0 1 1 1 0 1 1 0 0 1 1 1 0 0 1 1 0 0 0 1] [0 0 0 0 0 0 0 0 1 0 0 1 1 1 1 0 0 1 1 1 0 0 1 0 0 1 1 1 0 1 0 0 1 1 1] [0 0 0 0 0 0 0 0 0 1 1 1 0 1 0 1 1 1 0 1 0 0 0 1 1 1 0 1 0 0 1 1 1 0 1] [0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1] rang du 1 er bloc : 3 générateur 1 er bloc: (1 0 1 1 1 0 0) G^1 = (1 0 1 1 1 0 0 1 1 0 1 0 1 0 1 1 1 1 0 1 1 1 1 0 1 0 1 0 0 0 0 1 1 1 1) rang du 2 eme bloc : 3 générateur: 2 eme bloc: (1 1 1 0 1 0 0) G^2 = (0 0 0 0 0 0 0 1 1 1 0 1 0 0 1 1 0 1 0 0 1 1 1 1 0 1 0 0 0 0 0 1 0 1 1) 31

rang du 3 eme bloc : 0 rang du 4 eme bloc : 0 rang du 5 eme bloc : 1 générateur: 5 eme bloc: (1 1 1 1 1 1 1) G^3 = (0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1) Les 3 générateurs: (1 0 1 1 1 0 0 1 0 1 0 0 0 0 0 0 0 1 1 1 1 1 0 1 0 0 0 0 1 0 0 1 0 1 0) (0 0 0 0 0 0 0 1 1 1 0 1 0 0 1 1 0 1 0 0 1 1 1 1 0 1 0 0 1 1 1 0 1 0 0) (0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1) La matrice reconstruite : [1 0 1 1 1 0 0 1 0 1 0 0 0 0 0 0 0 1 1 1 1 1 0 1 0 0 0 0 1 0 0 1 0 1 0] [0 1 0 1 1 1 0 0 1 0 1 0 0 0 1 0 0 0 1 1 1 0 1 0 1 0 0 0 0 1 0 0 1 0 1] [0 0 1 0 1 1 1 0 0 1 0 1 0 0 1 1 0 0 0 1 1 0 0 1 0 1 0 0 1 0 1 0 0 1 0] [0 0 0 0 0 0 0 1 1 1 0 1 0 0 1 1 0 1 0 0 1 1 1 1 0 1 0 0 1 1 1 0 1 0 0] [0 0 0 0 0 0 0 0 1 1 1 0 1 0 1 1 1 0 1 0 0 0 1 1 1 0 1 0 0 1 1 1 0 1 0] [0 0 0 0 0 0 0 0 0 1 1 1 0 1 0 1 1 1 0 1 0 0 0 1 1 1 0 1 0 0 1 1 1 0 1] [0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1] 2.3.3 Exemple sur F 3 avec des mots de longueur 35 q:= 3 l:= 5 m:= 7 n:= 35 Elément aléatoire: (0 0 2 2 0 1 1 0 0 0 2 2 1 1 1 1 0 2 0 1 2 0 1 1 1 2 0 2 1 0 1 2 0 1 2) [35, 7, 16] Quasicyclic of degree 5 Linear Code over GF(3) Generator matrix: [1 0 0 0 0 0 2 0 1 0 2 1 0 2 0 0 2 0 2 0 1 0 2 1 1 2 2 0 1 2 1 0 2 0 2] [0 1 0 0 0 0 2 2 1 1 2 0 1 2 0 2 1 1 1 1 0 2 1 2 1 2 0 1 2 2 2 0 1 1 1] [0 0 1 0 0 0 2 2 0 1 0 0 0 0 0 0 1 1 0 1 2 1 1 2 0 0 1 0 2 1 0 2 2 1 0] [0 0 0 1 0 0 2 0 0 0 0 1 0 2 0 1 0 2 1 1 0 1 1 0 1 0 0 2 2 2 0 1 2 0 1] [0 0 0 0 1 0 2 2 1 0 2 1 1 2 0 0 0 0 1 1 2 2 0 2 1 0 2 0 2 1 0 0 0 2 2] [0 0 0 0 0 1 2 2 0 1 2 0 1 0 0 1 0 1 0 2 0 1 2 2 1 1 0 0 1 2 0 1 0 1 2] [0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1] 32

rang du 1 er bloc : 6 générateur 1 er bloc: (2 1 0 0 0 0 0) G^1 = (2 1 0 0 0 0 0 2 0 1 0 2 1 0 0 2 2 1 2 1 2 2 2 1 0 0 1 1 1 0 1 0 2 1 2) rang du 2 eme bloc: 0 rang du 3 eme bloc: 1 générateur: 2 eme bloc: (1 1 1 1 1 1 1) (0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1) Les deux générateurs: (2 1 0 0 0 0 0 2 0 1 0 2 1 0 1 0 0 2 0 2 0 0 0 2 1 1 2 2 2 1 2 1 0 2 0) (0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1) La matrice reconstruite : [2 1 0 0 0 0 0 2 0 1 0 2 1 0 1 0 0 2 0 2 0 0 0 2 1 1 2 2 2 1 2 1 0 2 0] [0 2 1 0 0 0 0 0 2 0 1 0 2 1 0 1 0 0 2 0 2 2 0 0 2 1 1 2 0 2 1 2 1 0 2] [0 0 2 1 0 0 0 1 0 2 0 1 0 2 2 0 1 0 0 2 0 2 2 0 0 2 1 1 2 0 2 1 2 1 0] [0 0 0 2 1 0 0 2 1 0 2 0 1 0 0 2 0 1 0 0 2 1 2 2 0 0 2 1 0 2 0 2 1 2 1] [0 0 0 0 2 1 0 0 2 1 0 2 0 1 2 0 2 0 1 0 0 1 1 2 2 0 0 2 1 0 2 0 2 1 2] [0 0 0 0 0 2 1 1 0 2 1 0 2 0 0 2 0 2 0 1 0 2 1 1 2 2 0 0 2 1 0 2 0 2 1] [0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1] 2.3.4 Différentes matrices obtenus dans K n avec K = F 2 5 m = 7; l = 5; n = 35; et w est une racine primitive de K [w^10 1 0 0 0 0 w^5 w^8 w^7 1 w^2 0 w^4 w^5 w^12 w^12 w^5 w^6] [ 0 w^10 1 0 0 0 0 w^5 w^8 w^7 1 w^2 w^6 w^4 w^5 w^12 w^12 w^5] [ 0 0 w^10 1 0 0 w^2 0 w^5 w^8 w^7 1 w^5 w^6 w^4 w^5 w^12 w^12] [ 0 0 0 w^10 1 0 1 w^2 0 w^5 w^8 w^7 w^12 w^5 w^6 w^4 w^5 w^12] [ 0 0 0 0 w^10 1 w^7 1 w^2 0 w^5 w^8 w^12 w^12 w^5 w^6 w^4 w^5] [ 0 0 0 0 0 0 w^5 w^10 1 w^5 w^10 1 w w^6 w^11 w w^6 w^11] [ w^5 1 0 0 0 0 w^6 1 w^4 0 w^7 0 0 w^8 0 w^4 w^11 w^14] [ 0 w^5 1 0 0 0 0 w^6 1 w^4 0 w^7 w^14 0 w^8 0 w^4 w^11] [ 0 0 w^5 1 0 0 w^7 0 w^6 1 w^4 0 w^11 w^14 0 w^8 0 w^4] [ 0 0 0 w^5 1 0 0 w^7 0 w^6 1 w^4 w^4 w^11 w^14 0 w^8 0] [ 0 0 0 0 w^5 1 w^4 0 w^7 0 w^6 1 0 w^4 w^11 w^14 0 w^8] [ 0 0 0 0 0 0 w^10 w^5 1 w^10 w^5 1 w^8 w^3 w^13 w^8 w^3 w^13] [ 1 0 0 0 0 0 w^10 w^5 w^6 w^10 w^3 w^12 w^10 w w^3 w^12 w^4 w^5] [ 0 1 0 0 0 0 w^12 w^10 w^5 w^6 w^10 w^3 w^5 w^10 w w^3 w^12 w^4] [ 0 0 1 0 0 0 w^3 w^12 w^10 w^5 w^6 w^10 w^4 w^5 w^10 w w^3 w^12] [ 0 0 0 1 0 0 w^10 w^3 w^12 w^10 w^5 w^6 w^12 w^4 w^5 w^10 w w^3] 33

[ 0 0 0 0 1 0 w^6 w^10 w^3 w^12 w^10 w^5 w^3 w^12 w^4 w^5 w^10 w] [ 0 0 0 0 0 1 w^5 w^6 w^10 w^3 w^12 w^10 w w^3 w^12 w^4 w^5 w^10] [ w^5 w^10 1 0 0 0 w^9 w^6 w w^11 0 0 w^11 w^11 w^8 w^14 w^13 1] [ 0 w^5 w^10 1 0 0 0 w^9 w^6 w w^11 0 1 w^11 w^11 w^8 w^14 w^13] [ 0 0 w^5 w^10 1 0 0 0 w^9 w^6 w w^11 w^13 1 w^11 w^11 w^8 w^14] [ 0 0 0 w^5 w^10 1 w^11 0 0 w^9 w^6 w w^14 w^13 1 w^11 w^11 w^8] [ 0 0 0 0 0 0 w^10 1 0 w^10 1 0 w^4 w^13 w^2 w^4 w^13 w^2] [ 0 0 0 0 0 0 0 w^10 1 0 w^10 1 w^2 w^4 w^13 w^2 w^4 w^13] [w^10 1 0 0 0 0 w^3 w^11 w^3 0 w 0 w^11 w^8 w^8 w^9 w w^7] [ 0 w^10 1 0 0 0 0 w^3 w^11 w^3 0 w w^7 w^11 w^8 w^8 w^9 w] [ 0 0 w^10 1 0 0 w 0 w^3 w^11 w^3 0 w w^7 w^11 w^8 w^8 w^9] [ 0 0 0 w^10 1 0 0 w 0 w^3 w^11 w^3 w^9 w w^7 w^11 w^8 w^8] [ 0 0 0 0 w^10 1 w^3 0 w 0 w^3 w^11 w^8 w^9 w w^7 w^11 w^8] [ 0 0 0 0 0 0 w^5 w^10 1 w^5 w^10 1 w^6 w^11 w w^6 w^11 w] [ 1 1 0 0 0 0 w^13 w^9 w^6 w^4 1 0 w w^9 0 w^11 w^7 w^2] [ 0 1 1 0 0 0 0 w^13 w^9 w^6 w^4 1 w^2 w w^9 0 w^11 w^7] [ 0 0 1 1 0 0 1 0 w^13 w^9 w^6 w^4 w^7 w^2 w w^9 0 w^11] [ 0 0 0 1 1 0 w^4 1 0 w^13 w^9 w^6 w^11 w^7 w^2 w w^9 0] [ 0 0 0 0 1 1 w^6 w^4 1 0 w^13 w^9 0 w^11 w^7 w^2 w w^9] [ 0 0 0 0 0 0 1 1 1 1 1 1 w^2 w^2 w^2 w^2 w^2 w^2] [ 1 1 0 0 0 0 w w^6 w^14 w^8 w^10 0 w^6 1 w^6 w^2 w^4 w^9] [ 0 1 1 0 0 0 0 w w^6 w^14 w^8 w^10 w^9 w^6 1 w^6 w^2 w^4] [ 0 0 1 1 0 0 w^10 0 w w^6 w^14 w^8 w^4 w^9 w^6 1 w^6 w^2] [ 0 0 0 1 1 0 w^8 w^10 0 w w^6 w^14 w^2 w^4 w^9 w^6 1 w^6] [ 0 0 0 0 1 1 w^14 w^8 w^10 0 w w^6 w^6 w^2 w^4 w^9 w^6 1] [ 0 0 0 0 0 0 1 1 1 1 1 1 w^10 w^10 w^10 w^10 w^10 w^10] 34

Références [1] V.Pless, Introduction to the theory of error-cerrecting codes. Wiley-Interscience series in Discrete Mathematics. [2] A.Poli, L Huguet Codes correcteurs, théorie et application. Masson éditeur, 1989. [3] J.Wolfmann, O.Papini Algèbre discrète et codes correcteurs Mathématiques et applications, vol. 20, collection de la SMAI, Springer-Verlag, 1995 35