Autour des nombres premiers

4
Chapitre
Chapitre 4.
Autour des nombres
premiers
Quoi de plus simple que la notion de nombre premier ? Tout un chacun, même le plus rétif aux
mathématiques, est en mesure de la comprendre : un nombre premier possède exactement deux
diviseurs. Euclide, encore lui, au IIIe siècle avant Jésus-Christ, écrivait dans la définition XII, au tout
début du livre VII des Éléments, le premier des trois consacré à l’arithmétique : le nombre premier est
celui qui est mesuré par l'unité seule. Derrière cette simplicité apparente, se cache une richesse inouïe,
que la calculatrice permet d’explorer. Nous verrons entre autres comment prouver qu’un certain
nombre de 183 chiffres est bien premier !
Sommaire
Chapitre 4. Autour des nombres premiers ........................................................... 73
Reconnaître si un nombre est premier ............................................................. 74
1.1 La fonction plus petit diviseur d’un entier..................................... 74
2.
1.2
Une fonction ppd.............................................................................. 75
1.3
Un premier test de primalité ........................................................... 77
1.4
Les limites d’un tel algorithme ....................................................... 78
Obtenir des listes de nombres premiers ................................................ 78
2.1 Le crible d’Ératosthène ................................................................... 79
2.2
3.
4.
Compter les nombres premiers ..................................................... 81
Le célèbre petit théorème de Fermat ..................................................... 84
3.1 Introduction historique .................................................................... 84
3.2
L’énoncé du petit théorème de Fermat ........................................ 84
3.3
Un critère pour prouver qu’un nombre est composé ................. 87
Quelle réciproque pour le petit théorème de Fermat ? ........................ 88
4.1 Réciproque or not réciproque ? ..................................................... 88
4.2
Une « réciproque » au théorème de Fermat ............................... 89
4.3
Quelques exemples......................................................................... 90
4.4
Un test de primalité ......................................................................... 93
ANNEXE : l’exponentiation modulaire .............................................................. 96
Christian Vassard (IUFM Rouen)
74
Mathématiques et TI-Nspire
Reconnaître si un nombre est premier
C’est évidemment la question la plus simple que l’on se pose quand on vient de donner la définition.
Les premiers nombres premiers sont archi-connus mais comment procède-t-on si l’on a affaire à un
nombre plus grand, comme 1 234 567 891 ou 1 234 567 891 234 567 ? Nous excluons dans ce
chapitre le recours à l’excellente fonction isprime de la calculatrice ; rien ne remplace la réflexion
que l’on peut mener soi-même autour de ces problèmes fondamentaux posés par l’arithmétique.
1.1 La fonction plus petit diviseur d’un entier
 Si l’on cherche à reformuler le problème posé, un entier n est premier lorsque le plus petit
diviseur strictement supérieur à 1 de n est… n lui-même. D’où l’intérêt de commencer en écrivant une
fonction donnant le plus petit diviseur p strictement supérieur à 1 d’un entier n, ce que nous écrirons à
l’avenir d’une notation peu répandue mais fort commode : ppd(n).
 Comment ferions-nous à la main avec un entier quelconque pour déterminer son ppd ?
On teste successivement si n est divisible par 2, puis par 3, etc. : on s’arrête dès que l’on a un diviseur.
Étudions ce qui se passe sur quelques exemples :
N
24
35
11
49
127
143
divisible par 2
Vrai faux
faux
faux
faux
faux
divisible par 3
faux
faux
faux
faux
faux
divisible par 4
faux
faux
faux
faux
faux
divisible par 5
vrai
faux
faux
faux
faux
divisible par 6
faux
faux
faux
faux
divisible par 7
faux
vrai
faux
faux
divisible par 8
faux
faux
faux
divisible par 9
faux
faux
faux
divisible par 10
faux
faux
faux
divisible par 11
vrai
faux
vrai
Un même calcul doit donc être effectué un certain nombre de fois : en commençant à d = 2, puis en
incrémentant de 1, on doit tester si n est divisible par d (c’est-à-dire pour la calculatrice si
mod(n,d)=0). Dès que c’est le cas, on renvoie la valeur de d trouvée ; sinon on poursuit et au pire,
dans le cas où n est premier, on s’arrête lorsque d2 dépasse n.
 Cette démarche peut être aisément transposée sur un tableur.
