Test de primalité AKS - AKS primality test

Le test de primalité AKS (également connu sous le nom de test de primalité Agrawal-Kayal-Saxena et test AKS cyclotomique ) est un algorithme déterministe de preuve de primalité créé et publié par Manindra Agrawal , Neeraj Kayal et Nitin Saxena , informaticiens à l' Indian Institute of Technology Kanpur , le 6 août 2002, dans un article intitulé « PRIMES is in P ». L'algorithme a été le premier à pouvoir déterminer de manière prouvée si un nombre donné est premier ou composé en temps polynomial , sans s'appuyer sur des conjectures mathématiques telles que l' hypothèse généralisée de Riemann . La preuve est aussi remarquable pour ne pas s'appuyer sur le domaine de l' analyse . En 2006, les auteurs ont reçu à la fois le prix Gödel et le prix Fulkerson pour leur travail.

Importance

AKS est le premier algorithme de preuve de primalité à être à la fois général , polynomial , déterministe et inconditionnel . Les algorithmes précédents avaient été développés pendant des siècles et atteignaient au plus trois de ces propriétés, mais pas les quatre.

  • L'algorithme AKS peut être utilisé pour vérifier la primalité de tout nombre général donné. De nombreux tests de primalité rapides sont connus et ne fonctionnent que pour les nombres avec certaines propriétés. Par exemple, le test de Lucas-Lehmer ne fonctionne que pour les nombres de Mersenne , tandis que le test de Pépin ne peut être appliqué qu'aux nombres de Fermat .
  • Le temps d'exécution maximal de l'algorithme peut être exprimé sous la forme d'un polynôme sur le nombre de chiffres du nombre cible. ECPP et APR prouvent ou réfutent de manière concluante qu'un nombre donné est premier, mais ne sont pas connus pour avoir des limites de temps polynomiales pour toutes les entrées.
  • L'algorithme est assuré de distinguer de manière déterministe si le nombre cible est premier ou composé. Les tests randomisés, tels que Miller-Rabin et Baillie-PSW , peuvent tester n'importe quel nombre donné pour la primalité en temps polynomial, mais sont connus pour ne produire qu'un résultat probabiliste.
  • L'exactitude de l'AKS ne dépend d'aucune hypothèse subsidiaire non prouvée . En revanche, la version de Miller du test Miller-Rabin est entièrement déterministe et s'exécute en temps polynomial sur toutes les entrées, mais son exactitude dépend de la vérité de l' hypothèse de Riemann généralisée encore non prouvée .

Bien que l'algorithme ait une immense importance théorique, il n'est pas utilisé dans la pratique, ce qui en fait un algorithme galactique . Pour les entrées 64 bits, le test de primalité Baillie-PSW est déterministe et exécute plusieurs ordres de grandeur plus rapidement. Pour les entrées plus importantes, les performances des tests ECPP et APR (également inconditionnellement corrects) sont de loin supérieures à celles de l'AKS. De plus, ECPP peut produire un certificat de primalité qui permet une vérification indépendante et rapide des résultats, ce qui n'est pas possible avec l'algorithme AKS.

notions

Le test de primalité AKS est basé sur le théorème suivant: Etant donné un entier et entier coprime à , est premier si et seulement si le polynôme relation de congruence

 

 

 

 

( 1 )

tient dans l'anneau polynomial . Notez que désigne l' indéterminé qui génère cet anneau polynomial.

Ce théorème est une généralisation aux polynômes du petit théorème de Fermat . Dans un sens, cela peut être facilement prouvé en utilisant le théorème du binôme avec la propriété suivante du coefficient du binôme :

pour tout si est premier.

Si la relation ( 1 ) constitue en elle-même un test de primalité, sa vérification prend un temps exponentiel : l' approche de la force brute nécessiterait l'expansion du polynôme et une réduction des coefficients résultants .

La congruence est une égalité dans l' anneau polynomial . L'évaluation dans un anneau quotient de crée une limite supérieure pour le degré des polynômes impliqués. L'AKS évalue l'égalité dans , rendant la complexité de calcul dépendante de la taille de . Pour plus de clarté, cela est exprimé comme la congruence

 

 

 

 

( 2 )

qui est le même que :

 

 

 

 

( 3 )

pour certains polynômes et .

Notez que tous les nombres premiers satisfont cette relation (choisir dans ( 3 ) donne ( 1 ), ce qui est vrai pour premier). Cette congruence peut être vérifiée en temps polynomial lorsque est polynomial aux chiffres de . L'algorithme AKS évalue cette congruence pour un grand ensemble de valeurs, dont la taille est polynomiale aux chiffres de . La preuve de validité de l'algorithme AKS montre que l'on peut trouver un et un ensemble de valeurs avec les propriétés ci-dessus telles que si les congruences sont vérifiées, alors est une puissance d'un nombre premier.

