Université de Versailles Saint-Quentin-En-Yvelines Projet de Master 1 Informatique Tests de primalité Auteurs : MARIN Sophie BOURDONNAY Jean-Ronan Encadrant : ROJAT Antoine Résumé du document Les nombres premiers ont un rôle important en mathématiques et ont des propriétés très utiles dans diverses applications particulièrement dans le domaine de la cryptographie. Nous allons évoquer différents tests en proposant une démonstration mathématique afin de justifier leur validité, et une implémentation pour pouvoir comparer leurs temps d’exécution. mai 2011 Sommaire 1 Introduction 1 2 Organisation 2.1 Les outils . . . . . . . . . . . . . . . . . . . . . . . . . 2.2 Organisation du projet . . . . . . . . . . . . . . . . . . 2.2.1 La modélisation et implémentation . . . . . . . 2.2.2 Génération des courbes à l’aide de GNUPlot . 2.2.3 Remarques sur les tests et les tracés de courbes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3 3 3 3 6 7 3 Algorithme de Wilson 3.1 Présentation de Wilson . . . . . . 3.2 Démonstration . . . . . . . . . . 3.3 Algorithme . . . . . . . . . . . . 3.4 Pour conclure sur cet algorithme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9 9 9 10 11 4 Algorithme de Cribles 4.1 Crible d’Ératosthène . . . . . . . . . . . . . . . . . 4.1.1 Présentation d’Eratosthène . . . . . . . . . 4.1.2 Démonstration du théorème fondamental de 4.1.3 Algorithmes . . . . . . . . . . . . . . . . . . 4.1.4 Pour conclure sur cet algorithme . . . . . . 4.2 Crible de Sundaram . . . . . . . . . . . . . . . . . 4.2.1 Démonstration . . . . . . . . . . . . . . . . 4.2.2 Algorithmes . . . . . . . . . . . . . . . . . . 4.2.3 Pour conclure sur cet algorithme . . . . . . . . . . . . . . . . . . . . . . . . l’arithmétique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13 13 13 13 13 14 16 16 17 18 5 Algorithme de Fermat 5.1 Présentation de Fermat . . . . . 5.2 Démonstrations . . . . . . . . . . 5.3 Algorithme . . . . . . . . . . . . 5.4 Pour conclure sur cet algorithme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20 20 20 21 21 6 Rabin Miller 6.1 Présentation de Miller et Rabin . 6.2 Démonstration . . . . . . . . . . 6.3 Algorithme . . . . . . . . . . . . 6.4 Pour conclure sur cet algorithme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23 23 23 25 25 7 AKS 7.1 Présentation . . . . . . . . . . . . . . . . . . . . . . . . 7.2 Résultats préliminaires et définitions . . . . . . . . . . 7.2.1 Définitions . . . . . . . . . . . . . . . . . . . . 7.2.2 Théorèmes admis . . . . . . . . . . . . . . . . . 7.2.3 Théorème démontrés . . . . . . . . . . . . . . . 7.3 Démonstration de la validité de l’algorithme . . . . . . 7.3.1 Encadrement de r . . . . . . . . . . . . . . . . 7.3.2 Application de l’introspection . . . . . . . . . . 7.3.3 Encadrement de H . . . . . . . . . . . . . . . . 7.3.4 Théorème fondamental d’AKS . . . . . . . . . 7.4 Algorithmes . . . . . . . . . . . . . . . . . . . . . . . . 7.4.1 Détection des puissances d’un nombre premier 7.4.2 Construction de r . . . . . . . . . . . . . . . . 7.4.3 Algorithme AKS . . . . . . . . . . . . . . . . . 7.5 Pour conclure sur cet algorithme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28 28 28 28 28 29 29 29 30 30 31 32 32 33 33 34 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8 Répartition des nombres premiers 9 Conclusion 9.1 Comparaison des tests 9.1.1 Cribles . . . . . 9.1.2 Probabilistes . 9.1.3 Déterministes . 9.2 Programmation JAVA 9.3 Partie Théorique . . . 9.4 Perspectives . . . . . . 35 . . . . . . . 37 37 37 37 37 38 38 38 10 Annexes 10.1 Complexité . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10.2 Démonstrations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39 39 39 Liste des théorèmes, définitions et preuves 47 Liste des images 48 Liste des tableaux 49 Liste des algorithmes 50 Liste des programmes 51 Références bibliographiques 52 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Tests de primalité 1 1 INTRODUCTION Introduction Un nombre premier est un entier qui admet deux diviseurs entiers, distincts, positifs Les nombres premiers ont un rôle important en mathématiques et ont des propriétés très utiles dans diverses applications particulièrement dans le domaine de la cryptographie. Il est utile de connaître le cardinal de l’ensemble des nombres premiers d’une certaine taille afin de d’avoir un grand choix de nombres pour éviter les attaques par recherche exhaustive. On démontrera, dans la dernière partie de ce rapport, l’encadrement x x suivant : ln(2) ln(x) ≤ π(x) ≤ e ln(x) avec π(x) qui représente le cardinal de l’ensemble des nombre premier allant de 2 à x. 60 x 7−→ e · x ln(x) 50 40 30 x 7−→ π(x) 20 x 7−→ ln(2) · 10 ~j O ~i 10 20 30 40 Figure 1: Représentation graphique ln(2) · 50 n ln(n) 60 ≤ π(n) ≤ e · 70 n ln(n) 80 90 x ln(x) 100 sur l’intervalle ]1, 100] Par exemple, l’agorithme RSA, qui est à clé publique, a besoin de deux nombre premiers p et q d’une taille assez grande. La clé publique contient le produit p × q, il faut en aucun cas qu’on puisse trouver ces nombres en factorisant n. C’est pour cela plus p et q sont grands, plus il y a des candidats possibles pour une factorisation de n. On remarque que π(n) n tend vers 0 en +∞, ce qui nous fait dire que plus n est grand, la densité est de plus en plus faible. MARIN Sophie BOURDONNAY Jean-Ronan page 1 sur 52 Tests de primalité 1 INTRODUCTION Très tôt, le problème de savoir si ,un nombre est premier ou non, captive l’attention des chercheurs. Les tests de primalité ont évolués grâce à ces travaux, ils sont devenus de plus en plus performants, de plus en plus rapides. Algorithme Année Principe Crible d’Eratosthène -240 Fermat 1640 a ∧ p, p ∈ P =⇒ ap−1 = 1 [p] Wilson 1773 p ∈ P ⇐⇒ (p − 1) ≡ −1 [n] Crible de Sundaram 1934 Chercher des nombres impairs composés Rabin et Miller 1976 Amélioration du théorème de Fermat AKS 2002 Polynômes cyclotomiques sur les corps finis Division par tous les entiers ≤ √ n Tableau 1: Algorithmes présentés Au début, les gens ont cherché si n était composé c’est à dire que n admet plus deux diviseurs afin de prouver qu’il n’était pas premier. Ceci nous amène à faire une différenciation de tests, les tests probabilistes et les tests déterministes. Les tests probabilistes émettent un résultat qui n’est fiable qu’avec une certaine probabilité. Cela peut parfois suffir, mais pas toujours. Cependant ils sont plus rapides que les tests dit déterministes qui sont parfaitement sûres du résultat qu’ils avancent, mais sont plus lents, et donc peuvent être jugés moins performants. Nous allons évoquer différents tests en proposant une démonstration mathématique afin de justifier leur validité, et une implémentation pour pouvoir comparer leurs temps d’exécution. MARIN Sophie BOURDONNAY Jean-Ronan page 2 sur 52 Tests de primalité 2 2 ORGANISATION Organisation 2.1 Les outils Eclipse C’est un logiciel de développement libre, extensible et polyvalent permettant de créer des projets en plusieurs langages de programmation. Il est particulièrement adapté pour le langage Java dans lequel nous allons implémenter nos tests de primalité ou de composition. Gnuplot Gnuplot est un logiciel libre permettant de tracer des courbes à partir d’une équation ou de relevés de mesures. Son avantage est qu’on peut exporter nos graphiques dans le format que nous choisissons. Le plus courant est d’exporter les courbes en pdf, nous avons besoin d’un format LATEX pour une question pratique. Subversion (SVN) Subversion est un système de gestion de versions, distribué sous licence Apache et BSD. Il peut être intégré à Eclipse par exemple. Nous avons preféré un mode console pour communiquer avec le serveur pour des raisons de simplicité. C’est un outil indispensable pour le bon fonctionnement d’un projet à faire seul ou à plusieurs. De plus, la sauvegarde du projet, c’est à dire du code source, du rapport, des courbes et de la présentation, est très appréciable. Cela permet aussi de pallier aux différents problèmes techniques (par exemple la perte de données) de nos machines de travail, et de mettre à jour en temps réel notre avancement où que l’on soit de façon plus simple que par mail. Google Code Google Code est le service de Repositoring pour les projets Open-Source totalement gratuit qui permet entre autre de disposer d’un serveur SVN gratuitement. Dia Dia est un logiciel libre qui permet de réaliser des diagrammes UML et autres schémas comme les réseaux, les circuits électriques, les organigrammes informatiques. Son interface est simple et efficace. Elle permet aussi d’exporter les schémas en plusieurs formats dont .pdf, .tex et .eps. 2.2 2.2.1 Organisation du projet La modélisation et implémentation Nous avons séparé nos sources en quatres packages. Nous avons essayé de séparer notre code en différentes parties les moins volumineuses possible et cohérentes, pour simplifier la perception du code. Outils Polynomes Algorithmes Timer Algo Wilson Fermat Miller_Rabin Aks Main Miller_Rabin_Threaded CreationCourbes VariablesTest Main Cribles Sundaram Eratosthene Figure 2: UML : Tous les packages MARIN Sophie BOURDONNAY Jean-Ronan page 3 sur 52 Tests de primalité 2 ORGANISATION Dans le dossier Outils se trouvent trois classes. La première est la classe Polynomes où se trouvent toutes les opérations dont on a besoin pour implémenter le test de AKS. La seconde contient tout le nécessaire pour appliquer la méthode de Newton utilisé dans le test de AKS également. La dernière est la classe Timer qui nous est indispensable pour mesurer le temps d’exécution de tous nos tests. Polynomes MethodeNewton -x: LinkedHashMap<BigInteger, BigInteger> -degre: BigInteger +Polynomes() +Polynomes(Polynomes) +Polynomes(BigInteger,LinkedHashMap<BigInteger, BigInteger>) +Polynomes(BigInteger,BigInteger) +get_degre(): BigInteger +get_map(): LinkedHashMap<BigInteger, BigInteger> +Afficher(): void +monome(BigInteger,BigInteger): void +calcul_degre(): void +egale(Polynimes): boolean +addition(Polynomes): Polynomes +soustraction(Polynomes): Polynomes +soustraction(BigInteger): Polynomes +multiplication(Polynomes): Polynomes +multiplication(BigInteger): Polynomes +modulo(Polynomes): Polynomes +modulo(BigInteger): Polynomes +expomod(BigInteger,Polynomes): Polynomes Timer -start: Calendar -stop: Calendar +running: boolean +Timer() +Timer_Start(): void +Timer_Stop(): void +get_Time(): long +print_Time(): void +a: BigInteger +b: BigInteger +n: BigInteger +bda: BigDecimal +bdb: BigDecimal +bdn: BigDecimal +bdeminvb: BigDecimal +eps: BigDecimal +MethodeNewton(BigInteger,BigInteger,BigInteger) +MethodeNewton(String,String,String,String) +f_bint(BigInteger): BigInteger +f_bdec(BigDecimal): BigDecimal +df_bint(BigInteger): BigInteger +df_bdec(BigDecimal): BigDecimal +suivant(BigDecimal,MathContext): BigDecimal +setEps(String): void +setb(BigInteger): void +chercheZero(): BigDecimal +estPuissancePremier(): boolean Figure 3: UML : package Outils Dans le package Main se trouve la classe main bien sûr mais aussi laclasse qui permet la création de nos fichiers résultats (CreationCourbes) et une autre (VariablesTests) qui regroupe toutes les variables dont on a besoin lors d’un test. Les fonctions de la classe CreationCourbes contiennent le même algorithme de test. Nous avons fait le choix de faire le même algorithme autant de fois que nous avions de tests, pour des raisons de facilités. CreationCourbes -algortithme_en_cours: Algo -crible_en_cours: Crible -test_en_cours: VariablesTest +CreationCourbes() +test_wilson(int,int,int) +test_rabin_miller(int,int,int) +test_rabin_miller_threaded(int,int,int) +test_fermat(int,int,int) +test_eratosthene(int,int,int) +test_sundaram(int,int,int) Main +main(String[] ): static void VariablesTest #nombre_bit: int #resultat: boolean #compteur: int #moyenne: double #aleatoire: SecureRandom #time_test: Timer #fdata: BufferedWriter #pratique_div_theorique: double +VariablesTest() +reinitialisation_VariablesTest(): void +new_p_probablePrime(): BigInteger +new_p(): BigInteger +nombre_bit_add(): void +get_nombre_bit(): int +set_nombre_bit(int): void +get_resultat(): boolean +set_resultat(boolean): void +compteur_init(): void +compteur_add(): void +get_compteur(): int +set_compteur(int): void +moyenne_init(): void +moyenne_add(long) +get_moyenne(): double +get_aleatoire(): SecureRandom +moyenn_div(int): void +get_moyenne(): double +get_aleatoire(): SecureRandom +get_time_test(): Timer +get_fdata(): BufferedWriter +set_fdata(String): void +get_pratique_div_theorique(): double +set_pratique_div_theorique(double): void Figure 4: UML : package Main MARIN Sophie BOURDONNAY Jean-Ronan page 4 sur 52 Tests de primalité 2 ORGANISATION Dans les packages Algorithmes et Cribles, détaillés par les images ci-dessous, sont regroupées les classes contenant les algorithmes de nos tests. Les Cribles étant une façon différente de tester si un nombre est premier, et pour des raisons de programmation (utilisation de grand tableau) nous l’avons séparé du reste. Algo #p: BigInteger #complexite_theorique: double #nom_fichier_resultat;: String Wilson Fermat +creation_fichier(VariablesTest): void +ecriture_fichier(VariablesTest): void +fermeture_fichier(VariablesTest): void +get_p(): BigInteger +set_p(BigInteger): void +get_complexite_theorique(): double +set_complexite_theorique(double): void +get_nom_fichier_resultat(): String +set_nom_fichier_resultat(String): void +Wilson(p:BigInteger) +facto_mod(BigInteger,BigInteger): BigInteger +estPremier_recursif(): boolean +estPremier(): boolean +atester(VariablesTest,int,int ): void +Fermat(BigInteger) +estPremier(): boolean +atester(VariablesTest,int,int): void Aks +n: BigInteger +r: BigInteger +a: BigInteger Miller_Rabin +d: BigInteger +s: BigInteger +Aks() +test1_composite(): void +construction_r(): void +atester(t:VariablesTest,nombre_bit_max:int, nombre_iteration:int): void +test3_composite(): boolean +test4_prime(): boolean +test5_composite(): boolean +estPremier(): boolean Miller_Rabin_Threaded +Miller_Rabin() +initialisation(VariablesTest) +trouve_d_et_s(): void +test1(BigInteger): boolean +test2(BigInteger) +estPremier(VariablesTest): boolean +void atester()(VariablesTest,int,int) +d: BigInteger +s: BigInteger +Miller_Rabin() +initialisation(VariablesTest) +trouve_d_et_s(): void +estPremier(VariablesTest): boolean +void atester()(VariablesTest,int,int) Figure 5: UML : package Algorithmes Cribles #p: BigInteger #complexite_theorique: double #nom_fichier_resultat;: String #tableau_eras: BigInteger[] #tableau_sun: BigInteger[][] #taille: int +creation_fichier(VariablesTest): void +ecriture_fichier(VariablesTest): void +fermeture_fichier(VariablesTest): void +get_p(): BigInteger +set_p(BigInteger): void +get_complexite(): double +set_complexite(double): void +get_nom_fichier_resultat(): String +set_nom_fichier_resultat(String): void +get_taille(): int +set_taille(int): void Sundaram +Sundaram() +Sundaram(BigInteger) +initialisation(VariablesTest): void +reinitialisation(BigInteger): void +estPremier(): void +atester(Variables,int,int): void Eratosthene +Eratosthene() +Eratosthene(BigInteger) +initialisation(VariablesTest): void +reinitialisation(BigInteger): void +set_tableau(): void +estPremier(): void +atester(Variables,int,int): void Figure 6: UML : package Cribles MARIN Sophie BOURDONNAY Jean-Ronan page 5 sur 52 Tests de primalité 2.2.2 2 ORGANISATION Génération des courbes à l’aide de GNUPlot Pour générer les courbes correspondants à nos fichiers résultats, nous avons écrit quatre codes GNUPlot différents. Le premier nous a servi pour choisir la courbe que nous allions présenter dans notre rapport en nous créant un fichier pdf contenant toutes les courbes pratiques ainsi que la courbe théorique de notre simulation. Les trois autres sont utiles quand nous avons choisi la courbes à présenter. Ils nous permettent de générer nos courbes en format LATEX . Nous vous présentons comme exemple le code GNUPlot dont nous nous sommes servi pour l’algorithme de Rabin et Miller en version non parallèle. Programme 1: makefile all : tex rm tex : pratique theorique p_th rm : r e s u l t a t 1 . data r e s u l t a t 2 . data r e s u l t a t 3 . data r e s u l t a t 4 . data r e s u l t a t 5 . data resultat6 . data resultat7 . data resultat8 . data resultat9 . data resultat10 . data gnuplot rabin_miller . gplt p s 2 p d f graph . ps xpdf graph . pdf pratique : resultat9 . data gnuplot rabin_miller_p . gplt theorique : resultat9 . data gnuplot rabin_miller_t . gplt p_th : resultat9 . data gnuplot rabin_miller_tp . gplt Programme 2: rabin_miller.gplt s e t t i t l e " A l g o r i t h m e␣ de ␣ Rabin ␣ e t ␣ M i l l e r ␣ : ␣ Te st " s e t x l a b e l "Nombre␣ de ␣ b i t s " set term post portrait solid color s e t o u t p u t " g r a p h . ps " s e t y l a b e l "Temps␣ d ’ e x e c u t i o n ␣ en ␣ms" p l o t ’ r e s u l t a t 1 . d a t a ’ u s i n g 1 : 3 t i t l e " Te st ␣ : ␣ t h e o r i q u e " w l p 1 s e t y l a b e l "Temps␣ d ’ e x e c u t i o n ␣ en ␣ms" p l o t ’ r e s u l t a t 1 . d a t a ’ u s i n g 1 : 2 t i t l e " Te st ␣ 1 ␣ : ␣ p r a t i q u e " w l p 1 s e t y l a b e l "Temps␣ d ’ e x e c u t i o n ␣ en ␣ms" p l o t ’ r e s u l t a t 1 . d a t a ’ u s i n g 1 : 4 t i t l e " Te st ␣ 1 ␣ : ␣ p r a t i q u e ␣ / ␣ t h e o r i q u e " w l p 1 s e t y l a b e l "Temps␣ d ’ e x e c u t i o n ␣ en ␣ms" p l o t ’ r e s u l t a t 2 . d a t a ’ u s i n g 1 : 2 t i t l e " Te st ␣ 2 ␣ : ␣ p r a t i q u e " w l p 1 s e t y l a b e l "Temps␣ d ’ e x e c u t i o n ␣ en ␣ms" p l o t ’ r e s u l t a t 2 . d a t a ’ u s i n g 1 : 4 t i t l e " Te st ␣ 2 ␣ : ␣ p r a t i q u e ␣ / ␣ t h e o r i q u e " w l p 1 s e t y l a b e l "Temps␣ d ’ e x e c u t i o n ␣ en ␣ms" p l o t ’ r e s u l t a t 3 . d a t a ’ u s i n g 1 : 2 t i t l e " Te st ␣ 3 ␣ : ␣ p r a t i q u e " w l p 1 s e t y l a b e l "Temps␣ d ’ e x e c u t i o n ␣ en ␣ms" p l o t ’ r e s u l t a t 3 . d a t a ’ u s i n g 1 : 4 t i t l e " Te st ␣ 3 ␣ : ␣ p r a t i q u e ␣ / ␣ t h e o r i q u e " w l p 1 ... Programme 3: rabin_miller_p.gplt s e t t e r m i n a l l a t e x s i z e 7 cm , 10 c m s e t x l a b e l ’ T a i l l e ␣ \\ ␣ en ␣ b i t s ’ s e t y l a b e l ’ Temps␣ \\ ␣ en ␣ s ’ set xrange [ 1 0 0 : 9 0 0 ] set yrange [ 0 : 5 5 ] s e t x t i c s 100 set ytics 5 s e t t i t l e " V e r s i o n ␣ s i m p l e ␣ Co m p l e x i t e ␣ P r a t i q u e " s e t o u t p u t " graphe_rms_pratique . t e x " plot ’ r e s u l t a t 9 . data ’ using 1 : 2 with l i n e s p o i n t s 1 4 MARIN Sophie BOURDONNAY Jean-Ronan page 6 sur 52 Tests de primalité 2 ORGANISATION Programme 4: rabin_miller_t.gplt s e t t e r m i n a l l a t e x s i z e 7 cm , 10 c m s e t x l a b e l ’ T a i l l e ␣ \\ ␣ en ␣ b i t s ’ s e t y l a b e l ’ Temps␣ \\ ␣ en ␣ s ’ set xrange [ 1 0 0 : 9 0 0 ] set yrange [ 0 : 7 0 0 ] s e t x t i c s 100 s e t y t i c s 100 s e t t i t l e " Co m p l e x i t e ␣ Th e o r i q u e " s e t o u t p u t " graphe_rm_theorique . t e x " plot ’ r e s u l t a t 9 . data ’ using 1 : 3 with l i n e s p o i n t s 1 4 Programme 5: rabin_miller_tp.gplt s e t t e r m i n a l l a t e x s i z e 7 cm , 10 c m s e t x l a b e l ’ T a i l l e ␣ \\ ␣ en ␣ b i t s ’ s e t y l a b e l ’ Temps␣ \\ ␣ en ␣ s ’ set xrange [ 1 0 0 : 9 0 0 ] set yrange [ 0 : 5 5 ] s e t x t i c s 100 set ytics 5 s e t t i t l e " V e r s i o n ␣ s i m p l e ␣ Co m p l e x i t e ␣ P r a t i q u e " s e t o u t p u t " graphe_rms_pratique . t e x " plot ’ r e s u l t a t 9 . data ’ using 1 : 2 with l i n e s p o i n t s 1 4 2.2.3 Remarques sur les tests et les tracés de courbes Nous avons effectué nos tests sur une machine multitâche avec un processeur à deux coeurs de 1.83 GHz. Pour chaque simulation lancée, on entre en paramètre le nombre de fichiers résultats que l’on aimerait générer, la taille maximale en bits des entiers testés et le nombre d’itérations qu’on souhaite faire pour une taille donnée. Ceci nous permet de moduler rapidement la taille des entiers et de ne pas à avoir à lancer manuellement un certain nombre de simulation afin de choisir nos courbes. Pour illustrer nos propos, les algorithmes correspondants sont décrit ci-dessous. Algorithme 1 Fonction de test multiples Creation des variables de test i←1 tant que i ≤ nombre_test faire Initialisation du test en cours Donner le numero du test comme nom au fichier générer Exécution de la fonction "atester(test_en_cours, nombre_bits_max, nombre_iteration)" Réinitialisation des variables de test fin tant que MARIN Sophie BOURDONNAY Jean-Ronan page 7 sur 52 Tests de primalité 2 ORGANISATION La fonction test : Algorithme 2 Fonction atester() moyenne_pratique ← 0 moyenne_theorique ← 0 compteur ← 0 Créer le fichier tant que nombre_bits ≤ nombre_bits_max faire tant que compteur ≤ nombre_iteration faire Générer un nouveau de p de taille nombre_bits Démarrer le timer Exécution de la fonction est_premier() Arrêt du timer compteur ← compteur + 1 moyenne_pratique ← moyenne_pratique + temps_mesuré moyenne_theorique ← moyenne_theorique + A(nombre_bits) fin tant que moyenne_pratique ← moyenne_pratique/nombre_iteration moyenne_theorique ← moyenne_theorique/nombre_iteration pratique_sur_theorique ← moyenne_pratique/moyenne_theorique Ecrire dans le fichier moyenne_pratique ← 0 moyenne_theorique ← 0 nombre_bit ← nombre_bit compteur ← 0 fin tant que Fermer le fichier Il y a plusieurs raisons pour lesquelles les résultats de nos simulations sont à nuancer. La première est que nous sommes sur une machine multitâche. Lorsque nous exécutons une simulation, le système d’exploitation et plusieurs programmes peuvent se trouver en tâches de fond. Tous ces programmes ont besoin des ressources en même temps donc les résultats de la simulation peuvent être gonflés invonlontairement. La seconde raison vient de notre façon d’obtenir le temps d’exécution. Les millisecondes ne sont pas forcement adaptées pour les petites valeurs. Nous avons d’abord voulu prendre la partie entière de notre moyenne finale, puis cela nous a semblé trop arrondi, donc nos courbes sont construites avec des nombres décimaux. MARIN Sophie BOURDONNAY Jean-Ronan page 8 sur 52 Tests de primalité 3 3 ALGORITHME DE WILSON Algorithme de Wilson 3.1 Présentation de Wilson John Wilson est un mathématicien anglais né en 1741 et mort en 1793. Il est entré à Cambrige en 1757, où il a fini major de sa promotion. Il se fait déjà remarquer en tant qu’étudiant en prenant la défense de son professeur de mathématiques Edward Waring à propos de son texte Miscellanea Analytica. Il enseigne les mathématiques à Cambrige et se fait rapidement une notoriété. Il quitte le monde universitaire et les mathématiques pour se lancer dans une carrière juridique qui fut brillante. Il est surtout connu pour le théorème suivant : p ∈ P ⇐⇒ (p − 1)! ≡ −1[p] Le théorème de Wilson a été découvert par un mathématicien arabe Ibn al-Haytham (aussi connu comme Alhazen) vers les années 1000, mais est attribué à John Wilson qui l’a conjecturé au XVII siècle. C’est Waring qui publia la conjecture en 1770, mais sans démonstration. La première preuve est due à Lagrange et a été publiée en 1773. Il semblerait que Leibniz connaissait le résultat un siècle plus tôt mais ne l’a jamais publié. 3.2 Démonstration On souhaite démontrer ce théorème : Théorème 1 (Théorème de Wilson) p ∈ P ⇐⇒ (p − 1)! ≡ −1[p] Preuve On rappelle que dans Z/pZ, il y p éléments : Z/pZ = {0, 1, 2, . . . , (p − 3), (p − 2), (p − 1)}. Si p est non premier, (p − 1)! est le produit de tous les éléments sauf 0 dans Z/pZ. Si p est premier, alors Z/pZ est corps, donc (p − 1)! est le produit des inversibles de Z/pZ. Nous allons d’abord montrer l’implication : p ∈ P =⇒ (p − 1)! ≡ −1[p] Si p ∈ P, alors (p − 1)! est composé de tous les inversibles de Z/pZ, et d’un nombre pair de facteurs. On peut donc séparer le produit (p − 1)! en deux facteurs : • l’un est le produit des couples des inversibles Π1 • l’autre est le produit des inversibles qui sont leurs propres inverses Π2 Dans Z/pZ, e est son propre inverse, cela signifie (p − 1)! = Π1 · Π2 e·e ≡ 1 e2 − 1 ≡ 0 (e − 1)(e + 1) ≡ 0 [p] [p] [p] Donc dans le corps Z/pZ, e ≡ 1 [p] ou e ≡ −1 ≡ p − 1 [p] Donc (p − 1)! ≡ 1 · (p − 1) · Π1 [p] On a un nombre pair de facteurs dans (p − 1)!, donc Π2 contient aussi un nombre pair de facteurs. On en déduit que Π2 ≡ 1[p] car il est composé uniquement des couples d’inversibles. On a donc : (p − 1)! ≡ 1 · (p − 1)[p] (p − 1)! ≡ p − 1[p] (p − 1)! ≡ −1[p] Ainsi on a montré que p ∈ P =⇒ (p − 1)! ≡ −1[p] Il nous reste à démontrer la réciproque : (p − 1)! ≡ −1[p] =⇒ p ∈ P 1<a<p Si p ∈ / P, alors il existe a ∈ N∗ tel que a divise p, donc p = a · k avec 1<k<p MARIN Sophie BOURDONNAY Jean-Ronan page 9 sur 52 Tests de primalité 3 ALGORITHME DE WILSON On peut se ramener à deux cas : Cas 1 : a 6= k Supposons a < k On peut écrire (p − 1)! = 1 · (. . .) · a · (. . .) · k · (. . .) · (p − 1)[p] Donc on a (p − 1)! = 0[p] Cas 2 : a = k p − 1 = a2 − 1 = (a − 1)(a + 1) avec 1 < a < p Si a > 2 alors a2 − 1 > 2a, donc si a ∈]2, +∞[, a2 − 1 > 2a, cela signifie que (p − 1)! = (p − 1)! = (p − 1)! = 1 · (. . .) · a · (. . .) · 2a · (. . .) · (p − 1) [p] 1 · (. . .) · 2a2 · (. . .) · (. . .) · (p − 1) [p] 0 [p] Donc on a (p − 1)! ≡ 0[p] On a montré : p∈ / P, p > 4 =⇒ (p − 1) 6≡ 0[p] Vérifions le cas p = 4 : 3! ≡ 2[4], 2 est bien différent de −1. De plus (p − 1)! ≡ 0[p] signifie que dans (p − 1)! apparaît une décomposition de p différente de p = 1 · p, donc p n’est pas premier, (p − 1)! ≡ 0[p] =⇒ p ∈ /P Par contrapostion , on en déduit que p ∈ / P =⇒ (p − 1)! 6≡ −1[p] De plus on a montré p ∈ P ⇐⇒ (p − 1)! ≡ −1[p] On peut conclure : p ∈ P ⇐⇒ (p − 1)! ≡ −1[p] 3.3 Algorithme On va utiliser le théorème démontré ci-dessus pour faire un algorithme de primalité. En effet on a prouvé que, lorsque p n’est pas premier, (p − 1)! ≡ 0[p]. On va faire une boucle pour calculer i![p] pour 1 < i < (p − 1). Dès que le calcul intermédiaire de la factorielle s’annule, on en déduit que i est un diviseur de p et donc que p n’est pas premier. Algorithme 3 Wilson si (p − 1)! ≡ 0 [p] alors premier ← f aux sinon premier ← vrai fin si Calcul de la complexité théorique La complexité de cet algortihme réside dans le calcul de la factorielle. On a besoin de faire environ p fois une multiplication modulaire. C = O(p · (O(multiplication) + O(modulo)) ) C = O(2n · (n2 + n2 ) ) C = O(2n+1 · n2 ) Complexité théorique des opérations $10.1 MARIN Sophie BOURDONNAY Jean-Ronan page 10 sur 52 Tests de primalité 3.4 3 ALGORITHME DE WILSON Pour conclure sur cet algorithme Cet algorithme est déterministe, ce qui nous permet d’être sûr de notre résultat, mais il est plus lent que la méthode naïve ($4.1) qui a une compléxité en O( n · 2n ). Nous avons implémenté deux versions de cet algorithme : l’une itérative, l’autre récursive. Cependant la mémoire nécessaire pour calculer la factorielle devient rapidement trop grande. C’est pourquoi nous nous sommes concentré sur la version itérative. Figure 7: Algorithme de Wilson : Impression d’écran de la console lors de l’exécution de la version récursive Pour avoir des valeurs significatives nous avons répété le test 10 fois pour chaque taille d’entier donné, et fait la moyenne des temps d’exécution. Ensuite nous recommençons l’expérience 5 fois pour choisir la courbe qui nous semble la plus intéressante à commenter. Nous nous sommes arrêté aux entiers de 30 bits car cet enchaînement commençait à devenir long. Dans le calcul qui suit, on va considérer que 1024 = 210 = 103 Pour un entier de 30 bits 10·3+1 2 T ≃ 2 (2 1,83·10)·30 9 9 Pour un entier de 32 bits 10·3+3 2 T ≃ 2 (2 1,83·10)·32 9 9 ·2)·900 T ≃ 2 (10 1,83·109 ·8)·1024 T ≃ 2 (101,83·10 9 T ≃ 2 1800 1,83 T ≃ 2 8·1024 1,83 T ≃ 983 secondes soit 16 minutes T ≃ 4476 secondes soit 74 minutes On a un facteur 4 entre le temps d’exécution théorique sur un entier de 30 bits et celui sur un entier de 32. L’allure de la courbe rappelle celle d’une fonction exponentielle, ce qui nous indique que le temps d’exécution croît très rapidement et de façon non linéaire. C’est pour cela qu’on a préféré s’arrêter aux entiers de 30 bits. MARIN Sophie BOURDONNAY Jean-Ronan page 11 sur 52 Tests de primalité 3 ALGORITHME DE WILSON Notre complexité théorique semble avoir la même allure que la complexité pratique : à première vue notre complexité théorique semble juste. Pour le vérifier nous avons tracé la courbe de la complexité pratique sur théorique. Ell est bornée entre 0.5 et 2, si on ne prend pas en compte les entiers de petites tailles. Ceci est tout à fait correct car la complexité théorique que nous avons calculée est juste à un coefficient multiplicatif près. De plus les aléas d’une simulation justifient que cette courbe soit pas vraiment une droite, mais qu’elle soit bornée. Complexité Pratique Complexité Théorique × 500000 × × × 500000 400000 Complexité Pratique / Théorique 9 × 8 7 400000 6 300000 Temps en s 300000 Temps en s 200000 200000 × 0 × 0 × × ××××××××××××××××××××× 5 10 15 20 25 30 Taille en bits × 100000 0 5 4 ×× 3 × 100000 Temps en s 0 × × × ×××××××××××××××××××× 5 10 15 20 25 30 Taille en bits × 2 1 0 × 0 5 × 10 × × ×× × × ×××× ××××× 15 20 Taille en bits 25 30 Figure 8: Algorithme de Wilson : Comparaison de temps d’exécution pratique et théorique MARIN Sophie BOURDONNAY Jean-Ronan page 12 sur 52 Tests de primalité 4 4 ALGORITHME DE CRIBLES Algorithme de Cribles 4.1 4.1.1 Crible d’Ératosthène Présentation d’Eratosthène Ératosthène est un astronome, géographe, philosophe et mathématicien grec du IIIe siècle av. J.-C. Ératosthène est nommé à la tête de la bibliothèque d’Alexandrie vers 245 av. J-C à la demande de Ptolémée III, pharaon d’Égypte, et devient précepteur de son fils. Selon les dires, il se laissa mourir de faim parce que, devenu aveugle, il ne pouvait plus admirer les étoiles. Il est surtout célèbre pour être le premier dont la méthode de mesure de la circonférence de la Terre soit connue. En tant que mathématicien, il établit le crible d’Ératosthène, méthode qui permet de déterminer par exclusion tous les nombres premiers. 4.1.2 Démonstration du théorème fondamental de l’arithmétique Théorème 2 (Théorème fondamental de l’arithmétique) Tout nombre entier n > 1 peut se décomposer en produit de facteurs premiers. Cette décomposition est unique à l’ordre près des facteurs Preuve Démontrons par récurrence, le théorème fondamentale de l’arithmétique Initialisation Pour n = 2, n = 1 · 2 donc la propriété P(2) est vraie Démontrons l’héridité Tout entier n > 1 admet au moins un diviseur premier a, donc soit na = 1 soit na > 1. Si na = 1 alors n = a. Si na > 1 alors n s’écrit n = a( na ) avec a < n. Par hypothèse de récurrence, n/a s’écrit sous forme de produit de facteurs premiers alors n s’écrit comme produit de facteurs premiers. En résumé L’initialisation est vraie, la propriété est bien héréditaire, donc on a bien démontré que tout nombre entier n > 1 peut se décomposer en produit de facteurs premiers, cette décomposition étant unique à l’ordre près des facteurs. 4.1.3 Algorithmes On teste chaque entier inférieur à i s’il divise p, pour tous entiers de 2 à p − 1 Algorithme 4 Crible 1 : Non optimisé Initialisation de T ableau[] à 1 pour i allant de 2 à p faire compteur ← 2i tant que compteur ≤ p faire T ableau[compteur] ← 0 compteur ← compteur + i fin tant que fin pour MARIN Sophie BOURDONNAY Jean-Ronan page 13 sur 52 Tests de primalité 4 ALGORITHME DE CRIBLES Calcul de la complexité théorique pour la version non optimisée La complexité de cet algortihme réside dans le parcours d’un tableau de taille p, c’est à direP que l’on va regarder les P iième cases une à une. Pour chaque i testé, on va regarder p p p 1 1 la complexité devient : p · i=2 i . Cette formule i cases. En Pp 1 i=2 i correspond à une somme harmonique. Or on sait Pfait, p 1 que lim i=2 i = ln(p). De plus cette égalité O(ln(p)) = O(log2 (p)) nous i=2 i − ln(n) = γ. Ceci nous permet de dire que n−→∞ Pp 1 permet de conclure que i=2 i peut être arrondi à n . Pp C = O( p · i=2 1i ) C = O( 2n · n ) Complexité théorique des opérations $10.1 Notre optimisation consiste à tester tous les entiers allant de 2 à √ √ p car tous les diviseurs de p sont compris entre 2 et p Algorithme 5 Crible 1 : Optimisé Entrées/Sorties : entier entier p, T ableau[] de taille p, Initialisation de T ableau[] à 1 √ pour i allant de 2 à p faire compteur ← 2i tant que compteur ≤ p faire T ableau[compteur] ← 0 compteur ← compteur + i fin tant que fin pour Calcul de la complexité théorique pour la version optimisée La complexité de cet algortihme réside cette fois-ci dans √ le parcours d’un tableau de taille p. On applique le même raisonnement que dans la version non optimisée. P C = O( p2 · pi=2 n C = O( 2 2 · n ) 4.1.4 1 i ) Pour conclure sur cet algorithme On a besoin de construire un tableau jusqu’à p. À partir de 23, 24 bits, on a constaté un dépassement de mémoire dû à la taille nécessaire pour le tableau. On a donc décidé de s’arrêter à 22 bits pour être sûr de nos valeurs. Contrairement à l’algorithme de Wilson ($3), ce n’est pas le temps qui nous arrête mais des problèmes techniques. Le crible d’Érastosthène est aussi un algorithme déterministe Dans l’implémentation de la version optimisée, on ne calcule pas la racine de p. Cela demande plus de ressources que le calcul du carré d’un nombre pour un entier de type double. On a remplacé notre condition d’arrêt de la boucle par compteur2 ≤ p. Ce léger changement nous a parfois permis de dépasser 23 bits. Figure 9: Algorithme d’Erathostène : Impression d’écran de la console lors d’une exécution MARIN Sophie BOURDONNAY Jean-Ronan page 14 sur 52 Tests de primalité 4 ALGORITHME DE CRIBLES Le stockage en mémoire d’un tableau de références de taille p est une limitation de ce crible. Par exemple, si on stocke 1 bit par nombre, la taille mémoire est en O( 2n ). Donc pour 23 bits cela nous donne une taille mémoire de 1 Mo et pour 24 bits 2 Mo. Nous avons aussi besoin de stocker un nombre de taille maximum n bits donc, pour un tableau de taille p (de taille n) de nombres de taille n, la taille mémoire est cette fois-ci en O( n · 2n ). Ceci nous donne une taille de 192 Mo pour 23 bits et de 402 Mo pour 24 bits. Dans notre implémentation, on stocke le nombre nécessaire de bits pour chaque nombre. Cela nous permet de prendre la somme des tailles des nombres stockés. Après avoir fait le calcul, on trouve 23 Mo pour 23 bits et 48 Mo pour 24 bits. En résumé, dans notre cas, on a un tableau de références de p objets de type BigInteger. La taille du tableau utilisé peut être calculée à l’aide de la formule suivante : p ∗ taille pointeurs ce qui nous donne n ∗ ⌈log(n)⌉. Le tableau ci-après va récapituler les tailles mémoires des étapes importantes de notre raisonnement. Pour un entier de 23 bits Pour un entier de 24 bits totales des cases = 23 bits pointeur = 23 bits tableau = 23 ∗ 223 = 24 Mo tableau de références et objets = 24 + 23 = 47 Mo totales des cases = 48 bits pointeur = 24 bits tableau = 24 ∗ 224 = 50M o Mo tableau de références et objets = 50 + 48 = 98 Mo Nous avons répété 10 fois chaque calcul et fait la moyenne pour avoir un résultat significatif. La courbe du temps d’exécution théorique semble avoir la même allure que celle du temps d’exécution pratique. En traçant la courbe pratique sur théorique, on obtient une constante qui varie entre 2 et 6. Ceci nous permet de dire que notre calcul de complexité théorique n’est pas si mauvais pour un n petit. On peut ajouter aussi à cela que dans la complexité théorique, nous ne tenons pas compte du calcul du compteur au carré, ce qui doit fausser quelque peu le résultat final. Complexité Pratique Complexité Théorique 300 × × Complexité Pratique / Théorique 8 × × × 250 6 1000 × 200 Temps en ms Temps150 en ms × 500 4 Coefficent × × × × × 100 × ×× × × × × 2 × × × ××××××××××××× 0 0 2 4 6 8 10 12 14 16 18 20 22 Taille en bits 50 × × × × ×××××××××××× 0 0 2 4 6 8 10 12 14 16 18 20 22 Taille en bits 0 ×××××× 0 2 4 6 8 10 12 14 16 18 20 22 Taille en bits Figure 10: Algorithme d’Eratosthène : Comparaison de temps d’exécution pratique et théorique MARIN Sophie BOURDONNAY Jean-Ronan page 15 sur 52 Tests de primalité 4.2 4.2.1 4 ALGORITHME DE CRIBLES Crible de Sundaram Démonstration Si un nombre impair n’est pas premier alors, par définition, il admet au moins deux diviseurs impairs distincts. L’idée est donc de considérer les produits de la forme : Np .Nn = (2p + 1).(2n + 1) On souhaite simplifier le produit Np .Nn = (2p + 1).(2n + 1) Np .Nn Np .Nn Np .Nn Np .Nn Np .Nn = = = = = (2p + 1) · (2n + 1) 4pn + 2p + 2n + 1 n · (4p + 2) + (2n + 1) 2n · (2p + 1) + (2n + 1) 2n · Np + Nn On pose (Ci )i∈N et (Lj )j∈N sont deux suites arithmétiques de premier terme 3 et de raison 2. × L0 L1 L2 L3 L5 L5 L6 C0 9 15 21 27 33 39 45 C1 15 25 35 45 55 65 75 C2 21 35 49 63 77 91 105 C3 27 45 63 81 99 117 135 C4 33 55 77 99 121 143 165 C5 39 65 91 117 143 169 195 C6 45 75 105 135 165 195 225 raison r0 = 6 r1 = 10 r2 = 14 r3 = 18 r4 = 22 r5 = 26 r6 = 30 Tableau 2: Tableau des produits des 7 premiers nombres impairs On remarque que les raisons sont des suites arithmétiques de premier terme 6 et de raison 4. i ∈ N, ri = 6 + 4i. On fixe L. La ligne des produits de L0 · Cj est une suite arithmétique de premier terme 9 et de raison 6. U0,j = 9 + 6j La ligne des produits de Li · Cj est une suite arithmétique de premier terme Ui,0 et de raison ri . i, j i, j i, j i, j ∈ N2 , ∈ N2 , ∈ N2 , ∈ N2 , Ui,j Ui,j Ui,j Ui,j = = = = Ui,0 + j · ri 9 + 6i + j · (6 + 4i) 9 + 6i + 6j + 4ij (2i + 3) · (2j + 3) (Ui,j )i∈N, j∈N est le produit de deux nombres impairs supérieurs ou égaux à 3 donc Ui,j est impair et composé. On en déduit que ce tableau ne contient aucun nombre premier. MARIN Sophie BOURDONNAY Jean-Ronan page 16 sur 52 Tests de primalité 4.2.2 4 ALGORITHME DE CRIBLES Algorithmes On va tester tous les nombres impairs de 3 à p−1 2 −1 Algorithme 6 Crible 2 : Non optimisé premier ← vrai i←0 j←0 tant que i < ( p−1 2 − 1) faire tant que j < ( p−1 2 − 1) faire matrice[i][j] ← (2i + 3) · (2j + 3) j ←j+1 fin tant que i←i+1 j←0 fin tant que Calcul de la complexité théorique pour la version non optimisé Pour chaque ligne i, on va multiplier i avec toutes les 3· p−1 p−1 2 colonnes qui sont des nombres impairs allant de 3 à p−1 2 , ce qui donne comme expression i · ( 2 ) · 2 . Il faut faire la somme des résultats obtenus pour chaque ligne i donc on obtient la somme des entiers impairs au carré. C = O( O(multiplication) · (somme des entiers impairs)2 ) 3+ p−1 2 )2 2 2 C = O( n2 · ( p−1 2 − 1)n · ( n 2 2 2 C = O( n · (2 ) · (2 4 )2 ) 3 C = O( n2 · 2 2 ·n ) ) Complexité théorique des opérations $10.1 Le produit i · j est égal à j · i donc le tableau est symétrique. De ce fait, on ne va tester que la moitié du tableau généré. Algorithme 7 Crible 2 : Optimisé premier ← vrai i←0 j←0 tant que i < ( p−1 2 − 1) faire tant que j < ( p−1 2 − 1) faire matrice[i][j] ← (2i + 3) · (2j + 3) j ←j+1 fin tant que i←i+1 j←i fin tant que MARIN Sophie BOURDONNAY Jean-Ronan page 17 sur 52 Tests de primalité 4 ALGORITHME DE CRIBLES Calcul de la complexité théorique pour la version optimisé Dans la version optimisée on se retrouve à ne calculer le Pi P p−1 3+ p−1 p−1 2 2 produit qu’au dessus de la diagonale de la matrice. Ceci revient à faire i=3 ) · i et nous autorise à j=1 ( 2 − 1) · ( 2 diviser par 2 la complexité non optimisée. 3 C = O( n2 · 2 2 ·n−1 ) 4.2.3 Pour conclure sur cet algorithme p On travaille encore avec un algorithme déterministe. Cette fois-ci on a besoin de construire une matrice carré de taille (p). On rencontre un problème de mémoire similaire au même endroit que le crible 1 ($4.1), c’est à dire que quand on teste un nombre de 23 bits cela fait explosé la mémoire. Figure 11: Algorithme de Sundaram : Impression d’écran de la console lors d’une exécution Concernant la mémoire, on peut appliquer pour ce crible le même raisonnement que pour celui d’Erathosthène ($4.1.4). En effet, on avait un tableau à une dimension de taille p et ici on a un tableau à deux dimensions de taille p/2 sur p/2. Les tailles des nombres à stocker sont divisée par 2, mais on en a 2 fois plus. Tout nos calculs faits précédemment sont donc les mêmes dans ce cas là. C’est pour cela que la mémoire explose pour le même nombre de bits donné. Pour un entier de 23 bits Pour un entier de 24 bits total des cases = 23 bits pointeur = 23 bits tableau = 23 ∗ 223 = 24 Mo tableau de références et objets = 24 + 23 = 47 Mo total des cases = 48 bits pointeur = 24 bits tableau = 24 ∗ 224 = 50M o Mo tableau de références et objets = 50 + 48 = 98 Mo MARIN Sophie BOURDONNAY Jean-Ronan page 18 sur 52 Tests de primalité 4 Complexité Pratique 1500 Complexité Pratique / Théorique Complexité Théorique 600 × × 1000 Temps en ms 60 × 500 50 400 40 500 200 100 0 0 20 × 10 × × ××××××××××××× 0 0 2 4 6 8 10 12 14 16 18 20 22 Taille en bits 25 × 30 Coefficent × × × × Temps300 en ms × × ×××××××××××××× 5 10 15 20 Taille en bits ALGORITHME DE CRIBLES 0 × × ××××× ×××××× ×× ×× 0 2 4 6 8 10 12 14 16 18 20 22 Taille en bits Figure 12: Algorithme de Sundaram : Comparaison de temps d’exécution pratique et théorique Nous avons répété 10 fois chaque calcul et fait la moyenne pour avoir un résultat significatif. On constate que, pour 22 bits, le crible de Sundaram met environ 2 fois plus de temps que le crible d’Eratosthène. Ceci est dû aux nombreux calculs de produits à effectuer pour remplir la matrice alors que dans le crible d’Erathostène on parcourt le tableau plusieurs fois. La courbe du temps d’exécution théorique semble avoir la même allure que celle du temps d’exécution pratique. En traçant la courbe pratique sur théorique, on obtient une courbe plutôt lisse mais avec trois points qui sortent de la droite. Cela est sûrement dû au fait qu’on exécute notre simulation sur une machine multitâche. Ils sont donc à négliger. Notre calcul de complexité semble correct mais nous allons retirer le point le plus éloigné de la "droite" pour faire un zoom de cette dernière. On a retiré l’"accident" de la courbe pratique sur théorique pour la regarder plus en détail. Globalement on peut dire que la courbes varie entre 1 et 4, en considérant les pics comme un accident mineur. Complexité Pratique / Théorique 60 × × 50 Complexité Pratique / Théorique 10 × 8 × 40 6 30 Coefficent Coefficent 4 × 20 10 2 × × ××××× ×××××× ×× ×× 0 0 2 4 6 8 10 12 14 16 18 20 22 Taille en bits 0 × × × × × ×× × × ×× ×× ×× 0 2 4 6 8 10 12 14 16 18 20 22 Taille en bits Figure 13: Algorithme de Sundaram : Comparaison de la courbe pratique sur théorique avec et sans accident majeur MARIN Sophie BOURDONNAY Jean-Ronan page 19 sur 52 Tests de primalité 5 5.1 5 ALGORITHME DE FERMAT Algorithme de Fermat Présentation de Fermat Pierre de Fermat, né au début du XVIIe siècle et mort en 1665, est un juriste et mathématicien français. Il s’est aussi intéressé aux sciences physiques. Il est le créateur de la théorie des nombres. Avec l’aide de Pascal, il participe aux avancées dans le calcul des probabilités. Il s’intéresse aussi à la géométrie analytique et au calcul différentiel. Il est surtout connu pour ses résultats en arithmétiques. 5.2 Démonstrations Théorème 3 (Petit théorème de Fermat) Si p ∈ P et a ∈ N tel que pgcd(a, p) = 1 alors ap−1 ≡ 1 [p] Preuve Si p ∈ P alors 1 ≤ k ≤ p − 1 p divise kp . En effet, on a : p! = k!(p − k)! kp Donc : p divise k!(p − k)! kp Or, pour tout 1 ≤ k ≤ p − 1, on a pgcd(p, k) = 1 et pgcd(p, p − k) = 1 donc pgcd(p, k!(p − k)!) = 1. Donc, d’après le théorème de Gauss : p divise kp Supposons a ∈ N et montrons par récurrence sur a la propriété : P(a) : ap = a[p] 0 = 0[p], on a bien P(a). Montrons, pour tout a ∈ N , que : P(a) =⇒ P(a + 1) Supposons P(a) : ap = a[p] p X p k p D’après la formule du binôme : (a + 1) = a [p] k k=0 Or, on a vu plus haut que : kp = 0 [p] pour tout 1 ≤ k ≤ p − 1. D’où : (a + 1)p = ap + 1 [p] Et d’après P(a) : (a + 1)p = a + 1[p], on en déduit donc P(a + 1). D’après le principe de récurrence, on a : ∀a ∈ N, P(a) est vraie Supposons maintenant a ∈ Z− . Si p est impair : ap = −(−a)p = −(−a) = a [p] Si p = 2 : a2 = (−a)2 = −a [2]. Or, a = −a [2] donc a2 = a[2]. Dans tous les cas, on a bien : ap = a[p]. L’égalité ci-dessus peut encore s’écrire :a · (ap−1 − 1) = 0[p] Or, p étant premier, Z/pZ est intègre donc : a = 0 [p] ou ap−1 = 1 [p] Or, pgcd(a, p) = 1 donc p ne divise pas a, on ne peut donc pas avoir a = 0 [p], d’où : ap−1 = 1 [p] Définition 1 (Définition d’un nombre de Carmichael) Un nombre de Carmichael est un entier composé n tel que ∀a ∈ N, n|an−1 Théorème 4 (Théorème de la probabilité du test de Fermat ) Si n ≥ 3 est un nombre impair, l’ensemble {1, ..., n − 1} nombres premiers à n qui ne sont pas des témoins de la décomposition de n. contient au plus (n−1) 2 Preuve Il nous faut estimer le nombre d’éléments a ∈ {1, 2, . . . , n − 1} tel que pgcd(a, n) = 1 et an ≡ a [n]. Q Il existe alors un a pour qui la relation (1) est vérifiée. On note n = p|n pe(p) la décomposition en facteurs premiers de n. Nous définissons les sous-groupes suivants de (Z/nZ)∗ : K = {a + nZ : pgcd(a, n) = 1, an−1 ≡ 1 [n] } On remarque qu’on a K ⊂ J ⊂ (Z/nZ)∗ J = {a + nZ : pgcd(a, n) = 1, an−1 ≡ 1 [pe(p) ] } Pour chaque entier a premier avec n qui n’est pas témoin de la composition de n, la classe résiduelle a + nZ appartient à K. Nous prouverons la validité du théorème en montrant que l’indice de K dans (Z/nZ)∗ est au moins 2. MARIN Sophie BOURDONNAY Jean-Ronan page 20 sur 52 Tests de primalité 5 ALGORITHME DE FERMAT L’indice de K dans J est de la forme 2 · k parce que le produit de deux éléments de K appartient à J. Si k = 1, alors n a deux diviseurs premiers, et donc il n’est pas un nombre de Carmichael. Cela implique que J est un sous-groupe de (Z/nZ)∗ et l’indice de J dans (Z/nZ)∗ est au moins 2. Il reste le cas k = 0. Alors n est une puissance d’un nombre premier et dans ce cas on peut vérifier que J a précisement p − 1 éléments, à savoir les éléments du sous-groupe d’ordre p − 1 du groupe (Z/pe Z)∗ . Par conséquent, l’indice de J dans (Z/nZ)∗ est au moins 2. 5.3 Algorithme Algorithme 8 Fermat premier ← vrai Générer a aléatoirement tel que pgcd(a, p) = 1 si ap−1 6≡ 1 [p] alors premier ← f aux fin si Calcul de la complexité théorique La complexité de cet algortihme réside dans le calcul d’une exponentiation modulaire (square and multiply). Pour simplifier les calculs, on pose que l’exposant et le modulo font la même taille. C = O( modPow(n, n) ) C = O( 2 · n3 ) Complexité théorique des opérations $10.1 5.4 Pour conclure sur cet algorithme Le test de Fermat est un test probabiliste qui vérifie la composition d’un nombre et non la primalité. Ce test est plutôt rapide, il est basé sur une exponentiation modulaire et le choix d’un nombre aléatoire. S’il n’était pas probabiliste ce serai un test très intéressant pour sa rapidité. Cependant la probabilité du test n’est pas très bonne, on a 1 chance sur 2 pour une itération que la réponse donnée soit juste. Pour améliorer, ce test il faut recommencer plusieurs fois le même test avec un nombre aléatoire différent on aura alors une probabilité de réussite de 21k avec k le nombre de a tiré aléatoirement. Les nombres de Carmichael représentent une faille de ce test, mais il n’y a pas seulement cela. Notre test a été fait avec une probabilité de 21 Figure 14: Algorithme de Fermat : Impression d’écran de la console lors d’une exécution On remarque que 27 sort comme premier or tout le monde sait que 27 = 3 · 9 et 27 n’est pas un nombre de Carmichael, on a aussi 874 qui est dit premiers qui est clairement un multiple de 2. Dans notre exemple, on a pas de nombre de Carmichael, mais ils sont construits de façon à faire échouer ce test. MARIN Sophie BOURDONNAY Jean-Ronan page 21 sur 52 Tests de primalité 5 ALGORITHME DE FERMAT Figure 15: Algorithme de Fermat : Impression d’écran de la console lors d’une exécution Nous avons testé les 5 premiers nombres de Carmichael, ils sont tous sortis comme des nombres premiers. Dans notre test on choisit un a tel que pgcd(a, n) = 1 et si n est un nombre de Carmichael, alors ∀a ∈ N, n|an−1 . Donc on va obtenir n = k·(an −a) avec k ∈ N. Le petit théorème de Fermat peut aussi s’énoncer de la façon suivante : ∀a, p ∈ P, ap −a ≡ 0 [p]. Les nombres de Carmichael respectent bien ce théorème tout en étant composé. Nous avons détaillé le calcul du temps d’exécution pour un entier de 800 bits. T ≃ T ≃ T ≃ 2∗8003 1,83·109 (210 ·106 ) 1,83·109 1 1,83 T ≃ 0, 6 secondes Complexité Pratique 25 Complexité Théorique · · · · ·· ··· ··· ····· ··· ···· ··· ·· ········ 15 ········· · ···· ····· ··· Temps ····· ·· en ms ·· · · · · 10 ····· · ··· ·· ······ ········ ··· ·· ········· 5 ····· ········· ············ ······ · ········ ·············· · · · · · · · · · 0 ·············· · 100 200 300 400 500 600 700 800 900 Taille en bits 20 700 · ·· ·· ·· ··· 600 ··· ·· ·· 500 ·· ·· ···· · ·· 400 ···· ·· Temps ·· en ms ····· · 300 ··· ··· ··· ·· ··· 200 ··· ··· ··· · · ·· ··· 100 ···· · · · · ···· ······· ·········· · · · · · · · · · · · · · · · · · · 0 100 200 300 400 500 600 700 800 900 Taille en bits Complexité Pratique / Théorique 0.3 · 0.25 0.2 ·· · ·· ·· · ·· ··· · ·· · · 0.1 ··· ···· ·· ·· ··· · ··· ·· ··· ··· ·· ··· ·· · · · · ····· · 0.05 ···· ······························· · ·· ·· ·· ···················································· ·· ·········· ·· · · · · · ·· · ·· ·· · · ···· ······ ·················· · Temps 0.15 en ms 0 ··· 100 200 300 400 500 600 700 800 900 Taille en bits Figure 16: Algorithme de Fermat : Comparaison de temps d’exécution pratique et théorique On constate que la courbe représentative du rapport compléxité pratique sur théorique tend vers une constante avoisinant les 0, 05. Cela signifie que la compléxité que nous avons calculé est correct à cette constante près. Dans notre simulation nous avons fait une seule itération du test de fermat ce qui nous donne une chance sur deux que le résultat donné par notre programme soit juste. Ceci est relativement "mauvais". MARIN Sophie BOURDONNAY Jean-Ronan page 22 sur 52 Tests de primalité 6 6 RABIN MILLER Rabin Miller 6.1 Présentation de Miller et Rabin Gary Lee Miller est professeur d’informatique à l’Université Carnegie Mellon, Pittsburg. En 2003, il a remporté le prix ACM Paris Kanellakis pour le test de primalité de Miller-Rabin. Miller a obtenu son doctorat de l’Université de Berkeley en 1975. Sa thèse était intitulée hypothèse de Riemann et tests de primalité. En dehors de la théorie algorithmique des nombres et des tests de primalité, il a travaillé dans les domaines de la géométrie algorithmique, du calcul scientifique, des algorithmes parallèles et des algorithmes randomisés. Rabin est né en 1931. Il a obtenu une maîtrise ès sciences de l’Université hébraïque de Jérusalem en 1953 et un doctorat de l’Université de Princeton en 1956. Il est professeur agrégé et directeur de l’Institut de mathématiques à l’Université hébraïque à 29 ans. En 1975, Rabin termine son mandat comme recteur de l’Université hébraïque de Jérusalem et se rend à l’Institut de Technologie du Massachusetts aux Etats-Unis en tant que professeur invité. En 2003, Miller, Rabin, Robert M. Solovay et Volker Strassen ont reçu le prix Paris Kanellakis pour leur travail sur les tests de primalité. Rabin est membre étranger de l’Académie nationale américaine des Sciences, membre de l’Académie française des sciences et membre de la Royal Society. 6.2 Démonstration On cherche à démontrer le théorème suivant : Théorème 5 (Théorème de Rabin et Miller) Si n est un nombre premier impair, alors n − 1 = 2s · d où s ∈ N et d est impair. Pour tout a ∈ Z/nZ tel que a soit premier avec n une des conditions suivantes doit être vérifiée : r ad = 1 [n] ou a2 ·d = −1 [n] avec 0 ≤ r ≤ s − 1 Preuve Z/nZ est un corps et a est premier avec n alors a est inversible. D’après le petit théorème de Fermat, an−1 s a2 ·d s (ad )2 Cas 1 = 1 = 1 = 1 [n] [n] [n] 20 = 1. On a donc ad = 1 [n] l (l−1) ·d 2 Cas 2 2l avec 1 ≤ l ≤ s. On a donc ad·2 (a2 ) = 1. Le seul élément d’ordre de 2 dans le corps Z/nZ est −1 donc (l−1) 2 ·d a = −1 Pour démontrer la validité du test de Rabin et Miller, on utilise le théorème de Fermat. Cependant il existe des nombres avec lesquelles on ne peut pas prouver la composition à l’aide de ce théorème. Ceci nous permet de faire une distinction entre des nombres qui peuvent être témoins de la décomposition et les autres. MARIN Sophie BOURDONNAY Jean-Ronan page 23 sur 52 Tests de primalité 6 RABIN MILLER Il nous faut maintenant démontrer la proportion de ces nombres qui ne sont pas témoins. Pour cela on va démontrer le théorème suivant : Théorème 6 (Théorème de la probabilité du test de Rabin et Miller) Si n ≥ 3 est un nombre impair, l’ensemble {1, ..., n− 1} contient au plus (n−1) nombres premiers à n qui ne sont pas des témoins de la décomposition de n. 4 r Preuve Il nous faut estimer le nombre d’éléments a ∈ {1, 2, . . . , n−1} tel que pgcd(a, n) = 1 et ad ≡ 1 [n](1) ou a2 pour un certain r ∈ {0, 1, s − 1}. d ≡ −1 [n](2) Supposons qu’il existe un tel a. Il existe alors un a pour qui la relation (1) est vérifiée. Si a satisfait (2), alors −a satisfait (1). On note k la valeur maximale de r pour Q laquelle il existe un entier a qui satisfait pgcd(a, n) = 1 et (2). On pose m = 2k d. Notons aussi n = p|n pe(p) la décomposition en facteurs premiers de n. Nous définissons les sous-groupes suivants de (Z/nZ)∗ : J = {a + nZ : pgcd(a, n) = 1, an−1 ≡ 1 [n] } K = {a + nZ : pgcd(a, n) = 1, am ≡ ±1 [pe(p) ] } On remarque qu’on a M ⊂ L ⊂ K ⊂ J ⊂ (Z/nZ)∗ L = {a + nZ : pgcd(a, n) = 1, am ≡ ±1 [n] } M = {a + nZ : pgcd(a, n) = 1, am ≡ 1 [n] } Pour chaque entier a premier avec n qui n’est pas témoin de la composition de n, la classe résiduelle a + nZ appartient à L. Nous prouverons la validité du théorème en montrant que l’indice de L dans (Z/nZ)∗ est au moins 4. L’indice d’un sous-groupe G de H est le nombre de fois où G apparaît dans H. L’indice de M dans K est une puissance de 2 parce que le carré de chaque élément de K appartient à M . Par conséquent, l’indice de L dans K est aussi une puissance de 2, à savoir 2j . Si j ≥ 2, nous avons fini. Si j = 1, alors n a deux diviseurs premiers. Cela implique que J est un sous-groupe de (Z/nZ)∗ et l’indice de J dans (Z/nZ)∗ est au moins 2. Par définition de m, l’indice de L dans K est 2 lui-aussi. Par conséquent, l’indice de L dans (Z/nZ)∗ est au moins 4. Il reste le cas j = 0. Alors n est une puissance d’un nombre premier et dans ce cas on peut vérifier que J a précisement p − 1 éléments, à savoir les éléments du sous-groupe d’ordre p − 1 du groupe (Z/pe Z)∗ . Par conséquent, l’indice de J dans (Z/nZ)∗ est au moins 4 à moins que nous n’ayons n = 9. Pour n = 9, l’assertion peut être vérifiée directement. Pour t répétitions du test, on aura une probabilité pour que le nombre n testé ne soit pas premier de 1 4t . Pour conclure, on a démontré que : r a ∈ Z/nZ, a ∈ P, ad = 1 [n] ou a2 MARIN Sophie BOURDONNAY Jean-Ronan ·d = −1 [n] avec 0 ≤ r ≤ s − 1 page 24 sur 52 Tests de primalité 6.3 6 RABIN MILLER Algorithme Algorithme 9 Rabin Miller test1 ← faux test2 ← faux générer aléatoirement a compris entre 1 et p − 1 si ad = 1 [p] alors test1 ← vrai sinon test1 ← faux fin si r si a2 ·d = p − 1 [p] alors test2 ← vrai sinon test2 ← faux fin si si test1 et test2 sont vrais alors premier ← vrai sinon premier ← faux fin si Calcul de la complexité théorique On va considérer que le test 1 et le test 2 ont la même complexité qui se trouve être celle de l’exponentiation modulaire (square and multiply). C = O( 5 · 2 · O(modPow(n, n)) ) C = O( 20 · n3 ) 6.4 Pour conclure sur cet algorithme Cet algorithme a valu le prix Paris Kanellakis à ses auteurs. Il sert à honorer les avancées théoriques ayant un impact important et démontrable sur l’informatique pratique. Cette méthode a permis de tester la primalité d’entiers de grande taille par des programmes, ce qui était impossible avant à cause du temps que cela prenait. On peut citer l’algorithme RSA qui a besoin de grands nombres premiers pour maintenir une sécurité correcte et qui est utilisé, par exemple, pour obtenir des certificats et sécuriser les paiements en ligne. Contrairement aux précédents algorithmes, celui-ci est probabiliste, mais beaucoup plus rapide. Nos tests seront faits avec 5 itérations du test donc avec une probabilité de 415 que le test soit juste. C’est la première fois qu’on ne rencontre ni de problème de capacité de mémoire lors de l’exécution, ni de problème au niveau du temps d’exécution. Nous avons détaillé le calcul du temps d’exécution pour un entier de 800 bits. 3 2∗800 T ≃ 10 1,83·10 9 10 6 ·10 ) T ≃ 10 (2 1,83·109 T ≃ 10 1,83 T ≃ 5 secondes MARIN Sophie BOURDONNAY Jean-Ronan page 25 sur 52 Tests de primalité 6 RABIN MILLER Notre simulation se fait sur des entiers de taille allant de 150 bits à 850 bits. Ceci nous permet de retirer les petites valeurs, et d’avoir un nombre de points correct pour discuter nos courbes. Complexité Pratique 40 35 30 25 Temps20 en ms 15 10 5 Complexité Théorique · ·· ··· · ···· ········ ······· · · ······ ··· · ········ · · ······· ······· · ······· ····· · ······ ····· ····· · ········ ····· ····· ····· · · ·········· ·· ······· ······ ×········ 0 100 200 300 400 500 600 700 800 900 Taille en bits 700 600 500 400 Temps en ms 300 200 100 · · ·· ··· ···· · ·· ··· ··· ··· ·· ···· · ··· ·· ··· · ··· ·· · ··· ··· ··· ··· ·· · · ··· ··· ··· · · ··· ··· ···· · · · · ··· ······ ······ 0 100 200 300 400 500 600 700 800 900 Taille en bits Complexité Pratique / Théorique 0.16 0.14 0.12 0.1 0.08 Coefficent 0.06 0.04 · · ····· ···· · ·· · ··· ······· ·· · ··· · ···················· · · ······· · · · ············· · ················· · · · · · ·· ·· ·················· ·· · · · ·· · · ·· ·· ································· · · ·· ··· 0.02 0 100 200 300 400 500 600 700 800 900 Taille en bits Figure 17: Algorithme de Rabin et Miller : Comparaison de temps d’exécution pratique et théorique La courbe pratique croît par pallier de 32 bits. Ceci est dû à l’utilisation du type BigInteger de Java pour les entiers. Les BigInteger sont construits à l’aide d’un ou plusieurs tableaux de 32 bits. Le rapport des résultats pratique sur théorique est borné quand la taille de l’entier testé est grande. On peut donc dire que la complexité théorique est juste car elle est bornée entre 0, 06 et 0, 04 dans notre exemple. On remarque que les tests sont indépendants donc on pourrait les paralléliser. Pour ce faire, on va parallèliser les tirages de a. On utilisera deux threads. MARIN Sophie BOURDONNAY Jean-Ronan page 26 sur 52 Tests de primalité 6 RABIN MILLER Version simple Complexité Pratique 55 · 50 45 Temps en ms 30 25 20 15 10 5 9 · 8 40 35 Complexité Pratique 10 · ··· ···· ···· ··· ···· · ········ · ········ · · ······ ····· · · · · · · ·· ····· · ········· · · · · · · ···· ···· ····· · · · · · · ·········· ····· ········· ········ 0 100 200 300 400 500 600 700 800 900 Taille en bits 7 6 · · · ··· ····· ····· ·· ····· ·· ·· ························ 4 · ··· ·· · ·· ··· ··· ····· · ········································ 3 · ··· · · ·· ····· ··················· · · · ··· · · ··· ·· ···················································· 2 · · · · · · ·········· · ·· · · ······ ······················································ ···· 1 · ·········································· · · ············ ··· ······················· ·· · · 0 ·· · 100 200 300 400 500 600 700 800 900 Taille en bits Temps 5 en ms Figure 18: Algorithme de Rabin et Miller : Comparaison de temps d’exécution de la version simple et parallèle Le test en version parallèle est exécuté sur deux coeurs. On remarque qu’un fois parallèlisé le test va environ 7 fois plus vite ce qui est un gain assez important, même si le test de Rabin et Miller est déjà rapide. Pour rendre, on a crée deux threads, l’un va effecter l’équivalent de 3 itérations complètes du test et l’autre 2. La courbe n’est pas lisse car on ne sait jamais quand l’ordinateur va donner la main aux threads. MARIN Sophie BOURDONNAY Jean-Ronan page 27 sur 52 Tests de primalité 7 7 AKS AKS 7.1 Présentation Le professeur Agrawal de l’Institut indien de technologie de Kanpur et deux de ses élèves, Kayal et Saxena résolvent une ancienne conjecture en théorie de la complexité : le test en temps polynomial de la primalité d’un nombre donné. Algorithme 10 Les grandes étapes d’AKS Étape 1 : Si n = ab pour a ∈ N et b > 1, alors n est Composé. Étape 2 : Déterminer le plus petit entier r tel que l’ordre de n dans Z/rZ soit supérieur à 4log(n)2 . Étape 3 : Si 1 < pgcd(a, n) < n pour un entier a ≤ r, alors n est Composé. Étape 4 : Si n ≤ r, alors n est Premier. p Étape 5 : Pour a = 1 à ⌊2 ϕ(r)log(n)⌋ : Si (X + a)n 6≡ X n + a dans (X rZ/nZ[X] −1)Z/nZ[X] alors n est Composé. Étape 6 : n est Premier. Les différentes étapes sont détaillées dans la partie 7.4. 7.2 7.2.1 Résultats préliminaires et définitions Définitions Définition 2 (Définiton de l’ordre d’un nombre) Si r ∈ N et a ∈ Z avec a et r premiers entre eux, l’ordre de a dans (Z/rZ) est le plus petit entier k tel que ak ≡ 1 [r]. On notera alors k = ωr (a) Définition 3 (Définition de l’intropsection) Soit K un anneau, P ∈ K[X] et n, p, r ∈ N et p est premier. On dit que n est introspectif pour P si P (X)n ≡ P (X n ) [X r − 1, p] Définition 4 (Définition d’un polynôme cyclotomique) Soit n ∈ N∗ . On appelle n-ième polynôme cyclotomique, ou n Y polynôme de division du cercle en n parties égales, le produit Φ(n) = (X − ζ) où ζ décrit les racines primitives n-ièmes ζ de l’unité dans C. 7.2.2 Théorèmes admis Théorème 7 (Théorème sur la décomposition d’un Y polynôme cyclotomique) Φ(n) est un polynôme unitaire à coeffin Φd (X) cients entiers de degré ϕ(n). On a la relation : X − 1 = d|n Théorème 8 (Théorème sur la décomposition d’un polynôme cyclotomique) Soient p, r ∈ N, p premier et pgcd(p, r) = 1. Le polynôme cyclotomique Φ(r) se décompose dans Fp [X] en un produit de polynômes unitaires irréductibles distincts de même degré k = ωr (p) MARIN Sophie BOURDONNAY Jean-Ronan page 28 sur 52 Tests de primalité 7.2.3 7 AKS Théorème démontrés Théorème 9 (Théorème de Fermet étendu) n ∈ P ⇐⇒ (X + a)n ≡ X n + a [n] Preuve En utilisant la formule du binôme de Newton, on sait que (−1)i · X i · an−i a pour coeficient n n n! n = 1 = 1. On voudrait savoir à quoi est congru 0 < i < n, (n−i)!i! [n]. Cas 1 : n ∈ P et 0 < i < n n! Pour n est premier, on a (n−i)!i! ≡ n· n ∈ P. n−1! (n−i)!i! ≡ 0 [n], donc n i n i = n! (n−i)!i! . On sait que ≡ 0 [n]. De plus d’après le théorème de Fermat, an = a [n] car ∀n ∈ P, (X − a)n ≡ X n − a [n] Cas 2 : n ∈ / P et 0 < i < n On prend pgcd(i, n) = 1 et ik est la plus grande puissance qui divise n. Ceci implique que ik ne divise pas premier avec an−i . n i et aussi que ik est Ainsi on a démontré n ∈ P ⇐⇒ (X + a)n ≡ X n + a [n] Théorème 10 (Théorème sur l’encadrement du ppcm de n entiers) Soit n ∈ N, n > 9. Le plus petit commun multiple des n premiers entiers naturels non nuls est supérieur ou égal à 2n . On le note ∆n ≥ 2n La démonstration de ce théorème est la preuve 6 située en annexe. 7.3 Démonstration de la validité de l’algorithme Pour se convaincre de la validité de l’algorithme AKS, on va le décomposer en plusieurs étapes. Nous allons d’abord borner la taille de r afin de vérifier qu’il n’y ait pas trop d’itération dans l’étape 5. Ensuite nous verrons comment l’aplication de l’introspection, nous permet de définir deux sous-groupes importants. L’encadrement de l’un des deux nous permmettra de valider l’étape 5 de l’algorithme qui est l’étape fondamentale de ce dernier. 7.3.1 Encadrement de r Théorème 11 (Encadrement de r) Il existe un entier r ≤ ⌈16 · log(n)5 ⌉ tel que ωr (n) > 4log(n)2 Preuve Soient r1 , r2 , . . . , ra tous les nombres tels que ωri (n) ≤ 4 · log(n)2 . ⌊4·log(n)2 ⌋ Y (ni − 1). On va ensuite chercher à majorer ce produit. Si 1 ≤ i ≤ a, nωri (n) ≡ 1 [ri ], alors chacun des ri divise b = 2 i=1 ⌊4·log(n)2 ⌋ b < b < n· n · ...· n 2 n1+2+...+⌊4·log(n) ⌋ b < b < b < 2 n 2 2 n(⌊4·log(n) ⌋) 4 n⌊16·log(n) ⌋ (⌊4·log(n)2 ⌋)·(⌊4·log(n)2 ⌋+1) car x(x+1) 2 ≤ x2 5 La taille de n est de 2log(n) , donc b < 2⌊16·log(n) ⌋ . D’après le théorème 10, on sait que le ppcm des 16 · log(n)5 premiers nombres 5 entiers est au moins 2⌈16·log(n) ⌉ . Si tous les ri sont inférieurs à ⌈16 · log(n)5 ⌉, alors ils divisent tous b et ∆16·⌈log(n)5 ⌉] ≤ b, ce qui est impossible. Donc on en conclut qu’il existe un entier r ≤ ⌈16 · log(n)5 ⌉ tel que ωr (n) > 4log(n)2 MARIN Sophie BOURDONNAY Jean-Ronan page 29 sur 52 Tests de primalité 7.3.2 7 AKS Application de l’introspection On pose p diviseur premier de n. Pour que p ne soit ni Composé à l’étape 3, ni Premier à l’étape 4, il faut choisir p tel que p > r. On pose aussi l = ⌊2 · ϕ(r) · log(n)⌋ On a donc ∀a, 1 ≤ a ≤ l, (X + a)n ≡ X n + a [X r − 1, n]. Comme p|n, on obtient : (X + a)n ≡ X n + a [X r − 1, p], ce qui nous donne (X + a)p ≡ X p + a [X r − 1, p]. n a l’air de se comporter comme p qui est premier. On peut remarquer aussi que p et n sont introspectifs pour X + a avec a ∈ [1 . . . l]. On en déduit que tout nombre appartenant à l’ensemble I = {ni · pj /i, j ≥ 0} est introspectif pour tout polynôme Ql de l’ensemble P = { a=1 (X + a)αi /αi ≥ 0}. On va définir deux groupes. Le premier, qu’on appelle G, est l’ensemble des résidus des nombres de I modulo r. n est premier avec r et p est premier, donc p est premier avec r. De tout ceci, on en déduit que G est un sous-groupe de (Z/rZ)∗ et aussi que n et p y sont inversibles. Soit t le cardinal de G. Ce groupe est engendré par n [r] et p [r] et on sait aussi que ωr (n) > 4 · log(n)2 . Cela nous permet d’affirmer que t > 4 · log(n)2 . Pour déterminer le second groupe, on va avoir besoin de considérer Φr le r-ième polynôme cyclotomique sur Fp [X]. D’après le théorème 7 et le théorème 8, on peut dire que Φr divise X r − 1 et se factorise en facteurs irréductibles de degré ωr (p). On pose Q un facteur irréductible. Le second groupe que l’on notera H est l’ensemble des résidus non nuls des polynômes de P dans F [X] F = QFpp [X] . 7.3.3 Encadrement de H On va admettre le théorème ci-après : Théorème 12 (Théorème admis sur l’encadrement de H) Si n est une puissance entière alors le cardinal de H est majoré. t+l−2 |H| ≥ t−1 La preuve est faite dans l’article [Eli]. On va supposer ensuite que n n’est pas une puissance de p et que le cardinal de H est majoré. Ceci revient à démontrer le théorème suivant : Théorème 13 (Théorème démontré sur l’encadrement de H) Si n n’est pas une puissance de p alors |H| < 1 2√t ·n 2 √ Preuve Nous allons considérer le sous-ensemble J √ de I défini par : J = { ni · pj |0 ≤ i, j ≤ ⌊ t⌋ }. Si n n’est pas une puissance de p, alors J possède ( t + 1)2 > t nombres distincts. On a t = |G|, donc cela signifie qu’il y a au moins deux nombres dans J qui sont égaux à r. Si l’on note m1 > m2 ces deux nombres, on obtient X m1 ≡ X m2 [X r − 1, p]. Soit P ∈ P, alors P (X)m1 ≡ P (X m1 ) ≡ P (X m2 ) ≡ P (X)m2 [X r − 1, p]. Il en découle que P (X)m1 ≡ P (X)m2 dans le corps F . Ainsi, P (X) ∈ H est une racine du polynôme R(Y ) = Y m1 − Y m2 dans F . Comme P (X) est un élément de H, le polynôme √ ⌊ t⌋ , or R(Y ) possède au moins H racines distinctes dans F . Cependant, le degré de R(Y ) est m ≤ max(J ). max(J ) = (n · p) 1 √ p divise n et p 6= n donc p < 21 n, de ce fait on en déduit que m1 < 21 n2· t . De plus on a posé m1 > m2 , donc on a montré |H| < MARIN Sophie BOURDONNAY Jean-Ronan 1 2√t n 2 page 30 sur 52 Tests de primalité 7.3.4 7 AKS Théorème fondamental d’AKS Théorème 14 (Théorème fondamental d’AKS) L’algorithme retourne que n est Premier si, et seulement si, n est premier. Preuve Si n est premier, alors le premier et le troisième points de l’algorithme ne peuvent pas retourner que n est Composé. D’après le théorème 9, l’étape 5 ne peut aussi pas retourné que n est Composé. Réciproquement, on suppose que l’algorithme retourne que n est Premier, d’après le théorème 12 avec t = |G| et l = ⌊2ϕ(r) · log(n)⌋, on obtient, t+l−2 |H| ≥ t−1 √ t > 4 · log(n)2 donc t > 2 t · log(n) ce qui nous amène : √ ⌊2 t · log(n)⌋ + l − 1 √ |H| ≥ ⌊2 t · log(n)⌋ p √ De plus l = ⌊2 ϕ(r) · log(n)⌋ ≥ ⌊2 t · log(n)⌋ donc √ 2⌊2 t · log(n)⌋ − 1 √ |H| ≥ ⌊2 t · log(n)⌋ √ Or d’après le théorème 10, on a 2 t · log(n) ≥ 3, |H| |H| |H| |H| ≥ ≥ ≥ ≥ √ 2⌊2 t·log(n)⌋ √ 2 t ) 2log(n √ n2 t √ 1 2 t 2 ·n √ D’après le théorème 13, |H| < 21 n2 t quand n n’est pas une puissance de p. On en déduit donc qu’il existe k > 0 tel que n = p · k. Or si k > 1, l’algorithme aurait alors retourné que n est Composé au moment de la première étape. Ainsi, on a k = 1 et n = p. Donc n est bien premier. MARIN Sophie BOURDONNAY Jean-Ronan page 31 sur 52 Tests de primalité 7.4 7.4.1 7 AKS Algorithmes Détection des puissances d’un nombre premier La méthode de Newton consiste à chercher une bonne appromixation de la fonction f (x) qui est dans notre cas le polynôme X α − a. Ensuite on pose que f (x) = f (x0 ) + (x − x0 )f ′ (x0 ), c’est à dire qu’on va approcher la fonction par sa tangente. Pour trouver un zéro de cette fonction, on va calculer 0 = f (x0 ) + (x − x0 )f ′ (x0 ) On va obtenir un point x1 qui sera plus proche du k) zéro chercher. La suite des xk est définie par xk+1 = xk − ff′(x (xk ) . f (xk ) f ′ (xk ) xα −a xk − α·xk α−1 k xk · (1 − α1 ) xk+1 = xk − xk+1 = xk+1 = − a α·xα−1 k Cette dernière expression est plus pratique à utiliser pour le calcul. On prendre comme borne ε = 0.01, c’est à dire qu’on considèra le zéro atteint quand on aura f (xn+1 − ε) < 0 et f (xn − ε) > 0. La fonction X α − a est continue sur R, donc continu sur cet intervalle , donc d’après le théorème des valeurs intermédiaires, x0 est entre xn+1 − ε et xn − ε. On fait cette recherche, seulement sur les entiers entre ces deux valeurs. Figure 19: Exemple de la méthode de newton Algorithme 11 Newton tant que f (xn+1 − ε) < 0 faire xn+1 ← xn n) xn − ff′(x (xn ) ← xn+1 fin tant que La suite utilisée converge de façon quadratique, la méthode est donc assez rapide. De plus cet algorithme ne coûte presque rien en terme de temps d’exécution par rapport l’étape 5. MARIN Sophie BOURDONNAY Jean-Ronan page 32 sur 52 Tests de primalité 7.4.2 7 AKS Construction de r Pour construire r rapidement, on va tester les entiers à partir de la borne (⌈4 · log(n)2 ⌉) jusqu’à qu’on en trouve un qui vérifie na [r] = 1. Algorithme 12 Construction du r a ← borne stop ← f aux tant que stop est f aux faire si nr [r] = 1 alors stop ← vrai sinon r ←r+1 fin si fin tant que Calcul de la complexité théorique C = O( borne · O(modPow(n, n)) ) C = O( 8 · log(n)2 · n3 ) 7.4.3 Algorithme AKS Algorithme 13 Algorithme AKS Etape 1 : Newton si n = ab alors retourne Composé fin si Etape 2 : Construction de r r ← Construction_r() Etape 3 si a ≤ r, 1 < pgcd(a, n) < n alors retourne Composé fin si Etape 4 si n ≤ r alors retourne Premier fin si Etape 5 : Polynômes a←1 p tant que a ≤ 2 · ⌊ φ(r) · log(n)⌋ faire si (X + a)n 6≡ X n + a [n, X r − 1] alors retourne Composé fin si fin tant que Etape 6 retourne Premier MARIN Sophie BOURDONNAY Jean-Ronan page 33 sur 52 Tests de primalité 7.5 7 AKS Pour conclure sur cet algorithme Nous n’avons pas calculé la complexité théorique, car il aurait fallu qu’on essaye de calculer avant la complexité de toutes les opérations de polynômes que nous avons implémenté. Nous avons pas cherché à optimiser nos algorithmes de calculs. Nous représentons les polynômes à l’aide d’une map qui est un couple (clé, valeur). La clé représente la puissance et la valeur le coefficient. Notre implémentation d’AKS est très lente à cause de nos opérations sur les polynômes. Si nos fonctions sur les polynômes étaient mieux faites, l’algorithme irait plus vite à l’étape 5. Complexite Pratique 3e+06 × × 2.5e+06 2e+06 Temps1.5e+06 en ms 1e+06 500000 × ×××××× 0 0 1 2 3 4 5 6 7 8 9 101112 Taille en bits Figure 20: Algorithme AKS : Courbe représentative du temps d’exécution pratique en fonction du nombre de bits On a exécuté l’algorithme pour un nombre de 1024 bits sans rentrer dans la boucle de l’étape 5 qui fait exploser assez vite le chromomètre, ni passer par l’étape 1, pour afin de remarquer qu’il n’y a pas un nombre trop grand d’itération dans l’étape 5 par rapport à l’entier en testé et que les étapes lourdes de l’algorithme sont la 1 et la 5. Figure 21: Algorithme AKS : Impression d’écran MARIN Sophie BOURDONNAY Jean-Ronan page 34 sur 52 Tests de primalité 8 8 RÉPARTITION DES NOMBRES PREMIERS Répartition des nombres premiers Cette partie est inspiré d’un sujet de CAPES de 2008, sur les inégalités de Tchébychev. Cela va nous permettre de répondre à la question "Connaissant un entier n, combien y-a-t-il d’entier premiers entre 2 et n? Cette question est importante, cela dimensionne la sécurité d’un cryptosystème basé sur RSA, il est intéressant de connaitre le cardinal de cet ensemble. Dans la suite on notera π(n) le cardinal de cet ensemble. L’objectif de ce qui suit est de vous permettre d’etablir l’encadrement de π(n) : n n ln(2) ≤ π(n) ≤ e ln(n) ln(n) Rappel : le plus petit commun multiple des entiers inférieurs ou égaux à n est noté ∆n Les numéros entre parenthèses indiquent que l’énoncé est démontré en annexes. Théorème n 2n n et 2n + 1 2n n divisent ∆2n+1 À l’aide de ce théorème, on déduire que n · (2n + 1) 2n n divise ∆2n+1 . (1) On s’intéresse à la progression des coefficients binominaux et on arrive cette inégalité ∀k ≤ 2n, 2n ≤ 2n (preuve 2). Elle k n n est majorée par (1 + 1)2n (3). De cette majoration, on en déduire que (2n + 1) 2n ≥ 4 (4). Cette inéquation nous permet n d’affirmer que ∆2n+1 ≥ n · 4n .(5), mais elle nous ammène aussi à conclure que n ≥ 9, ∆n ≥ 2n (6). On va maintenant utiliser la notion de valuation p-adique d’un nombre n notée vp (n) De cette définition, on peut remarquer ∀n ∈ N, ∀p ∈ P, n ≥ pvp (∆n ) .(7), mais également que n = Y pvp (n) (8). p∈P, p≤n L’égalité précedente nous permet de déduire que ∆n ≤ nπ(n) (9). Ce dernier encadrement permet de déduire la minoration proposée ci-dessus pour π(n). La minoration établie précédement est utile car elle permet de s’assurer que pour une valuer de n fixée, on aura au moins un certain nombre de nombres premiers. Afin de compléter l’analyse Ydu comportement de π(n), il nous faut maintenant proposer une majoration. On va démontrer l’encadrement suivant : p ≤ 4n p∈P,p≤n Pour le prouver, on remarque que ∀a, b ∈ N, 0 < b 2 Y ≤ a < b, p divise a (10). De ce résultat, on montre ensuite que b p∈P, a<p≤b 2m + 1 ∀m ∈ N∗ , p divise (11). m+1 p∈P, m+1<p≤2m+1 2m+1 En remarquant que 2m+1 , et en utilisant le fait que ∀k ∈ {1, . . . , 2m+1}, 2m+1 > 0, on montre que m+1 = m k Y m ∗ À l’aide des résultats précédents, on obtient que ∀m ∈ N , p ≥ 4 (13) Y 2m+1 m ≤ 4m (12). p∈P, m+1<p≤2m+1 ∗ On va maintenant prouver par récurrence que ∀n ∈ N , n = 1, Y p∈P, p≤2n Y p∈P, p≤2n p ≤ 4n n p = 2 et 4 = 4, on a bien 2 ≤ 4. On suppose maintenant que la propriété est vraie au rang n. A fortiori, ∀k ∈ {1, . . . , 2n}, Considérons maintenant le produit Y p, on peut écrire : p∈P, p≤2n+1 Y p∈P, p≤2n+1 Puisque n ≥ 1, n + 1 < 2n, ainsi, par hypothèse de récurrence, on obtient : Et d’après les résultats précedement démontré, on a : Y p∈P, n+1<p≤2n+1 MARIN Sophie BOURDONNAY Jean-Ronan p= Y p∈P, p≤n+1 p ≤ 4n . p× Y p∈P, p≤k p∈P, p≤n+1 Y Y p p∈P, n+1<p≤2n+1 p ≤ 4n+1 . p ≤ 4n page 35 sur 52 Tests de primalité 8 RÉPARTITION DES NOMBRES PREMIERS Y On peut donc conclure que p∈P, p≤2n+1 p ≤ 4n+1 × 4n = 42n+1 Afin d’achever la preuve, il faut montrer que Y p∈P, p≤2n+2 Ceci repose sur le fait que Y p= p∈P, p≤2n+1 premiers dans ces deux produits. A l’aide de ce résultat et de cette inégalité p ≤ 42n+2 . Y p. En effet, 2n + 2 est pair donc il y a bien le même nombre de nombres Y p ≤ 42n+1 , on conclut que p∈P, p≤2n+2 p∈P, p≤2n+1 Y p∈P, p≤2n+1 p ≤ 42n+2 . En conclusion, on a prouvé que : ∀n ∈ N∗ , Y p∈P, p≤2n p ≤ 4n On va maintenant s’intéresser à la fonction exponentielle, par définition, on a ∀x ∈ R, ez = +∞ i X z i=0 i! . m (14). On peut déduire que m! > ( m e ) En remarquant que ∀i ∈ {1, . . . , n}, pi > i, on montre que π(n)! ≤ 4n . (15). Ceci nous permet d’arriver à l’inégalité suivante : π(n) · ln(π(n)) − π(n) ≤ n · ln(4) (16) Cette inégalité fait apparaître la fonction f : x 7−→ x · ln(x) − x En montrant que f est strictement croissante sur l’intervalle [1; +∞[ (18), on arrive à ce résultat : ∀n ≥ 3, e−ln(4) e < ln(ln(n)) ln(n) (19). est majorée par e−1 et en supposant qu’il existe En utilisant le fait que la fonction h est définie sur ]0, +∞[ par h(x) = ln(x) x n m m ∈ N, m ≥ 3 tel que π(m) > e· ln(m) , on a arrive à une contradiction. Ceci permet de conclure que n ∈ N, n > 2, π(n) ≤ e· ln(n) (20) Ainsi, on a obtenu une majoration de π(n). Finalement, si on reprend la majoration et la minoration démontrées, on a obtenu l’encadrement suivant de π(n) : n n ln(2) · ≤ π(n) ≤ e · ln(n) ln(n) MARIN Sophie BOURDONNAY Jean-Ronan page 36 sur 52 Tests de primalité 9 9 CONCLUSION Conclusion 9.1 Comparaison des tests Nous avons traité différents types de tests pouvant servir à tester la primalité d’un nombre. On va les séparer en trois grandes catégories, les cribles, les test déterministes, et les test probabilistes. 9.1.1 Cribles Les cribles sont un cas particuliers des tests de primalités déterministe. On a implémenté deux cribles celui d’Eratosthène et de Sundaram. Leurs points commun est leur important besoin de mémoire pour s’exécuter. Par contre ce qui est assez intéréssant c’est que l’on obtient tous les nombres premiers inférieurs au nombre testé. En termes de complexité du nombres de calculs nécessaires ils ne sont pas si performants par rapport aux algorithmes probabilistes et à certains déterministes. Sundaram a voulu améliorer le cribles d’Eratosthène, ce qu’il fait en regardant uniquement les nombres impairs, mais le calcul d’un produit de deux nombres impairs grands demande beaucoup de ressources. 9.1.2 Probabilistes La force des algorithmes probabiliste est leur rapidité, mais en contre-partie le résultat retourné n’est pas totalement sûr. Pour augmenter la probabilité de réussite il faut augmenter le nombre de tests que l’on fait, d’où l’intérêt de parallèliser ces tests. Notre implémentation de Rabin et Miller en version threadé est très satisfaisante. On arrive à montrer qu’un nombre de 800 bits est premier avec une probabilité d’échouer de 415 en moins de 5 ms. Ce test est très pratique dans l’application d’algorithmes cryptographiques si on n’a pas besoin sûr à 100 % la primalité des nombres employés. 9.1.3 Déterministes Les tests déterministes sont les tests idéaux. Ils renvoient toujours la bonne réponses. Le problème c’est qu’avant l’algorithme AKS, les tests déterministes ne s’exécutaient pas en temps polynômial ce qui ne permettait pas de vérifier la primalité des grands nombres rapidement. De plus même AKS est relativement lent. On le voit bien avec l’algorithme de Wilson, ou les cribles. Que ce soit le temps d’exécution ou la forte demande de mémoire, il y avait toujours quelque chose qui restreignait leur utilisation. À l’heure actuelle, la question des ressources se posent moins que dans les années 1970 - 1980, car la vitesse de calcul dont on dispose augmente très rapidement. C’est pour cela que les algorithmes probabilistes ont tenu une place très importantes dans ce domaine et les auteurs ont été récompensé. L’algorithme de Wilson demande une masse de calcul trop importante tout comme les cribles qui eux sont en plus gourmands en mémoire. C’est pour cela que ces types de tests ont été abandonné pour une utilisation pratique, car quelque soit les progrès de calculs qu’on puisse faire, ils resteront très lourd. L’algorithme AKS peut être sûrement amélioré à l’aide des fonctions sur les polynômes optimisées. On pourait se demander si cela en vaut la peine car les algorithmes probabilistes comme Rabin et Miller peut renvoyé un résultat avec une probabilité d’erreur qui tend vers 0, avec un nombre itération assez grand. MARIN Sophie BOURDONNAY Jean-Ronan page 37 sur 52 Tests de primalité 9 CONCLUSION Algorithme Type Complexité Wilson Déterministe O(2n+1 · n2 ) Crible d’Erathostène Déterministe O( 2 2 · n ) Crible de Sundaram Déterministe O( n2 · 2 2 ·n−1 ) Fermat Probabiliste O( 2 · n3 ) Rabin Miller Probabiliste O( 20 · n3 ) AKS Déterministe Non calculé n 3 Tableau 3: Récapitulatif des algorithmes présentés 9.2 Programmation JAVA Ce projet nous a permis d’avoir une expérience en JAVA, qui est un langage que nous avons peu utilisé dans notre scolarité. JAVA est un langage orienté objet, cela nous a facilité la modélisation de notre projet. Ce langage est multi-plateforme, ce qui fait qu’il est très utilisé. Cependant la gestion de la mémoire étant gérée par le langage, cela nous pose parfois problème avec des grands nombres qui prennent beaucoup de place. 9.3 Partie Théorique Toute la partie mathématiques du projet, nous a posé certaines difficultés, surement dû à notre manque de pratique de ce genre de démontration. De plus nous avons été très peu confronté au calcul de complexité. Cela nous a permis de mieux réfléchir à notre implémentation. 9.4 Perspectives On aurait pu déterminer les facteurs des nombres composés. Cela était possible pour l’algorithme de Wilson et le crible d’Erathostène. Les fonctions sur les polynômes auraient demandé un peu plus de travail pour les optimiser. MARIN Sophie BOURDONNAY Jean-Ronan page 38 sur 52 Tests de primalité 10 10.1 10 ANNEXES Annexes Complexité On pose n la taille de entier p Opérations multiply() mod() modPow(p,p) Complexité O(n2 ) O(n2 ) O(2 · n3 ) Tableau 4: Complexité théorique des opérations de BigInteger 10.2 Démonstrations Preuve 1 ( n(2n + 1) 2n n divisent ∆2n+1 ) Vérifions que n et 2n + 1 sont premiers entre eux. On pose d1 un diviseur commun à n et à 2n + 1. On peut donc écrire n = a · d1 et 2n + 1 = b · d1 . De plus 2n + 1 − 2n = 1 donc on obtient b · d1 − 2a · d1 = 1, autrement dit d1 (b − 2a) = 1. Cette égalité nous permet de dire que d1 est un diviseur de 1. Or les seuls diviseurs de 1 sont 1 et -1. On en déduit que le pgcd(n , 2n + 1) = 1, donc n et 2n + 1 sont premiers entre eux. 2n On sait que n 2n n et 2n + 1 n divisent ∆2n+1 . 2n 2n Il existe d2 tel qu’on puisse écrire ∆2n+1 = d2 · (n 2n n ), comme 2n + 1 n divise ∆2n+1 et ∆2n+1 = d2 · (n n ), on en déduit 2n que 2n + 1 2n n divise d2 · (n n ), c’est à dire 2n + 1 divise d2 · n. En résumé, on a 2n + 1 divise d2 · n et le pgcd(n , 2n + 1) = 1, donc, d’après le théorème de Gauss, 2n + 1 divise d2 c’est à dire qu’il existe d2 = d3 · (2n + 1) . On a ∆2n+1 = d2 · (n 2n n ) et d2 = d3 · (2n + 1) donc ∆2n+1 = d3 · (2n + 1) · n 2n . n On a bien démontré que 2n n(2n + 1) , divisent ∆2n+1 n Preuve 2 (∀k ≤ 2n, 2n k 2n ) n (2n)! (2n−k)!k! ≤ On va démontrer plutôt que Cas 1 : k = n 2n On a directement 2n k = n Cas 2 : 0 ≤ k < n On va démontrer cette inégalité : On peut écrire : n! k! (2n)! 2n k = (2n−k)!k! (2n)! ≤ (n!) 2 , autrement ≤ (2n−k)! k! et 2n n = (2n)! (2n−n)!n! = (2n)! (n!)2 dit (n!)2 ≤ (2n − k)!k! ou encore n! k! ≤ (2n−k)! k! On peut écrire k < 2n − n ce qui donne n < 2n − k. 2n−k! n! = 1×...×n×(n+1)×...×(2n−k) 1×...×n = (n + 1) × . . . × (2n − k) n! k! = 1×...×k×(k+1)×...×(n) 1×...×k = (k + 1) × . . . × n Ces deux produits contiennent n − k − 1 d’éléments. On va donc les comparer termes à termes. Soit k < n, on a (k + 1) < (n + 1) si la relation d’ordre des premiers termes nous renseigne sur les relations d’ordre suivante car ce sont le produit de deux suites (2n−k)! , donc de nombres croissantes, on peut donc en conclure (k + 1) × . . . × n < (n + 1) × . . . × (2n − k). On a 0 ≤ k < n, n! k! ≤ k! 2n 2n 0 ≤ k < n, ≤ k n MARIN Sophie BOURDONNAY Jean-Ronan page 39 sur 52 Tests de primalité 10 ANNEXES Cas 3 : n ≤ k < 2n On peut que 2n − n ≤ k ou que 2n − k ≤ n. aussi écrire (2n)! 2n = k (k!)(2n−k)! (2n)! 2n = (2n−k)!(k)! 2n−k 2n Donc 2n k = 2n−k , de plus d’après le résultat du cas 1 n < 2n − k et 0 ≤ k < n, n + 1 ≤ k < 2n, 2n 2n ≤ k n ∀k ∈ N, k < 2n, 2n 2n ≤ k n Ainsi nous avons démontré : Preuve 3 ( 2n n ≤ 2n 2n−k , on en déduit que ≤ (1 + 1)2n ) À l’aide de la formule du binôme de Newton on obtient : 2n (1 + 1) = 2n X 2n k k=0 On en déduit 2n k 2n n ≤ 2n X 2n k=0 k ·1 2n−k k ·1 = 2n X 2n k=0 k . Donc on a bien : 2n ∀n ∈ N , ≤ (1 + 1)2n n ∗ 2n contient 2n + 1. Tous les éléments de la somme k 2n X 2n 2n sont inférieur ou égale à 2n . On peut donc écrire que : (2n + 1) ≥ . On déduit donc de ceci : n n k Preuve 4 ((2n + 1) 2n n ≥ 4n ) On a (1 + 1)2n = 4n et on sait que 2n k=0 k=0 2n ∗ ∀n ∈ N , (2n + 1) ≥ 4n n n Preuve 5 (∆2n+1 ≥ n · 4n ) D’après le résultat précedent, on a n(2n + 1) 2n n ≥ n · 4 . Or on sait que n(2n + 1) ∆2n+1 donc 2n ∗ ∀n ∈ N , ∆2n+1 ≥ n(2n + 1) n 2n n divise Preuve 6 ( n ≥ 9, ∆n ≥ 2n ) On va avoir deux cas : Cas 1 : n impair, n = 2m + 1 On a alors ∆2m+1 ≥ m · 4m . On va chercher une solution à l’inégalité suivante m · 4m ≥ 22m+1 . Elle est équivalente à m2m ≥ 22m , donc si m ≥ 2 alors n ≥ 5. n est impair , n ≥ 5 =⇒ ∆n ≥ 2n Cas 2 : n pair, n = 2m + 2 On a alors ∆2m+2 ≥ m · 4m On va chercher une solution à l’inégalité suivante m · 22m ≥ 22m+2 . Elle est équivalente à m ≥ 4, donc si m ≥ 4 alors n ≥ 10. n est pair , n ≥ 10 =⇒ ∆n ≥ 2n MARIN Sophie BOURDONNAY Jean-Ronan page 40 sur 52 Tests de primalité 10 ANNEXES Ainsi on a démontré ∀n ∈ N, n ≥ 9 =⇒ ∆n ≥ 2n Preuve 7 (∀n ∈ N, ∀p ∈ P, n ≥ pvp (∆n ) ) On va maintenant utiliser la notion de valuation p-adique d’un nombre entier n k notée vp (n). Par définition, ∀p ∈ P, vp (n) = max{k Y∈ N, p |n} De cette définition, on peut remarquer que : n = pvp (n) . vp (∆n ) est un élément de l’ensemble {k ∈ N, pk |n} ce qui veut dire p∈P qu’il existe un entier i ∈ {1, . . . , n} tel que vp (∆n ) = vp (i). Y Y On peut donc écrire d’après la définition précédente que k = pvp (k) . On obtient pvp (k) ≤ n. p∈P p∈P Or comme vp (k) = vp (∆n ). On peut conclure que ∀n ∈ N, ∀p ∈ P, n ≥ pvp (∆n ) Q Preuve 8 (∆n = p≤n pvp (∆n ) ) On souhaite montrer que, dans cette décomposition, les seuls nombres premiers p qui interviennent sont tels que p ≤ n. On va raisonner par l’absurde en supposant qu’il existe un nombre premier p1 ∈ P tel que p1 > n ≥ 1 et vp1 (∆n ) ≥ 1. On a vu précédement que pour tout p ∈ P, il existe un entier k ∈ {1, . . . , n} tel que vp (∆n ) = vp (k) et qu’on a : Y k= pvp (k) ≥ pvp (k) p∈P Dans le cas où p = p1 , il existe un entier k1 ∈ {1, . . . , n} tel que vp1 (∆n ) = vp1 (k1 ) et qu’on a : Y k1 = pvp (k1 ) ≥ p1 vp1 (k1 ) p∈P Par hypothèse, vp1 (∆n ) ≥ 1, et p1 > 1, donc on a p1 vp1 (k1 ) ≥ p1 . Ceci implique que k1 ≥ p1 . Nous avons considéré au départ que p1 > n, donc k1 > n. Or k1 ∈ {1, . . . , n}, on obtient donc une contradiction. L’hypothèse p > n ≥ 1 est fausse. On peut donc en conclure que la décomposition en facteurs premiers de ∆n s’écrit sous la forme Y ∆n = pvp (∆n ) p≤n MARIN Sophie BOURDONNAY Jean-Ronan page 41 sur 52 Tests de primalité 10 ANNEXES Preuve 9 (∆n ≤ nπ(n) ) Pour tout entier n ≥ 0, on note π(n) le nombre de nombres premiers compris dans l’ensemble {0, . . . , n}. Y Y Nous avons vu précédement que si p ∈ P , alors pvp (∆n ) ≤ n. Nous allons donc écrire l’inégalité pvp (∆n ) ≤ n. p≤n De plus, on sait que ∆n = Y pvp (∆n ) et p≤n Y p≤n n = nπ(n) , donc on peut dire que p≤n ∀n ≥ 1, ∆n ≤ nπ(n) Q a b Preuve 10 (∀a, b ∈ N, 0 < 2b ≤ a < b, p∈P, a<p≤b p divise b ) Soient a, b ∈ N tels que 0 < 2 ≤ a < b. Y Le produit p contient autant de facteurs qu’il y a de nombres premiers compris dans l’ensemble {a + 1, ..., b} et tous les a<p≤b facteurs p sont des nombres premiers. Ce produit divise b a , si tous ses facteurs premiers divisent l’entier Nous devons alors montrer que pour tout nombre premier p dans l’ensemble {a + 1, ..., b}, p divise l’entier On prend un p premier quelconque dans l’ensemble {a + 1, ..., b}. De plus, on a que b (b − a)! = (a + 1) × . . . × b a b a b! (b−a)!a! = = (a+1)×...×b (b−a)! b a . b a . donc, on en conclut Le produit (a + 1) × . . . × b contient tout les nombres de l’ensemble {a + 1, ..., b}. Parmis ces nombres, on trouve p, donc p divise (b − a)! ab (b − a)! est le produit de tous les nombres allant de 1 jusqu’à (b − a). Par hypothèse, a et b sont deux entiers tels que 2b ≤ a < b ce qui nous donne b ≤ 2a < 2b ou b − a ≤ a < 2b − a. Cela implique que tous les facteurs de (b − a)! sont inférieurs ou égale à a. Or p ∈ {a + 1, ..., b}, donc p divise aucun des facteurs de (b − a)!. En résumé, on a p et (b − a)! premiers entre eux et p diviseur de (b − a)! ab , donc on peut conclure que : Y a p divise b a<p≤b Q 2m+1 Preuve 11 (∀m ∈ N∗ , ) On pose pour tout entier m ≥ 1, a = m + 1 et b = 2m + 1. p∈P, m+1<p≤2m+1 p divise m+1 Ceci nous permet d’appliquer le résultat précédent, et on obtient directement Y 2m + 1 p divise m+1 p∈P, m+1<p≤2m+1 Preuve 12 ( 2m+1 m ≤ 4m ) En applicant la formule du binôme de Newton, on obtient , (1 + 1)2m+1 = 2m+1 X k=0 2m+1 = 2m+1 m+1 = m (2m+1)! (2m+1−m)!m! (2m+1)! (2m+1−m−1)!(m+1)! MARIN Sophie BOURDONNAY Jean-Ronan = = m 2m+1 X 2m + 1 2m + 1 2m+1−k k X 2m + 1 1 1 = + k k k (2m+1)! (m+1)!m! (2m+1)! m!(m+1)! k=0 Donc on a ∀m ≥ 1, k=m+1 2m+1 m = 2m+1 m+1 page 42 sur 52 Tests de primalité 10 ANNEXES On a aussi les égalités suivants de coefficients binomiaux : 2m+1 0 = 2m+1 2m+1−0 = 2m+1 2m+1 2m+1 1 = 2m+1 2m+1−1 = 2m+1 2m .. . = .. . = .. . = 2m+1 2m+1−m = 2m+1 m+1 2m+1 m On va maintenant faire la somme terme à terme de chaque égalité, ce qui nous donne : 2m+1 0 + ...+ 2m+1 m m X 2m + 1 ⇐⇒ ⇐⇒ ⇐⇒ m X 2m + 1 = 2· m X 2m + 1 = k 2m+1 2m+1 2m+1 X 2m + 1 k m X 2m + 1 + 2m+1 X k k=0 k k=0 + ...+ k=m+1 2· k=0 = k k=0 2m+1 m+1 = k=m+1 2m + 1 k (1 + 1)2m+1 De plus, (1 + 1)2m+1 = (2)2m+1 = 2 · (2)2m = 2 · 4m . On va remplacer (1 + 1)2m+1 par 2 · 4m puis simplifier, on obtient : m X 2m + 1 k k=0 = 4m Si la somme est égale à 4m alors chaque terme est inférieur à 4m On peut conclure ∀m ≥ 1, Preuve 13 (∀m ∈ N∗ , Ceci implique que Q p∈P, m+1<p≤2m+1 Y m+1<p≤2m+1 p≤ 2m + 1 k ≤ 4m Y p ≥ 4n ) On a montré que 2m + 1 , et aussi m+1 Donc d’après le résultat précédent, on a ∀m ∈ N∗ , )m ) ∀x ∈ R, ez = Preuve 14 (m! > ( m e Y m+1<p≤2m+1 Y m+1<p≤2m+1 2m + 1 p≤ . m p∈P, m+1<p≤2m+1 p divise 2m+1 m+1 . p ≥ 4n +∞ i X z i! i=0 C’est la somme d’une série entière à termes strictement positifs. Soit un entierm tel que m ≥ 1 . Tous les termes de cette somme m sont strictement inférieurs à exp(x), en particulier le terme xm! em > MARIN Sophie BOURDONNAY Jean-Ronan m mm ⇐⇒ m! > ( )m m! e page 43 sur 52 Tests de primalité 10 ANNEXES Donc on a bien, m! > ( m m ) e Preuve 15 (π(n)! ≤ 4n ) Soit n ≥ 2 un entier. Vérifions, pour répondre à cette question, que l’on a π(n)! ≤ Y p p≤n Pour tout entier n ≥ 0, on rappele que π(n) est le nombre de nombres premiers compris dans l’ensemble {0, . . . , n}. Notons p1 , . . . , pπ(n) les nombres premiers compris dans l’ensemble {0, . . . , n} tels que p1 < . . . < pπ(n) et p1 = 2, p2 = 3, p3 = 5, de sorte que le produit de l’inégalité à vérifier s’écrive sous la forme : Y p = p1 × . . . × pπ(n) p≤n Nous allons démontrer par récurrence que pour tout entier k ≥ 1, on a l’inégalité k ≤ pk . On va considérer la propriété Pk , définie pour k ≥ 1 par Pk , k ≤ pk . Initialisation : pour k = 1, on a pk = p1 = 2 et 1 ≤ 2, la propriété P1 et vraie. Hérédité : Supposons que, pour un certain n ≥ 1, la propriété Pn soit vraie. Montrons qu’alors la propriété Pn+1 le soit aussi. La suite d’entiers (pi ) est strictement croissante : pn+1 − pn > 0 ou encore pn+1 − pn ≥ 1, mais aussi pn+1 ≥ 1 + pn . De plus on a par hypothèse de récurrence pn + 1 ≥ n + 1, on a pn+1 ≥ n + 1. Pour conclure : On a vérifié que P1 et que l’implication Pn =⇒ Pn+1 soient vraies. Donc la propriété Pk est vrai pour tout k ≥ 1. Donc en multiplicant membre à membre, on obtient : 1 × . . . × π(n) ≤ p1 × . . . × pπ(n) . Nous avons démontré précédement ∀n ≥ 1, Y p≤n p ≤ 4n Donc nous avons bien montré que π(n)! ≤ 4n Preuve 16 (π(n) · ln(π(n)) − π(n) ≤ n · ln(4)) En prenant le cas où m = π(n) ≥ 1, l’inégalité devient vrai pour tout entier m ≥ 1, ainsi que le résultat précédent, donc on a : m! > ( m m π(n) π(n) ) =⇒ 4n ≥ π(n)! > ( ) e e π(n) ln(( π(n) ) ≤ ln(4n ) e ) Or ln(e) = 1 donc on a : ⇐⇒ π(n) · ln( π(n) e ) ≤ n · ln(4) ⇐⇒ π(n) · [ln(π(n)) − ln(e)] ≤ n · ln(4) π(n) · ln(π(n)) − π(n) ≤ n · ln(4) Preuve 17 (f est strictement croissante sur l’intervalle [1; +∞[) f est dérivable sur ]0, +∞[, et pour tout réel x > 0 f ′ (x) = ln(x) + x · MARIN Sophie BOURDONNAY Jean-Ronan 1 − 1 = ln(x) x page 44 sur 52 Tests de primalité 10 ANNEXES Or, pour tout réel x ≤ 1, ln(x) ≤ 0. D’où f est strictement croissante sur l′ intervalle [1; +∞[ Preuve 18 (∀n ≥ 3, e−ln(4) < e sur ]1, +∞[, pour tout réel x > 1 ln(ln(n)) ) ln(n) On va considérer la fonction g, définie sur ]1, +∞[, par g(x) = g ′ (x) = ln(x) − x · (ln(x))2 1 x = x ln(x) . g est dérivable ln(x) − 1 (ln(x))2 Or ln(x) − 1 > 0 lorsque ln(x) > 1, c’est-à-dire lorsque x > e. g ′ etant du signe de ln(x) − 1, si x ∈]e, +∞[, alors g ′ (x) > 0 et donc g est strictement croissante sur ]e, +∞[ On va prendre n ≥ 3 > e, pour que g soit strictement croissance sur ]e, +∞[. n0 n0 3 3 > ln(3) ⇐⇒ e · ln(n > e · ln(3) ≃ 7, 42 g(n0 ) > g(3) ⇐⇒ ln(n 0) 0) n0 n0 ∈ [1, +∞[. On suppose que e · ln(n < π(n0 ). Cela signifie que e · ln(n 0) 0) On sait que f est strictement croissante sur ]1, +∞[, on peut donc écrire : f (e · n0 n0 n0 n0 ) < f (π(n0 )) ⇐⇒ e · · ln(e · −e· < π(n0 ) · ln(π(n0 )) − π(n0 ) ln(n0 ) ln(n0 ) ln(n0 ) ln(n0 ) Or on a démontré l’inégalité, pour tout entier n ≥ 2, π(n)! ≤ 4n , ceci nous permet d’arriver à l’implication suivante : π(n) · ln(π(n)) − π(n) ≤ n · ln(4) =⇒ π(n0 ) · ln(π(n0 )) − π(n0 ) ≤ n0 · ln(4) e· n0 ln(n0 ) · (ln(e) + ln(n0 ) − ln(ln(n0 ))) − e · ⇐⇒ e ln(n0 ) · (1 + ln(n0 ) − ln(ln(n0 ))) − ⇐⇒ e ln(n0 ) +e· ⇐⇒ e − e · ⇐⇒ e−ln(4) e ln(n0 ) ln(n0 ) ln(ln(n0 )) ln(n0 ) < −e· ln(ln(n0 )) ln(n0 ) − e ln(n0 ) e ln(n0 ) n0 ln(n0 ) < n0 ln(4) < ln(4) < ln(4) < ln(4) ln(ln(n0 )) ln(n0 ) Donc on a bien : ∀n ≥ 3, e − ln(4) ln(ln(n)) < e ln(n) Preuve 19 (h est majorée par e−1 ) h est dérivable sur ]0, +∞[ : h′ (x) = 1 x − ln(x) × 1 1 − ln(x) = x2 x2 h′ est du signe de 1 − ln(x). On a 1 − ln(x) > 0 quand 1 > ln(x) ou encore e > x. Donc x ∈ [1, e[, h′ (x) > 0 x = e, h′ (x) = 0 x ∈ [e, +∞[, h′ (x) < 0 Ceci nous indique que h croit de 1 à e pour décroitre de e à +∞, donc la fonction atteint son maximun en e. h(e) = MARIN Sophie BOURDONNAY Jean-Ronan ln(e) = e−1 e page 45 sur 52 Tests de primalité 10 ANNEXES On peut donc dire : h est majorée par e−1 sur [1, +∞[ Preuve 20 (n ∈ N, n > 2, π(n) ≤ e · n ) ln(n) Pour tout réel x ≥ 1, on a h(x) ≤ e−1 . Puisque ln(n0 ) ≥ 1, on peut écrire : h(x) ≤ e−1 ⇐⇒ 1 1 ln(ln(n0 )) ln(x) ≤ ≤ ⇐⇒ x e n0 e On utilise ensuite le résultat précédent, on a les l’inégalités suivantes : e − ln(4) 1 ln(ln(n0 )) < ⇐⇒ e − ln(4) < 1 ⇐⇒ e < ln(4) + 1 < e n0 e Or e ≃ 2, 72 et ln(4) + 1 ≃ 2, 39, on obtient une contradiction. Ceci permet donc de conclure que : ∀n ∈ N, n > 2, π(n) ≤ e · MARIN Sophie BOURDONNAY Jean-Ronan n ln(n) page 46 sur 52 Liste des théorèmes, définitions et preuves 1 2 3 1 4 5 6 2 3 4 7 8 9 10 11 12 13 14 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 Théorème de Wilson . . . . . . . . . . . . . . . . . . . . . . . Théorème fondamental de l’arithmétique . . . . . . . . . . . . Petit théorème de Fermat . . . . . . . . . . . . . . . . . . . . Définition d’un nombre de Carmichael . . . . . . . . . . . . . Théorème de la probabilité du test de Fermat . . . . . . . . Théorème de Rabin et Miller . . . . . . . . . . . . . . . . . . Théorème de la probabilité du test de Rabin et Miller . . . . Définiton de l’ordre d’un nombre . . . . . . . . . . . . . . . . Définition de l’intropsection . . . . . . . . . . . . . . . . . . . Définition d’un polynôme cyclotomique . . . . . . . . . . . . Théorème sur la décomposition d’un polynôme cyclotomique Théorème sur la décomposition d’un polynôme cyclotomique Théorème de Fermet étendu . . . . . . . . . . . . . . . . . . . Théorème sur l’encadrement du ppcm de n entiers . . . . . . Encadrement de r . . . . . . . . . . . . . . . . . . . . . . . . Théorème admis sur l’encadrement de H . . . . . . . . . . . . Théorème démontré sur l’encadrement de H . . . . . . . . . . Théorème fondamental d’AKS . . . . . . . . . . . . . . . . . n(2n + 1) 2n divisent ∆2n+1 . . . . . . . . . . . . . . . . . . n 2n ∀k ≤ 2n, 2n ≤ . . . . . . . . . . . . . . . . . . . . . . . k n 2n 2n . . . . . . . . . . . . . . . . . . . . . . . . . n ≤ (1 +1) n (2n + 1) 2n ≥ 4 . . . . . . . . . . . . . . . . . . . . . . . . . n ∆2n+1 ≥ n · 4n . . . . . . . . . . . . . . . . . . . . . . . . . . n ≥ 9, ∆n ≥ 2n . . . . . . . . . . . . . . . . . . . . . . . . . ∀n ∈ N, n ≥ pvp (∆n ) . . . . . . . . . . . . . . . . . . Q ∀p ∈ vP, p (∆n ) . . . . . . . . . . . . . . . . . . . . . . . . ∆n = p≤n p ∆n ≤ nπ(n) . . . . . . . . Q . . . . . . . . . . . . . . . . . . . . ∀a, b ∈ N, 0 < 2b ≤ a < b, p∈P, a<p≤b p divise ab . . . . . . Q . . . . . . . . . ∀m ∈ N∗ , p∈P, m+1<p≤2m+1 p divise 2m+1 m+1 2m+1 m ≤ 4 . . . . . . . . . . . . . . . . . . . . . . . . . . . m Q ∀m ∈ N∗ , p∈P, m+1<p≤2m+1 p ≥ 4n . . . . . . . . . . . . . . m . . . . . . . . . . . . . . . . . . . . . . . . . . . . m! > ( m e ) π(n)! ≤ 4n . . . . . . . . . . . . . . . . . . . . . . . . . . . . . π(n) · ln(π(n)) − π(n) ≤ n · ln(4) . . . . . . . . . . . . . . . . f est strictement croissante sur l’intervalle [1; +∞[ . . . . . . ∀n ≥ 3, e−ln(4) < ln(ln(n)) . . . . . . . . . . . . . . . . . . . . e ln(n) h est majorée par e−1 . . . . . . . . . . . . . . . . . . . . . . n . . . . . . . . . . . . . . . . . . n ∈ N, n > 2, π(n) ≤ e · ln(n) MARIN Sophie BOURDONNAY Jean-Ronan . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9 13 20 20 20 23 24 28 28 28 28 28 29 29 29 30 30 31 39 39 40 40 40 40 41 41 42 42 42 42 43 43 44 44 44 45 45 46 page 47 sur 52 Liste des figures 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 n n ≤ π(n) ≤ e · ln(n) sur l’intervalle ]1, 100] . . . . . . . . . . . . . . . Représentation graphique ln(2) · ln(n) UML : Tous les packages . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . UML : package Outils . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . UML : package Main . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . UML : package Algorithmes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . UML : package Cribles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Algorithme de Wilson : Impression d’écran de la console lors de l’exécution de la version récursive . . . . Algorithme de Wilson : Comparaison de temps d’exécution pratique et théorique . . . . . . . . . . . . . Algorithme d’Erathostène : Impression d’écran de la console lors d’une exécution . . . . . . . . . . . . . . Algorithme d’Eratosthène : Comparaison de temps d’exécution pratique et théorique . . . . . . . . . . . Algorithme de Sundaram : Impression d’écran de la console lors d’une exécution . . . . . . . . . . . . . . Algorithme de Sundaram : Comparaison de temps d’exécution pratique et théorique . . . . . . . . . . . . Algorithme de Sundaram : Comparaison de la courbe pratique sur théorique avec et sans accident majeur Algorithme de Fermat : Impression d’écran de la console lors d’une exécution . . . . . . . . . . . . . . . . Algorithme de Fermat : Impression d’écran de la console lors d’une exécution . . . . . . . . . . . . . . . . Algorithme de Fermat : Comparaison de temps d’exécution pratique et théorique . . . . . . . . . . . . . Algorithme de Rabin et Miller : Comparaison de temps d’exécution pratique et théorique . . . . . . . . . Algorithme de Rabin et Miller : Comparaison de temps d’exécution de la version simple et parallèle . . . Exemple de la méthode de newton . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Algorithme AKS : Courbe représentative du temps d’exécution pratique en fonction du nombre de bits . Algorithme AKS : Impression d’écran . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . MARIN Sophie BOURDONNAY Jean-Ronan . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1 3 4 4 5 5 11 12 14 15 18 19 19 21 22 22 26 27 32 34 34 page 48 sur 52 Liste des tableaux 1 2 3 4 Algorithmes présentés . . . . . . . . . . . . . . . . . Tableau des produits des 7 premiers nombres impairs Récapitulatif des algorithmes présentés . . . . . . . . Complexité théorique des opérations de BigInteger . MARIN Sophie BOURDONNAY Jean-Ronan . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2 16 38 39 page 49 sur 52 Liste des algorithmes 1 2 3 4 5 6 7 8 9 10 11 12 13 Fonction de test multiples Fonction atester() . . . . Wilson . . . . . . . . . . . Crible 1 : Non optimisé . Crible 1 : Optimisé . . . . Crible 2 : Non optimisé . Crible 2 : Optimisé . . . . Fermat . . . . . . . . . . . Rabin Miller . . . . . . . Les grandes étapes d’AKS Newton . . . . . . . . . . Construction du r . . . . Algorithme AKS . . . . . MARIN Sophie BOURDONNAY Jean-Ronan . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7 8 10 13 14 17 17 21 25 28 32 33 33 page 50 sur 52 Liste des programmes 1 2 3 4 5 makefile . . . . . . . rabin_miller.gplt . . rabin_miller_p.gplt rabin_miller_t.gplt rabin_miller_tp.gplt . . . . . MARIN Sophie BOURDONNAY Jean-Ronan . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6 6 6 7 7 page 51 sur 52 Références bibliographiques [Buc06] Johannes Buchmann. Introduction à la cryptographie. 2006. [Eli] Julien Elie. L’algorithme aks ou les nombres premiers sont de la classe p. http://www.trigofacile.com. [Knu98] D. Knuth. The Art of Computer Programming, volume Volume 2. 2nd edition, 1998. [Mil76] Gary Lee Miller. Riemann’s hypothesis and tests for primality. Journal of Computer and System Sciences, Volume 13(Numéro3):pages 300–317, 1976. invited publication. [Rab80] Michael O. Rabin. Probabilistic algorithm for testing primality. Journal of Number Theory, Volume 12:pages 128–138, 1980. MARIN Sophie BOURDONNAY Jean-Ronan page 52 sur 52