L’entier à étudier est placé dans la cellule A1 et mémorisé dans une variable n. On teste tous les
entiers compris entre 2 et n , que l’on peut placer dans la colonne B, avec une instruction seq. On
exclut d’emblée le 1.
Dans la colonne C, on repère ceux qui divisent n s’ils existent ; sinon on met void dans la cellule.
Plutôt que recopier arbitrairement sur un certain nombre de lignes, il vaut mieux utiliser un seq,
comme on l’a déjà vu dans un exemple précédent :
=seq(when(mod('n,k)=0,k,_,_),k,2,√('n))
Dans la colonne D, on supprime les nombreux void de la colonne C.
© T³ France 2011 / Photocopie autorisée
Autour des nombres premiers
75
Les résultats peuvent alors être indiqués : si la cellule D1 n’est pas vide (not isvoid(d1) est vrai), son
contenu donne le ppd de l’entier n considéré et on sait que n n’est pas premier ; si la cellule est vide,
le ppd de n vaut n et n est premier.
Le fait que les colonnes s’ajustent en fonction du nombre considéré nous autorise à travailler avec des
entiers suffisamment grands (attention à la limitation à 2500 lignes pour le tableur). Le tableur
présente cependant un défaut : il effectue tous les calculs quand bien même sait-on dès le début que le
nombre considéré est un multiple de 2, par exemple.
1.2 Une fonction ppd
 La fonction nous donnera plus de souplesse : pour un multiple de 2, ou de 3, par exemple, elle
doit pouvoir renvoyer une réponse rapide, quand bien même le nombre serait gigantesque.
Une boucle While s’impose puisqu’on ne sait pas a priori combien de fois on va parcourir cette
boucle. Deux façons de sortir de la boucle1 : soit parce qu’on a trouvé un diviseur qui sera le ppd
cherché, soit parce qu’on a dépassé n et dans ce cas, le ppd vaut n.
À l’inverse, on reste dans la boucle tant qu’on n’a pas trouvé de diviseurs (mod(n,d)0) et que d2 est
inférieur ou égal à n.
Voici le code d’une première fonction ppd1, basé sur les remarques précédentes :
1
C’est souvent une bonne façon de déterminer la condition à mettre dans la boucle. On sait plus facilement quand on doit en sortir… il
suffit de prendre la négation.
© T³ France 2011 / Photocopie autorisée
76
Mathématiques et TI-Nspire
Ci-dessous quelques-uns des résultats obtenus :
Mais la fonction, on s’en doute, peut encore notablement être améliorée. En effet si n est impair, il est
inutile de rechercher un diviseur pair. En d’autres termes, dès qu’on sait qu’un entier n’est pas
divisible par 2, pas besoin de tester s’il est divisible par 4, 6, 8, etc.
Concrètement, on peut donc au préalable tester si n est divisible par 2, puis ne plus tester que les
diviseurs impairs en commençant à d = 3. Globalement, on peut espérer aller deux fois plus vite
lorsqu’il faut balayer beaucoup de diviseurs, notamment quand le nombre considéré est premier 2.
C’est l’objet de la fonction ppd suivante :
2
20 s avec ppd1 appliquée à 10 000 000 000 037… 12 s avec ppd.
© T³ France 2011 / Photocopie autorisée
Autour des nombres premiers
77
Les résultats sont corrects et obtenus plus rapidement :
1.3 Un premier test de primalité
L’essentiel du travail est fait avec la fonction ppd précédente : n > 1 est premier si et seulement si
ppd(n)=n. Le cas n = 1 doit être envisagé à part. Le code du programme est donné ci-après. On
remarquera l’emploi de If Then, Elseif Then, Else et Endif, qui permet de gérer ici trois éventualités.
Testons cette fonction avec quelques entiers. Pour les petites valeurs, les réponses sont données
presqu’immédiatement, ainsi d’ailleurs que pour des valeurs plus grandes, pourvu qu’elles possèdent
un petit diviseur. Les cas les plus défavorables correspondent aux nombres premiers, ce qui est le cas
des exemples qui suivent :
Le premier résultat est obtenu à la calculatrice en une quinzaine de secondes, le second en 48
secondes mais le troisième demande 2 minutes 33 secondes. La dégradation des performances est
particulièrement rapide : pourtant le dernier nombre étudié ne possède que 12 chiffres.
© T³ France 2011 / Photocopie autorisée
78
Mathématiques et TI-Nspire
1.4 Les limites d’un tel algorithme
Prouver qu’un entier n d’une cinquantaine de chiffres, disons de l’ordre de 1050 pour fixer les idées,
est un nombre premier reste définitivement inaccessible à notre fonction estprem.
En effet on doit tester pour un tel nombre approximativement la moitié des entiers compris entre 1 et
n, soit la bagatelle de quelque 5  1024 entiers.
On peut facilement construire un programme de test pour essayer d’estimer la rapidité de la
calculatrice ou du logiciel :
Avec la TI-Nspire modèle 3.0, et une batterie chargée à bloc, l’exécution de la fonction précédente,
qui calcule les restes de 1050 dans une division par les 50 000 premiers entiers, s’effectue en 35
secondes3.
Bref, et même si c’est une approximation très grossière, on peut penser que pour tester 5  1024
entiers, il faudra environ :
5 × 1024 × 35
 3,5  1021 secondes
50000
soit 1,1  1014 années, soit un peu plus (!) que … l’âge de l’univers (estimé à 15  109 années...) !
Quelles piles y résisteraient ?
L’ordinateur est une centaine de fois plus rapide : il exécuterait la même tâche en 1,1 × 1012 années…
on n’y gagne pas grand-chose !
Il ne suffit donc pas d’avoir un algorithme pour résoudre un problème, encore faut-il que cet
algorithme s’exécute en un temps raisonnable : on conçoit que ce point puisse devenir crucial.
La fonction isprime de la calculatrice est à ce titre beaucoup plus performante que notre estprem.
Elle s’appuie sur des algorithmes incomparablement plus performants que ceux basés sur la méthode
des divisions successives.
2. Obtenir des listes de nombres premiers
C’est aussi un autre point sur lequel on est amené à réfléchir : comment obtenir tous les nombres
premiers inférieurs à un entier donné ? Le crible d’Ératosthène apporte une réponse simple et
classique à cette question.
3
Et mon ordinateur ACER demande 0,35 seconde pour tester les mêmes 50 000 nombres. Plus exactement, il en teste 5 000 000 en 35
secondes. Mon ordinateur semble être approximativement 100 fois plus rapide que ma calculatrice, au moins pour ces calculs.
© T³ France 2011 / Photocopie autorisée
Autour des nombres premiers
79
2.1 Le crible d’Ératosthène

Rappelons la méthode, bien connue de tous les élèves et étudiants.
Soit donc à établir la liste de tous les entiers premiers inférieurs ou égaux à un entier n donné,
supérieur ou égal à 2. On procède de la façon suivante :
On part de la liste de tous les entiers de 1 à n : on peut les écrire comme ci-dessous en ligne par 6 pour
faire apparaître les congruences modulo 6.
1
7
13
19
25
31
37
43
49
2
8
14
20
26
32
38
44
50
3
9
15
21
27
33
39
45
51
4
10
16
22
28
34
40
46
52
5
11
17
23
29
35
41
47
53
6
12
18
24
30
36
42
48
54
Les étapes du crible sont les suivantes :
on raye 1, qui bien sûr n’est pas premier ;
le plus petit nombre non rayé est 2 : on le garde et on barre tous les autres multiples de 2 qui,
par définition, ne sont pas premiers ;
le plus petit nombre non rayé est 3 : on le garde et on barre tous les autres multiples de 3 (le
plus petit multiple de 3 non barré est 32 car 3 × 2 a déjà été barré comme multiple de 2) ;
le plus petit nombre non rayé est 5 : on le garde et on barre tous les autres multiples de 5 (à
partir de 52 car 5 × 4, 5 × 3 et 5 × 2 ont déjà été barrés précédemment comme multiple de 2 ou
de 3) ;
on poursuit de la même façon : à chaque étape, on garde le plus petit nombre non barré r et on
barre tous ses autres multiples à partir de r2 ;
on s’arrête lorsque le plus petit nombre non barré r est tel que r2 > n.
Théorème
Les nombres non barrés dans le crible d’Ératosthène sont les nombres premiers inférieurs ou
égaux à n.
Le résultat est quasi-évident. Justifions-le en deux mots. Il est tout d’abord clair que tout nombre
premier inférieur ou égal à n ne peut pas être barré, puisqu’il n’est le multiple d’aucun entier non
trivial.
Réciproquement soit p un entier tel que 2  p  n non rayé dans la liste. Il n’est donc multiple d’aucun
entier compris entre 2 et n. En d’autres termes, il n’admet aucun diviseur strict compris entre 2 et
n. Bref, p est un nombre premier.
 Ces notions étant rappelées, on peut s’intéresser à la mise en œuvre du crible d’Ératosthène sur la
calculatrice, en ne perdant pas de vue l’intérêt de l’excellente instruction void, déjà maintes fois
utilisée.
© T³ France 2011 / Photocopie autorisée
80
Mathématiques et TI-Nspire
Le point de départ : la valeur de n en paramètre d’entrée, qui nous sert à générer la liste l de tous les
entiers de 2 à n. La variable linf sert à mémoriser les nombres premiers obtenus. Précisons aussi que
les nombres à barrer à chaque étape sont mis à void dans la liste, ce qui permet très facilement de les
retirer à chaque passage dans la boucle avec delVoid. Ne restent plus à la fin que les nombres
premiers inférieurs ou égaux à n.
Examinons le principe de la boucle : on traite le terme de rang i de la liste, le premier terme non rayé,
dont on sait qu’il est premier.
Premier point : on l’incorpore à la liste linf.
Deuxième point en plusieurs étapes regroupées en une seule instruction à détailler :
tout d’abord, on repère dans la liste l, et à partir de la position qui suit i, donc la position i + 1
tous les multiples de l[i] :
seq(when(mod(l[k],l[i])=0,void,l[k]),k,i+1,dim(l))),
delvoid de ce qui précède, pour éliminer les void inutiles,
enfin on n’oublie pas d’incorporer à la liste les nombres premiers déjà obtenus, dans linf
Ceci étant fait, il reste à incrémenter de 1 la valeur de l’indice i pour s’occuper du terme qui suit dans
la liste… sauf si son carré dépasse n évidemment…
Les résultats que l’on obtient sont intéressants :
© T³ France 2011 / Photocopie autorisée
Autour des nombres premiers
81
2.2 Compter les nombres premiers
 … et donc obtenir des valeurs de la célèbre fonction (x) qui compte le nombre de nombres
