Nombres-Premiers | Dr. Goulu

Suites infinies en Python

Mon, 26 Jun 2017 00:00:00 +0000

Depuis que je programme en Python, j’entasse les petits bouts de code utiles ou potentiellement réutilisables dans “Goulib”, ma librairie perso et néanmoins disponible en open-source (licence LGPL) sur , , ReadTheDocs pour , avec des

Comme la valeur d’un code se mesure surtout par les tests qui vérifient son bon fonctionnement, je me suis lancé dans un ambitieux projet (de plus…) : tester un maximum de fonctions de mes modules et en calculant des suites de l’ , plus connue sous son acronyme anglais OEIS.

Pour cela j’ai fait un truc dont je suis vachement fier* :

La classe Sequence

Ce ( ) permet de représenter une (sequence en anglais) finie ou infinie de nombres** à partir d’‘une ou plusieurs fonctions passées à :

iterf : un ou générateur produisant les termes de la suite l’un après l’autre
itemf : une fonction retournant le i-ème paramètre de la suite
containf : une fonction renvoyant vrai (True) si son paramètre appartient à la suite.

On peut créer par exemple la série (infinie) des nombres premiers ainsi :

=Sequence(containf= )

Ensuite, l’objet ainsi créé avec n’importe quelle combinaison de ces 3 paramètres peut être utilisé indifféremment:

comme un générateur : for p in A000040() : print(p) # affiche les nombres premiers (jusqu’à l’infini)
comme une liste: A000040 \[999\]# renvoie le 1000ème nombre premier (parce que Python indice à partir de 0…)
comme un ensemble: 201420142013 in A000040 # renvoie True car ce nombre est premier.

Evidemment, si on dispose de fonctions plus efficaces pour chacun de ces paramètres, on peut les utiliser pour rendre les calculs bien plus rapides. Par exemple pour la suite de Fibonacci, on peut exploiter trois algorithmes différents :

=Sequence(iterf= , itemf= , containf= )

En passant, voici comment est définie la séquence “auto descriptrice"qui orne la bannière de l’OEIS ci-dessus:

=Sequence( ( lambda x: ( ( ( ( (x))))) ,1))

Compact et presque clair, non ?

Dérivation

Une Sequence peut être dérivée d’une autre grâce à plusieurs méthodes:

renvoie une Sequence correspondant à la Sequence source filtrée par une fonction. Par exemple: =A000040.filter( ) renvoie les “exposants de Mersenne”, les nombres premiers p tels que $2^p - 1$ est premier.
applique une fonction à chaque terme de la Sequence source. Par exemple la série des carrés des nombres premiers peut se définir ainsi: =A000040.apply(lambda n:n*n)
Pour éviter l’utilisation d’apply dans des cas trivialement simples, l’addition (et la soustraction) d’une Sequence et d’un entier sont définies. Par exemple: = +1 définit les à partir des nombres de la forme $2^{2^n}$
renvoie une Sequence dont le n-ième terme est obtenu en sommant les n premiers termes de la Sequence source: =A000040.accumulate()
renvoie une Sequence produite en appliquant applique une fonction à chaque paire de termes consécutifs. Ainsi la suite des différences entre nombres premiers consécutifs s’écrit: =A000040.pairwise(operator.sub)

On peut aussi combiner deux Sequences pour en créer une nouvelle:

L’opérateur % (modulo, pourquoi pas…) renvoie les termes de la Sequence opérande de gauche qui ne sont PAS dans l’opérande de droite. Ainsi: =A000040 % définit la Sequence des nombres premiers qui ne sont pas
L’opérateur & (and) renvoie les termes de la Sequence opérande de gauche qui sont aussi dans l’opérande de droite. Ainsi: = & A000040 définit la suite des nombres premiers dont qui ne s’écrivent qu’avec des 0 et des 1.
L’opérateur | (or) renvoie la fusion de deux séquences à l’aide du génial . Ainsi: = | définit les nombres ayant 4 diviseurs (dont 1 et eux-mêmes) comme l’union de ceux qui sont le produit de deux nombres premiers avec ceux qui sont le cube d’un nombre premier.

Il y a encore deux méthodes un peu “tirées par les cheveux” du point de vue mathématique, mais qui fonctionnent très bien informatiquement:

