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

Transcription

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

2 Table des matières 1 Codes Correcteurs Préliminaires Codes Cycliques Quelques lemmes Codes Quasi-Cycliques Transformation de la matrice génératrice d un code quasi-cyclique Partie théorique Objectif et méthode Théorème de transformation Partie programmation de la transformation d une matrice d un code quasicyclique en Magma Bibliothèque contenant les fonctions et procédures Algorithme de transformation de la matrice Graphe de complexité temps Différents exemples obtenus avec le programme en magma Exemple sur F 2 avec des mots de longueur Exemple sur F 2 avec des mots de longueur Exemple sur F 3 avec des mots de longueur Différentes matrices obtenus dans K n avec K = F

3 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

4 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 = 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

5 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

6 Exemple 3 Matrice de controle du code de Hamming de longueur H =

7 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 : G = 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 ( ) qui est égal à la somme des deux premières lignes de G donne ( ) 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

8 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

9 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 g 0 g 1 g 2... g r... 0 G = 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 C 4 : g 4 (X) = (X 1)(X 3 + X + 1) = X 4 + X 3 + X 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 =

10 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

11 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 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

12 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

13 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

14 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 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

15 2 Transformation de la matrice génératrice d un code quasi-cyclique 2.1 Partie théorique 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 f 1l ) G 2 = ( 0 g 2 f 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

16 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 M 0 A = 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 g i,0 g i,1 g i,2... g i,si... 0 A i = 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 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

17 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

18 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

19 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

20 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 A P = 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 g i,0 g i,1 g i,2... g i,si... 0 A i = 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

21 2.2 Partie programmation de la transformation d une matrice d un code quasi-cyclique en Magma 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

22 /***************************************************************/ /*** 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

23 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

24 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

25 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; 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

26 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

27 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(); Graphe de complexité temps Temps en seconde 200 Temps de calul en fonction de la longueur des mots du code 450 complexite.txt using 1 : Longueur des mots du code 27

28 2.3 Différents exemples obtenus avec le programme en magma Exemple sur F 2 avec des mots de longueur 75 q := 2 l := 5 m := 15 n := 75 Element aléatoire : ( ) Matrice générée à partir des permutations et de la fonction LinearCode() : [ ] [ ] [ ] [ ] [ ] [ ] [ ] [ ] [ ] [ ] [ ] [ ] [ ] [ ] [ ] rang du premier bloc : 4 générateur de ce bloc : ( ) générateur à la taille pour la multiplication : ( ) G 1 (vecteur qui génére les 4 premières lignes de la matrice) : ( ) rang du deuxième bloc : 6 générateur de ce bloc : ( ) générateur à la taille pour la multiplication : ( ) G 2 (vecteur qui génére les 6 lignes suivantes de la matrice) : ( ) rang du troisième bloc : 4 générateur de ce bloc : ( ) générateur à la taille pour la multiplication : ( ) G 3 (vecteur qui génére les 4 lignes suivantes de la matrice) : ( ) rang du quatrième bloc : 1 generateur de ce bloc : ( ) générateur à la taille pour la multiplication : (1) G 1 (vecteur qui génére la dernière ligne de la matrice) : ( ) 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

29 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 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 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 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 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

30 f i := x 13 + x 12 + x g := 0 g q := 0 r := x 13 + x 12 + x réduction : 2 3 f i := x 14 + x 13 + x 9 + x 8 + x 7 + x 6 + x 5 + x 4 + x g := x 11 + x 10 + x 6 + x 5 + x + 1 r := x 7 + x 6 + x 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 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 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

31 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 : ( ), ( ), ( ), ( ) On reconstruit la matrice et on obtient : [ ] [ ] [ ] [ ] [ ] [ ] [ ] [ ] [ ] [ ] [ ] [ ] [ ] [ ] [ ] Exemple sur F 2 avec des mots de longueur 35 q:= 2 l:= 5 m:= 7 n:= 35 Elément aléatoire: ( ) [35, 7, 7] Quasicyclic of degree 5 Linear Code over GF(2) Generator matrix:(obtenu avec LinearCode) [ ] [ ] [ ] [ ] [ ] [ ] [ ] rang du 1 er bloc : 3 générateur 1 er bloc: ( ) G^1 = ( ) rang du 2 eme bloc : 3 générateur: 2 eme bloc: ( ) G^2 = ( ) 31