premiers inférieurs ou égaux à x…
Évidemment, le travail qu’on vient de faire est suffisant pour les premiers résultats : la dimension de
la liste erat(x) répond à la question posée :
 Observons graphiquement ce qui se passe. On représente d’abord dans une feuille de calcul dans
la colonne A les valeurs de x, de 1 à 1000 (un peu moins sur la calculatrice…) et dans la colonne B les
valeurs qui correspondent de (x) :
On demande ensuite la représentation graphique du nuage de points dont les abscisses sont dans la
liste xx et les ordonnées dans la liste yy. Si l’on pouvait mettre en évidence une formule, ou quelque
chose d’approchant…
Mais rien de bien connu n’apparaît : notamment les courbes qui ont des formes voisines, comme celle
des fonctions racine et logarithme népérien, approximent très mal le nuage de points, comme le
montre le graphique ci-dessous.
© T³ France 2011 / Photocopie autorisée
82
Mathématiques et TI-Nspire
Poursuivons notre réflexion sur le tableur en calculant4 cette fois xx/yy.
Cherchons cette fois à représenter le nuage de points dont les coordonnées sont (xx,zz).
On observe à la calculatrice une très bonne corrélation logarithmique, comme le montre l’écran
suivant. On aurait la formule :
x
 0,060873  0,844062ln x
y
4
Dans la zone grisée de la colonne C, remarquer la multiplication par 1. ou 1.0 pour forcer le calcul en mode approché. La technique est
classique et sera réutilisée plusieurs fois dans la suite.
© T³ France 2011 / Photocopie autorisée
Autour des nombres premiers
D’où l’on déduit π  x   y 
83
x

0,060873  0,844062ln x
x
.
0,060873 

ln x  0,844062 

ln x 

On sait bien que le théorème des nombres premiers, démontré en 1896 par Charles de la Vallée
x
Poussin et Jacques Hadamard, donne comme équivalent de (x) pour x tendant vers l’infini
: on
ln x
n’en est pas si loin, à partir de considérations statistiques élémentaires.
© T³ France 2011 / Photocopie autorisée
84
Mathématiques et TI-Nspire
3. Le célèbre petit théorème de Fermat
3.1 Introduction historique
En 1640, Fermat, dans une lettre à Frénicle, a pour la première fois énoncé un théorème concernant
les nombres premiers, sans doute le plus important de l’arithmétique, et qui porte aujourd’hui son
nom.
« Tout nombre premier mesure infailliblement une des puissances moins un de quelque
progression que ce soit et l’exposant de la dite puissance est sous multiple du nombre
premier moins un... »
Ce que l’on peut traduire en disant que tout nombre premier p divise5 am – 1 dès l’instant que
l’exposant m est multiple de p – 1. En particulier, si m = p – 1, alors p divise ap – 1 – 1. En langage
moderne, on rencontre une formulation en termes de congruences.
3.2 L’énoncé du petit théorème de Fermat
Le petit théorème de Fermat
Soit p un nombre premier et a un entier quelconque.
Alors :
ap  a (mod p).
Autre formulation possible
Si a n’est pas un multiple de p, alors :
ap – 1  1 (mod p)
Une des multiples démonstrations possibles de ce célèbre théorème repose sur le lemme suivant, qui
n
mentionne une propriété des coefficients   .
k 
Lemme : une propriété des coefficients binomiaux
n
Si p est un nombre premier et k un entier tel que 0 < k < p alors   est un multiple de p.
k 
On comprend bien que cela ne soit jamais le cas lorsque k = 0 ou k = p, valeurs pour lesquelles le
coefficient binomial vaut 1...
Il peut être intéressant d’observer ce qui se passe en utilisant le tableur :
5
mesure dans le texte...
© T³ France 2011 / Photocopie autorisée
Autour des nombres premiers
85
7
L’examen attentif du triangle de Pascal permet de conjecturer la propriété énoncée. Ainsi, à part  
0
7
7
et   qui valent l’un et l’autre 1, tous les   sont des multiples de 7… car 7 est bien premier !
7
k 
Démonstration du lemme
Nous proposons une démonstration par récurrence. Le résultat est clairement évident lorsque k = 1,
 p
