TP 8 : algorithmes et arithmétique 1 L`algorithme d

T.P. 8 : algorithmes et arithm´etique
1 L’algorithme d’Euclide ´etendu
Impl´ementer en Python, l’algorithme d’Euclide ´etendu vu au cours §1.4. Par commodit´e, le
voici explicit´e sur un exemple appliqu´e `a a=19 et b=15.
k ukvkrkqk
0 1 0 19 0
1 0 1 15 1
2 1 −1 4 3
3−3 4 3 1
4 4 −5 1 3
5 0
A chaque ´etape, si on ne s’int´eresse qu’au triplet Lk=[uk, vk, rk]alors Lk+1=Lk−1−qkLk. On
pourra donc coder [u,v,r] dans une liste.
●(M1) comme une liste de Python : dans ce cas, il faut expliquer `a Python comment ajouter
deux listes et multiplier une liste par un nombre.
●(M2) comme un np.array : l’avantage est que numpy sait ajouter les listes et les multiplier
par un nombre.
2 L’algorithme d’exponentiation rapide
Le but de cette algorithme est de calculer la puissance N-i`eme xNd’un nombre xqui peut ˆetre
un entier ou un flottant, avec un minimum d’op´erations.
L’int´erˆet de cet algo. ne se limite pas aux entiers. Si on l’introduit ici, c’est qu’ensuite on
l’appliquera aussi dans les anneaux de congruences, o`u il est encore plus efficace, et qu’on
s’en servira pour des probl`emes d’arithm´etiques...
a) L’id´ee essentielle : Si N=a0+a12⋅ ⋅ ⋅ + an2n, ´ecriture en base deux, avec ai∈{0,1}alors :
xN=xa0(x2)a1...(x2n)an.
Ensuite deux points de vue possibles, cela d´epend si on connait d´ej`a l’´ecriture en base 2 de
Nou pas.
b) 1`ere m´ethode (des poids faibles vers les poids forts)
En lisant le d´eveloppement en base deux de droite `a gauche : c’est le plus souvent comme cela
que l’algorithme est pr´esent´e, car dans ce cas, on peut aussi obtenir les chiffres successifs du
d´eveloppement en base 2`a chaque ´etape par l’algorithme des poids faibles d´ej`a vu au T.P. 5 :
pas besoin d’avoir fait le calcul du d´ev. en base 2 avant !
Pour mettre en oeuvre l’algorithme on utilise trois variables qu’on va appeler res et aux
comme r´esultat et auxiliaire et la variable Nqui au d´epart contient comme valeur l’exposant
Net qui va permettre `a chaque ´etape de calculer le chiffre du d´eveloppement en base 2 de
N.
De mani`ere pas compl`etement formelle, `a l’´etape i:
●On stocke dans aux la valeur de x2i, obtenue comme carr´e de x2i−1obtenu `a l’´etape
pr´ec´edente.
●En mˆeme temps, on divise `a chaque ´etape Npar 2 pour connaˆıtre le i-`eme chiffre aide
son ´ecriture en base 2. i.e. on it`ere N =N//2 . Le aiest le reste de la division euclidienne
de Npar 2.
●Enfin toujours `a l’´etape i,si ai=1, on multiplie res par x2ic’est-`a-dire la valeur de aux
`a l’´etape i, sinon on ne change pas res.
1

