Rapport de TER Transformation de la matrice g´en´eratrice d’un code quasi-cyclique

Rapport de TER

Transformation de la matrice g´en´eratrice d’un code quasi-cyclique

NARDEAU Nicolas, BENMOUSSA Wafa

2006-2007

Table des mati` eres

1 Codes Correcteurs 3

1.1 Pr´eliminaires . . . 3

1.2 Codes Cycliques . . . 7

1.3 Quelques lemmes . . . 11

1.4 Codes Quasi-Cycliques . . . 13

2 Transformation de la matrice g´en´eratrice d’un code quasi-cyclique 15 2.1 Partie th´eorique . . . 15

2.1.1 Objectif et m´ethode . . . 15

2.1.2 Th´eor`eme de transformation . . . 16

2.2 Partie programmation de la transformation d’une matrice d’un code quasi- cyclique en Magma . . . 21

2.2.1 Biblioth`eque contenant les fonctions et proc´edures . . . 21

2.2.2 Algorithme de transformation de la matrice . . . 25

2.2.3 Graphe de complexit´e temps . . . 27

2.3 Diff´erents exemples obtenus avec le programme en magma . . . 28

2.3.1 Exemple sur F2 avec des mots de longueur 75 . . . 28

2.3.2 Exemple sur F2 avec des mots de longueur 35 . . . 31

2.3.3 Exemple sur F³ avec des mots de longueur 35 . . . 32

2.3.4 Diff´erentes matrices obtenus dans Kⁿ avecK =F2⁵ . . . 33

1 Codes Correcteurs

1.1 Pr´ eliminaires

K un ensemble fini, non vide, n un entier naturel non nul.

Kⁿ l’ensemble desx= (x1, .., xn) tels quexi ∈K.

D´efinition 1 (Distance de Hamming) Soient x et y deux ´el´ements de Kⁿ, la dis- tance de Hamming entre x et y est le nombre de composantes pour lesquelles ces

´

el´ements sont diff´erents six= (x₁, .., x_n)ety= (y₁, .., y_n)alorsd(x, y) :=card{i= 1,2.., n/x_i 6=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´efinition 2 (D´efinition d’un code) Un code surK de longueurn est un sous-ensem- ble de Kⁿ. n est appel´e la longueur du code C et les ´el´ements de C sont appel´es 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 =F2.

Code Lin´eaires

D´efinition 3 SoitK un corps un fini,Kⁿun K-espace vecoriel. C est uncode lin´eaire si et seulement si c’est un sous espace vectoriel de Kⁿ. Il est de dimension k s’il est un sous-espace vectoriel de dimension k.

D´efinition 4 (Support d’un mot) Soit x= (x₁, .., x_n) un mot de C. Alors : Supp(x) :={i/xi 6= 0}

.

D´efinition 5 (Poids de Hamming) Soit x= (x₁, .., x_n) un mot de C. Alors w(x) = card(Supp(x))

D´efinition 6 (Distance minimale d’un code lin´eaire C) SoitC un code lin´eaire, sa distance minimale est d´efinie par d:=M in_x∈C w(x)

Propri´et´es 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 λ 6= 0, w(λx) =w(x) e) w(x+y)≤w(x) +w(y)

Propri´et´es 2 (Nombre de mots d’un code lin´eaire C) Si q est le cardinal de K et siC est un code lin´eaire de longueur n et de dimensionk. Alors le nombre de mots de C est q^k.

Preuve 1 C 'K^k en tant que K-espace vectoriel.

Nombre d’erreurs commises lors d’une transmission : si x = (x₁, .., x_n) est un mot envoy´e et x⁰ = (x⁰₁, .., x⁰_n) le mot re¸cu. Alors le nombre d’erreurs commises est d(x, x⁰). On suppose par exemple qued(x, x⁰)≤e (e est le nombre maximum d’erreurs).

Condition de d´ecodage d’ordre e, et rayon de recouvrement :

D´efinition 7 (Condition de d´ecodage) Un code C v´erifie la condition de d´ecodage d’ordre e si pour tout x⁰ ∈ Kⁿ, il existe au plus un mot x∈ C tel que d(x, x⁰) ≤e. c-`a-d que les boules ferm´ees (pour la distance de Hamming) de rayone centr´ees sur les mots de C sont 2 `a 2 disjointes.

D´efinition 8 (Rayon de recouvrement) Soit C un code de Kⁿ, et soit r le plus petit rayon tel que les boules de rayon r centr´ees en chaque mot de C forment un recouvrement de Kⁿ, r est appel´e rayon de recouvrementde C.

Remarque 1 Soit dla distance minimale d’un code C : d= minx∈C w(x). Si d≥2e+ 1 alors C v´erifie la condition de d´ecodage d’ordre e.

Code Parfait

D´efinition 9 (capacit´e 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`ere de <sup>d−1</sup><sub>2</sub> est ´egale `a e, e s’appelle alors la capacit´e de correction du code.

D´efinition 10 Un code est dit parfait si sa capacit´e de correction est ´egale `a son rayon de recouvrement.

Codes ´equivalents

- SoientCetDdeux codes de longueurn, ils sont´equivalentss’il existe une permuta- tionσde 1,2, .., ntelle queDsoit l’image deC parϕ: (x₁, .., x_n)7−→(x_σ(1), .., x_σ(n)) - Deux codes ´equivalents ont la meme capacit´e de correction et aussi les mˆemes dis-

tances entres les mots, la mˆeme longueur et le mˆeme cardinal.

Matrice g´en´eratrice d’un code lin´eaire

D´efinition 11 Une matrice g´en´eratrice d’un code lin´eaire C sur le corps K est une matrice sur K dont les lignes forment une base de C.