puisque    p .
1
Soit donc p un entier premier et k un entier vérifiant 1 < k < p.
On sait que :
p  p  1 p  2  ...  p  k  1
 p
p!

 
k!
 k  k ! p  k !
 p
Puisque   est un entier, k! divise p(p – 1)(p – 2)...(p – k + 1).
k
D’autre part, comme 1 < k < p, et comme p est premier, k! est premier avec p (car chacun des facteurs
k, k – 1, k – 2, ..., 2, 1 l’est aussi). D’après le théorème de Gauss, on peut en déduire que k! divise
donc (p – 1)(p – 2)...(p – k + 1) : le quotient de (p – 1)(p – 2)...(p – k + 1) par k! est donc entier, d’où
 p
l’on tire que p divise   .
k 
Démonstration du petit théorème de Fermat
Soit donc p un nombre premier. Nous allons démontrer la propriété par récurrence sur l’entier a.
La propriété est manifestement vraie pour a = 0 ou 1, car 0p  0 (mod p), de même que 1p  1 (mod p).
Supposons maintenant que pour un entier arbitraire a, ap  a (mod p).
Nous pouvons écrire, d’après la formule du binôme :
© T³ France 2011 / Photocopie autorisée
86
Mathématiques et TI-Nspire
 a  1
p
p 1
 p
 a p    a k  1
k 1  k 
… et en passant aux congruences modulo p :
 a  1
p
 a p 1
d'après le lemme
 a 1
d'après l'hypothèse de récurrence
Ceci prouve que la propriété est vraie pour tout entier naturel a.
Que se passe-t-il maintenant si a < 0 ?
Par division euclidienne de a par p, on peut écrire :
a = pq + r avec 0  r < p.
Par suite, a p  r p  r  a
 mod p  .
Le petit théorème de Fermat est ainsi démontré dans sa première formulation pour tout entier relatif a.
Démonstration de la deuxième formulation
Intéressons-nous maintenant à la deuxième affirmation. Si l’on sait que ap  a (mod p), il existe un
entier relatif k tel que ap – a = kp soit a(ap – 1 – 1) = kp.
Si par ailleurs a n’est pas un multiple de p, on sait que a et p sont premiers entre eux. Comme p divise
a(ap – 1 – 1) et est premier avec a, le théorème de Gauss permet de conclure que p divise ap – 1 – 1, ce
qui prouve que ap – 1  1 (mod p).
Remarque
Des démonstrations s’appuyant sur la théorie des groupes peuvent être faites (pas au lycée) : elles sont
évidemment plus rapides !
L’idée est de se placer dans le corps  / p , ,  . Comme a n’est pas un multiple de p, il n’est pas
congru à 0 modulo p : en tant que tel, il est donc inversible. Le groupe des éléments inversibles de
 / p , , possède p – 1 éléments : ceci suffit pour dire que a p1  1  mod p  .
Ce raisonnement se généralise à un entier n quelconque. Si on considère un entier a premier avec n, il
est inversible dans l’anneau  / n , ,  : le groupe des éléments inversibles de cet anneau possède
  n  éléments, où   n  désigne le nombre d’entiers inférieurs à n et premiers avec n. On peut en
déduire a  n  1  mod n  . C’est le théorème d’Euler.
Théorème d’Euler
Soit n un entier naturel quelconque et a un entier premier avec n.
Alors :
a  n  1  mod n  .
Exemples

7 étant premier... 26  1 (mod 7).

À quoi est congru 538 mod 11 ? On sait déjà que 510  1 (mod 11) puisque 11 est premier.
Par suite :
538 = 510 × 3 + 8 = (510)3 × (52)4  13  34  81  4 (mod 11)
© T³ France 2011 / Photocopie autorisée
Autour des nombres premiers
87
La calculatrice6 permet, bien sûr, de vérifier ces résultats :
Pour des nombres entiers plus grands, la fonction mod est assez vite prise en défaut, car elle effectue
d’abord le calcul de la puissance, qui peut devenir très grand. Nous verrons en annexe comment écrire
une fonction puismod remédiant à ce problème. Dans l’immédiat, nous utiliserons dans la suite la
fonction pwrmod de la bibliothèque numtheory :
Le théorème de Fermat, essentiel en arithmétique, montre, s’il en était besoin, l’importance de
disposer d’un algorithme d’exponentiation modulaire performant.
3.3 Un critère pour prouver qu’un nombre est composé
Par contraposition, on sait que si ap n’est pas congru à a modulo p, le nombre p est forcément un
nombre composé. Voilà un critère simple, facile à mettre en œuvre, un critère qui prouve qu’un
nombre est composé sans même qu’il soit nécessaire de chercher à le factoriser.
Par exemple, les nombres de Fermat
F5  22  1  232  1
5
F6  22  1  264  1
6
F7  22  1  2128  1
7
F8  22  1  2256  1
8
F9  22  1  2512  1
9
F10  22  1  21 024  1
10
6
Mais il n’est pas mauvais de savoir faire ces calculs à la main...
© T³ France 2011 / Photocopie autorisée
88
Mathématiques et TI-Nspire
sont forcément composés7 si l’on s’en tient aux écrans suivants : ap n’est pas congru à a modulo Fi,
sauf dans le cas de la première ligne, avec a = 2.
On conçoit bien que l’obtention de facteurs de ces nombres de Fermat soit autrement plus difficile...
4. Quelle réciproque pour le petit théorème de Fermat ?
4.1 Réciproque or not réciproque ?
L’existence d’une réciproque serait fort intéressante, car elle donnerait une condition nécessaire et
suffisante relativement simple et efficace d’un point de vue algorithmique pour qu’un entier donné
soit premier. Quelques nombres pris au hasard ne donnent pas de contre-exemples : il faut donc faire
une exploration systématique à la calculatrice pour avoir une idée de ce qui se passe.
On se propose donc de chercher d’éventuels nombres entiers n composés, mais tels que an – 1 soit
congru à 1 mod n pour un certain entier a. Select_range, de la bibliothèque numtheory donne les
réponses suivantes :
7
Avec F11, on atteint les limites du logiciel.
© T³ France 2011 / Photocopie autorisée
Autour des nombres premiers
89
Les contre-exemples, s’ils ne sont pas extrêmement nombreux, sont rapidement trouvés avec TINpsire… Ainsi par exemple la recherche précédente prouve que 3670  1 (mod 671), bien que 671 soit
un nombre composé (= 11  61).
Remarque
Point n’est d’ailleurs besoin de la calculatrice pour prouver que 2340  1 modulo 341. C'est en tout cas
un bon terrain pour démontrer la puissance du calcul des congruences. Remarquons tout d’abord que :
210 = 1024 = 3 × 341 + 1 donc 210  1 (mod 341).
Par suite, 2340 = (210)34  134 = 1 (mod 341).
C’est aussi simple que cela !
De la même façon, 390  1 (mod 91) (basé sur la remarque que 36 = 729  1 (mod 91)).
Toute cette étude pour conclure que la réciproque du petit théorème de Fermat est fausse : si la
condition ap–1  1 (mod p) est nécessaire pour que p soit premier, elle n’est malheureusement pas
suffisante. On y perd à regret une caractérisation simple des nombres premiers. Pour autant, la
réflexion mathématique autour de cette réciproque ne s’arrête pas là ! Une première idée, que nous
développerons dans le prochain chapitre, est d’étudier de plus près les (relativement rares) contreexemples à cette réciproque : elle débouche sur la notion de nombre pseudo-premier. Une autre
approche est possible, celle qui consiste à ajouter des hypothèses qui vont transformer cette
réciproque en une proposition vraie.
4.2 Une « réciproque » au théorème de Fermat
En 1927, le mathématicien américain Lehmer démontra le théorème suivant, qui est une amélioration
d’un théorème proposé par Edouard Lucas en 1891.
Une réciproque du théorème de Fermat : le théorème de Lehmer
Soit n un entier naturel et soient q1, ..., qs les facteurs premiers distincts de n – 1.
Si, pour un nombre entier a strictement supérieur à 1, on a a
 1 (mod n) mais a