Exercice `a faire : impl´ementer cette id´ee d’algorithme en Python.
Rappel l’algo. de d´ev. en base deux des poids faibles vers les poids forts illustr´e
sur un exple :
24 =2×12 +0→a0=0,
12 =2×6+0→a1=0,
6=2×3+0→a2=0,
3=2×1+1→a3=1,
1=2×0+1→a4=1.
c) 2`eme m´ethode (des poids forts vers les poids faibles)
En lisant l’´ecriture en base 2de gauche `a droite : cette m´ethode ´evite l’utilisation d’une
variable auxiliaire, mais n´ecessite d’avoir calcul´e le d´eveloppement en base 2 de N: ce qui
n’est pas un gros probl`eme pratique en Python, mais jouerait sur les questions de coˆut.
L’id´ee astucieuse, qui est utile dans d’autres contextes (algorithme de H¨orner), est d’´ecrire :
xN=((...(xan)2xan−1)2...)xa1)2xa0
Par exemple avec 24 qui s’´ecrit 11000 en base 2 : x24 =(((x)2.x)2)2)2).
On lit donc l’´ecriture en base 2de Nde gauche `a droite en ignorant le premier 1, on part de
res := 1 et `a chaque ´etape s’il y a un 1dans le d´eveloppement de xen base 2on remplace
res par (res*res)*x, sinon on prend juste le carr´e i.e. on remplace res par (res*res).
Exercice `a faire : impl´ementer cette id´ee d’algorithme en Python
d) Montrer que si Ns’´ecrit avec n+1 chiffres en base 2, alors cet algorithme permet de calculer
xNavec au plus 2nmultiplications.
e) Comparer la vitesse de vos fonctions avec celle de la fonction pow(x,N) de Python qui utilise
ce mˆeme algorithme d’exponentiation rapide.
2

T.P. 8 : algorithmes et arithm´etique (suite)
3 Le test de Fermat
3.1 Exponentiation modulaire
Pour exp´erimenter le test de Fermat, nous commen¸cons par modifier l’algorithme d’exponen-
tiation rapide pour le faire travailler dans les anneaux de congruences (Z/nZ,+,×).
Ecrire une fonction exp_mod(x,N,m) qui applique l’algorithme d’exponentiaton rapide pour
calculer xN, en r´eduisant `a chaque ´etape le r´esultat modulo m, autrement dit, en rempla¸cant le
r´esultat `a chaque ´etape par son reste dans la division euclidienne par m.
Remarque : La fonction Python pow fait exactement cela si on lui rentre l’argument facultatif
m. (A condition de ne pas prendre celle du module math !)
3.2 Le test de Fermat
Le petit th´eor`eme de Fermat dit que si nest un nombre premier alors pour tout a∈N,an≡a[n].
Ce th´eor`eme fournit donc une C.N. pour qu’un nombre soit premier. Si on a un atel que an/≡a[n],
on est sˆur que nn’est pas premier. On dira que nne passe pas le test de Fermat pour la valeur a
en question et donc n’est pas premier.
a) Ecrire une fonction test_Fermat qui prend en argument un nombre net un argument
facultatif a, qui sinon admet a=2 comme valeur par d´efaut, et qui teste si n≪passe ≫le test
de Fermat pour tous entiers entre 2 et a, en renvoyant un bool´een.
b) D´eterminer la liste des nombres non premiers entre 1 et 10000 qui passent le test de Fermat
pour a=2 puis a=3. On utilisera une fonction du type de la fonction premier_mieux du
cours, qu’on appellera simplement premier pour tester la primalit´e du nombre.
3.3 Fabrications d’entiers al´eatoires avec de gros facteurs premiers
a) Ecrire une fonction alea qui prend comme argument facultatif un nombre n, avec comme
valeur par d´efaut n=500 et qui renvoie un nombre entier impair al´eatoire `a nchiffres.
b) Fabriquer `a l’aide de la fonction pr´ec´edente une liste de 10 nombres al´eatoires `a 300 chiffres
chacun et tester la primalit´e de chacun avec le test na¨ıf de la fonction premier. Pour le
premier nombre pour lequel ce test prend beaucoup de temps arrˆeter la recherche et comparer
au test de Fermat pour 2,3...
c) Fabriquer (de mani`ere automatique !) une liste de 10 nombres pour lesquels la fonction
premier ne s’arrˆete pas avant un grand diviseur (`a choisir) et appliquer le test de Fermat
pour ces nombres pour 2 et 3.
d) Tester l’algorithme d’Euclide avec deux nombres `a 300 chiffres. Il r´epond souvent 1. Comparer
avec le temps de calcul de la D.F.P.
3.4 Nombre de Carmichael
Un nombre de Carmichael est un entier n≥2non premier qui v´erifie la propri´et´e que pour tout
entier a∈Z:an≡a[n].
A l’aide de la fonction pr´ec´edente, ´ecrire un programme qui donne la liste de tous les nombres
de Carmichael inf´erieurs `a 10000.
3

