RUR et candidat-RUR

Pour l’instant, nous ne savons « que » calculer un candidat-RUR, l’objectif ultime (calcul d’une RUR) ne sera atteint que si l’on résout également le problème de l’élément séparant. Il y a deux possibilités : soit celui-ci est connu avant le calcul de RUR, soit on choisit une forme linéaire quelconque pour calculer le candidat-RUR, auquel cas il faudra vérifier a posteriori que celle-ci sépare V (I) pour lever toute ambiguïté sur le résultat.

3.4.5.1 Calculer un élément séparant sans connaître de candidat-RUR

Conséquence directe des lemmes 3.8, 3.9 et du théorème 3.10, l’algorithme suivant permet de calculer une forme linéaire séparant V (I) :

Algorithm FindSep-Classic Input : Q1, MXi, i= 1n

Output : a linear form t which separates V (I) • d4rank(Q1) • for i = 1n^{d(d − 1)}₂ ◦ M_t4 P j=0 n ijM_Xi ◦ compute ft= charpol(Mt)

◦ compute f¯ the squarefree part of ft t ◦ if degree(f¯ ) = d then return(t)t

Une remarque est que charpol(Mt) peut être calculé de la même façon que dans l’algorithme RUR-Candidate, c’est à dire à partir des Trace(ti), i = 1D ou encore être remplacé par le polynôme minimal de Mt. Cette ligne de calcul ne sera donc jamais plus coûteuse que le calcul d’un candidat-RUR.

Une seconde remarque est qu’on obtient, en pratique, un élément séparant après 1 ou 2 ten-tatives. On distinguera donc la complexité théorique qui nécessite n^{d(d − 1)}₂ tentatives dans le pire cas, de la complexité pratique ou « en moyenne » qui est de l’ordre du coût des calculs pré-sents dans la boucle.

L’opération coûteuse de cet algorithme est en fait le calcul du rang de Q1 (rank(Q1)). En termes de nombre d’opérations arithmétiques, il est en O(D3) ce qui est équivalent au nombre d’opérations arithmétiques effectuées pour un calcul de candidat-RUR. Mais si Q1 est de dimen-sion D et admet des coefficients de taille s′, alors la taille des coefficients apparaissant dans sa forme réduite (calcul de son rang) est O(D s′) FR-[112]. Ce phénomène est observable en pra-tique (12 exemples provenant de FR-[113]):

1,00 0,50 0,25 0,12 0,06 0,03 0,02

e1 e2 e3 e4 e5 e6 e7 e8 e9 e10 e11 e12 H erm ite : Tailles relatives des coefficients (echelle log. base 2)

Entre (Table) Sortie

Figure 3.1. Taille des coefficients dans Q1avant et après réduction

Si l’on reporte le coût de cette réduction avec les tailles de coefficients que l’on a à traiter, on obtient alors FR-[114] :

Comp. binary op. arith. Op. Rank(Q1) O(D4δ(s + D)) O(D3)

Ainsi, si l’on garantit qu’un candidat-RUR est une RUR en calculant un élément séparant a priori par l’algorithme FindSep-Classic, cette dernière opération est la plus coûteuse du pro-cessus global, même si l’on se contente d’observer la complexité « en moyenne ».

3.4.5.2 Vérifier si un élément est séparant connaissant un candidat-RUR

En combinant le lemme 3.18 et le théorème 3.10, on obtient un critère simple, réutilisant une partie des calculs déjà effectués, pour vérifier si un candidat-RUR est une RUR :

Corollaire 3.22.

FR

FR

RUR si et seulement si Q1ft(t) = [0,,0], Q1gt,1(t)Xi− gt,Xi(t) = [0,0], i = 1n avec Q1= [Trace(wiwj)]_i=1D

j=1D.

L’algorithme qui suit FR-[117], réalise exactement les calculs suggérés par ce corollaire, la seule astuce additionnelle étant la manière dont est calculé ft(t) : on calcule en fait itérative-ment les polynômes de Horner (Hi(t), i = 0D) qui lui sont associés pour faciliter celui des vecteurs gt,1(t)Xi− gt,Xi(t) :

Algorithm CheckRUR-Classic

Input : Q1, f_t, M_t, M_Xi,Trace(tj), Trace(Xitj), i = 1n, j= 1D

Output : FALSE iff t is not a separating element.