Remarque 2 Un code poss`ede en g´en´eral plusieurs matrices g´en´eratrices.

Exemple 2

M=





1 0 0 1 0 0 1 0 1 1 0 0 1 0 1





La matriceM est de rang3, c’est la matrice d’un codeC de longueur5et de dimension 3 sur F² (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).

Propri´et´es 3 Si G est une matrice g´en´eratrice de C, un code lin´eaire(n, k), alors : a) Les autres matrices g´en´eratrices de C sont de la forme A∗G o`u A est une matrice

carr´ee inversible k×k.

b) Le code C est l’ensemble des mots de la forme :

x_k = (u₁, .., u_k)∗G o`u U = (u₁, .., u_k)∈K^k

c) Si c₁,··, c_k sont les vecteurs colonnes de G, les mots du code C sont tous obtenus sous la forme x_k = (< c₁, 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´en´eratrice d’un code C⁰ ´equivalent `a C.

D´efinition 12 (matrice g´en´eratrice normalis´ee) Une matrice g´en´eratrice d’un code C (n, k) est normalis´ee si la matrice form´ee par les k premi`eres colonnes est la matrice unit´e.

D´efinition 13 (Codages des messages au moyen d’un code lin´eaire) Le codage des messages au moyen d’une matrice g´en´eratrice G d’un code C se r´esume : M essage7−→

u= (u₁, .., u_k)7−→x_k = (u₁, .., u_k)∗G la matrice G est choisie comme matrice g´en´eratice d’un code e-correcteur, et e est choisi en fonction des statistiques d’erreurs commmises lors de la transmission. Si G est normalis´ee, alors on trouve :

u= (u₁, .., u_k)7−→(u₁, .., u_k, x_k+1, x_k+2, .., x_n)

u1, .., uk sont appel´es symboles d’information et xk+1, xk+2, .., xn symboles de controles.

D´efinition 14 (Code Syst´ematique) Un code poss´edant une matrice g´en´eratrice nor- malis´ee entraine un code syst´ematique.

Orthogonal d’un code C

D´efinition 15 Soit C un code (n, k), le code orthogonal de C est l’espace vectoriel orthogonal `aC pour le produit scalaire usuel de Kⁿ. (le code orthogonal de C est un code lin´eaire (n, n−k))

D´efinition 16 (Matrice de Controle) On appelle matrice de controle de C, toute matrice g´en´eratrice de son orthogonal.

Propri´et´es 4 Soit H une matrice de controle de C et x= (x₁, .., x_n). Le mot x∈C ssi H^tx= 0.

Codes de Hamming binaires

D´efinition 17 On appelle code de Hamming (binaire) de longueur 2^k−1 tout code ad- mettant comme matrice de controle H, une matrice dont les 2^k−1colonnes sont tous les vecteurs de F^k2\ {0}, il est appel´e code Hamming de param`etre k.

Exemple 3 Matrice de controle du code de Hamming de longueur 7.

H=





1 0 0 0 1 1 1 0 1 0 1 0 1 1 0 0 1 1 1 0 1





1.2 Codes Cycliques

D´efinition 18 Un code C est dit cyclique si : a) C est un code lin´eaire.

b) Si (x₁, .., x_n)∈C, alors (x_n, x₁, .., xn−1)∈C.

Exemple 4 Soit C le code de matrice g´en´eratrice :

G=





1 0 0 1 0 0 1 0 0 0 1 0 0 1 0 0 1 0 0 0 1 0 0 1 0 0 1





Ce code poss`ede 2³ = 8 ´el´ements.

On peut v´erifier que pour chacun de ses mots, un d´ecalage `a droite donne un autre mot du code C.

Par exemple le mot (110110110) qui est ´egal `a la somme des deux premi`eres lignes de G donne (011011011) qui est ´egal `a la somme de la 2^eme et 3^eme lignes de G.

Repr´esentation polynomiale des codes cycliques

- Soit C un code lin´eaire de longueur n, pour chaque motm de C,m:= (a₀, .., an−1) on lui associe le polynˆome m(X) :=a₀+a₁X+..+an−1Xⁿ⁻¹.

Un d´ecalage `a droite correspond donc `a faire :Xm(X)mod(Xⁿ−1).

- C est donc cyclique Ssi∀m ∈C xm(X)mod(Xⁿ−1) est un polynˆome associ´e `a un mot deC.

D´efinition 19 Soit K un corps fini, et soit n∈N^∗. a) On appelle repr´esentation polynomiale de Kⁿ,

l’application Θ de Kⁿ dans K[X]/(Xⁿ−1): Θ : Kⁿ −→K[X]/(Xⁿ−1)

(a₀, .., an−1)7−→a₀+a₁x+..+an−1xⁿ⁻¹

b) On appellerepr´esentation polynomialed’un codeC, l’ensemble des repr´esentations polynomiales des mots de C : Θ(C).

Remarque 4 La repr´esentation polynomiale Θ de Kⁿ, est un isomorphisme d’espace vectoriel sur K.

Th´eor`eme 1 SoitCun code lin´eaire surK, le codeCestcycliquessi sarepr´esentation polynomiale Θ(C) est un id´eal de K[X]/(Xⁿ−1).

Preuve 2 Si C est cyclique, Xm(X) est dans Θ(C) pour tout ´el´ement m(X) de Θ(C), il en est de mˆeme pour les Xⁱm(X) et puisque C est lin´eaire les polynˆomes (d0+d1X+ ...)m(X) aussi et donc tous les multiples quelconques de m(X).

Inversement, si tous les multiples quelconques d’un ´el´ement 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´eal de K[X]/(Xⁿ−1) est principal (la preuve de ce r´esultat repose sur l’existence de la division euclidienne).

