docRapport de TER Transformation de la matrice génératrice d`un code
download 
Plainte Transcription
Rapport de TER Transformation de la matrice génératrice d`un code
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
1.1 Préliminaires . . . . .
1.2 Codes Cycliques . . . .
1.3 Quelques lemmes . . .
1.4 Codes Quasi-Cycliques
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
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 . . . . . . . . . . . . . . . . . . . . . . . . .
2.1.2 Théorème de transformation . . . . . . . . . . . . . . . . . . . . .
2.2 Partie programmation de la transformation d’une matrice d’un code quasicyclique en Magma . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2.2.1 Bibliothèque contenant les fonctions et procédures . . . . . . . . .
2.2.2 Algorithme de transformation de la matrice . . . . . . . . . . . .
2.2.3 Graphe de complexité temps . . . . . . . . . . . . . . . . . . . . .
2.3 Différents exemples obtenus avec le programme en magma . . . . . . . .
2.3.1 Exemple sur F2 avec des mots de longueur 75 . . . . . . . . . . .
2.3.2 Exemple sur F2 avec des mots de longueur 35 . . . . . . . . . . .
2.3.3 Exemple sur F3 avec des mots de longueur 35 . . . . . . . . . . .
2.3.4 Différentes matrices obtenus dans K n avec K = F25 . . . . . . . .
2
.
.
.
.
3
3
7
11
13
15
. 15
. 15
. 16
.
.
.
.
.
.
.
.
.
21
21
25
27
28
28
31
32
33
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 = (x1 , .., xn ) tels que xi ∈ 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 = (x1 , .., xn ) et y = (y1 , .., yn ) alors d(x, y) := card{i = 1, 2.., n/xi 6= yi }.
a)
b)
c)
d)
d(x, y) ∈ R+
d(x, y) = 0 ⇔ x = y
d(x, y) = d(y, x)
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 = F2 .
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 = (x1 , .., xn ) un mot de C. Alors :
Supp(x) := {i/xi 6= 0}
.
Définition 5 (Poids de Hamming) Soit x = (x1 , .., xn ) 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 := M inx∈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 λ 6= 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 = (x1 , .., xn ) est un
0
0
0
mot envoyé et x = (x1 , .., xn ) le mot reçu. Alors le nombre d’erreurs commises est
0
0
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
0
0
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 = minx∈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 ϕ : (x1 , .., xn ) 7−→ (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
1 0 0 1 0
M= 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 F2 (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 :
xk = (u1 , .., uk ) ∗ G où U = (u1 , .., uk ) ∈ K k
c) Si c1 , ··, ck sont les vecteurs colonnes de G, les mots du code C sont tous obtenus
sous la forme xk = (< c1 , u >, .., < ck , u >) avec u ∈ K k et < ., . > est le produit
scalaire usuel sur K k .
0
Remarque 3 Une matrice G obtenue par permutation des colonnes de G serait une
0
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 : M essage 7−→
u = (u1 , .., uk ) 7−→ xk = (u1 , .., uk ) ∗ 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 = (u1 , .., uk ) 7−→ (u1 , .., uk , xk+1 , xk+2 , .., xn )
u1 , .., uk sont appelés symboles d’information et xk+1 , xk+2 , .., xn 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 = (x1 , .., xn ). Le mot x ∈ C ssi
H t x = 0.
Codes de Hamming binaires
Définition 17 On appelle code de Hamming (binaire) de longueur 2k − 1 tout code admettant comme matrice de controle H, une matrice dont les 2k − 1 colonnes sont tous les
vecteurs de Fk2 \ {0}, il est appelé code Hamming de paramètre k.
5
Exemple 3 Matrice de controle du code de Hamming
1 0 0 0 1 1
0 1 0 1 0 1
H=
0 0 1 1 1 0
6
de longueur 7.
1
1
1
1.2
Codes Cycliques
Définition 18 Un code C est dit cyclique si :
a) C est un code linéaire.
b) Si (x1 , .., xn ) ∈ C, alors (xn , x1 , .., xn−1 ) ∈ C.
Exemple 4 Soit C le code de matrice
1 0
0 1
G=
0 0
génératrice :
0 1 0 0 1 0 0
0 0 1 0 0 1 0
1 0 0 1 0 0 1
Ce code possède 23 = 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 2eme et 3eme 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 := (a0 , .., an−1 )
on lui associe le polynôme m(X) := a0 + a1 X + .. + an−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)
(a0 , .., an−1 ) 7−→ a0 + a1 x + .. + an−1 xn−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 (d0 + d1 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)
b)
c)
d)
g(X) est l’unique polynôme unitaire de degré r dans Θ(C).
g(X) génère Θ(C) comme idéal principal de K[X]/(X n − 1).
g(X) divise xn − 1
{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
de coefficients
Pn−r−1un ensemble
i
{ai ∈ K, i = 0, .., n − rP
− 1} tels que P (X) =
a
X
g(X)
c-à-d
P (X) =
i
i=0
n−r−1
i
a(X)g(X) avec a(X) = i=0 ai X .
0
Preuve 3
1) Si on suppose qu’il existe g (X), un autre polynôme unitaire de degré r
0
0
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 xn − 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) = r0 + r1 X + .. + rn−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) = r0 g(X) + r1 Xg(X) + .. + rn−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) = g0 + g1 X + .. + gr 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.
g0 g1 g2 . . . gr 0 . . . 0
0 g0 g1 g2 . . . gr . . . 0
G = .. . . . . . . . .
..
.
.
.
.
.
.
. ...
. .
0 . . . 0 g0 g1 g2 . . . gr
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 F2 est :
X 7 − 1 = (X − 1)(X 3 + X + 1)(X 3 + X 2 + 1)
Les codes cycliques de longueur 7 sur F2 différents de {0} sont donc ceux générés comme
suit :
C0 : g0 (X) = X 7 − 1 = 0 C0 = {0, .., 0}
C1 : g1 (X) = X − 1
C2 : g2 (X) = X 3 + X + 1
C3 : g3 (X) = X 3 + X 2 + 1
C4 : g4 (X) = (X − 1)(X 3 + X + 1) = X 4 + X 3 + X 2 + 1
C5 : g5 (X) = (X − 1)(X 3 + X 2 + 1) = X 4 + X 2 + X + 1
C6 : g6 (X) = (X 3 + X + 1)(X 3 + X 2 + 1) = X 6 + X 5 + X 4 + X 3 + X 2 + X + 1
Pour C4 , on a : G4 est une matrice génératrice
1 0 1 1 1 0 0
G4 = 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 C4 est 3
Pour les autres on a :
C0 : 0, C1 : 6, C2 : 4, C3 : 4, C4 : 3, C5 : 3, C6 : 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 × m0 .
Alors, le pgcd de X m − 1 et des polynômes Li (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(L1 (X), L2 (X) . . . , Lm0 (X), X m −1). D’abord on a g(X) |
d(X), car g(X) | Li (X) ∀i = 1...m0 et g(X) | X m − 1.
De plus g(X) ∈ Θ(C) et donc :
0
g(X) =
m
X
0
yi (X)Li (X) car (Li (X)m
i=1 ) est une base de Θ(C).
i=1
0
=
m
X
yi (X)Li (X) + 0 × (X m − 1)
i=1
0
=(
m
X
yi (X)ai (X)) × d(X).
i=1
Alors d(X) | g(X).
Et on a bien : g(X) = d(X).
Lemme 2 Soit l’application ϕ : Mr,m (Fq ) −→ Mm,m (Fq ) ; M 7−→ M 0 avec r ≤ m telle
que :
rl
M
0
M =
m−r l
0
L’application ϕ ne change pas le code engendré par les lignes de la matrice.
Preuve
6 Soient Li P
(X), i = 1...m, les polynômes
correspondants aux lignes de M 0 .
Pm
Pm
r
λi (X)Li (X) = i=1 λi (X)Li (X) + i=r+1 λi (X)Li (X)
i=1P
Car m
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é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 = (g0 , g1 , ..., gm−r , 0, ..., 0) ∈ M1,m (Fq ).
Alors on a : G ∗ ϕ(M ) = G
Preuve 7 On a :
M=
Ir | A
tel que Ir matrice identité ∈ Mr,r
0
Alors G = G ∗ ϕ(M ) = (g0 , g1 , ..., gm−r , 0, ..., 0)
11
M
0
Et donc :
0
G = (g0 , g1 , ..., gm−r , 0, ..., 0)
Ir | A
0 | 0
0
0
= (g0 , g1 , ..., gr , gr+1
, ..., gm
)
On a G et G0 deux éléments de C. Or W = G − G0 = (0, 0, ..., 0, g”r+1 , ..., g”m ) ∈ C et W
s’écritPdonc en combinaison linéaire des vecteurs de la base de C. Alors :
W = ri=1 λi Li = (λ1 , λ2 , ..., λr , λ0r+1 , ..., λ0m )
Or on sait que W = (0, 0, ..., 0, g”r+1 , ..., g”m ) et donc λi = 0, ∀i = 1..r. Puisque W =
P
r
0
i=1 λi Li 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 Fq , posons n = r × l.
C = (x0 , .., xl−1 | xl , .., x2l−1 | x2l , .., x3l−1 | ... | xl(r−1) , .., xlr−1 )
On réorganise les mots pour trouver :
C = (x0 , xl , x2l , .., xl(r−1) | xl , xl+1 , .., xl(r−1)+1 | ... | xl−1 , x2l−1 , .., xlr−1 )
Et ceci moyennant l’application suivante :
r−1
Φ : (A0 , A1 , .., Aj = ((xjl+i )l−1
i=0 ), .., Ar−1 ) 7−→ (C0 , C1 , .., Cj = ((xil+j )i=0 ), .., Cl )
où :
C0 = (x0 , xl , x2l , ..., xl(r−1) ), C1 = (xl , xl+1 , ..., xl(r−1)+1 ), ..., Cl = (xl−1 , x2l−1 , .., xlr−1 )
Or le code C est quasi-cyclique d’indice l donc par construction, les Ci 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 = (x1 , x2 .., xm | xm+1 , xm+2 .., x2m | ... | x(l−1)m+1 , .., xlm )
Construction d’une matrice génératrice d’un code quasi-cyclique : Soit V un
espace vectoriel de dimension n = m × l sur Fq .
V := {(x1 , .., xn )/xi ∈ Fq pour xi = 1..n}
Soit v un élément de V tiré au hasard.
v = (x1 , x2 .., xm | xm+1 , xm+2 .., x2m | ... | x(l−1)m+1 , .., xlm )
13
Soit σ la permutation définie comme suit :
σ : V −→ V
x := (x1 , x2 .., xm | xm+1 , xm+2 .., x2m | ... | x(l−1)m+1 , .., xlm ) 7−→ (xm , x1 .., xm−1 | x2m , xm+1 .., x2m−1 | ... | xlm , x(l−1)m+1 , .., xlm−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
x1
B xm
B
B
M=B
.
B
.
@
.
x2
x2
x1
.
.
.
x3
...
...
xm
xm−1
xm+1
x2m
xm+2
xm+1
...
...
.
.
.
x1
.
.
.
.
.
.
xm+2
xm+3
...
...
...
...
x2m
x2m−1
.
.
.
xm+1
...
...
...
...
x(l−1)m+1
xlm
x(l−1)m+2
x(l−1)m+1
.
.
.
.
.
.
x(l−1)m+2
x(l−1)m+3
Cette matrice est la matrice génératrice d’un code quasi-cyclique.
14
...
...
...
...
xlm
xlm−1
.
.
.
x(l−1)m+1
1
C
C
C
C
C
A
2
Transformation de la matrice génératrice d’un code
quasi-cyclique
2.1
2.1.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 := (M1 | M2 | .. | Ml )
Les Mi sont des matrices de taille m0 × m auxquelles on peut associer un code cyclique
que l’on notera Ci . 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 M 1. On récupère le générateur g1 du code C1
et le rang r1 de la matrice M 1. On effectue la multiplication g1 × ϕ(M ) (où ϕ est
l’application définie dans le lemme 2). On récupère alors le premier générateur G1
de la matrice. Ce générateur engendrera les r1 premières lignes.
– Puis on réitère le même procédé avec la matrice M2 en enlevant les r1 premières
lignes (on note le rang de cette matrice r2 ). On
P obtient0 ainsi le deuxième générateur
G2 . On continue comme cela jusqu’à ce que
ri = m .
– A partir de maintenant, on travaille uniquement sur les générateurs Gi . Nous allons
effectuer une réduction. Pour réduire un générateur Gi , on utilise les générateurs Gj
tels que j > i. Regardons les générateurs comme suit :
G1 = g1 f11 f12 . . . f1l
G2 = 0 g2 f22 . . . f2l
Chaque élément de Gi est en faite un vecteur de longueur m qui selon sa position
appartient à un des codes Ci . Dans ce cas, on travaille dans le code C2 . En utilisant
la représentation polynomiale, on effectue la division de f11 par g2 . On a f11 =
g2 ∗ q + r11 et donc r11 = f11 − g2 ∗ q. On remplace alors f11 par r11 . Pour que le mot
appartienne toujours au code quasi-cyclique, il faut reporter l’opération sur le reste
du mot en posant r1i = f1i − f2i ∗ q, ∀i = 2 . . . l et en remplaçant f1i par r1i . Puis
on recommence cette opération sur G1 avec les autres vecteurs Gj tel que j > 2.
Ensuite on effectue le même type d’opération sur G2 avec les Gj tels que j > 2. Puis
sur G3 , G4 , . . . , et ceux juqu’à épuisement des Gi .
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 Gi , on effectue ri
permutation, puis on juxtapose les vecteurs.
On obtient alors la matrice :
A1 B1 . . . . . .
0 A2 . . . . . .
0
M =
.
.
0 0
. ...
0 0 0 Ak
Tels que les Ai sont de la forme
gi,0
0
Ai = ..
.
0
en posant si := m − ri où ri est le rang de la matrice :
gi,1 gi,2 . . . gi,si 0 . . . 0
gi,0 gi,1 gi,2 . . . gi,si . . . 0
..
...
... ... ... ...
...
.
. . . 0 gi,0 gi,1 gi,2 . . . gi,si
Les Ai sont des matrices génératrices de codes cycliques et le générateur de ce code
est le mot gi = (gi,0 , gi,1 , gi,2 , . . . , gi,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 m0 × 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 m0 × m. Chacun d’entre eux représente un code cyclique
que l’on notera Ci pour i = 1 . . . l et auxquels on associe la matrice Mi .
M := (M1 | M2 | .. | Ml )
On commence par le code cyclique C1 dans un premier temps on récupère le rang r1 de la
matrice M1 .
Extraction du polynôme générateur de C1 : On veut trouver le générateur du code
cyclique C1 que l’on note g1 (X). On connait maintenant le degré du polynôme recherché
deg(g1 (X)) = s1 = m − r1 où r1 est le rang de la matrice M1 .
16
On sait que g1 (X) divise X m − 1 ainsi que tout les polynômes Li (X) dont les coefficients
sont les éléments de la i-ème ligne de la matrice M1 .
On effectue donc un calcul de pgcd :
. pgcd1 = pgcd(L1 (X), X m − 1)
. pgcd2 = pgcd(L2 (X), pgcd1 )
..
.
. pgcdi = pgcd(Li (X), pgcdi−1 ) tant que deg(pgcdi ) deg(g1 (X))
On en déduit alors :
1 Le degré des pgcd diminue :
On a pgcdi+1 = pgcd(Li+1 (X), pgcdi ).
donc pgcdi+1 | pgcdi .
donc deg(pgcdi+1 ) ≤ deg(pgcdi ).
2 Si l’algorithme va jusqu’à la m0 ème étapes alors :
pgcdm0 = pgcd(pgcdm0 −1 , L0m (X))
pgcdm0 = pgcd(pgcd(pgcdm0 −2 , Lm0 −1 ), Lm0 (X))
..
.
pgcdm0 = pgcd(pgcd(. . . pgcd(pgcd(L1 (X), X m − 1)L2 (X))L3 (X) . . . Lm (X))
En appliquant Bézout on trouve :
pgcd(L1 (X), X m − 1) = U1 (X)L1 (X) + U2 (X)(X m − 1)
Si on le réapplique à chaque fois que l’on calcule un pgcd dans la formule de pgcdm0 on
trouve alors :
pgcdm0 = . . . U3 (X)(U1 (X)L1 (X) + U2 (X)(X m − 1)) + U4 (X)L2 (X)) . . .
0
pgcdm0 = U00 (X)(X m − 1) + U10 (X)L1 (X) + . . . + Um
0 (X)Lm0 (X)
0
Donc puisqu’il existe U00 (X), U10 (X) . . . Um
0 (X) tels que :
0
pgcdm0 = U00 (X)(X m − 1) + U10 (X)L1 (X) + . . . + Um
0 (X)Lm0 (X).
Alors pgcdm0 = pcgd(L1 (X) + L2 (X) . . . + Lm0 (X), X m − 1).
D’après le lemme 1 on sait que :
g1 (X) = pcgd(L1 (X), L2 (X) . . . , Lm0 (X), X m − 1)
Donc on trouve bien que pgcdm0 = g1 (X).
Donc même au pire, si l’agorithme va jusqu’à la m0 ème étape on tombe sur le polynôme
générateur g1 (X).
17
Récupération des vecteurs générateurs Gi : On effectue le produit de
G = (g0 , g1 , ..., gm−r1 , 0, ..., 0) ∈ M1,m (Fq ) par ϕ(M ) = (M1 |M2 |...|Ml ) où M est la matrice
du code quasi-cyclique, et ϕ est l’application définie dans le Lemme 2 :
On fait : (g0 , g1 , ..., gm−r1 , 0, ..., 0)(M1 |M2 |...|Ml )
En tenant compte du Lemme 3, on trouve :
1
2
l−1
G1 = (g1 , g2 .., gm−r1 , 0, ..., 0|f11 , f21 , .., fm
|f12 , f22 , .., fm
|...|f1l−1 , f2l−1 , .., fm
)
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 0 constituée
par les m0 − r1 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 g2 (X) du code cyclique C20
dont la matrice génératrice est M20 constituée par les m0 − r1 dernières lignes de M2 , on
pose r2 le rang de M20 .
On effectue le produit de G = (g2,0 , g2,1 , ..., g2,m−r2 , 0, ..., 0) ∈ M1,m (Fq ) par ϕ(M 0 ) , on
trouve donc le vecteur suivant :
G2 := (0, 0, ..., 0|g2,0 , g2,1 , ..., g2,m−r2 , 0, ..., 0|P11 , P21 , .., Pm1 |, .., |P1l−2 , P2l−2 , .., Pml−2 )
On prendra donc comme second générateur le vecteur G2 .
P
Et ainsi de suite on récupére tous les vecteurs générateurs on s’arrête lorsque
ri = m 0 .
Dorénavant, on va travailler exclusivement sur ces vecteurs générateurs.
Réduction des Gi :
Le principe : On réduit chaque générateur Gi par tous les Gj qui le suivent (pour les
j ≥ i + 1)
Réduction de G1 par G2 :
on a :
1
2
l−1
G1 = (g1 , g2 .., gm−r1 , 0, ..., 0|f11 , f21 , .., fm
|f12 , f22 , .., fm
|...|f1l−1 , f2l−1 , .., fm
)
et
G2 := (0, 0, ..., 0|g2,0 , g2,1 , ..., g2,m−r2 , 0, ..., 0|P11 , P21 , .., Pm1 |, .., |P1l−2 , P2l−2 , .., Pml−2 )
On va réduire G1 par G2 :
1
Soit f 1 (X) le polynôme dont les coefficients sont (f11 , f21 , .., fm
).
On effectue la division euclidienne de f 1 (X) par g2 (X) :
On trouve : f 1 (X) = q 1 (X)g2 (X) + r1 (X)
Donc, r1 (X) = f 1 (X) − q 1 (X)g2 (X)
Montrons que r1 (X) ∈ Θ(C2 ) (Θ(C2 ) la représentation polynomiale du code cyclique C2 )
On sait que f 1 (X) ∈ Θ(C2 ) car :
18
1
2
l−1
G1 = (g1 , g2 .., gm−r1 , 0, ..., 0|f11 , f21 , .., fm
|f12 , f22 , .., fm
|...|f1l−1 , f2l−1 , .., fm
)
appartient au code quasi-cyclique C = (C1 |C2 |...|Cl ) en tant que code quasi-cyclique
constitué par des codes cycliques concaténés.
On sait aussi que q 1 (X)g2 (X) ∈ Θ(C20 ) =< g2 (X) > et puisque C20 ⊆ C2 alors q 1 (X)g2 (X) ∈
Θ(C2 ) et donc r1 (X) ∈ Θ(C2 ) pour tout i = 2...l − 1.
On pose : ri (X) = f i (X) − q 1 (X)P i−1 (X)
Les ri (X) appartiennent bien à Θ(Ci+1 ) car :
. f i (X) ∈ Θ(Ci+1 )
. q 1 (X)P i−1 (X) ∈ Θ(Ci+1 ) [car P i−1 (X) ∈ Θ(Ci+1 ) et Ci+1 est un code cyclique].
On récupère donc un vecteur :
1
2
l−1
G01 := (g1 , g2 .., gm−r1 , 0, ..., 0|r11 , r21 , .., rm
|r12 , r22 , .., rm
|...|r1l−1 , r2l−1 , .., rm
)
qui appartient bien au code quasi-cyclique C = (C1 |C2 |...|Cl ).
On a donc effectué la réduction de G1 par G2 , on aura alors à réduire G01 par G3 et ainsi
de suite..
Ceci est en ce qui concerne la réduction du vecteur générateur G1 .
On récupère à la fin le premier vecteur générateur réduit :
1
2
l−1
G1 = (g1 , g2 .., gm−r1 , 0, ..., 0|R11 , R21 , .., Rm
|R12 , R22 , .., Rm
|...|R1l−1 , R2l−1 , .., Rm
)
On passe alors à la réduction du vecteur générateur G2 par tous les Gj qui le suivent
(pour les j ≥ 3), on commencera donc par le réduire par G3 , même démarche et ainsi de
suite..
Lorsqu’on sera arrivé au bout de la réduction de G2 , on récupèrera le 2 ième vecteur
générateur réduit :
1
l−2
G2 = (0, 0, ..., 0|g2,0 , g2,1 , ..., g2,m−r2 , 0, ..., 0|S11 , S21 , .., Sm
|, .., |S1l−2 , S2l−2 , .., Sm
)
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 :
1
2
l−1
G1 = (g1 , g2 .., gm−r1 , 0, .., 0|R11 , R21 , ............................, Rm
|R12 , R22 , .., Rm
|...|R1l−1 , R2l−1 , .., Rm
)
1
l−2
G2 = (0, 0, ......................, 0|g2,0 , g2,1 , ..., g2,m−r2 , 0, .............., 0|S11 , S21 , ......., Sm
|...|S1l−2 , S2l−2 , .., Sm
)
1
l−3
G3 = (0, 0, ......, 0|0, 0, .........................., 0|g3,0 , g3,1 , ..., g3,m−r3 , 0, ..., 0|T11 , T21 , .., Tm
|..|T1l−3 , T2l−3 , .., Tm
)
..
.
Soit σ la permutation qui correspond à un shift. On effectue sur chaque Gi : ri shifts
successifs. Et on récupère ainsi pour chaque Gi , la matrice :
Gi
σ(Gi )
ri l
..
.
ri
i
σ (G )
19
Supposons qu’on avait récupéré k vecteurs Gi .
La famille (G1 , σ(G1 ), .., σ r1 (G1 ), G2 , σ(G2 ), .., σ r1 (G2 ), .., Gk , σ(Gk ), .., σ rk (Gk )) est une famille libre, car déja les Gi 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
P
code quasi-cyclique C qui est de cardinal ki=1 ri ,
P
Or par construction, on sait que ki=1 ri = m0 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 :
G1
σ(G1 )
..
.
r1 1
σ (G )
G2
2
σ(G )
..
.
P=
r2 2
σ (G )
..
.
Gk
σ(Gk )
.
..
rk
k
σ (G )
En forme plus détaillée peut être :
A1 B1 . . . . . .
0 A2 . . . . . .
P=
0 0 ... . . .
0 0 . . . Ak
Tels que les Ai sont de la forme (on
gi,0 gi,1
0 gi,0
Ai = .. . .
.
.
0 ...
pose si := m − ri ) :
gi,2 . . . gi,si 0
gi,1 gi,2 . . . gi,si
... ... ...
...
0 gi,0 gi,1 gi,2
...
...
...
0
0
..
.
. . . gi,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
2.2.1
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
/***************************************************************/
/*** 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
Temps de calul en fonction de la longueur des mots du code
450
400
350
300
250
Temps en seconde
200
150
100
50
0
10
”complexite.txt” using 1 :2
10000
1000
100
Longueur des mots du code
27
100000
2.3
Différents exemples obtenus avec le programme en magma
2.3.1
Exemple sur F2 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
[0
[0
[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
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
1
0
0
0
0
0
0
0
0
0
0
0
1
0
0
1
0
0
0
0
0
0
0
0
0
0
0
1
1
0
1
0
0
0
0
0
0
0
0
0
0
0
1
1
1
1
0
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
1
1
1
0
0
0
0
0
0
0
0
0
0
0
1
0
1
0
0
0
0
0
0
0
0
0
0
0
0
0
1
0
1
0
0
0
0
0
0
0
0
0
0
0
1
0
1
1
0
0
0
0
0
0
0
0
0
0
0
1
1
0
0
0
0
0
0
0
0
0
0
0
0
0
0
1
1
0
0
0
0
0
0
0
0
0
0
0
0
0
0
1
1
0
0
0
0
0
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
0
0
0
0
0
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
0
0
0
0
0
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
0
0
0
0
0
1
0
1
0
1
0
0
1
1
1
0
0
0
0
0
1
1
1
1
1
1
0
1
0
0
0
0
0
0
0
1
1
1
0
0
1
1
0
1
0
0
0
0
0
0
0
1
1
1
0
0
1
1
0
1
0
0
0
0
0
0
0
0
0
1
0
0
0
0
1
0
0
0
0
0
1
0
1
0
1
1
0
1
1
1
0
0
0
0
0
1
1
1
1
1
1
1
1
0
0
0
0
0
0
0
1
1
1
0
0
1
1
1
1
0
0
0
0
0
0
0
1
1
1
0
0
1
1
1
1
0
0
0
0
0
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
0
0
0
0
0
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
0
1
1
1
0
0
0
1
0
1
0
1
1
1
1
0
1
0
0
1
0
0
1
1
1
1
1
0
0
0
0
0
1
1
1
1
0
0
0
0
0
0
1
0
0
0
1
0
1
0
0
1
0
0
0
0
0
0
1
0
0
0
1
0
1
0
0
1
0
0
0
0
0
0
1
0
0
1
0
1
0
0
1
1
1
0
1
1
1
1
0
0
1
0
1
0
0
1
1
0
1
1
0
0
0
0
0
0
0
1
1
0
0
0
0
1
0
1
0
0
0
0
0
1
1
1
1
0
1
1
1
0
0
1
0
0
0
0
1
0
1
1
1
1
0
0
0
0
0
1
0
1
1
1
1
0
1
0
1
0
0
1
1
1
1
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
1
1
1
1
0
1
1
0
1
0
0
1
1
1
1
1
0
1
1
1
1
0
0
1
0
0
0
1
1
1
1
1
0
1
0
1
0
1
1
0
0
0
0
1
1
1
0
1
0
1
1
0
1
0
0
0
0
0
0
1
1
1
0
1
1
1
0
1
0
1
0
0
0
0
0
1
0
0
1
0
1
0
0
0
0
1
1
1
1
1
1
1
0
1
1
0
0
1
0
0
1
0
1
1
1
1
0
1
1
0
0
1
1
1
0
1
0
0
1
1
1
1
0
0
1
0
1
0
1
1
1
0
0
0
1
1
0
1
1
1
0
1
0
0
1
0
0
0
0
0
1
0
1
0
0
1
1
1
1
0
1
1
1
1
1
1
1
0
0
0
0
0
0
1
1
1
0
1
1
1
1
1
1
1
0
0
1
1
0
1
0
0
0
1
1
1
0
1
1
1
1
1
0
0
1
1
0
0
0
1
1
0
1
0
0
1
1
0
0
1
0
1
0
1
0
0
0
0
1
0
0
1
1
0
0
1
0
1
0
1
0
0
1
0
1
1
0
0
0
0
1
1
1
0
1
0
1
1
1
1
1
1
1
1
0
1
1
0
0
1
0
1
0
1
0
1
1
0
0
1
1
1
0
1
1
0
0
0
0
1
1
1
0
1
0
0
1
0
1
0
0
1
0
0
1
0
1
1
0
1
0
0
1
0
1
0
0
0
1
1
0
0
0
1
1
1
1
1
0
1
0
1
1
0
0
1
0
1
1
1
0
1
0
0
1
0
1
0
0
0
0
1
1
1
0
1
1
0
1
1
0
0
0
0
0
1
0
0
0
1
1
1
0
1
0
0
1
0
1
0
1
1
0
1
1
0
0
1
0
1
0
1
0
1
1
0
1
0
0
0
1
1
1
0
1
0
1
0
0
0
1
0
0
1
0
1
1
0
0
1
0
0]
0]
0]
0]
1]
1]
1]
1]
1]
1]
1]
0]
1]
1]
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)
G1 (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)
G2 (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)
G3 (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)
G1 (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 1ere à l’aide de la 2eme :
Travaille sur le deuxième bloc :
fi := x14 + x11 + x8 + x4 + x3 + x
g := x9 + x6 + x5 + x4 + x + 1
r := x8 + x7 + x6 + x5 + x3 + x2 + x + 1
28
q := x5 + x + 1
On répercute la combinaison linéaire au reste de la ligne :
fi := x14 + x13 + x12 + x10 + x9 + x7 + x4 + x
g := x14 + x13 + x9 + x8 + x7 + x6 + x5 + x4 + x3 + 1
g ∗ q := x19 + x18 + x15 + x14 + x12 + x11 + x9 + x8 + x5 + x3 + x + 1
r := x13 + x11 + x10 + x8 + x7 + x5
fi := x14 + x13 + x10 + x9 + x3 + x2
g := x14 + x13 + x12 + x11 + x8
g ∗ q := x19 + x18 + x17 + x16 + x15 + x13 + x11 + x9 + x8
r := x14 + x11 + x10 + x8 + x4 + x + 1
fi := x14 + x12 + x10 + x9 + x7 + x6 + x5 + x2 + x + 1
g := x6 + x5 + x3 + x
g ∗ q := x11 + x10 + x8 + x7 + x6 + x5 + x4 + x3 + x2 + x
r := x14 + x12 + x11 + x9 + x8 + x4 + x3 + 1
réduction de la 1ere à l’aide de la 3eme :
fi := x13 + x11 + x10 + x8 + x7 + x5
g := x11 + x10 + x6 + x5 + x + 1
r := x10 + x7 + x6 + x5 + x3 + x
q := x2 + x
On répercute la combinaison linéaire au reste de la ligne :
fi := x14 + x11 + x10 + x8 + x4 + x + 1
g := x12 + x7 + x2
g ∗ q := x14 + x13 + x9 + x8 + x4 + x3
r := x13 + x11 + x10 + x9 + x3 + x + 1
fi := x14 + x12 + x11 + x9 + x8 + x4 + x3 + 1
g := x14 + x13 + x11 + x10 + x9 + x8 + x6 + x5 + x4 + x3 + x + 1
g ∗ q := x16 + x14 + x13 + x9 + x8 + x4 + x3 + x
r := x13 + x12 + x11 + 1
Et ainsi de suite :
réduction : 1 4
fi := x13 + x11 + x10 + x9 + x3 + x + 1
g := x14 + x13 + x12 + x11 + x10 + x9 + x8 + x7 + x6 + x5 + x4 + x3 + x2 + x + 1
r := x13 + x11 + x10 + x9 + x3 + x + 1
q := 0
29
fi := x13 + x12 + x11 + 1
g := 0
g ∗ q := 0
r := x13 + x12 + x11 + 1
réduction : 2 3
fi := x14 + x13 + x9 + x8 + x7 + x6 + x5 + x4 + x3 + 1
g := x11 + x10 + x6 + x5 + x + 1
r := x7 + x6 + x5 + 1
q := x3
fi := x14 + x13 + x12 + x11 + x8
g := x12 + x7 + x2
g ∗ q := x15 + x10 + x5
r := x14 + x13 + x12 + x11 + x10 + x8 + x5 + 1
fi := x6 + x5 + x3 + x
g := x14 + x13 + x11 + x10 + x9 + x8 + x6 + x5 + x4 + x3 + x + 1
g ∗ q := x17 + x16 + x14 + x13 + x12 + x11 + x9 + x8 + x7 + x6 + x4 + x3
r := x14 + x13 + x12 + x11 + x9 + x8 + x7 + x5 + x4 + x2
réduction : 2 4
fi := x14 + x13 + x12 + x11 + x10 + x8 + x5 + 1
g := x14 + x13 + x12 + x11 + x10 + x9 + x8 + x7 + x6 + x5 + x4 + x3 + x2 + x + 1
r := x9 + x7 + x6 + x4 + x3 + x2 + x
q := 1
fi := x14 + x13 + x12 + x11 + x9 + x8 + x7 + x5 + x4 + x2
g := 0
g ∗ q := 0
r := x14 + x13 + x12 + x11 + x9 + x8 + x7 + x5 + x4 + x2
réduction : 3 4
fi := x12 + x7 + x2
g := x14 + x13 + x12 + x11 + x10 + x9 + x8 + x7 + x6 + x5 + x4 + x3 + x2 + x + 1
r := x12 + x7 + x2
q := 0
fi := x14 + x13 + x11 + x10 + x9 + x8 + x6 + x5 + x4 + x3 + x + 1
g := 0
30
g ∗ q := 0
r := x14 + x13 + x11 + x10 + x9 + x8 + x6 + x5 + x4 + x3 + x + 1
On obtient alors les vecteurs suivants après la réduction :
(1
(0
(0
(0
1
0
0
0
1
0
0
0
1
0
0
0
0
0
0
0
1
0
0
0
0
0
0
0
1
0
0
0
1
0
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
0
0
1
0
0
0
1
0
0
0
0
1
0
0
1
1
0
0
1
1
0
0
1
0
0
0
1
0
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
1
1
0
1
0
1
0
0
0
0
0
1
0
0
0
0
0
0
0
1
1
1
0
1
1
1
0
1
1
0
0
0
0
0
0
0
0
0
0
1
0
1
0
0
0
1
0
0
0
0
0
0
0
0
0
0
0
0
0
1
0
0
1
1
1
0
1
0
1
1
1
1
1
0
1
0
1
0
1
0
0
0
1
0
1
0
1
0
1
1
1
0
0
0
1
1
1
0
1
1
0
0
1
1
0
0
1
0
0
1
1
1
0
0
1
0
0
0
1
1
0
1
0
0
0
1
0
0
1
0
0
0
0
1
0
0
1
1
0
0
1
1
0
0
0
1
0
0
1
0
0
0
1
1
0
0
1
1
0
0
0
1
0
1
1
1
0
1
1
0
0
1
1
1
0
0),
1),
1),
0)
On reconstruit la matrice et on obtient :
[1
[0
[0
[0
1
1
0
0
1
1
1
0
1
1
1
1
0
1
1
1
1
0
1
1
0
1
0
1
1
0
1
0
1
1
0
1
0
1
1
0
0
0
1
1
1
0
0
1
0
1
0
0
0
0
1
0
0|
0|
0|
1|
1
0
0
0
1
1
0
0
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
1
1
1
0
0
1
1
0
0
0
1
0
0
0
0
0
0
0
0
0|
0|
0|
0|
0
0
0
0
1
0
0
0
0
1
0
0
1
0
1
0
0
1
0
1
1
0
1
0
1
1
0
1
1
1
1
0
0
1
1
1
0
0
1
1
1
0
0
1
0
1
0
0
0
0
1
0
0
0
0
1
0|
0|
0|
0|
1
0
1
0
1
1
0
1
0
1
1
0
1
0
1
1
0
1
0
1
0
0
1
0
0
0
0
1
0
0
0
0
0
0
0
0
1
0
0
0
1
1
0
0
1
1
1
0
0
1
1
1
1
0
1
1
0|
1|
0|
1|
1
0
1
1
0
1
0
1
0
0
1
0
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
1
0
0
0
1
1
0
0
1
1
1
0
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
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
0
0
0
0
0
0
0
0
0|
0|
0|
0|
0|
0|
1
0
0
0
0
0
1
1
0
0
0
0
0
1
1
0
0
0
0
0
1
1
0
0
1
0
0
1
1
0
1
1
0
0
1
1
1
1
1
0
0
1
0
1
1
1
0
0
0
0
1
1
1
0
1
0
0
1
1
1
0
1
0
0
1
1
0
0
1
0
0
1
0
0
0
1
0
0
0
0
0
0
1
0
0|
0|
0|
0|
0|
1|
1
0
0
0
0
0
0
1
0
0
0
0
0
0
1
0
0
0
0
0
0
1
0
0
0
0
0
0
1
0
1
0
0
0
0
1
1
1
0
0
0
0
1
1
1
0
0
0
0
1
1
1
0
0
0
0
1
1
1
0
0
0
0
1
1
1
0
0
0
0
1
1
0
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
0
0
0
1
1
0
0
0
0
1
1
1
0
0
0
1
1
1
1
0
0
0
1
1
1
1
0
1
0
1
1
1
1
1
1
0
1
1
1
0
1
1
0
1
1
1
0
1
1
0
1
0
1
0
1
1
0
0
0
1
0
1
1
0
0
0
1
0
1
0
0
0
0
1
0
0|
0|
0|
0|
0|
1|
0
1
1
1
1
0
0
0
1
1
1
1
1
0
0
1
1
1
0
1
0
0
1
1
1
0
1
0
0
1
1
1
0
1
0
0
0
1
1
0
1
0
1
0
1
1
0
1
1
1
0
1
1
0
1
1
1
0
1
1
0
1
1
1
0
1
1
0
1
1
1
0
1
1
0
1
1
1
1
1
1
0
1
1
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
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
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
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
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|
1|
0
0
0
1
0
0
0
0
1
0
0
0
0
1
0
0
0
0
1
0
0
0
0
1
0
0
0
0
1
0
0
0
0
1
0
0
0
0
1
0
0
0
0
1
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
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
1
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 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 F2 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
[0
[0
[0
[0
0
1
0
0
0
0
0
0
0
1
0
0
0
0
1
1
0
0
0
0
0
0
1
1
0
0
0
0
1
1
1
0
0
0
0
1
0
1
0
0
0
0
0
0
0
1
0
0
0
0
0
0
0
1
0
0
0
0
0
0
0
1
0
1
1
1
1
0
1
0
0
1
0
1
1
1
0
1
1
0
1
1
0
0
0
1
1
0
1
1
0
1
0
1
0
1
0
0
1
0
0
0
0
1
0
1
0
1
1
0
1
0
0
1
1
1
1
1
0
0
0
0
1
1
0
0
0
0
0
0
1
1
0
1
1
1
1
0
0
0
0
0
0
1
0
0
0
0
0
0
0
1
0
0
0
0
0
0
0
1
0
1
1
1
1
0
1
0
0
1
0
1
1
1
0
1
1
0
1
1
0
0
0
1
1
0
1
1
0
0
0
0
0
0
0
1
1
0
1
1
1
0
1
0
0
1
1
0
1
1
1
0
0
0
0
1
1
0
0
0
0
1
1
1
0
1
0
0
1
0
1
1]
0]
0]
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
[0
[0
[0
[0
[0
0
1
0
0
0
0
0
1
0
1
0
0
0
0
2.3.3
1
1
0
0
0
0
0
1
1
1
0
0
0
0
0
1
1
0
0
0
0
0
0
1
0
0
0
0
1
0
0
1
0
0
0
0
1
0
1
1
0
0
1
0
1
1
1
1
0
0
1
0
0
1
1
0
0
0
1
1
0
1
0
0
0
0
0
1
0
0
0
0
0
0
0
1
0
0
1
1
1
1
0
0
0
0
1
1
1
1
0
0
0
0
0
1
1
0
1
0
0
1
0
1
0
1
1
0
0
1
0
0
1
1
1
0
0
1
0
1
1
1
1
0
0
0
1
0
0
1
0
0
0
0
1
0
1
1
0
0
1
0
1
1
1
1
0
0
1
0
0
1
1
0
0
0
1
1
0
1
0
0
0
0
0
1
0
0
0
0
0
0
0
1
0
1
0
1
1
0
0
1
0
1
0
1
1
0
1
0
0
1
1
1
1
1
1
0
0
0
1
1
1
0
1
0
1
0
1
1
1
0
1
0
1
0
1
0]
1]
0]
0]
0]
1]
1]
Exemple sur F3 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
[0
0
1
0
0
0
0
0
0
0
1
0
0
0
0
0
0
0
1
0
0
0
0
0
0
0
1
0
0
0
0
0
0
0
1
0
2
2
2
2
2
2
0
0
2
2
0
2
2
0
1
1
0
0
1
0
0
0
1
1
0
0
1
0
2
2
0
0
2
2
0
1
0
0
1
1
0
0
0
1
0
0
1
1
0
2
2
0
2
2
0
0
0
0
0
0
0
0
1
0
2
0
1
0
1
1
2
1
1
0
0
0
1
0
1
1
2
0
1
1
2
1
0
1
1
0
1
32
0
1
1
1
1
2
1
1
0
2
0
2
0
1
0
2
1
1
2
1
1
2
1
1
1
0
2
1
1
2
2
0
2
2
1
1
1
0
1
1
1
1
2
2
0
0
0
1
1
2
0
1
0
2
0
1
0
1
0
2
0
0
1
1
2
2
2
2
1
1
2
2
1
2
1
2
1
1
2
0
0
0
0
1
0
0
2
1
0
1
1
2
1
2
2
0
0
1
0
1
1
0
2
1
1
2]
1]
0]
1]
2]
2]
1]
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
[0
[0
[0
[0
[0
[0
1
2
0
0
0
0
0
2.3.4
0
1
2
0
0
0
0
0
0
1
2
0
0
0
0
0
0
1
2
0
0
0
0
0
0
1
2
0
0
0
0
0
0
1
0
2
0
1
2
0
1
0
0
2
0
1
2
0
0
1
0
2
0
1
2
0
0
1
0
2
0
1
0
2
0
1
0
2
0
0
1
2
0
1
0
2
0
0
1
2
0
1
0
0
1
0
2
0
2
0
1
0
1
0
2
0
2
1
0
0
1
0
2
0
1
2
0
0
1
0
2
1
0
2
0
0
1
0
1
2
0
2
0
0
1
1
0
2
0
2
0
0
1
0
2
2
1
1
2
1
0
0
2
2
1
1
1
2
0
0
2
2
1
1
1
2
0
0
2
2
1
1
1
2
0
0
2
1
2
1
1
2
0
0
1
2
2
1
1
2
0
1
2
0
2
0
1
2
1
1
2
0
2
0
1
1
2
1
2
0
2
0
1
1
2
1
2
0
2
1
0
1
2
1
2
0
1
2
0
1
2
1
2
1
0]
2]
0]
1]
2]
1]
1]
Différentes matrices obtenus dans K n avec K = F25
m = 7; l = 5; n = 35; et w est une racine primitive de K
[w^10
1
0
0
0
[
0 w^10
1
0
0
[
0
0 w^10
1
0
[
0
0
0 w^10
1
[
0
0
0
0 w^10
[
0
0
0
0
0
0
0
0
0
1
0
[ w^5
[
0
[
0
[
0
[
0
[
0
0 w^6
0
0
0 w^7
0
0
1 w^4
0 w^10
[
[
[
[
1
0
0
0
1
w^5
0
0
0
0
0
1
w^5
0
0
0
0
0
1
w^5
0
0
0
0
0
1
w^5
0
0
1
0
0
0
0
1
0
0
0
0
1
0
0
0
0
w^5 w^8
0 w^5
w^2
0
1 w^2
w^7
1
w^5 w^10
1
w^6
0
w^7
0
w^5
w^7
w^8
w^5
0
w^2
1
1 w^2
w^7
1
w^8 w^7
w^5 w^8
0 w^5
w^5 w^10
w^4
0
1 w^4
w^6
1
0 w^6
w^7
0
1 w^10
w^7
0
w^4
1
w^6
w^5
0 w^4 w^5 w^12 w^12 w^5 w^6]
w^2 w^6 w^4 w^5 w^12 w^12 w^5]
1 w^5 w^6 w^4 w^5 w^12 w^12]
w^7 w^12 w^5 w^6 w^4 w^5 w^12]
w^8 w^12 w^12 w^5 w^6 w^4 w^5]
1
w w^6 w^11
w w^6 w^11]
0
0 w^8
0 w^4 w^11 w^14]
w^7 w^14
0 w^8
0 w^4 w^11]
0 w^11 w^14
0 w^8
0 w^4]
w^4 w^4 w^11 w^14
0 w^8
0]
1
0 w^4 w^11 w^14
0 w^8]
1 w^8 w^3 w^13 w^8 w^3 w^13]
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 w^12 w^10 w^5 w^6 w^10 w^3 w^5 w^10
w w^3 w^12 w^4]
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 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
0
0
0
0
1
0
0
1
w^6 w^10 w^3 w^12 w^10 w^5
w^5 w^6 w^10 w^3 w^12 w^10
w^3 w^12 w^4
w w^3 w^12
w^5 w^10
w]
w^4 w^5 w^10]
[ w^5 w^10
1
0
0
[
0 w^5 w^10
1
0
[
0
0 w^5 w^10
1
[
0
0
0 w^5 w^10
[
0
0
0
0
0
[
0
0
0
0
0
0 w^9 w^6
0
0 w^9
0
0
0
1 w^11
0
0 w^10
1
0
0 w^10
w w^11
0
0 w^11 w^11 w^8 w^14 w^13
1]
w^6
w w^11
0
1 w^11 w^11 w^8 w^14 w^13]
w^9 w^6
w w^11 w^13
1 w^11 w^11 w^8 w^14]
0 w^9 w^6
w w^14 w^13
1 w^11 w^11 w^8]
0 w^10
1
0 w^4 w^13 w^2 w^4 w^13 w^2]
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^10
1
0
0
[
0
0 w^10
1
0
[
0
0
0 w^10
1
[
0
0
0
0 w^10
[
0
0
0
0
0
0
0
0
0
1
0
[
[
[
[
[
[
1
0
0
0
0
0
1
1
0
0
0
0
0
1
1
0
0
0
0
0
1
1
0
0
0
0
0
1
1
0
0 w^13 w^9 w^6 w^4
1
0
0 w^13 w^9 w^6 w^4
0
1
0 w^13 w^9 w^6
0 w^4
1
0 w^13 w^9
1 w^6 w^4
1
0 w^13
0
1
1
1
1
1
[
[
[
[
[
[
1
0
0
0
0
0
1
1
0
0
0
0
0
1
1
0
0
0
0
0
1
1
0
0
0
0
0
1
1
0
0
w w^6 w^14 w^8 w^10
0 w^6
1 w^6 w^2 w^4 w^9]
0
0
w w^6 w^14 w^8 w^10 w^9 w^6
1 w^6 w^2 w^4]
0 w^10
0
w w^6 w^14 w^8 w^4 w^9 w^6
1 w^6 w^2]
0 w^8 w^10
0
w w^6 w^14 w^2 w^4 w^9 w^6
1 w^6]
1 w^14 w^8 w^10
0
w w^6 w^6 w^2 w^4 w^9 w^6
1]
0
1
1
1
1
1
1 w^10 w^10 w^10 w^10 w^10 w^10]
w^3 w^11 w^3
0
w
0 w^11 w^8 w^8 w^9
w
0 w^3 w^11 w^3
0
w w^7 w^11 w^8 w^8 w^9
w
0 w^3 w^11 w^3
0
w w^7 w^11 w^8 w^8
0
w
0 w^3 w^11 w^3 w^9
w w^7 w^11 w^8
w^3
0
w
0 w^3 w^11 w^8 w^9
w w^7 w^11
w^5 w^10
1 w^5 w^10
1 w^6 w^11
w w^6 w^11
34
0
w w^9
1 w^2
w
w^4 w^7 w^2
w^6 w^11 w^7
w^9
0 w^11
1 w^2 w^2
w^7]
w]
w^9]
w^8]
w^8]
w]
0 w^11 w^7 w^2]
w^9
0 w^11 w^7]
w w^9
0 w^11]
w^2
w w^9
0]
w^7 w^2
w w^9]
w^2 w^2 w^2 w^2]
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