• H0= a0[1, 0,,0]; • for i = 1D Hi(t) = MtHi−1(t) + aiHi−1(t); • if Q1HD(t)[0,,0] then return(FALSE); • gt,1(t) =P i=1 D Trace(tj)H_D−i−1(t) • for i = 1n ◦ gt,Xi(t) =P i=1 D Trace(Xit^j)HD−i−1(t) ◦ if Q1( MXigt,1(t)− gt,Xi(t))[0,,0] then return(FALSE) • return(TRUE)

Si l’on calcule la complexité de cet algorithme on obtient cette fois les mêmes complexités (arithmétique et binaire) que pour la fonction Traces-Classic (FR-[117]):

Comp. binary op. arith. Op. CheckRUR-Classic O((D4+ n D3)(s + D)) O(D3+ n D2)

En d’autres termes, vérifier qu’un candidat-RUR est une RUR est définitivement une opéra-tion difficile qui cependant n’est, en théorie, pas plus coûteuse que le calcul d’un candidat-RUR.

Dans le cas de l’utilisation de l’algorithme Classic pour le calcul d’un candidat-RUR, on peut se contenter de la fonction CheckRUR-Classic, même en pratique. Par contre, cette opé-ration est la plus coûteuse en théorie si l’on utilise la stratégie BS/GS-B. Dans ce qui suit, on réutilise le principe de « produit transposé » [20] qui est à la source de [131] ou encore de [19] pour calculer p(t) pour un polynôme ∀p, t ∈ Q[X1,, X_n]. Notons que l’algorithme suivant FR-[117] prend comme paramètre une fonction MulTk qui peut être MulTk-A, MulTk-B ou n’importe quelle fonction permettant de multiplier par tk modulo I.

Algorithm ReducedEval

• Input : k, 1, t¯ ,, tk, mulTk(u) and p = P_i=0D piTi • Output : p(t)∈ Q[X1,, Xn]/I (as a vector w.r.t. B) • Set u = [0,,0], k′=^D_k

• for i = k′0 do u = mulTk (u) +P j=0 k

pki+ jtj • return(u)

La fonction ReducedEval effectue clairement O(D1/2Tk) opérations, Tk étant le nombre d’opérations que nécessite mulTk. Munis de ce « produit transposé », on peut faire évoluer la fonction de vérification d’un candidat-RUR FR-[117] :

Algorithm CheckRUR-BS/GS

• Input : ft, gt, gt,1,, gt,na RUR-Candidate, B, t, Q

• Output : TRUE if and only if the RUR-Candidate is a RUR

• f_t(t) = ReducedEval(ft),

• if Q.ft(t)[0,,0] then return(FALSE); • gt,1(t) = ReducedEval(gt);

• for i = 1ndo

◦ g_t,i(t) = ReducedEval(gt,i);

◦ if Q1( MXigt,1(t)− gt,Xi(t))[0,,0] then return(FALSE) • return(TRUE)

En appliquant toujours le même modèle de complexité, on obtient (FR-[117]) : Comp. binary op. arith. Op. CheckRUR-BS/GS

(MulTk-B) ^{O(n D7/2(s + D)) O(n D5/2)}

Dans le cas de l’utilisation des fonctions CheckRUR-BS/GS et RURCandidate-BS/GS avec la stratégie MulTk-B, nous n’avons donc pas réussi à rendre la vérification moins coûteuse que le calcul du candidat-RUR, celle-ci devient même l’opération dominante, ce qui relativise l’apport réel théorique des techniques de type « pas de bébé/pas de géant » et confirme encore une fois que certifier un élément séparant l’opération principale d’un algorithme non probabi-liste.

Au final, on peut proposer un algorithme complet déterministe pour le calcul de RUR dont la complexité théorique est m fois la complexité la complexité théorique du calcul d’un candidat-RUR et de la vérification de l’élément (supposé) séparant qui lui est associé, m étant le nombre d’essais nécessaires pour « tirer » un élément séparant. En pratique, 1 essai suffira, presque toutes les formes linéaires étant séparantes.

On termine cette section en remarquant que la conjonction de RUR-Candidate-BS/GS et de CheckRUR-BS/GS tous deux appliqués avec MulTk-B donne un algorithme déterministe pour le calcul d’un candidat-RUR accompagné d’un test de validation pour l’élément séparant (l’algorithme calcule donc une RUR ou renvoie une erreur si la forme linéaire n’est pas sépa-rante) avec une complexité équivalente à l’algorithme proposé dans [19] qui lui est probabiliste, ne vérifie pas l’élément séparant et perd éventuellement l’information sur les multiplicités.