Th´eor`eme 2 Soit Θ(C) l’id´eal de K[X]/(X<sup>n</sup>−1)associ´e `a un code lin´eaire cyclique C.

Soit g(X) un polynˆome unitaire de plus petit degr´e dans Θ(C).

Soit r :=deg(g(X)). Alors on a les propositions suivantes : a) g(X) est l’unique polynˆome unitaire de degr´e r dans Θ(C).

b) g(X) g´en`ere Θ(C) comme id´eal principal de K[X]/(Xⁿ−1).

c) g(X) divise xⁿ−1

d) {Xⁱg(X), i= 0, .., n−r−1} est une base de Θ(C), consid´er´ee 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) = Pn−r−1

i=0 a_iXⁱg(X) c-`a-d P(X) = a(X)g(X) avec a(X) =Pn−r−1

i=0 a_iXⁱ.

Preuve 3 1) Si on suppose qu’il existe g⁰(X), un autre polynˆome unitaire de degr´e r

dansΘ(C)alorsg(X)−g⁰(X)∈Θ(C), ce qui est impossible cardeg(g(X)−g⁰(X))≤r−1.

2) Supposons que g(X) ne g´en`ere pas Θ(C), cela revient a dire qu’il existe P(X) de Θ(C) tel que P(X) = q(X)g(X) +r(X) o`u deg(r(X))≤ r−1, Comme Θ(C) est un id´eal 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`ese faite sur g(X).

3) Supposons que g(X) ne divise pas xⁿ−1. Alors :

Xⁿ−1 = q(X)g(X) +r(X) avec deg(r(x))≤r−1

et de meme le fait quer(X)appartienne `aΘ(C)est en contradiction avec l’hypoth`ese sur le degr´e de g.

4) Comme g(X) est un g´en´erateur de Θ(C), alors tout polynˆome de Θ(C) est de la forme a(X)g(X) avec deg(a)≤n−1.

Les polynˆomes g(X), Xg(X), .., Xⁿ⁻¹g(X) forment donc une famille g´en´eratrice de Θ(C), on veut en extraire une base.

Soit a(X)g(X) un ´el´ement de Θ(C) et soith(X) tel que Xⁿ−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`u r(X) = 0, le reste r(X) est donc de la forme r(X) = r<sub>0</sub> +r<sub>1</sub>X +..+rn−r−1X<sup>n−r−1</sup> d’o`u : a(X)g(X) = h(X)q(X)g(X) +r(X)g(X).

Donc a(X)g(X) = (Xⁿ−1)q(X) +r(X)q(X), en passant `a K[X]/(Xⁿ−1) on a : a(X)g(X) = r(X)g(X) =r₀g(X) +r₁Xg(X) +..+rn−r−1X^n−r−1g(X) La famille g(X), Xg(X), .., X^n−r−1g(X) est donc aussi une famile g´en´eratrice de Θ(C).

Montrons maintenant qu’elle est aussi libre :

Dans K[X]/(Xⁿ−1), supposons λ₀g(X) +λ₁Xg(X) +..+λn−r−1X^n−r−1g(X) = 0 ceci implique dans K[X] que (λ₀+λ₁X+..+λ_n−r−1X^n−r−1)g(X)≡0[Xⁿ−1].

Soit P(X) :=λ₀+λ₁X+..+λn−r−1X^n−r−1.

Le polynˆome P est soit nul soit de degr´e inf´erieur `an−1et en mˆeme temps divisible par X<sup>n</sup> −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`u P(X) = 0 d’o`u λ₀ =λ₁ =

· · · = λn−r−1X^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´en´erateur est g(X), est k=n−deg(g(X)).

Th´eor`eme 3 Soit g(X) = g0 +g1X+..+grX<sup>r</sup> le g´en´erateur d’un code cyclique C de longueurnsurK, la matriceG`aklignes etncolonnes suivante o`ur =deg(g(X)) = n−k, est une matrice g´en´eratrice de C.

G=











g₀ g₁ g₂ . . . g_r 0 . . . 0 0 g₀ g₁ g₂ . . . g_r . . . 0 ... . .. ... ... ... . . .. ...

0 . . . 0 g₀ g₁ g₂ . . . g_r











Preuve 4 Une matrice g´en´eratrice est obtenue en choisissant comme lignes les n-uplets correspondants aux polynˆomes de la base pr´ec´edente. Soit :

g(X), Xg(X), .., X^n−r−1g(X)

Ce sont tous les d´ecalages successifs du premier, d’ou le r´esultat.

Exemple 5 La d´ecomposition de X⁷−1 en diviseurs irr´eductibles de F2 est : X⁷−1 = (X−1)(X³+X+ 1)(X³+X²+ 1)

Les codes cycliques de longueur 7 sur F² diff´erents de{0} sont donc ceux g´en´er´es comme suit :

C₀ : g₀(X) = X⁷−1 = 0 C₀ ={0, ..,0}

C₁ : g₁(X) = X−1 C₂ : g₂(X) = X³+X+ 1 C₃ : g₃(X) = X³+X²+ 1

C₄ : g₄(X) = (X−1)(X³+X+ 1) =X⁴+X³+X²+ 1 C₅ : g₅(X) = (X−1)(X³+X² + 1) =X⁴+X²+X+ 1

C₆ : g₆(X) = (X³+X+ 1)(X³+X²+ 1) =X⁶+X⁵ +X⁴+X³+X²+X+ 1 Pour C₄, on a : G₄ est une matrice g´en´eratrice

G₄ =





1 0 1 1 1 0 0 0 1 0 1 1 1 0 0 0 1 0 1 1 1