Historique et durée de fonctionnement

Dans la première version de l'article cité ci-dessus, les auteurs ont prouvé que la complexité temporelle asymptotique de l'algorithme était (en utilisant Õ de la notation O big )—la douzième puissance du nombre de chiffres en n fois un facteur qui est polylogarithmique dans le nombre de chiffres. Cependant, cette limite supérieure était plutôt lâche; une conjecture largement répandue sur la distribution des nombres premiers de Sophie Germain , si elle était vraie, réduirait immédiatement le pire des cas à .

Dans les mois qui ont suivi la découverte, de nouvelles variantes sont apparues (Lenstra 2002, Pomerance 2002, Berrizbeitia 2002, Cheng 2003, Bernstein 2003a/b, Lenstra et Pomerance 2003), qui ont grandement amélioré la vitesse de calcul. En raison de l'existence de nombreuses variantes, Crandall et Papadopoulos se réfèrent à la « classe AKS » des algorithmes dans leur article scientifique « Sur la mise en œuvre des tests de primalité de la classe AKS », publié en mars 2003.

En réponse à certaines de ces variantes, et à d'autres retours, l'article « PRIMES is in P » a été mis à jour avec une nouvelle formulation de l'algorithme AKS et de sa preuve d'exactitude. (Cette version a finalement été publiée dans Annals of Mathematics .) Alors que l'idée de base est restée la même, r a été choisi d'une nouvelle manière et la preuve de l'exactitude a été organisée de manière plus cohérente. La nouvelle preuve reposait presque exclusivement sur le comportement des polynômes cyclotomiques sur des corps finis . La nouvelle limite supérieure de la complexité temporelle a ensuite été réduite à l'aide de résultats supplémentaires de la théorie des tamis à .

En 2005, Pomerance et Lenstra ont fait la démonstration d'une variante d'AKS qui fonctionne en opération, menant à une autre version mise à jour de l'article. Agrawal, Kayal et Saxena ont proposé une variante qui se produirait si la conjecture d'Agrawal était vraie ; cependant, un argument heuristique de Pomerance et Lenstra a suggéré qu'il est probablement faux.

L'algorithme

L'algorithme est le suivant :

Entrée : entier n  > 1 .
  1. Vérifier si n est une puissance parfaite : si n  =  a b pour les entiers a  > 1 et b  > 1 , sortie composite .
  2. Trouvez le plus petit r tel que ord r ( n ) > (log 2 n ) 2 . (si r et n ne sont pas premiers entre eux, alors sautez ce r )
  3. Pour tout 2 ≤ a ≤ min ( r , n −1), vérifier que a ne divise pas n : Si a | n pour certains 2 ≤ a ≤ min ( r , n −1), sortie composite .
  4. Si nr , sortie prime .
  5. Pour a  = 1 à faire
    si ( X + a ) nX n + a (mod X r - 1, n ), la sortie composite ;
  6. Premier de sortie .

Ici, ord r ( n ) est l' ordre multiplicatif de n modulo r , log 2 est le logarithme binaire , et est la fonction totale d'Euler de r .

L'étape 3 est montrée dans l'article en vérifiant 1 < ( a , n ) < n pour tout ar . On peut voir que cela équivaut à une division d'essai jusqu'à r , ce qui peut être fait très efficacement sans utiliser pgcd . De même, la comparaison de l'étape 4 peut être remplacée en faisant en sorte que la division d'essai renvoie prime une fois qu'elle a vérifié toutes les valeurs jusqu'à et y compris

Une fois au-delà des très petites entrées, l'étape 5 domine le temps pris. La réduction essentielle de la complexité (d'exponentielle à polynomiale) est obtenue en effectuant tous les calculs dans l'anneau fini

constitué d' éléments. Cet anneau ne contient que les monômes , et les coefficients sont dans lesquels a des éléments tous codables dans les bits.

La plupart des améliorations ultérieures apportées à l'algorithme se sont concentrées sur la réduction de la taille de r, ce qui accélère l'opération de base à l'étape 5, et sur la réduction de la taille de s , le nombre de boucles effectuées à l'étape 5. Généralement, ces changements ne modifient pas le calcul. complexité, mais peut conduire à de nombreux ordres de grandeur en moins de temps, par exemple la version finale de Bernstein a une accélération théorique d'un facteur de plus de 2 millions.

Aperçu de la preuve de validité