4 Le principe du R.S.A (Appendice au T.P. 8)
4.1 Pr´erequis math´ematiques : la fonction ϕd’Euler
Nous avons d´emontr´e en exercice le r´esultat suivant :
Th´eor`eme : Si (G, ˙ )est un groupe ab´elien fini `a n´el´ements alors pour tout x∈G, on a xn=e.
Nous avions vu que ce th´eor`eme, appliqu´e `a G=Z/pZ∗pour pun nombre premier donne
imm´ediatement le petit th´eor`eme de Fermat. Nous allons voir ici une g´en´eralisation.
a) Pour tout n∈N∗, on note ϕ(n)le nombre d’entiers k∈[[1, n]] tels que k∧n=1.
i) Calculer ϕ(p)si pest premier.
ii) Relier ϕ(n)au nombre d’´el´ements inversibles de l’anneau (Z/nZ,+,×)(avec d´em.).
iii) En d´eduire la propri´et´e suivante, due `a Euler :
∀a∈Z,∀n∈N∗, a ∧n=1⇒aϕ(n)≡1[n]
iv) Quel r´esultat connu la question pr´ec´edente g´en´eralise-t-elle ?
b) i) Montrer que si a∧b=1 alors ϕ(ab)=ϕ(a)ϕ(b)(plus difficile !)
ii) Montrer que si pet qsont deux nombres premiers distincts, alors pour tout apremier
avec pq, on a a(p−1)(q−1)≡1[pq].
iii) On garde les hyp. du b).
Soit e∈N∗premier avec (p−1)(q−1)et soit d∈N∗tel que de ≡1[(p−1)(q−1)].
Justifier l’existence de l’entier det montrer que ade ≡a[pq].
4.2 Cryptage de Rivest, Shamir, Adleman (1978)
4.2.1 La fabrication de la cl´e de codage : sa partie publique, sa partie secr`ete
Dans la m´ethode R.S.A., il y a deux personnes dont les rˆoles sont bien distincts. Nous parlerons
d’un chef et d’un subordonn´e, le subordonn´e devant transmettre des messages chiffr´es (i.e. prot´eg´e
par un code secret) au chef.
Le chef choisit deux nombres premiers pet q(assez grands, disons de 150 chiffres chacun en
base 10). Il calcule le produit n=pq (c’est facile pour un ordinateur : pour des nombres de 100
chiffres, cela ne fait que 10000 op´erations, et un ordi en fait 1011 par secondes), puis le nombre
(p−1)(q−1).
Il choisit ensuite un nombre epremier avec (p−1)(q−1).
Question 1 Pourquoi est-ce facile `a faire ?
Il rend alors publique la cl´e R.S.A. i.e. les nombres net e, mais surtout pas les nombres pet q.
Il calcule de son cˆot´e, un nombre dtel que de ≡1[(p−1)(q−1)].
Question 2 Comment peut-on le faire en pratique ?
On notera que cela n´ecessite de connaˆıtre le nombre (p−1)(q−1)=pq −q−p+1 (ce qui revient `a
connaˆıtre pet q). Pour cela, si on n’est pas le chef, il suffirait de factoriser n. Mais, tout le principe
de la m´ethode R.S.A. est : il est trop compliqu´e de d´ecomposer nen facteur premier, mˆeme pour
un ordinateur !
A ce stade, le chef a une cl´e secr`ete qui est (n, p, q, e, d)avec n=p×qet il a rendu publique
(pour quiconque veut lui envoyer des messages) une partie de la cl´e : (n, e).
4.2.2 Comment un subordonn´e peut envoyer des messages au chef ?
Le message est repr´esent´e par un nombre. Ce nombre est d´ecoup´e en paquets de chiffres suc-
cessifs, pour que chaque paquet d´efinisse un nombre inf´erieur `a l’entier nd´efini par la cl´e publique.
Pour chaque paquet m, le subordonn´e calcule m′=meet envoie m′au chef.
4.2.3 Comment le chef peut d´ecoder le message re¸cu ?
Le chef est le seul `a connaˆıtre d, il calcule m′dmodulo n, et il retombe sur le message original
m.
4