En appliquant le th´eor`eme sur la dimension de chaque code, on trouve effectivement que la dimension de C₄ est 3

Pour les autres on a :

C₀ : 0, C₁ : 6, C₂ : 4, C₃ : 4, C₄ : 3, C₅ : 3, C₆ : 1.

1.3 Quelques lemmes

Lemme 1 Soit C un code cyclique de longueur m, soit Θ(C) sa repr´esentation polyno- miale et M une matrice g´en´eratrice de C de taille m×m⁰.

Alors, le pgcd de X^m−1 et des polynˆomesLi(X) dont les coefficients sont respectivement les ´el´ements des lignes de M est le polynˆome g(X) g´en´erateur de l’id´eal Θ(C).

Preuve 5 On posed(X) = pcgd(L₁(X), L₂(X). . . , L_m⁰(X), X^m−1). D’abord on ag(X)| d(X), car g(X)|Li(X) ∀i= 1...m⁰ et g(X)|X^m−1.

De plus g(X)∈Θ(C) et donc :

g(X) =

m⁰

X

i=1

y_i(X)L_i(X) car (L_i(X)^m_i=1⁰ ) est une base de Θ(C).

=

m⁰

X

i=1

y_i(X)L_i(X) + 0×(X^m−1)

= (

m⁰

X

i=1

y_i(X)a_i(X))×d(X).

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 7−→ M⁰ avec r ≤ m telle que :

M⁰ = rl m−rl

M 0

L’application ϕ ne change pas le code engendr´e par les lignes de la matrice.

Preuve 6 Soient L_i(X), i= 1...m, les polynˆomes correspondants aux lignes de M⁰. Pm

i=1λ_i(X)L_i(X) =Pr

i=1λ_i(X)L_i(X) +Pm

i=r+1λ_i(X)L_i(X) Car Pm

i=r+1λi(X)Li(X) = 0 car Li(X) = 0,∀i=r+ 1...m

Lemme 3 Soient C un code cyclique de longueur m, M une matrice g´en´eratrice norma- lis´ee de C, r le rang de M (c’est aussi son nombre de lignes), et soit g(X) le polynˆome g´en´erateur de l’id´eal Θ(C).

Soit G= (g₀, g₁, ..., gm−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´e ∈M_r,r

Alors G⁰ =G∗ϕ(M) = (g₀, g₁, ..., gm−r,0, ...,0) M

0

Et donc :

G⁰ = (g0, g1, ..., gm−r,0, ...,0)

Ir | A 0 | 0

= (g0, g1, ..., gr, g_r+1⁰ , ..., g_m⁰ )

On a G et G⁰ deux ´el´ements de C. Or W =G−G⁰ = (0,0, ...,0, g”_r+1, ..., g”_m)∈C etW s’´ecrit donc en combinaison lin´eaire des vecteurs de la base de C. Alors :

W =Pr

i=1λ_iL_i = (λ₁, λ₂, ..., λ_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 = Pr

i=1λ_iL_i alors W = 0,d’o`u G=G⁰, et donc G∗ϕ(M) = G.

1.4 Codes Quasi-Cycliques

Soit σ la permutation circulaire (l’op´erateur de d´ecalage d’un rang vers la droite) Un code lin´eaire C de longueur n, de dimension k et de distance d, est dit quasi-cyclique s’il v´erifie :

∃l ∈N^∗/σ^l ∈C, ∀c∈C.

Le plus petit entier naturel v´erifiant ceci est appel´e l’indice du code.

On r´eordonne les ´el´ements SoitCun code quasi-cyclique de longueurn, de dimension k, de distanced et d’indice l surFq, posons n=r×l.

C = (x₀, .., x_l−1 |x_l, .., x_2l−1 |x_2l, .., x_3l−1 |...|x_l(r−1), .., x_lr−1) On r´eorganise les mots pour trouver :