Pour que l'algorithme soit correct, toutes les étapes qui identifient n doivent être correctes. Les étapes 1, 3 et 4 sont trivialement correctes, puisqu'elles sont basées sur des tests directs de la divisibilité de n . L'étape 5 est également correcte : puisque (2) est vrai pour tout choix d' un premier avec n et r si n est premier, une inégalité signifie que n doit être composé.

Le cas difficile de l'algorithme est l'énoncé itéré à l'étape 5. Si cela dans l'anneau fini R se trouve entraîner l'incongruence

cela équivaut à

,

de sorte qu'après avoir réduit aux r monômes au moyen de doit seulement être vérifié.

Exemple 1 : n = 31 est premier

Entrée : entier n  = 31 > 1.
  1.   If n = ab for integers a > 1 and b > 1, output composite.
        For [ b=2, b <= log2(n), b++,
          a=n1/b;
          If [ a is integer, Return[Composite]]
        ];
        a=n1/2...n1/4={5.568, 3.141, 2.360}
    
  2.   Find the smallest r such that Or(n) > (log2 n)2.
        maxk=⌊(log2 n)2⌋;
        maxr=Max[3, ⌈(Log2 n)5⌉]; (*maxr really isn't needed*)
        nextR=True;
        For [r=2, nextR && r < maxr, r++,
          nextR=False;
          For [k=1,(!nextR) &&k ≤ maxk, k++,
            nextR=(Mod[nk, r]==1 || Mod[nk, r]==0)
          ]
        ];
        r--; (*the loop over increments by one*)
         
        r = 29
    
  3.   If 1 < gcd(a,n) < n for some ar, output composite.
        For [a=r, a > 1, a--,
          If [(gcd=GCD[a,n]) > 1 && gcd < n, Return[Composite]]
        ];
         
        gcd={GCD(29,31)=1, GCD(28,31)=1, ..., GCD(2,31)=1} ≯ 1
    
  4.   If nr, output prime.
        If [n ≤ r, Return[Prime]]; (* this step may be omitted if n > 5690034 *)
         
        31 > 29
    
  5.   For a = 1 to  do
        if (X+a)nXn+a (mod Xr − 1,n), output composite;
         
        φ[x_]:=EulerPhi[x];
        PolyModulo[f_]:=PolynomialMod[ PolynomialRemainder[f,xr-1,x],n];
        max=Floor[Log[2,n]φ[r]];
        For[a=1, a ≤ max, a++,
          If[PolyModulo[(x+a)n-PolynomialRemainder[xn+a, xr-1], x]≠0,
            Return[Composite]
          ]
        ];
         
        (x+a)31 =
          a31 +31a30x +465a29x2 +4495a28x3 +31465a27x4 +169911a26x5 +736281a25x6 +2629575a24x7 +7888725a23x8 +20160075a22x9 +44352165a21x10 +84672315a20x11 +141120525a19x12 +206253075a18x13 +265182525a17x14 +300540195a16x15 +300540195a15x16 +265182525a14x17 +206253075a13x18 +141120525a12x19 +84672315a11x20 +44352165a10x21 +20160075a9x22 +7888725a8x23 +2629575a7x24 +736281a6x25 +169911a5x26 +31465a4x27 +4495a3x28 +465a2x29 +31ax30 +x31
         
        PolynomialRemainder [(x+a)31, x29-1] =
          465a2 +a31 +(31a+31a30)x +(1+465a29)x2 +4495a28x3 +31465a27x4 +169911a26x5 +736281a25x6 +2629575a24x7 +7888725a23x8 +20160075a22x9 +44352165a21x10 +84672315a20x11 +141120525a19x12 +206253075a18x13 +265182525a17x14 +300540195a16x15 +300540195a15x16 +265182525a14x17 +206253075a13x18 +141120525a12x19 +84672315a11x20 +44352165a10x21 +20160075a9x22 +7888725a8x23 +2629575a7x24 +736281a6x25 +169911a5x26 +31465a4x27 +4495a3x28
         
        (A) PolynomialMod [PolynomialRemainder [(x+a)31, x29-1], 31] = a31+x2
         
        (B) PolynomialRemainder [x31+a, x29-1] = a+x2
         
        (A) - (B) = a31+x2 - (a+x2) = a31-a
         
        max =  = 26
         
        {131-1=0 (mod 31), 231-2=0 (mod 31), 331-3=0 (mod 31), ..., 2631-26=0 (mod 31)}
    
  6.   Output prime.
        31 Must be Prime
    

Où PolynomialMod est une réduction modulo par terme du polynôme. ex. PolynomialMod[x+2x 2 +3x 3 , 3] = x+2x 2 +0x 3

Les références

Lectures complémentaires

Liens externes