(mod n) pour tous les i compris entre 1 et s, alors le nombre n est premier.
n–1
n 1
qi
 1
Remarquons que, qi étant un diviseur premier de n – 1, n – 1 est bien un entier...
qi
On obtient bien une « réciproque » au théorème de Fermat, en imposant bien sûr une hypothèse
supplémentaire, basée sur la connaissance des facteurs premiers de n – 1. On dispose donc d’un
théorème qui permet de prouver qu’un entier donné n est premier, pourvu que l’on sache factoriser
n – 1.
Démonstration
Une première démonstration peut être proposée avec les outils de la théorie des groupes. Comme
an – 1  1 (mod n), d’après le théorème de Bézout, les entiers a et n sont premiers entre eux. Par
conséquent, a appartient au groupe des éléments inversibles de l’anneau  / n , ,  .
Appelons d l’ordre de a dans ce groupe : on a donc ad  1 (mod n).
Comme an – 1  1 (mod n), n – 1 est un multiple de d. Montrons que d = n – 1.
Sinon, on a : d < n – 1.
Écrivons la décomposition en facteurs premiers de n – 1 sous la forme :
© T³ France 2011 / Photocopie autorisée
90
Mathématiques et TI-Nspire
n – 1 = q11  q 2 2  ... q s  s
avec les qi premiers et deux à deux distincts et les i strictement positifs.
Comme d divise n – 1, il existe un entier k tel que :
q11  q 2 2  ... q s  s = kd.
Nécessairement k est différent de 1, car d est strictement inférieur à n – 1. Donc k admet dans sa
décomposition en facteurs premiers au moins un des nombres premiers qi. Pour un de ces qi, on a :
n – 1 = kd = k  d où, d’après nos hypothèses, k = k’ est un entier.
qi
qi qi
qi
Ceci prouve que d divise n – 1.
qi
Mais alors a
n 1
qi
 (ad)k’  1k  1 (mod n), ce qui est contraire aux hypothèses du théorème.
Par conséquent, on a bien prouvé que d = n – 1.
D’après le théorème d’Euler, on sait aussi que a  n  1
 mod n  ,
où   n  désigne l’indicateur
d’Euler, c’est-à-dire le nombre de nombres inférieurs ou égaux à n et premiers avec n.   n  est donc
un multiple de n – 1. Comme   n  est par définition inférieur ou égal à n – 1, on a bien prouvé que
  n   n  1 , donc que n est premier (il ne peut pas avoir de diviseurs compris entre 2 et n – 1).