C = (x₀, 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 :

Φ : (A0, A1, .., Aj = ((xjl+i)^l−1_i=0), .., Ar−1)7−→(C0, C1, .., Cj = ((xil+j)^r−1_i=0), .., Cl) o`u :

C₀ = (x₀, x_l, x_2l, ..., xl(r−1)), C₁ = (x_l, x_l+1, ..., xl(r−1)+1), ..., C_l= (xl−1, x2l−1, .., xlr−1) Or le codeC est quasi-cyclique d’indicel donc par construction, lesC_i sont bien des codes cycliques.

Dans toute la suite de notre travail, nous utiliserons des codes quasi-cycliques organis´es comme pr´esent´e ci-dessus apr´es le passage par l’application Φ.

Notation : D´esormais, 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 ´egale `a m×l que l’on notera n.

si x est un mot du code alors il est de la forme :

x= (x₁, x₂.., x_m |x_m+1, x_m+2.., x_2m |...|x_(l−1)m+1, .., x_lm)

Construction d’une matrice g´en´eratrice d’un code quasi-cyclique : Soit V un espace vectoriel de dimensionn =m×l sur Fq.

V :={(x1, .., xn)/xi ∈F^q pour xi = 1..n}

Soit v un ´el´ement de V tir´e au hasard.

v = (x₁, x₂.., x_m |x_m+1, x_m+2.., x_2m |...|x(l−1)m+1, .., x_lm)

Soit σ la permutation d´efinie comme suit :

σ : V −→V

x:= (x₁, x₂.., x_m|x_m+1, x_m+2.., x_2m|...|x_(l−1)m+1, .., x_lm)7−→(x_m, x₁.., 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´efinir va nous permettre de construire une matrice g´en´eratrice du code.

Travaillons sur notre ´el´ementv, `a partir de cet ´el´ement nous allons construire une famille dem vecteurs par application deσ.

Notons cette famille B , on a alors B :={V, σ(V), σ²(V), .., σ^m−1(V)}

Cette famille est la plus grande que l’on puisse construire `a partir de σ car (σ^m =Id).

On obtient donc une famille de m vecteurs. On v´erifie 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 :

M= 0 B B B B B

@

x₁ x₂ . . . 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₁ . . . xm−1 x_2m x_m+1 . . . x2m−1 . . . x_lm x_(l−1)m+1 . . . x_lm−1

.. .

.. . . . .

.. .

.. .

..

. . . .

..

. . . .

.. .

..

. . . .

.. .

x₂ x₃ . . . x₁ x_m+2 x_m+3 . . . x_m+1 . . . x_(l−1)m+2 x_(l−1)m+3 . . . x_(l−1)m+1

1 C C C C C A

Cette matrice est la matrice g´en´eratrice d’un code quasi-cyclique.

2 Transformation de la matrice g´ en´ eratrice d’un code quasi-cyclique

2.1 Partie th´ eorique

2.1.1 Objectif et m´ethode

Notre objectif est de r´ealiser la transformation d’une matrice g´en´eratrice d’un code quasi-cyclique en une forme canonique unique.

Supposons que l’on poss`ede la matrice M g´en´eratrice d’un code quasi-cyclique. Cette matrice peut ˆetre vue en bloc sous la forme suivante.

M := (M₁ |M₂ |..|M_l)

Les M_i sont des matrices de taille m⁰ ×m auxquelles on peut associer un code cyclique que l’on notera Ci. Pour r´ealiser la transformation de cette matrice, nous effectuons les

´

etapes suivantes :

– On applique `a la matriceM un pivot de gauss. On obtient alors une nouvelle matrice M.

– Par suite, on travaille sur la matrice M1. On r´ecup`ere le g´en´erateur g<sub>1</sub> du code C<sub>1</sub> et le rang r1 de la matrice M1. On effectue la multiplication g1×ϕ(M) (o`u ϕ est l’application d´efinie dans le lemme 2). On r´ecup`ere alors le premier g´en´erateur G<sub>1</sub> de la matrice. Ce g´en´erateur engendrera les r<sub>1</sub> premi`eres lignes.

– Puis on r´eit`ere le mˆeme proc´ed´e avec la matrice M2 en enlevant les r1 premi`eres lignes (on note le rang de cette matricer₂). On obtient ainsi le deuxi`eme g´en´erateur G<sub>2</sub>. On continue comme cela jusqu’`a ce queP

r_i =m⁰.

– A partir de maintenant, on travaille uniquement sur les g´en´erateursGi. Nous allons effectuer une r´eduction. Pour r´eduire un g´en´erateurG_i, on utilise les g´en´erateursG_j tels que j > i. Regardons les g´en´erateurs comme suit :

G1 = g₁ f₁₁ f₁₂ . . . f_1l G₂ = 0 g₂ f₂₂ . . . f_2l

Chaque ´el´ement de Gi est en faite un vecteur de longueur m qui selon sa position appartient `a un des codesC_i. Dans ce cas, on travaille dans le codeC₂. En utilisant la repr´esentation polynomiale, on effectue la division de f₁₁ par g₂. On a f₁₁ = g2∗q+r11 et doncr11 =f11−g2∗q. On remplace alorsf11 parr11. Pour que le mot appartienne toujours au code quasi-cyclique, il faut reporter l’op´eration sur le reste du mot en posant r_1i =f_1i −f_2i∗q, ∀i = 2. . . l et en rempla¸cant f_1i par r_1i. Puis on recommence cette op´eration sur G1 avec les autres vecteurs Gj tel que j > 2.

Ensuite on effectue le mˆeme type d’op´eration surG₂ avec lesG_j tels quej >2. Puis surG₃, G₄ , . . . , et ceux juqu’`a ´epuisement des G_i.

– On peut alors construire la nouvelle matrice `a l’aide de la permutation σ d´efinie 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 :

M⁰ =











A₁ B₁ . . . . 0 A2 . . . . 0 0 . .. . . .

0 0 0 A_k











Tels que les A_i sont de la forme en posant s_i :=m−r_i o`ur_i est le rang de la matrice :

A_i=











gi,0 gi,1 gi,2 . . . gi,si 0 . . . 0 0 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











Les A_i sont des matrices g´en´eratrices de codes cycliques et le g´en´erateur 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´ed´e est unique et canonique.

2.1.2 Th´eor`eme de transformation

Th´eor`eme 4 SoitCun code quasi-cyclique, alors il existe une unique matriceM g´en´eratrice de forme canonique (forme d´efinie pr´ec´edement) qui g´en´eralise 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´en´eratrice de ce code de taille m⁰×n.

On r´ealise un pivot de Gauss sur cette matrice et on obtient une autre matrice g´en´eratrice du code quasi-cyclique que l’on note toujours M. Apr`es cela, on proc`ede aux op´erations suivantes :

Modification de la matrice : Regardons maintenant les blocs concat´en´es qui forment la matrice, ils sont tous de taille m⁰×m. Chacun d’entre eux repr´esente un code cyclique que l’on notera C_i pour i= 1. . . l et auxquels on associe la matrice M_i.

M := (M₁ |M₂ |..|M_l)

On commence par le code cyclique C1 dans un premier temps on r´ecup`ere le rang r1 de la matrice M₁.

Extraction du polynˆome g´en´erateur deC₁ : On veut trouver le g´en´erateur du code cyclique C₁ que l’on note g₁(X). On connait maintenant le degr´e du polynˆome recherch´e deg(g₁(X)) = s₁ =m−r₁ o`u r₁ est le rang de la matrice M₁.

On sait que g₁(X) divise X^m−1 ainsi que tout les polynˆomes L_i(X) dont les coefficients sont les ´el´ements de la i-`eme ligne de la matrice M₁.

On effectue donc un calcul de pgcd : . pgcd₁ = pgcd(L₁(X), X^m−1) . pgcd₂ = pgcd(L₂(X), pgcd₁)

...

. pgcd_i = pgcd(L_i(X), pgcd_i−1) tant que deg(pgcd_i)deg(g₁(X)) On en d´eduit alors :

1 Le degr´e 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’`a la m<sup>0</sup> `eme ´etapes 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₁(X), X^m−1)L₂(X))L₃(X). . . L_m(X)) En appliquant B´ezout on trouve :

pgcd(L₁(X), X^m−1) =U₁(X)L₁(X) +U₂(X)(X^m−1)

Si on le r´eapplique `a chaque fois que l’on calcule un pgcd dans la formule de pgcdm⁰ on trouve alors :

pgcd_m⁰ = . . . U₃(X)(U₁(X)L₁(X) +U₂(X)(X^m−1)) +U₄(X)L₂(X)). . . pgcd_m⁰ = U₀⁰(X)(X^m−1) +U₁⁰(X)L₁(X) +. . .+U_m⁰ 0(X)L_m⁰(X)