renvoie une Sequence (par défaut) en triant les termes de la Sequence d’origine. Par exemple, voici la suites des surfaces des dans l’ordre croissant: =Sequence(math2.primitive_triples).apply(lambda x:x \[0\]*x \[1\]//2) .sort()
renvoie une Sequence où les termes redondants de la suite d’origine sont absents, par exemple: = .unique() // oui, parce que le 5 appartient à deux paires de nombres premiers jumeaux …

Ces méthodes utilisent respectivement et qui fonctionnent tant que la suite initiale est “presque” triée, à savoir tant que l’écart n entre un terme $a_i+n \leq a_i$ n’excède pas le paramètre “buffer” de la fonction. On peut évidemment trouver des suites qui ne pourront “mathématiquement” pas être traitées ainsi, mais informatiquement j’arrive à reproduire les suites de l’OEIS rencontrées jusqu’ici avec buffer=100 seulement

Le dictionnaire OEIS

J’ai ainsi constitué peu à peu le fichier qui définit actuellement environ 150 séries de l’OEIS, et que j’étoffe lorsque l’occasion se présente. A la fin de ce module, j’utilise la géniale possibilité d’introspection de Python pour regrouper toutes les Sequence définies dans un dictionnaire fort utile pour les tests:

\[python\]

# Construit le dictionnaire OEIS par introspection : Simple et WOW ! oeis={} # on crée le dictionnaire vide seqs=globals().copy() # on copie tous les objets déclarés dans ce module for id in seqs: # on parcourt tous les identificateurs des objets if id

\[0\]

==‘A’ and len(id)==7: # et s’ils ont un nom de séquence OEIS … oeis

\[id\]

=seqs

\[id\]

# on les ajoute au dictionnaire … seqs

\[id\]

.name=id # et on définit leur champ name

\[/python\]

Performance

Un point important est qu’aucun calcul n’est effectué lors des opérations ci-dessus. Ce n’est qu’au moment d’utiliser les Sequence ainsi définies que les fonctions iterf, itemf, containf et leurs éventuelles compositions sont évaluées.

C’est un peu “automagique”, mais il faut tout de même veiller à utiliser les algorithmes les plus efficaces, et c’est même un des buts que je poursuis avec ce projet. Par exemple la suite des nombres premiers dont qui ne s’écrivent qu’avec des 0 et des 1 = & A000040 aurait pu s’écrire également: A020449=A000040 & A007088 mais la première formulation est beaucoup plus rapide car la série A007088 des nombres ne s’écrivant qu’avec des 0 et des 1 croît beaucoup plus vite que celle des nombres premiers A000040. Il est par conséquent beaucoup plus rapide de tester si les nombres du genre 1101010101011101 sont premiers que d’énumérer tous les nombres premiers de 16 chiffres et de jeter ceux qui contiennent d’autres chiffres que des 0 ou 1.

Malgré toutes ces précautions, parcourir une suite infinie prendra forcément un temps infini, et ces idiots d’ordinateurs ne sont toujours pas foutus de gérer le . J’ai donc écrit un qui limite le temps de calcul d’une boucle ainsi :

for x in (suite,1): print(x) # affiche tous les termes calculables en 1 seconde (au total)

Ce décorateur est utilisé en particulier dans la fonction appelée par pour afficher les dix premiers termes d’une Sequence, ou du moins ceux qu’on peut calculer en moins d’une seconde.

Les suites particulièrement lentes sont par exemple ou dont le n-ième terme donne le nombre de nombres inférieurs à 10^n satisfaisant une certaine condition. Faute de meilleur algorithme, chaque terme prend 10x plus de temps que le précédent …

Tests

Voià, tous les ingrédients sont prêts pour tester si mes beaux algorithmes fonctionnent correctement, ce qui était le but initial je le rappelle.

Pour ceci, il suffit de vérifier que chaque Sequence fournit bien les mêmes termes que ceux disponibles dans l’OEIS. Ceci est facilité par le fait que l’OEIS fournit pour chaque suite les n premières valeurs dans un fichier texte en accessible par le web. Par exemple fournit les 10'000 premiers nombres premiers.

Donc mon fichier est lui aussi génialement simple* : il traverse le dictionnaire oeis et pour chaque Sequence il télécharge les N termes de référence du site OEIS, vérifie que les n premiers termes de la Sequence sont bien ceux attendus, et produit une erreur sinon. Ou un avertissement si itimeout a limité n à moins de 10.

Ces tests sont automatiquement exécutés (avec beaucoup d’autres) chaque fois que je pousse une nouvelle version de , ce qui fait que je suis averti si modification crée un problème avec une ancienne version de Python ou si un Pingouin détecte un problème invisible de mes Fenêtres.

Débogage… de l’OEIS !

J’ai ainsi beaucoup débogué, amélioré et optimisé la plupart des fonctions de et beaucoup d’ , et je compte poursuivre dans cette voie qui permet d’utiliser les données de l’OEIS comme une référence, validées par de nombreux utilisateurs.

Sauf que des fois, le bug était chez eux. Et je ne suis pas peu fier d’ sur l’OEIS :

, comme déjà mentionné dans , le 20ème terme de la série est 145, pas 142.
, dont certains termes avaient besoins de 0 supplémentaires. Tant qu’à faire j’ai fourni un B-file contenant les 1000 premiers termes exacts pour remplacer l’ancien qui n’en avait que 500.

A cette occasion j’ai remarqué que l’édition de l’OEIS est un peu rébarbative, ce qui peut décourager les contributeurs débutants. Peut-être que mon modeste projet pourrait servir de base à un site plus interactif, utilisant du code (Python of course) pour calculer dynamiquement les suites requises …

Ce long article mijoté pendant plus de six mois se termine par un appel aux allumés du code bonnes volontés : si cet article vous a motivé , n’hésitez pas à contribuer à la Goulib sur GitHub.

Pour ma part je m’attaque aux et qui seront l’occasion de nettoyer le code du en utilisant et testant le module

Notes

*sinon je n’en parlerais pas ici… **ou d’autres objets mais je n’ai pas encore trouvé quoi…

Comment trouver des nombres premiers

Sun, 15 Apr 2012 00:00:00 +0000

"the centrality of prime numbers" par barabeke sur Flickr

Les ont beau être étudiés depuis au moins 2300 ans, ils n’ont jamais été aussi mystérieux ni utiles qu’aujourd’hui.

Mystérieux, car la démonstration de l’ , qui permettrait de définir la répartition des nombres premiers, attend toujours son .

Utiles, car nos cartes à puces, téléphones et ordinateurs consomment des quantités industrielles de “grands” nombres premiers, en particulier pour le cryptage . La sécurité de cette méthode “ ” repose sur le fait que la de grands nombres demande un temps prohibitivement long, alors qu’il est très rapide de trouver de grands nombres premiers.

Comment trouver de petits nombres premiers

Ceci parait surprenant de prime abord, puisqu’on apprend à l’école à déterminer si n est premier en tentant de le diviser par les nombres premiers déjà connus inférieurs à √n, ce qui n’est autre qu’une factorisation. On découvre à l’école aussi le , qui fournit depuis 2000 ans les nombres premiers les uns après les autres à tous les heureux possesseurs de feuilles quadrillées ou de mémoires informatiques:

Animation du Crible d’Erathosthène (Wikipédia)

Cette méthode n’a été légèrement améliorée qu’en 1999 avec le et reste excellente pour créer des listes de nombres premiers consécutifs. Ainsi le site les fournit tous jusqu’à 32 416 187 567 *

Mais alors, comment le célèbre a-t-il pu répondre en 1643 à un certain (dont nous reparlerons plus bas):

Vous me demandez si le nombre 100 895 598 169 est premier ou non, et une méthode pour découvrir, dans l’espace d’un jour, s’il est premier ou composé. À cette question, je réponds que ce nombre est composé et se fait du produit de ces deux : 898423 et 112303, qui sont premiers.

Et bien parce que 3 ans plus tôt il avait pondu et démontré lui-même son , qui constitue en même temps probabiliste. Grâce à cela, il a su “rapidement” que 100895598169 n’est pas premier. Par contre, comment il a effectué les opérations et factorisé le nombre avec un papier et un crayon en un seul jour, ça je n’en ai avais aucune idée **

Et je ne sais pas non plus comment Mersenne a généré 898423 et 112303 parce que bizarrement, ce ne sont pas des nombres de Mersenne, dont nous parlerons plus bas… En fait, ô surprise, 898423 = 112303 x 23-1, donc Mersenne a généré le grand premier à partir du petit, lequel a d’ailleurs la même forme : 112303 = 7019 x 24-1.

Comment trouver de très grands nombres premiers

Il existe donc des méthodes pour générer des nombres premiers. Aucune ne produit des nombres premiers “à tous les coups” ( ce serait le Graal que certains recherchent encore mais qui n’existe probablement pas ), mais ces méthodes fournissent des grands nombres qui ont une probabilité d’être premiers nettement plus élevée que des nombres de même taille choisis au hasard.

Au IXème siècle déjà, avait remarqué que pas mal de petits nombres premiers ont la forme “321” p = 3×2n-1 . Les sont listés dans . Le plus grand connu actuellement est 3×24235414−1 mais aussi 3×27033641+1 qui n’est pas strictement un Thabit à cause du +1 au lieu du -1 final.

Les ont une forme encore plus simple : p = 2n-1 où n est premier. Et Mersenne ne les a pas découverts : connaissait déjà les plus petits ( 3, 7, 31 et 127 ) en 300 avant J.C. Mersenne en a juste fait une en ajoutant 8191 découvert par Ibn Fallus au XIIIème siècle et 131071 et 524287 découverts par en 1588. Et puis il s’est planté magistralement : sa liste incluait les nombres 267-1 et 2257-1 qui ne sont pas premiers et omettait 231-1, 261-1, 289-1 et 2107-1 qui le sont. C’est dommage, car Mersenne n’a ainsi jamais détenu le record du plus grand nombre premier qui a un nombre de Mersenne. Depuis 2009, le record est 243112609-1 , qui compte 12 837 064 chiffres, trouvé grâce au programme . Le rôle de ce logiciel est surtout de faire passer le génial qui est déterministe (non probabiliste) mais ne marche qu’avec les Mersenne.

Bref, aucun nombre de Mersenne n’est de Mersenne et si je n’avais pas autant de lecteurs en République Française, je proposerais de les rebaptiser “ ” pour souligner leur beauté en binaire. En effet, 2n-1 s’écrit simplement avec une suite de n “1” en binaire. Par exemple 127= 27-1 s’écrit 1111111 en binaire.

Il existe plusieurs autres formules fournissant des candidats premiers :

Les de la forme 22n + 1. Fermat pensait qu’ils étaient tous premiers, mais c’est faux : seuls les 5 premiers le sont, les 28 suivants ne le sont pas, et les autres sont trop grands pour être testés.
Les sont de la forme k·2n+1 ( , record 659×2617815+1 )
: n·2n--1 ( , 3752948 × 23752948 − 1)
: n·2n+1 ( , 6679881 · 26679881 + 1)
les “Cullen généralisés” : n·bn+1,où n+2 > b ( record 427194 × 113427194 + 1)

on voit qu’elles sont toutes des généralisations ou cas particuliers des autres, et que les repunits y jouent un rôle important. Les (PSG) sont des nombres p tels que 2p+1 est aussi premier ( ). Ce “générateur” fournit des nombres moins grands que les autres, mais soulève plein de questions intéressantes : quelle est la longueur maximale d’une formée par des PSG, y’a-t-il une infinité de PSG etc. Et de plus, le établit un lien entre le “petit " théorème de Fermat susmentionné et qui a obsédé les matheux jusqu’en 1994. Et comme je n’ai pas compris grand chose à sa démonstration, je suis plein d’admiration pour cette dame autodidacte qui étonna les mâlethématiciens d’il y a 200 ans.

Si vous voulez vous aussi devenir célèbre, mais facilement, participez à , une application de la plateforme de calcul distribuée BOINC qui chasse les records de grands nombres premiers. Avec un peu de chance le prochain grand nombre premier sera découvert sur votre ordinateur tout en .

Comment trouver des nombres premiers d’une longueur donnée

Fin 2009, une équipe internationale a cracké un code , en factorisant le produit de deux nombres premiers de 120 chiffres à l’aide de l’ et de beaucoup d’ordinateurs. Cet exploit signifie qu’une clé RSA nécessite aujourd’hui des nombres premiers d’au moins 512 bits, soit 154 chiffres décimaux pour être indécryptable.

Nous avons vu plus haut comment obtenir tous les nombres premiers nettement plus courts, ou quelques nombres premiers nettement plus longs, mais pour RSA, nous avons besoin d’obtenir en quelques secondes des nombres premiers de 154 chiffres, avec un seul petit processeur enfermé dans le boitier d’un routeur par exemple, et sans que le nombre transite par un réseau où il pourrait être intercepté. De plus, le nombre ne doit pas être stocké dans une table dont un pirate pourrait essayer les combinaisons : il doit être généré aléatoirement.

Mais au fait, existe-t-il beaucoup de nombres premiers de 154 chiffres ? Oh que oui : la densité des nombres premiers autour de n est de 1/ln(n), or donne environ 0.3% : environ 3 nombres de 154 chiffres sur 1000 sont premiers, donc il y en a des giga milliards de floppées. Donc tout ce que notre petit routeur a à faire de temps en temps c’est:

générer un nombre aléatoire de 154 chiffres en tirant au hasard 511 bits à pile ou face, et en ajoutant un 512ème bit = 1 pour faire un nombre impair. facile et ultra rapide.
vérifier si le nombre est premier à l’aide d’un plus moderne que celui de Fermat comme celui de .
si le test dit que le nombre n’est pas premier, ajouter 2 au nombre aléatoire pour obtenir le nombre impair suivant et recommencer l’opération 2. Il faudra répéter ceci en moyenne 300 fois avant que Miller et Rabin disent “probablement premier”

Pour vous faire une idée de la vitesse de ceci, allez au milieu de et cliquez le bouton “auto generate prime number p and q” : vous obtiendrez 2 nombres premier de 512 bits pour le prix d’un seul click.

cliquez sur l’image et scrollez vers le milieu de la page

Oui mais, me direz vous, les tests probabilistes ne garantissent pas absolument que les nombres soient premiers. Il y a un risque qu’on encode le message avec une clé foireuse, et donc qu’il soit “facile” à décoder. Effectivement, mais on admet généralement que la probabilité qu’un nombre de cette taille soit est de l’ordre d’une sur 1030. Et si votre message est si précieux que vous n’êtes pas prêt à courir ce risque, réfléchissez à : le risque qu’un rayon cosmique change un bit du nombre pendant un test de primalité déterministe est un million de fois plus élevé ! J’aime bien cette idée qu’un algorithme probabiliste soit plus fiable qu’une machine considérée comme déterministe, pas vous ?

Notes :

* 32'416'187'567 est tellement proche de 8*2^32 que j’ai une petite idée de la mémoire utilisée par le crible…

** ajout du 18 mai 2014 : Blogdemaths a éclairé ma lanterne à ce sujet dans un article intitulé “ ”

Pour en savoir plus

sur le Site du Zéro
Jean-Paul Delahaye (2000). Merveilleux nombres premiers. Pour la Science.
: une librairie Python avec les fonctions qu’il faut

Sommes Egales de Nombres Premiers Consécutifs

Tue, 03 Jun 2008 00:00:00 +0000

Le quatrième et dernier problème de la mérite un article à lui tout seul. (J’ai parlé des trois autres dans )

Il s’agit de trouver le plus petit P qui soit en même temps :

la somme de 9 nombres premiers consécutifs
la somme de 119 nombres premiers consécutifs
la somme de 215 nombres premiers consécutifs
et la somme de 675 nombres premiers consécutifs !

(les nombres 9, 119, 215 et 675 sont différents pour chaque concurrent…)

C’est étonnant, mais beaucoup de nombres premiers sont des sommes de nombres premiers consécutifs (abrégé SNPC ci après), par exemple :

5+7+11+13+17 = 53 7+11+13+17+19 =67 11+13+17+19+23 =83

De plus, il est fréquent qu’un même nombre premier soit égal à plusieurs SNPC. Par exemple sur on mentionne:

34421 = 269 + … + 709 (71 nombres premiers) 34421 = 1429 + … + 1571 (23 nombres premiers) 34421 = 3793 + … + 3853 (9 nombres premiers) 34421 = 4889 + … + 4937 (7 nombres premiers) 34421 = 11467 + … + 11483 (3 nombres premiers)

Le nombre P recherché n’est donc peut-être pas très grand, d’autant que la somme des 675 premiers nombres premiers ne vaut que 1'578'242. Il n’y a probablement pas besoin de calculer en “bigint”, les entiers sur 32 bits, voire 64 disponibles avec n’importe quel langage de programmation devraient suffire. Par contre, il est pratique de disposer de fonctions prédéfinies pour manipuler des nombres premiers, c’est pourquoi j’ai choisi d’utiliser .

Les fonctions suivantes suffisent pour résoudre le problème posé: (code modifié le 4/6/8 suite aux commentaires de b0z0)

\[gist id="0e35207dedf4e337c937"\]

La fonction SCP (Sum of Consecutive Primes) renvoie la somme des n nombres premiers consécutifs en commençant par le i-ème nombre premier en utilisant la fonction prédéfinie Prime

\[j\]

qui renvoie directement le j-ème nombre premier.

Cette somme n’étant pas forcément un nombre premier, la fonction PSP (Prime Sum of Primes) appelle répétitivement SCP en augmentant i jusqu’à ce que la somme soit un nombre premier, vérifié grâce au test de primalité , une fonction non triviale bien utile ici. Pour une raison expliquée plus bas, PSP renvoie une paire de résultats : la somme, et l’indice du premier nombre premier de la somme.

Enfin, la fonction CPSP (Compound Prime Sum of Primes) implante l’algorithme que j’ai inventé pour la circonstance. Elle prend en paramêtre la liste des nombres de nombres premiers consécutifs sommés. Pour résoudre notre problème, on appellera CPSP

\[{675, 215, 119, 9}\]

on initialise une liste p avec les n résultats de PSP obtenus pour chacun des nombres de nombres premiers consécutifs à additioner. Ainsi, pour CPSP \[{675, 215, 119, 9}\], p est initialisé à {{1583291,2},{149993,15},{41641,10},{127,2}}. Autrement dit, 1583291 est le plus petit nombre premier qui soit la somme de 675 nombres premiers consécutifs, et cette somme commence avec le 2ème nombre premier. 149993 est le plus petit nombre premier qui soit la somme de 215 nombres premiers, en commençant par le 15ème, et ainsi de suite
par paresse (qualité indispensable chez les programmeurs…) , la détection de la fin de l’algorithme est réduite au minimum vital : dès que la liste p n’est plus modifiée par l’algorithme, on arrête
Pour chaque élément de la liste p en commençant par le deuxième, on regarde si la somme est inférieure à la somme du premier indice. Si c’est le cas, on calcule une somme supérieure en incrémentant l’indice correspondant, jusqu’à ce que la somme soit égale à la première, ou la dépasse. Après cette étape, la liste p devient {{1583291,10},{1600981,840},{1589563,1526},{1584829,15997}} : on voit que les sommes 2,3 et 4 ont dépassé la somme 1
Si la somme 1 est plus petite que la somme 2, on augmente la somme 1 jusqu’à ce que’elle atteigne ou dépasse la somme 2. On arrive ainsi à {{1623917,10},{1600981,840},{1589563,1526},{1584829,15997}}. On boucle au point 2

Les trois dernières boucles donnent les listes suivantes qui montrent bien le fonctionnement de l’algorithme:

{{8256361,1127},{8112103,3883},{8115539,6728},{8112787,71376}} {{8275409,1130},{8259353,3947},{8264171,6833},{8256383,72536}} {{8275409,1130},{8275409,3954},{8275409,6841},{8275409,72696}}

et voilà : 8'275'409 est égale à la somme des:

675 nombres premiers consécutifs à partir du 1130-ème (9109)
215 nombres premiers consécutifs à partir du 3954-ème (37339)
119 nombres premiers consécutifs à partir du 6841-ème (68821)
9 nombres premiers consécutifs à partir du 72696-ème (919421)

Quelques minutes pour choisir le bon outil (Mathematica) + quelques minutes de programmation + 30 secondes de calcul, c’est gagné !

les Nombres Premiers

Sat, 20 Jan 2007 00:00:00 +0000

A l’occasion de la découverte de la plus grande paire de nombres premiers jumeaux, et en parallèle avec la rédaction d’un articule sur le calcul distribué, j’ai partiellement ré-écrit cet article de 2005 sur les nombres premiers.

Introduction

Un nombre P est premier s’il ne se divise que par 1 ou lui-même. Il n’est donc “pas dans le livret”, autrement dit, il n’existe pas deux nombres entiers A et B plus grands que 1 tels que A x B = P.

Les premiers nombres premiers sont 2,3,5,7,11,13,17,19,23,29,31 …

Le grands nombres premiers ont une grande importance pratique en cryptographie, donc dans les dispositifs de sécurité informatique ou électronique, les systèmes de paiement etc.

Ces systèmes vitaux actuellement se basent sur des idées connues depuis des millénaires, mais qui n’ont été prouvées que récemment. Par exemple:

pour être absolument certain qu’un nombre N est premier, il faut essayer de le factoriser (trouver ses facteurs A et B, par lesquels on pourrait diviser N), ce qui implique d’essayer un grand nombre de divisions, et ça prend beaucoup de temps.
il existe des “tests de primalité” qui peuvent dire très rapidement si un nombre est “très probablement” premier ou pas, sans effectuer de factorisation : si le test dit que le nombre n’est pas premier, il n’en fournit pas les facteurs.
il n’existe pas de formule qui donnent à coup sur des nombres premiers, mais il en existe qui marchent une 40aine de fois de suite, ce qui n’est pas mal du tout:
- 103n2-3945n + 34381 est premier pour n=0,1,…,42 (R. Ruby)
- 47n2^2-1710n + 10181 est premier pour n=0,1,…,42 (G. Fung)
- 36n2^2-810n + 2753 est premier pour n=0,1,…,44 (R. Ruby)

Nombres de Mersenne et grands nombres premiers

Les “nombres de Mersenne” 2n-1 sont “assez souvent” des nombres premiers, par exemple:

22-1=3, 23-1=7, 25-1=31, 27-1=127, 213-1=8191

Comme 2^n-1 est une fonction exponentielle, on peut trouver “facilement” de très grands nombres premiers

En 1588, P. Cataldi calcul a que 217-1=131071 et 219-1 = 524 287 sont premiers, puis Euler en 1750 prouva que 231-1=147'483'647 est premier.

S’ensuivit une course au plus grand nombre premier dont on trouve un

En 1878, énonça un test de primalité très puissant, qui lui permit de prouver que 2127-1 = 170141183460469231731687303715884105727 est premier, sans effectuer les divisions

les nombres premiers suivants furent découvert dès 1952 avec des ordinateurs.

Actuellement, le plus grand nombre premier connu est 232'582'657-1. Il fait 9'808'358 décimales et à été découvert en septembre 2006 par le projet , dont je reparle dans un .

Nombres premiers jumeaux

En examinant la différence entre des nombres premiers consécutifs, on s’aperçoit qu’elle vaut plus souvent 2 que toute autre valeur. Il existe donc des nombres premiers “jumeaux” : 5-7, 11-13, 17-19 par exemple, mais on en connait de beaucoup plus grands. En fait on pense qu’il existe une infinité de telles paires. Comment les trouver ? Par exemple en cherchant “autour” des nombres de Mersenne !

Le 15 janvier 2007, des nombres premiers jumeaux de 58'711 décimales ont été , également en utilisant le . Ce sont 2'003'663'613 × 2195'000±1

Curiosités

La Spirale d’Ulam

Un matheux nommé Ulam s’ennuyait à une conférence et à commencé à écrire les nombres 1,2,3,4 etc en spirale sur du papier quadrillé, puis à noircir les cases correspondant aux nombres premiers.

A sa grande surprise il a vu apparaitre des “lignes” obliques qui correspondent à des fonctions génératrices de nombres premiers de forme a.n2+b.n + c, comme les fonctions mentionnées plus haut. (voir la )

En généralisant, on peut colorier les cases de la spirale d’Ulam avec une couleur représentant le nombre de facteurs premiers de chaque case. Mais ma représentation préférée est celle-ci, dans laquelle le nombre de facteurs définit le rayon de petites boules centrées à chaque case :

Un copain métaphysique m’a sommé de mentionner aussi la “Croix de Plichta”, mais il s’agit AMHA d’une justification un peu simpliste de la théorie ésotérique un peu planante de monsieur Plichta…

Pourquoi simpliste :

2 et 3 sont des premiers par définition. Pourtant ils ne sont pas marqués comme tels dans la croix.
Le nombre situé sur le rayon R (de 1 à 24) au Nième tour s’écrit R+24*(N-1). Donc si R est multiple de 2 ou 3, tous les nombres sur les mêmes rayons le seront aussi et ne seront donc pas premiers. La “croix” résulte donc d’un “crible” par 2 et 3.
Les nombres sur les rayons magiques ne sont pas tous premiers, et c’est bien là le problème…

Bref, ne pas se laisser impressionner par une quelconque régularité apparente des petits nombres premiers…

Références

Jean-Paul Delahaye (2000). Merveilleux nombres premiers. Pour la Science.
articles de Jean-Paul Delahaye dans