L’autre démonstration n’utilise pas ces outils. On appelle H l’ensemble de tous les entiers naturels
non nuls h tels que ah  1 (mod n). Cet ensemble est non vide car il contient par hypothèse n – 1. Il
admet donc un plus petit élément d.
Soit h un élément de H. Effectuons la division euclidienne de h par d :
h = qd + r avec 0  r < d
Par suite, ah = (ad)q × ar.
En raisonnant avec les congruences modulo n, on obtient : 1  1q ar, ce qui prouve que ar est congru à
1 modulo n. Comme r < d et d’après le choix de d, c’est impossible que ar  1 (mod n), à moins que r
ne soit nul. Par suite, h = qd, ce qui prouve que h est un multiple de d, plus petit élément strictement
positif de H.
H est donc égal à {d ; 2d ; 3d ; ...}. On peut poursuivre la démonstration précédente de la même façon
que précédemment.
4.3 Quelques exemples
Le théorème s’applique particulièrement bien, on l’a déjà souligné, au cas où n – 1 possède des
facteurs premiers peu nombreux et facilement identifiables. Montrons ainsi que n = 700 001 est
premier. La factorisation de n – 1 est immédiate : n – 1 = 700 000 = 7 × 25 × 55.
Quatre calculs sont à faire :
an – 1, a
n 1
2
= a350 000, a
n 1
5
= a140 000 , a
n 1
7
= a100 000
pour vérifier que l’on est bien dans les conditions d’application du théorème. La valeur de a peut être
changée jusqu’à ce que l’on puisse conclure sur la primalité de n (voir ci-dessous l’essai, non
concluant avec a = 2, et celui avec a = 3).
© T³ France 2011 / Photocopie autorisée
Autour des nombres premiers
91
Ces calculs peuvent être présentés dans une feuille de calcul. On commence par mémoriser la cellule
A2 dans une variable n et la cellule A5 dans une variable a. Les principales instructions peuvent être
lues ci-dessous ; en particulier, on utilise la fonction listprimediv de la bibliothèque numtheory pour
récupérer la liste des diviseurs premiers de n – 1. Notons que dans la cellule B1 figure le calcul de
a n 1 modulo n avec =numtheory\pwrmod(a,n-1,n).
Étudions maintenant la primalité de
n = 500 000 0064 + 1 = 62 500 003 000 000 054 000 000 432 000 001 297
qui possède 35 chiffres !
La décomposition en facteurs premiers de n – 1 donne :
n – 1 = 500 000 0064 = (2 × 11 × 47 × 79 × 6121)4.
© T³ France 2011 / Photocopie autorisée
92
Mathématiques et TI-Nspire
Cette fois-ci, six calculs sont à faire : an – 1, a
a = 2 ne permet pas de conclure.
n 1
2
, a
n 1
11
, a
n 1
47
, a
n 1
79
n 1
, a 6 121 . Une fois de plus, la valeur
Par contre, avec a = 3, on peut affirmer que n est premier :
Une plus grande valeur peut être testée, en l’occurrence :
n = 16913198441637350056768509998876743488187674959937803239626320931682275360001
qui possède 77 chiffres !
Tout d’abord, n – 1 se factorise facilement : il se trouve que c’est un nombre hautement composé8
(voir le chapitre Autour des diviseurs d’un entier).
Mais de nombreux essais sont nécessaires pour trouver une valeur de a qui permette de conclure :
toutes les valeurs de a comprises entre 2 et 30 conduisent à des résultats infructueux.
De guerre lasse, c’est en attribuant à a, dans la cellule A5, la valeur :
= RandInt(1,108)
qu’un résultat favorable est apparu, assez rapidement au demeurant. Bref, le nombre proposé de 77
chiffres est bien premier.
8
Nous avons remarqué que les nombres hautement composés sont souvent très proches, à un près, de nombres premiers.
© T³ France 2011 / Photocopie autorisée
Autour des nombres premiers
93
4.4 Un test de primalité
Un test de primalité peut être écrit en s’appuyant sur les résultats précédents. Qu’on ne se méprenne
pas : il ne s’agit pas d’écrire une fonction plus efficace que la fonction isprime de la calculatrice !
Nous resterons modestes, mesurant la difficulté qu’il y a à être performant en la matière.
La fonction lehmer1(n,a) teste un nombre n avec une certaine base a, que l'on peut choisir
arbitrairement : comme on l’a vu dans le tableur, le résultat renvoyé peut être false ou true, mais aussi
parfois "?" quand le nombre a choisi ne permet pas de conclure c'est-à-dire quand les hypothèses du
théorème de Lehmer ne sont pas vérifiées (voir l'exemple précédent, 700 001 avec la base 2).
La structure du programme est simple.
On calcule d’abord an – 1 mod n.
© T³ France 2011 / Photocopie autorisée
94
Mathématiques et TI-Nspire
Si le résultat obtenu n’est pas congru à 1, le nombre n est composé d’après le théorème de Fermat.
L’affaire est alors classée…
Sinon on récupère la liste des diviseurs premiers de n – 1 comme dans le tableur (fonction
listprimediv de la bibliothèque numtheory).
Concrètement, cela signifie que l’on puisse facilement factoriser l’entier n – 1. C’est loin d’être
toujours possible, le problème de la factorisation d’un entier étant sûrement un des plus délicats de
l’arithmétique. En cas de difficulté, il vaut mieux renoncer (ou utiliser l’excellente fonction isprime !)
Pour chacun des diviseurs premiers p de cette liste, on calcule simultanément tous les n – 1,
p
mémorisés dans la variable list.
On entre ensuite dans une boucle While dont on sort soit quand on a épuisé tous les diviseurs de n,
soit quand a
n 1
p
est congru à 1 modulo n.
Tant que le résultat obtenu n’est pas congru à 1, on peut espérer appliquer le théorème de Lehmer.
Quand on sort de la boucle, il y a donc deux cas à envisager :
soit l’un des restes modulo n de a
n 1
p
vaut 1 et on ne peut pas conclure avec la base choisie a ;
soit on a épuisé toutes les valeurs de a
le nombre n est premier.
n 1
p
modulo n, en trouvant toujours autre chose que 1 et
Voici quelques-uns des résultats obtenus, le premier en un temps tout à fait honorable pour un nombre
entier de 35 chiffres9 !
Comme on l’a vu sur le tableur, la recherche de l’entier qui convient peut parfois être un peu longue :
il s’agit de faire preuve de patience ! Quelques tâtonnements sont parfois nécessaires :
9
Pour lequel la méthode des divisions successives serait complètement inefficace, il faut bien le dire !
© T³ France 2011 / Photocopie autorisée
Autour des nombres premiers
95
Ou alors, après quelques essais systématiques infructeux, il ne faut pas hésiter, comme nous l’avons
fait dans le tableur, à générer au hasard, avec Randint, un entier entre 1 et 108 par exemple :
Tout ceci pour prouver la primalité d’un entier de 183 chiffres.
Certes, le logiciel renvoie une réponse rapide avec isprime.
Sans doute utilise-t-il des techniques algorithmiques qui notamment tiennent compte des résultats de
Lehmer… Il n’est donc pas inutile de les connaître !
© T³ France 2011 / Photocopie autorisée
96
Mathématiques et TI-Nspire
ANNEXE : l’exponentiation modulaire
Un problème de calcul
Intéressons-nous au calcul du reste dans la division de 10n par 7 : la fonction mod semble évidemment
tout indiquée pour un tel calcul.
Ainsi, on constate que le calcul de mod(10n,7) se fait sans aucun problème jusqu’à n = 992. En
revanche, pour des exposants de 10 compris entre 993 et 999, la calculatrice renvoie 0 (suivi du point
décimal pour indiquer qu’elle est passée en mode approché) et au delà de 10 1000, elle renvoie
mod(,7).
Il est clair que la calculatrice effectue en premier le calcul de la puissance. Tout le problème est
finalement de savoir si le calcul de cette puissance est exact ou approché. Or, comme le laisse voir
l’écran ci-dessous, la TI-Nspire travaille en arithmétique exacte pour des nombres entiers possédant
jusqu’à 993 chiffres10 ; pour des entiers n vérifiant 10993  n < 101000, elle passe en écriture
scientifique ; au delà, le nombre est considéré comme égal à l’infini.
Faut-il pour autant renoncer à tout calcul exact, d’autant que le résultat de mod(101000,7) est
banalement un entier compris entre 0 et 6 ?
S’en priver serait en tout cas regrettable, car l’exponentiation modulaire intervient dans de
nombreuses situations en arithmétique (pensons par exemple au théorème de Fermat ou au théorème
d’Euler, à la cryptographie, ...).
Nous nous proposons donc, dans la suite, de mettre au point un algorithme efficace d’exponentiation
modulaire, nous permettant de venir à bout des calculs précédents.
10
C’était 615 chiffres pour une voyage 200 !
© T³ France 2011 / Photocopie autorisée
Autour des nombres premiers
97
Le calcul de proche en proche
 Comment donc résoudre le problème précédent ? L’idée la plus immédiate serait de faire les
calculs de proche en proche, jusqu’à obtenir le résultat demandé.
Par exemple, pour obtenir 51063 modulo 2159, on peut faire les calculs suivants :
mod(5,2159) = 5 ;
mod(52,2159) = 25 ;
mod(53,2159) = 25  5 = 125 ;
mod(54,2159) = 125  5 = 625 ;
mod(55,2159) = 966, qui est le reste dans la division de 625  5 = 3125 par 2159 ;
etc.
Mais cet algorithme, qui permet à coup sûr d’arriver au résultat (on se ramène toujours à des entiers
naturels inférieurs à 2159), est glouton en temps, à cause des 1062 étapes intermédiaires qu’il
demande. Autant dire que pour des exposants plus élevés, le calcul ne pourra pas être mené à son
terme…
 Tout réside donc dans un calcul efficace de ces produits successifs. Or on peut faire mieux et
plus rapidement, à moindre frais. Prenons un exemple simple, sans se préoccuper pour le moment de
mod. Pour calculer a128, il est maladroit d’effectuer les 127 produits successifs qui définissent la
puissance. Pour avoir le résultat, il vaut beaucoup mieux procéder ainsi :
calcul de a2, puis de a4, a8, a16, a32, a64 et enfin a128,
ce qui ne demandera que 7 élévations au carré successives.
Mais si l’exposant n’est pas une puissance de 2 ?
Prenons par exemple a96 : à défaut d’être lui-même une puissance de 2, 96 s’écrit comme somme de
deux puissances de 2 : 96 = 64 +32. Par suite, a96 = a64 × a32, dont le calcul résulte des élévations au
carré obtenues plus haut.
La méthode peut toujours être mise en œuvre : car écrire un nombre sous la forme d’une somme de
puissances de 2 revient à décomposer ce nombre dans la base 2…
Examinons par exemple ce que l’on obtiendrait pour notre exposant 1063. Procédons par étapes.
Étape 1 : on décompose 1063 en base 2, en procédant à des divisions successives par 2.
1063 2
1 531 2
1 265 2
1 132 2
0 66
0
© T³ France 2011 / Photocopie autorisée
2
33
2
1
16
2
0
8
2
0
4
2
0
2
2
0
1
2
1
0
98
Mathématiques et TI-Nspire
On sait que le premier reste correspond au chiffre des unités, le second des « deuzaines »11 et ainsi de
suite. Autrement dit le nombre s’écrit en partant des derniers restes obtenus soit
1063 = 10000100111
d’où l’on déduit la décomposition de 1063 en somme de puissances de 2 :
1063 = 210 + 25 + 22 + 21 + 20 = 1024 + 32 + 4 + 2 + 1.
Étape 2 : par suite, d’après les propriétés des puissances, on peut écrire :
a1063 = a1 2 4321024 = a  a2  a4  a32  a1024.
Étape 3 : on procède ensuite à des élévations au carré successives à partir de a :
a , a2 , a4 , a8, a16, a32 , a64, a128, a256, a512, a1024
Nous intéressent uniquement ceux qui sont entourés, qui permettent d’obtenir a1063. Remarquons
qu’ils correspondent en fait à des restes égaux à 1 dans les divisions précédentes… Il suffit de faire le
produit de ces entiers, éventuellement modulo un autre entier, pour avoir le résultat cherché…
Bilan : comme précédemment, on constate qu’on a beaucoup moins d’opérations à effectuer que les
1062 de la première méthode ! En fait, 11 divisions par 2 et 10 élévations au carré successives et 4
multiplications suffiront à donner le résultat. Le gain est appréciable, et on peut s’attendre à ce que
l’algorithme soit particulièrement efficace !
En reprenant le calcul de 51063 modulo 2159, la démarche précédente conduit à12 :
restes dans
les
divisions
par 2
élévations au
carré successives
carrés
modulo
n = 2159
z modulo 2159
5
1 (unité)
1 (deuzaine)
5
5
2
25
mod(525,2159)=125
4
mod(125625,2159)=401
5
1 (etc.)
5
625
0
58
2005
0
16
2126
32
1089
64
630
128
1803
256
1514
0
5
512
1497
1
51024
2126
5
1
5
0
5
0
5
0
5
mod(4011089,2159)=571
mod(5712126,2159)=588
On peut en conclure que mod(51063,2159)=588 : nous avons par cette méthode mené le calcul à son
terme.
11
Un peu comme dix donne dizaine…
12
Les variables a et z utilisées ici correspondent à celles du programme qui suit.
© T³ France 2011 / Photocopie autorisée
Autour des nombres premiers
99
Le tableau, tel qu’il est présenté, résume la méthode employée : on calcule les carrés successifs de 5
modulo 2159, et on ne cumule dans z (multiplicativement d’une part et modulo 2159 d’autre part) que
les valeurs correspondant à un reste égal à 1. Le nombre de multiplications, effectuées modulo 2159
pour que les calculs n’explosent pas, est donc singulièrement diminué. On obtient finalement 588, ce
que le calcul confirme :
La méthode s’appliquerait sans plus de difficulté à un nombre plus grand, 9 1063 par exemple, pour
lequel l’utilisation bête et brutale de mod donnerait 0 (… car 91063 dépasse 101000).
L’algorithme sur le tableur
La présentation du paragraphe précédent suggère d’employer le tableur pour automatiser les calculs :
c’est un premier pas vers la mise en œuvre effective de l’algorithme.
Quelques remarques. Tout d’abord, le nombre est mémorisé dans une variable a, l’exposant dans une
variable y et l’entier du modulo dans une variable n.
Dans la colonne C, on calcule les quotients des divisions successives par 2 : on saisit int(c2/2) dans la
cellule C3 et on recopie sur quelques lignes. La colonne D est consacrée au reste : dans D3, on tape
=mod(c2,2).
Dans la cellule E3, on saisit =a puis dans E4, =mod(e32,n) ; on recopie sur le même nombre de
lignes.
© T³ France 2011 / Photocopie autorisée
100
Mathématiques et TI-Nspire
Enfin, dans F2, on met =1, puis dans F3, =when(d3=1,mod(d2.e3,n),d2,void) : on n’effectue la
multiplication modulo n que dans le cas où le reste est égal à 1, sinon on ne fait rien.
Le résultat est lu en face du premier 0 dans la suite des quotients, ou encore du dernier reste égal à 1
dans la colonne D : ici on peut écrire que mod(91063,2159) = 1685.
Écriture de fonctions
 Passons à l’écriture d’une fonction, avec les idées exposées précédemment. Nous l’avons appelée
puismod, avec trois paramètres en entrée, a, y et n : elle permet le calcul du reste dans la division par
n de ay.
puismod(a,y,n) = reste dans la division de ay par n
La fonction est conditionnée par une boucle While, gérée par la variable y, qui mémorise les quotients
successifs dans la division par 2 : en effet, on ne sait pas a priori combien de fois on va parcourir
cette boucle. On en sort par contre dès que le quotient est nul, ce qui signifie que la décomposition en
base 2 de l’exposant est terminée.
À chaque passage dans la boucle, on calcule, modulo n, le carré de a et on met à jour la nouvelle
valeur de y.
On mène parallèlement la décomposition de l’exposant y en base 2 et le calcul demandé, stocké dans
la variable z. Si le reste dans la division par 2 vaut 1, le carré de a doit être cumulé multiplicativement
dans la variable z ; sinon, il n’y a rien à faire.
Le code est proposé ci-après.
La fonction puismod est très efficace et les réponses sont renvoyées en un temps très court ; au
contraire de mod, elle autorise des calculs avec des exposants relativement grands. Le dernier résultat
renvoyé, 0., est incorrect car on est passé en mode approché (remarquer le point qui suit la réponse) :
mais il met en jeu des nombres qu’on peut qualifier de gigantesques pour une calculatrice…
© T³ France 2011 / Photocopie autorisée
Autour des nombres premiers
101
 Mais une autre piste consiste à utiliser la récursivité, comme nous l’avons déjà fait pour le calcul
du pgcd, avec l’avantage d’une écriture relativement simple et naturelle.
Supposons que l’on cherche à calculer ay modulo n. On peut alors écrire :
y
si y est pair, ay modulo n est égal  a 2  2 modulo n ;
si y est impair, ay modulo n est égal a  a 2 
y 1
2
modulo n.
On peut en déduire l’écriture d’une fonction récursive. L’exposant y est amené ainsi à avoir des
valeurs de plus en plus petites, par divisions par 2 successives. Il finira par valoir 1, et dans ce cas, on
sait que la valeur à retourner est a.
Les résultats sont obtenus assez rapidement mais restent décevants : lorsque ay dépasse les capacités
de la machine, le calcul ne peut plus être effectué. Rien de mieux donc que la fonction mod :
Essayons de comprendre pourquoi en examinant comment le calcul se fait à partir par exemple de
expmod(2,30,10) :
30 est pair, donc le premier appel renvoie mod(expmod(22,15,10),10) ;
l’instruction précédente engendre un appel de la fonction expmod qui renvoie, puisque 15 est
impair et distinct de 1, 22.mod(expmod(24,7,10),10) ;
© T³ France 2011 / Photocopie autorisée
102
Mathématiques et TI-Nspire
encore un appel de la fonction expmod qui renvoie, puisque 7 est impair et distinct de 1,
24.mod(expmod(28,3,10),10) ;
encore un appel de la fonction expmod qui renvoie, puisque 3 est impair et distinct de 1,
28.mod(expmod(216,1,10),10) ;
cette fois, l’exposant vaut 1 et la fonction renvoie 216.
Bilan : la suite des appels récursifs de notre fonction conduit à estimer :
mod(22.mod(24.mod(28.mod(expmod(216,1,10),10),10),10),10).
Ici, l’évaluation de 216 n’entraîne pas de dépassement de capacité, mais on conçoit aisément que le
même type de problème qu’avec mod peut survenir assez rapidement.
Mais cette fois-ci, on peut contrôler dans la fonction la taille des nombres renvoyés : il suffit de
ramener chaque calcul à son reste modulo n en utilisant le plus souvent possible la fonction mod. On
obtient alors la fonction récursive suivante :
Les résultats sont alors satisfaisants, mais si de trop nombreux appels récursifs à la fonction exmod
sont effectués, on risque de saturer la mémoire de la calculatrice, ou de l’ordinateur… Pour cette
raison, notre fonction puismod précédente13, qui n’a pas ce défaut, doit être préférée à celle-ci :
Nous avons signalé l’existence d’une fonction pwrmod dans la bibliothèque numtheory qui remplit le même rôle que notre puismod et
qui possède la même syntaxe. C’est même celle que nous avons utilisée dans tout le chapitre. Au demeurant, ce n’est pas parce que les
fonctions pré-écrites existent déjà qu’il faut se dispenser de réfléchir sur les algorithmes en œuvre. Ce que nous avons fait dans cette
annexe…
13
© T³ France 2011 / Photocopie autorisée