Donc puisqu’il existe U₀⁰(X), U₁⁰(X). . . U_m⁰ 0(X) tels que :

pgcd_m⁰ =U₀⁰(X)(X^m−1) +U₁⁰(X)L₁(X) +. . .+U_m⁰ 0(X)L_m⁰(X).

Alors pgcd_m⁰ =pcgd(L₁(X) +L₂(X). . .+L_m⁰(X), X^m−1).

D’apr`es le lemme 1 on sait que :

g₁(X) = pcgd(L₁(X), L₂(X). . . , L_m⁰(X), X^m−1) Donc on trouve bien que pgcd_m⁰ =g₁(X).

Donc mˆeme au pire, si l’agorithme va jusqu’`a la m<sup>0</sup> `eme ´etape on tombe sur le polynˆome g´en´erateur g₁(X).

R´ecup´eration des vecteurs g´en´erateurs G_i : On effectue le produit de

G= (g₀, g₁, ..., gm−r1,0, ...,0)∈M_1,m(Fq)parϕ(M) = (M₁|M₂|...|M_l)o`u M est la matrice du code quasi-cyclique, et ϕ est l’application d´efinie dans le Lemme 2 :

On fait : (g₀, g₁, ..., gm−r₁,0, ...,0)(M₁|M₂|...|M_l) En tenant compte du Lemme 3, on trouve :

G₁ = (g₁, g₂.., gm−r₁,0, ...,0|f₁¹, f₂¹, .., f_m¹|f₁², f₂², .., f_m²|...|f₁^l−1, f₂^l−1, .., f_m^l−1) C’est le premier vecteur g´en´erateur qu’on r´ecup`ere.

Pour le2i`eme vecteur g´en´erateur on r´eapplique la mˆeme chose `a la matriceM⁰ constitu´ee par les m⁰−r₁ derni`eres lignes de M (on a bien vu dans le Lemme 2 que l’application ϕ ne change pas le code engendr´e par la matrice)

On cherche par le mˆeme algorithme le polynˆome g´en´erateur g₂(X) du code cyclique C₂⁰ dont la matrice g´en´eratrice est M₂⁰ constitu´ee par les m⁰−r₁ derni`eres lignes de M₂, on pose r2 le rang de M₂⁰.

On effectue le produit de G = (g_2,0, g_2,1, ..., g2,m−r₂,0, ...,0) ∈ M_1,m(Fq) par ϕ(M⁰) , on trouve donc le vecteur suivant :

G₂ := (0,0, ...,0|g_2,0, g_2,1, ..., g2,m−r₂,0, ...,0|P₁¹, P₂¹, .., P_m¹|, ..,|P₁^l−2, P₂^l−2, .., P_m^l−2) On prendra donc comme second g´en´erateur le vecteur G2.

Et ainsi de suite on r´ecup´ere tous les vecteurs g´en´erateurs on s’arrˆete lorsque P

r_i =m⁰. Dor´enavant, on va travailler exclusivement sur ces vecteurs g´en´erateurs.

R´eduction des G_i :

Le principe : On r´eduit chaque g´en´erateur G_i par tous les G_j qui le suivent (pour les j ≥i+ 1)

R´eduction de G₁ par G₂ : on a :

G1 = (g1, g2.., gm−r1,0, ...,0|f₁¹, f₂¹, .., f_m¹|f₁², f₂², .., f_m²|...|f₁^l−1, f₂^l−1, .., f_m^l−1) et

G₂ := (0,0, ...,0|g_2,0, g_2,1, ..., g2,m−r2,0, ...,0|P₁¹, P₂¹, .., P_m¹|, ..,|P₁^l−2, P₂^l−2, .., P_m^l−2) On va r´eduire G₁ par G₂ :

Soit f¹(X) le polynˆome dont les coefficients sont (f₁¹, f₂¹, .., f_m¹).

On effectue la division euclidienne de f¹(X) par g2(X) : On trouve : f¹(X) =q¹(X)g₂(X) +r¹(X)

Donc, r¹(X) = f¹(X)−q¹(X)g₂(X)

Montrons que r¹(X)∈Θ(C2) (Θ(C2) la repr´esentation polynomiale du code cyclique C2) On sait que f¹(X)∈Θ(C₂) car :

G₁ = (g₁, g₂.., gm−r₁,0, ...,0|f₁¹, f₂¹, .., f_m¹|f₁², f₂², .., f_m²|...|f₁^l−1, f₂^l−1, .., f_m^l−1)

appartient au code quasi-cyclique C = (C₁|C₂|...|C_l) en tant que code quasi-cyclique constitu´e par des codes cycliques concat´en´es.

On sait aussi queq¹(X)g₂(X)∈Θ(C₂⁰) =< g₂(X)>et puisqueC₂⁰ ⊆C₂alorsq¹(X)g₂(X)∈ Θ(C₂) et donc r¹(X)∈Θ(C₂) pour tout i= 2...l−1.

On pose : rⁱ(X) = fⁱ(X)−q¹(X)Pⁱ⁻¹(X) Les rⁱ(X) appartiennent bien `a Θ(C_i+1) car :

