Nous allons donner quelques ´el´ements d’´etude d’un probl`eme de stabilit´e des codes modules sous l’effet de diverses applications lin´eaires.
Si l’on fixe Fq un corps fini et θ un automorphisme de Fq, on note Cn,r l’ensemble des codes modules engendr´es par un polynˆome de degr´e r et de longueur n. Chacun des ´el´ements de cet ensemble a une matrice g´en´eratrice de la forme :
G = g0 . . . gr−1 gr 0 . . . 0 0 θ(g0) . . . θ(gr−1) θ(gr) . . . 0 0 . .. . .. . .. . .. . .. ... 0 0 . . . 0 θn−r−1(g0) . . . θn−r−1(gr−1) θn−r−1(gr) . o`u le polynˆome g´en´erateur du code est g(X) = g0+ g1X + ... + grXr.
Il peut ˆetre int´eressant de se demander : 1. Quelles applications de Fn
q pr´eservent Cn,r?
2. Quelles applications laissent fixe un code module donn´e ?
Outre l’int´erˆet th´eorique de ces questions, une connaissance du comportement de Cn,r
sous l’action de permutations par exemple, peut avoir des applications dans le crypto-syst`eme de McEliece. C’est un protocole cryptographique utilisant une famille de codes correcteurs dont la s´ecurit´e repose en particulier sur l’indistinguabilit´e d’un code permut´e de cette famille d’un code lin´eaire quelconque. Pour une explication de ce cryptosyst`eme, on pourra consulter l’article fondateur de McEliece [17].
En ce qui concerne les applications laissant fixe un code, nous allons principalement nous int´eresser aux applications lin´eaires qui pr´eservent ´egalement le poids d’un mot, c’est-`a-dire des applications φ telles que pour tout code, C de Fn
q : d(φ(C)) = d(C).
Ces applications sont exactement les applications monomiales, une ´etude tr`es compl`ete est faite dans le livre [2].
Notation 9. — Nous noterons Aut(C) l’ensemble des applications monomiales pr´eservant le code C.
Il est, en g´en´eral, difficile d’exhiber l’ensemble des automorphismes d’un code quel-conque. Cela peut n´eanmoins ˆetre ´etudi´e pour des familles de codes particuli`eres, par exemple Thierry Berger dans [1] a obtenu des r´esultats sur l’ensemble des automorphismes d’un code de Gabidulin pour la m´etrique rang.
6.1.1 Reconnaissance d’un code module
Avant de mener une telle ´etude, il faut au pr´ealable pouvoir reconnaˆıtre un code module qui n’est pas forc´ement donn´e par sa matrice g´en´eratrice sous forme usuelle.
Nous allons voir un algorithme qui va permettre de d´eterminer rapidement si une ma-trice est la mama-trice g´en´erama-trice d’un code module et de trouver le cas ´ech´eant le polynˆome g´en´erateur.
Soit C le code module engendr´e par g(X) = g0+g1X +...grXret G la matrice g´en´eratrice qui en d´ecoule. On consid`ere ˆG une autre matrice g´en´eratrice de C, c’est-`a-dire une matrice dont les lignes forment ´egalement une base du code.
Notons q1, ..., qn−r les polynˆomes de Fq[X, θ] correspondant aux lignes de ˆG, ce sont des multiples `a gauche de g puisque tous les mots du code sont issus de multiples `a gauche de g.
Proposition 6.1.1. — Le plus grand diviseur commun `a droite de la famille {q1, ..., qn−r} est le polynˆome g´en´erateur du code g.
D´emonstration. — D´ej`a nous venons de voir que g est un diviseur commun `a droite `a tous les qi. Montrons que c’est le plus grand.
Par l’absurde notons h le pgcd `a droite des q1, ..., qn−r et supposons que deg(h) > deg(g). Nous avons les relations suivantes :
qj = tjh.
Le polynˆome h est de degr´e strictement sup´erieur `a r donc comme les qj sont de degr´e au plus n − 1 on a deg(tj) ≤ n − r − 2. Il existe donc une combinaison lin´eaire :
n−r
!
j=1
tj = 0.
En r´epercutant la combinaison lin´eaire sur les qj on se rend compte qu’ils sont li´es ce qui est absurde.
6.1.2 Mise en oeuvre algorithmique
De cette proposition, on d´eduit directement l’algorithme suivant qui teste si une matrice g´en´eratrice, M , engendre un code module et trouve, dans ce cas, le polynˆome g´en´erateur.
1. On transforme les lignes de la matrice M en polynˆomes q1, ..., qn−r. 2. On calcule le pgcd `a droite des qi, notons le g.
3. Si le pgcd n’est pas de degr´e r, le code ne peut pas provenir d’un code module. 4. Si le pgcd est de degr´e r, on regarde si g, Xg, ..., Xn−r−1g sont dans le code, si oui
c’est un code module engendr´e par g, sinon ce n’est pas un code module puisque g ´etait le seul candidat possible.
Le calcul du pgcd est rapide grˆace `a l’algorithme d’Euclide.
L’algorithme ci-dessus va maintenant nous servir dans les r´esultats empiriques qui suivent.
6.1.3 R´esultats empiriques
Voyons quelques r´esultats concernant les codes modules sur le corps F2, c’est-`a-dire en commutatif.
Le tableau qui suit est `a lire de la fa¸con suivante : en colonne la longueur n du code, en ligne le polynˆome g´en´erateur. Les deux chiffres se trouvant dans une case du tableau sont le cardinal des automorphismes monomiaux laissant fixe le code module et le cardinal des automorphismes monomiaux envoyant le code module sur un autre code module (y compris lui mˆeme ´eventuellement). Le nombre total des automorphismes monomiaux est n!.
Remarquons que le second nombre est un multiple du premier. En effet soit C un code module engendr´e par g et Aut(C) le groupe des automorphismes monomiaux qui pr´eservent ce code. S’il existe un automorphisme monomial φ qui envoie le code module C sur un autre code module ˆC alors pour tout ψ de Aut(C), on a φ ◦ ψ qui envoie ´egalement C sur ˆC. Donc le quotient du second nombre du tableau par le premier nombre correspond au cardinal des codes modules atteints via un automorphisme monomial.
De plus Aut( ˆC) = φAut(C)φ−1.
Avec exactement le mˆeme raisonnement, nous voyons que le nombre de codes correcteurs atteints `a partir d’un code module est ♯Autn!(C).
Deg 1 3 4 5 6 7 X 2, 2 6, 6 24, 24 120, 120 X + 1 6, 6 24, 24 120, 120 720, 720 Deg 2 X2 4, 4 12, 12 48, 48 240, 240 X2+ 1 8, 8 12, 12 72, 72 144, 144 X2+ X 6, 6 24, 24 120, 120 720, 720 X2+ X + 1 4, 4 8, 8 48, 48 48, 48 Deg 3 X3 12, 12 36, 36 144, 144 X3+ 1 8, 16 48, 48 48, 48 X3+ X 8, 16 12, 12 72, 72 X3+ X + 1 8, 16 24, 48 168, 336 X3 + X2 12, 12 48, 48 240, 240 X3+ X2+ 1 8, 16 24, 48 168, 336 X3+ X2+ X 4, 4 8, 8 48, 48 X3 + X2+ X + 1 12, 12 16, 16 48, 48 Deg 4 X4 48, 48 144, 144 X4+ 1 16, 48 48, 96 X4+ X 16, 48 48, 96 X4+ X + 1 8, 32 8, 16 X4 + X2 16, 48 24, 24 X4+ X2+ 1 72, 72 24, 24 X4+ X2+ X 8, 32 24, 48 X4 + X2+ X + 1 48, 144 168, 336 X4 + X3 36, 36 144, 144 X4+ X3+ 1 8, 32 8, 16 X4+ X3+ X 8, 32 24, 48 X4 + X3+ X + 1 48, 144 16, 16 X4+ X3+ X2 8, 8 16, 16 X4+ X3+ X2+ 1 48, 144 168, 336 X4+ X3+ X2+ X 12, 12 16, 16 X4+ X3+ X2+ X + 1 48, 48 48, 48
Il est relativement peu fr´equent qu’un automorphisme monomial envoie un code module sur un autre code module.
Une des questions qui reste ouverte est de pr´evoir quand cela va ˆetre le cas au vu du polynˆome g´en´erateur g.
Une autre question int´eressante est de comprendre la structure des classes d’isom´etries des codes modules. Voil`a `a titre d’exemples les polynˆomes de degr´e 4 de F2[X] regroup´es par classes d’isom´etries, c’est-`a-dire que deux polynˆomes sont dans la mˆeme classe si les
codes modules qu’ils engendrent sont ´equivalents via un automorphisme monomial. Ici la longueur du code n vaut 6, les param`etres du code sont inscrits devant :
[6, 2, 1] : X4 [6, 2, 2] : X4+ 1, X4+ X, X4+ X2 [6, 2, 3] : X4 + X + 1, X4+ X2+ X, X4+ X3+ 1, X4+ X3+ X [6, 2, 3] : X4 + X2+ 1 [6, 2, 4] : X4+ X2+ X + 1, X4+ X3+ X + 1, X4+ X3+ X2+ 1 [6, 2, 2] : X4+ X3 [6, 2, 2] : X4+ X3+ X2 [6, 2, 2] : X4+ X3+ X2+ X [6, 2, 2] : X4+ X3+ X2+ X + 1
Un enjeu serait de comprendre et de pr´evoir ces ensembles de polynˆomes ´equivalents.