Chapitre 3 Analyse que quelques algorithmes - IMJ-PRG

Chapitre 3
Analyse que quelques algorithmes
arithm´etiques
3.1 Puissance rapide et applications.
Proposition 3.1.1 Soit (G, ∗)un groupe commutatif dont on note la loi multiplicativement. On
peut calculer anen O(log(n)) op´erations ∗.
Remarque 3.1.2 On distinguera deux situations assez diff´erentes selon que le coˆut de x∗yest
ind´ependant des ´el´ements x, y de Gou pas. Donnez 2exemples de Gdans chaque situation.
Entr´ee: Un ´el´ement gde Get un naturel n.
Sortie: Un ´el´ement de G:gn
Fonction puiss(g, n) ;
u←1; v←g; //u,v : 2 variables locales ;
tantque n > 1faire
si npair alors
v←v∗v;n←n/2;
sinon
u←u∗v;v←v∗v;n←(n−1)/2;
fsi
ftantque
retourner u∗v;
Algorithme 1: Puissance rapide.
Exercice 3.1.3 Programmez en python et en xcas une fonction de puissance rapide : puis(u,n,loi)
et testez la.
3.1.1 RSA.
Proposition 3.1.4 On consid`ere un entier n=p.q o`u pet qsont des nombres premiers impairs
distincts. Pour tout entier epremier avec φ(n)=(p−1)(q−1), la fonction ψe: (Z
//nZ /)×→
(Z
//nZ /)×,x7→ xe[n]est bijective, et la connaissance de pet qpermet de trouver sa r´eciproque en
temps polynomial (en log n).
Remarque 3.1.5 On ne connait pas d’algorithme polynomial (en log n) pour trouver les facteurs
premiers d’un entier. De plus la donn´ee de (n, φ(n)) est ´equivalente (en temps polynomial) `a la
donn´ee de (p, q)
Exercice 3.1.6 Dans la documentation officielle de Python, en ´etudiant les ”builtin functions”,
trouver comment obtenir un caract`ere `a partir d’un code ascii, et vice versa. Trouver dans xcas
comment convertir une chaine en la liste des codes ascii de ses caract`eres.
1

Un exemple de programme python pour encoder une chaine vers un entier. thonverb
(python)
def c h a i n e 2 e n t i e r s (L ) :
”””On enc ode une c ha in e de c a r a c t e r e par l ’ e n t i e r somme su r i d es
c i . 25 6ˆ i ou c i e s t l e cod e a s c i i du ieme c a r a c t e r e de l a c ha in e ”””
a=1; s=0 # s e s t l a somme p a r t i e l l e , e t a l a p u i s s a n c e de 256 c o ur an t e
for iin L :
s=s+a∗ord ( i )
a=a ∗256
return s
print c h a i n e 2 e n t i e r s ( ’ ab cdef tutu ’ )
Exercice 3.1.7 Avec xcas, trouver p, q avec nextprime tels que n:=p*q;ifactor(n); ne semble
pas r´epondre. Choisissez un entier e, trouvez son inverse modulo φ(n)avec xcas, (ou si vous avez
le temps avec une fonction Python bezout que vous auriez programm´e). Puis cr´eez une fonction
python qui encode un message d’au plus 20 caract`eres en un entier, et une fonction qui d´ecode cet
entier.
3.1.2 Algorithmes probabilistes : Monte Carlo & Las Vegas.
Il existe deux types d’algorithmes probabilistes.
-Las Vegas : La r´eponse est fixe, mais pas le temps d’ex´ecution. Il continue d’utiliser une
donn´ee al´eatoire jusqu’`a ce qu’il trouve la r´eponse voulue. (il joue jusqu’`a gagner)
-Monte Carlo : Ici le temps d’ex´ecution est fixe, mais pas la r´eponse. Autrement dit, on
produit une r´eponse `a partir d’un nombre fix´e de tirages al´eatoires. Ex une valeur approch´ee
d’int´egrale.
S’il est clair que dans le protocole RSA la donn´ee de n, φ(n) permet de trouver l’inverse de ψeil
n’est pas tout `a fait vrai qu’il faut connaˆıtre φ(n) pour trouver cet inverse en temps polynˆomial.
En effet, il suffit de connaˆıtre un multiple xde (p−1) ∨(q−1).
Remarque 3.1.8 xest un multiple de (p−1) ∨(q−1) si et seulement si, pour tout apremier
avec p.q on a ax= 1 [p.q]
Nous donnons donc ici un algorithme probabiliste qui donne les nombres premiers p, q `a partir d’un
multiple de (p−1) ∨(q−1).
Tout d’abord, un algorithme de type Monte Carlo (qui n’utilise pas la connaissance de pet q,
uniquement celle de n=p.q
Entr´ee: Un multiple xde (p−1) ∨(q−1) o`u p, q sont premiers impairs. Une probabilit´e π.
Sortie: Une r´eponse sˆure : x/2 n’est pas multiple de (p−1) ∨(q−1). ou bien;
une r´ep. prob : x/2 est probablement un multiple de (p−1) ∨(q−1).
t←1;
tantque t > (1 −π)faire
arecoit une valeur al´eatoire entre 0 et n−1 telle que a∧n= 1;
si ax/26= 1 [n]alors
t←0;
sinon
t←t/2 //la probabilit´e de perdre est de 1/2;
fsi
ftantque
si t= 0 alors
retourner x/2 non multiple;
sinon
retourner x/2 probablement multiple;
fsi
Algorithme 2: Test x/2
2

On peut maintenant utiliser cet algorithme de type Las Vegas pour trouver (p, q) avec une
probabilit´e de type pile ou face.
Entr´ee: Un multiple xde (p−1) ∨(q−1) o`u p, q sont premiers impairs, tel que x/2 n’ait
pas la mˆeme propri´et´e;
Sortie: (p, q);
p←1;
tantque p= 1 ou p=nfaire
arecoit une valeur al´eatoire entre 0 et n−1 telle que a∧n= 1;
p= (ax/2−1) ∧n;
ftantque
sinon
retourner (p, n/p);
fsi
Algorithme 3: Trouve p,q
3.2 Primalit´e
3.2.1 Liste ou tests
Entr´ee: un entier N
Sortie: la liste des premiers inf´erieurs `a N;
Fonction Premiers(N);
liste ←[2 : N] ; //la liste est index´ee de 0 `a N−1;
i←0;
tantque i < longueur(liste) faire
p←liste[i] ; m←2p;
tantque m≤Nfaire
si mest dans la liste alors
Enlever mde la liste;
fsi
m←m+p;
ftantque
i←i+ 1;
ftantque
retourner liste;
Algorithme 4: Crible d’Eratost`ene
Exercice 3.2.1 Progammez en Python le crible d’Eratost`ene, et donnez un ordre de grandeur de
Npour qu’il mette plus de 1 `a 2 minutes pour r´epondre.
Th´eor`eme 3.2.2 (Petit th´eor`eme de Fermat) Si pest un nombre premier, alors pour tout a
premier avec p, on a
ap−1≡1 (mod p).
On dit qu’un entier a, 1 <a<n, est t´emoin de la non primalit´e de nsi an−16≡ 1 (mod n), sinon
on dit que npasse le test de Fermat pour a. Si an’est pas t´emoin alors que nn’est pas premier,
on dit que nest faux t´emoin.
3

Entr´ee: Un entier N;
Sortie: La liste des entiers inf´erieurs `a N,N≥5, qui passent le test de Fermat pour 2 et 3;
Fonction TestFermat(N);
liste←[2,3];
pour nentre 5et Nfaire
si 2n−1≡1 (mod n)alors
si 3n−1≡1 (mod n)alors
Ajouter n`a la liste;
fsi
fsi
fpour
retourner liste;
Algorithme 5: test de fermat
Exercice 3.2.3 Ecrire les fonctions correspondantes en Python, et trouver les intrus dans la liste
obtenue avec TestFermat(3000).
3.2.2 Le test de Miller-Rabin
Entr´ee: entier impair n`a tester, entier tdonnant le nombre de t´emoins.
Sortie: un r´eponse sure nest non premier, ou bien une r´eponse probabiliste : nest
probablement premier
b←0 ;r←n−1;
tantque rest pair faire
b←b+ 1 ; r←r/2 ; // n−1=2br,rimpair ;
ftantque
pour jde 1`a tfaire
choisir au hasard dentre 2 et n−2;
d←(drmod n) ; // positif si dvaut 1 ou n−1;
si d6= 1 et d6=n−1alors
k←1;
tantque k < b et d6=n−1faire
d←(d2mod n) ; k←k+ 1 ; // calcul des carr´es successifs;
si d= 1 alors
retourner (“non premier”) ; // plus d’espoir de trouver −1 : n´egatif;
fsi
ftantque
si d6=n−1alors
Sortie(“non premier”);
fsi
fsi
fpour
retourner (“tr`es probablement premier”) ;
Algorithme 6: Test de Miller-Rabin
Exercice 3.2.4 1. En s’appuyant sur le th´eor`eme suivant, justifier le test de Miller-Rabin.
2. On admet que dans le test de Miller-Rabin le nombre de faux t´emoins pour un entier nnon
premier est au plus n/4. Combien de t´emoins suffisent pour que la r´eponse positive soit exacte avec
une probabilit´e sup´erieure `a 1−(A.N. = 10−6).
Th´eor`eme 3.2.5 Si pest premier impair, et si n−1 = 2br, avec rimpair, alors pour tout a
premier avec n:
soit ar≡1 (mod n),
soit il existe k,0≤k < b, tel que : ar2k≡ −1 (mod n).
Exercice 3.2.6 Etudier la preuve du th´eor`eme et la majoration du nombre de faux t´emoins.
4