. fⁱ(X)∈Θ(C_i+1)

. q¹(X)Pⁱ⁻¹(X)∈Θ(C_i+1) [car Pⁱ⁻¹(X)∈Θ(C_i+1) et C_i+1 est un code cyclique].

On r´ecup`ere donc un vecteur :

G⁰₁ := (g₁, g₂.., gm−r₁,0, ...,0|r¹₁, r₂¹, .., r_m¹|r₁², r₂², .., r_m²|...|r^l−1₁ , r₂^l−1, .., r^l−1_m ) qui appartient bien au code quasi-cyclique C = (C₁|C₂|...|C_l).

On a donc effectu´e la r´eduction de G₁ par G₂, on aura alors `a r´eduire G⁰₁ par G₃ et ainsi de suite..

Ceci est en ce qui concerne la r´eduction du vecteur g´en´erateur G₁. On r´ecup`ere `a la fin le premier vecteur g´en´erateur r´eduit :

G¹ = (g₁, g₂.., gm−r₁,0, ...,0|R¹₁, R¹₂, .., R_m¹ |R₁², R²₂, .., R²_m|...|R^l−1₁ , R^l−1₂ , .., R^l−1_m ) On passe alors `a la r´eduction du vecteur g´en´erateur G₂ par tous les G_j qui le suivent (pour les j ≥3), on commencera donc par le r´eduire par G3, mˆeme d´emarche et ainsi de suite..

Lorsqu’on sera arriv´e au bout de la r´eduction de G₂, on r´ecup`erera le 2 i`eme vecteur g´en´erateur r´eduit :

G² = (0,0, ...,0|g_2,0, g_2,1, ..., g2,m−r₂,0, ...,0|S₁¹, S₂¹, .., S_m¹|, ..,|S₁^l−2, S₂^l−2, .., S_m^l−2) On r´eduira de la mˆeme mani`ere les autres vecteurs g´en´erateurs.

Reconstruction d’une matrice g´en´eratrice du code quasi-cyclique C `a partir des vecteurs g´en´erateurs r´eduits : A l’issue de l’op´` eration de r´eduction, on aura obtenu des vecteurs :

G¹= (g1, g2.., g_m−r1,0, ..,0|R¹₁, R¹₂, ..., R_m¹ |R²₁, R²₂, .., R²_m|...|R^l−1₁ , R^l−1₂ , .., R^l−1_m ) G²= (0,0, ...,0|g_2,0, g_2,1, ..., g_2,m−r2,0, ...,0|S₁¹, S₂¹, ..., S¹_m|...|S₁^l−2, S₂^l−2, .., S_m^l−2) G³= (0,0, ...,0|0,0, ...,0|g3,0, g3,1, ..., g_3,m−r3,0, ...,0|T₁¹, T₂¹, .., T_m¹|..|T₁^l−3, T₂^l−3, .., T_m^l−3)

...

Soit σ la permutation qui correspond `a un shift. On effectue sur chaque G<sup>i</sup> : r<sub>i</sub> shifts successifs. Et on r´ecup`ere ainsi pour chaque Gⁱ, la matrice :

r_i l









 Gⁱ σ(Gⁱ)

... σ^ri(Gⁱ)











Supposons qu’on avait r´ecup´er´e k vecteurs G_i.

La famille(G¹, σ(G¹), .., σ^r1(G¹), G², σ(G²), .., σ^r1(G²), .., G^k, σ(G^k), .., σ^rk(G^k))est une fa- mille libre, car d´eja lesG_i pour(i= 1..k)sont libres entre eux par construction (voir leurs formes ci-dessus, l’emplacement des z´eros au d´ebut de chaque vecteur empeche le fait qu’ils soient li´es)

Ensuite, en faisant des shifts, le mˆeme argument tient. C’est donc une famille libre du code quasi-cyclique C qui est de cardinal Pk

i=1r_i, Or par construction, on sait que Pk

i=1r_i =m⁰ donc c’est bien une base de C.

Nous allons donc prendre pour nouvelle matrice P g´en´eratrice du code quasi-cyclique C la matrice :

P=

















































 G¹ σ(G¹)

... σ^r1(G¹)

G² σ(G²)

... σ^r2(G²)

... G^k σ(G^k)

... σ^rk(G^k)



















































En forme plus d´etaill´ee peut ˆetre :

P=











A₁ B₁ . . . . 0 A₂ . . . . 0 0 . .. . . . 0 0 . . . A_k











Tels que les A_i sont de la forme (on pose s_i :=m−r_i) :

A_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 ... . .. ... ... ... . . .. ... 0 . . . 0 g_i,0 g_i,1 g_i,2 . . . g_i,si











La matrice P ainsi obtenu est unique car apr`es l’´etape du pivot de Gauss, chaque ´etape effectuer entraine un r´esultat unique. En effet, lorsqu’on l’on cherche les g´en´erateurs g, il n’en existe qu’un `a chaque fois. De plus lorsque l’on effectue les r´eductions `a l’aide des diff´erents vecteurs, l’unicit´e d´ecoule directement de la division euclidienne. Les diff´erentes

´

etapes entrainent donc l’unicit´e de la matrice obtenue et cette forme est canonique quelque soit le code quasi-cyclique sur lequel on travaille.

2.2 Partie programmation de la transformation d’une matrice d’un code quasi-cyclique en Magma

2.2.1 Biblioth`eque contenant les fonctions et proc´edures

/************************************************************************/

/*** proc´edure qui r´ealise la permutation dans un code quasi-cyclique ***/

/*** de longueur n, d’indice l et ayant des codes cycliques engendr´es ***/

/*** par des polyn^omes qui divise X^m-1 avec m=n/l ***/

/************************************************************************/

procedure sigma(~x,m,l)

// x : ´el´ement 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’´el´ement tirer au hasard ***/

/*******************************************************/

procedure list(x,~L,k,l) // x : ´el´ement al´eatoire

// L : liste o`u l’on stocke les permutations // k : nombres de permutations effectu´ees // 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;

/***************************************************************/

/*** proc´edure de cr´eation de la matrice g´en´eratrice du code ***/

/***************************************************************/

function matrice_du_code(L,m,n,Fq)

// L: liste `a 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´ecupere 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´ecupere 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];

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´ecesssaire ***/

/*** `a la multiplication pour recuperer la premiere ligne d’un "bloc" ***/

/************************************************************************/

function extractvect(v,d)

// v g´en´erateur d’un code cyclique

// d nombre de lignes restant dans la matrice g´en´eratrice du code u:=[**]; // initialisation chaine vide

// on r´ecupere les coordonn´ees du vecteur g´en´erateur 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´edure de construction d’un polyn^ome `a 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´ecup`ere 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);

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´ecup´eration des coefficients du polyn^ome // remplacement dans le vecteur par les coefficients du polyn^ome // puis par des z´ero pour compl´eter

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´edure qui r´ealise 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´en´erateur de la matrice // m longueur des codes cycliques

// l indice du code quasi-cyclique

// k ´el´ement de la liste que l’on veut modifier

// h ´el´ement de la liste gr^ace auquel on effectue la r´eduction // p variable qui permet de savoir dans quel bloc on travail F<x>:=PolynomialRing(Fq);

// on trouve le quotient et le reste

fi:=0;g:=0;

polyn^ome(~fi,G[k],m,p,Fq); // on r´ecup`ere le polyn^ome `a modifier print"fi:=",fi;

polyn^ome(~g,G[h],m,p,Fq); // on r´ecup`ere le polyn^ome par lequel on divise print"g:=",g;

r:=fi mod g; // r´ecup`eration du reste de la division print"r:=",r;

q:=fi div g; // r´ecup`eration du quotient de la division print"q:=",q;

remplace(~G[k],m,r,p); // remplacement de f par le reste r // r´ep´ercution 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´ecup`ere le polyn^ome `a modifier print"fi:=",fi;

polyn^ome(~g,G[h],m,e,Fq); // on r´ecup`ere le polyn^ome qui sert `a la modification print"g:=",g;

r:=((fi-(g*q))mod (x^m+1)); // on r´epercute 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´erentes valeurs n´ecessaires ***/

/**********************************************************/

// chargement de la biblioth`eque qui contient les fonctions et les proc´edures load"bibliotheque_final.mag";

// d´eclartion des diff´erentes 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);

print"q:=",q,"\tl:=",l,"\tm:=",m,"\tn:=",n;

v:=Random(V);

print "\nElement al´eatoire:\n";

print v,"\n";

// construction et r´ealisation de la mise sous forme canonique de la matrice du code L:=[**];list(v,~L,m,l); // on g´en`ere la liste contenant les permutations

MAT:=matrice_du_code(L,m,n,Fq); // on construit la matrice du code m1:=Rank(MAT); // on r´ecup`ere 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´erents rang

// j : permet de connaitre le nombre de vecteur g´en´erateur G:=[**];RANG:=[**];pos:=[**]; // initialisation des listes

// G : liste des g´en´erateurs

// RANG : liste des diff´erents rang

// pos : liste permettant de se placer dans la matrice while(r lt m1) do

j:=j+1;

// r´ecup´eration 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 `a la boucle suivante j:=j-1;

continue;

end if;

gene:=generateur(A,m,Fq); // on r´ecup`ere le g´en´erateur du code cyclique print"generateur:",j,"eme bloc:",gene;

A:=SubmatrixRange(MAT,r+1,1,m1,n); // on recupere la sous matrice `a modifier v:=extractvect(gene,m1-r); // on met le vecteur `a taille pour la multiplication G[j]:=v*A;G[j]; // on r´ecup`ere le vecteur generateur du j eme bloc

RANG[j]:=rang; // on r´ecup`ere le rang de ce bloc

pos[j]:=i; // on recup`ere la position de ce bloc dans la matrice r:=rang + r ; // on fait la somme des rangs des diff´erents blocs i:=i+1;

end while;

// Reduction des diff´erents g´en´erateurs for k:=1 to j-1 do

for h:=k+1 to j do

reduct_ligne(~G,m,l,k,h,pos[h]-1,Fq);

end for;

end for;

// on r´ealise l’affichage des g´en´erateurs r´eduits for i:=1 to j do

G[i];

end for;

print "\n";

// on reconstruit la matrice qui a la forme canonique souhait´ee 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´e temps

0 50 100 150 200 250 300 350 400 450

10 100 1000 10000 100000

Temps en seconde

Longueur des mots du code

Temps de calul en fonction de la longueur des mots du code

”complexite.txt” using 1 :2