Autour des nombres premiers

Autour des nombres premiers

L’utilisation des calculatrices est interdite.

Pr´ eambule

Chiffrer les donn´ ees est n´ ecessaire pour assurer la confidentialit´ e lors d’´ echanges d’informations sensibles. Dans ce domaine, les nombres premiers servent de base au principe de cl´ es publique et priv´ ee qui permettent, au travers d’algorithmes, d’´ echanger des messages chiffr´ es. La s´ ecurit´ e de cette m´ ethode de chiffrement repose sur l’existence d’op´ erations math´ ematiques peu coˆ uteuses en temps d’ex´ ecution mais dont l’inversion (c’est-` a-dire la d´ etermination des op´ erandes de d´ epart ` a partir du r´ esultat) prend un temps exorbitant. On appelle ces op´ erations « fonctions ` a sens unique ».

Une telle op´ eration est, par exemple, la multiplication de grands nombres premiers. Il est ais´ e de calculer leur produit. Par contre, connaissant uniquement ce produit, il est tr` es difficile de d´ eduire les deux facteurs premiers. Le sujet ´ etudie diff´ erentes questions sur les nombres premiers.

Les programmes demand´ es sont ` a r´ ediger en langage Python. Il n’est pas n´ ecessaire d’avoir r´ eussi

`

a ´ ecrire le code d’une fonction pour pouvoir s’en servir afin de r´ epondre ` a une autre question.

D´ efinitions et notations

• Un nombre premier est un entier naturel qui admet exactement deux diviseurs, 1 et lui-mˆ eme.

Ainsi 1 n’est pas consid´ er´ e comme premier.

• Un flottant est la repr´ esentation d’un nombre r´ eel en m´ emoire.

• Le s´ eparateur pour les flottants est « . » et non « , ».

• Quand une fonction Python est d´ efinie comme prenant un « nombre » en param` etre cela signifie que ce param` etre pourra ˆ etre indiff´ eremment un flottant ou un entier.

• On note bxc la partie enti` ere de x.

• abs(x) retourne la valeur absolue de x. La valeur retourn´ ee est du mˆ eme type de donn´ ees que celle en argument.

• int(x) retourne sous forme d’entier la partie enti` ere de x, c’est-` a-dire l’entier n tel que n 6 x < n + 1.

• round(x) retourne sous forme de flottant la valeur de l’entier le plus proche de x. Si deux entiers sont ´ equidistants, l’arrondi se fait vers la valeur paire.

• floor(x) retourne sous forme de flottant la valeur du plus grand entier inf´ erieur ou ´ egal ` a x.

• ceil(x) retourne sous forme de flottant la valeur du plus petit entier sup´ erieur ou ´ egal ` a x.

• log(x) retourne sous forme de flottant la valeur du logarithme n´ ep´ erien de x.

• log(x, n) retourne sous forme de flottant la valeur du logarithme de x en base n.

• La fonction time() du module time retourne un flottant repr´ esentant le nombre de secondes depuis le 01/01/1970 avec une r´ esolution de 10

seconde (horloge de l’ordinateur).

• L’op´ erateur usuel de division / retourne toujours un flottant, mˆ eme si les deux op´ erandes sont des multiples l’un de l’autre.

• L’infini en Python s’´ ecrit float("inf").

• En Python 3, on peut utiliser des entiers illimit´ es de plus de 32 bits avec le type long.

Partie I. Pr´ eliminaires

o Q1 – Dans un programme Python on souhaite pouvoir faire appel aux fonctions log, sqrt, floor et ceil du module math (round est disponible par defaut). ´ Ecrire des instructions permettant d’avoir acc` es ` a ces fonctions et de calculer le logarithme n´ ep´ erien de 0.5.

o Q2 – ´ Ecrire une fonction sont_proches(x, y) qui retourne True si la condition suivante est remplie et False sinon.

|x − y| 6 atol + |y| × rtol

O` u atol et rtol sont deux constantes, ` a d´ efinir dans le corps de la fonction, valant respectivement 10

et 10

. Les param` etres x et y sont des nombres quelconques.

o Q3 – On donne la fonction mystere ci-dessous. Que retourne mystere(1001, 10) ? Le param` etre x est un nombre strictement positif et b un entier naturel non nul.

1 def m y s t e r e ( x , b ) : 2 i f x < b :

3 return 0

4 e l s e:

5 return 1 + m y s t e r e ( x / b , b )

o Q4 – Exprimer ce que renvoie mystere en fonction la partie enti` ere d’une fonction usuelle.

o Q5 – On donne le code suivant :

1 pas = 1 e−5 2

3 x2 = 0

4 f o r i in range( 1 0 0 0 0 0 ) :

5 x1 = ( i + 1 ) ∗ pas

6 x2 = x2 + pas

7

8 print( ”x1 : ” , x1 ) 9 print( ”x2 : ” , x2 )

Apr` es l’avoir ex´ ecut´ e de nombreuses fois on a syst´ ematiquement un r´ esultat qui ressemble ` a : x1: 1.0

x2: 0.9999999999980838

Commenter.

Partie II. G´ en´ eration de nombres premiers II.a Approche syst´ ematique

Le crible d’´ Eratosth` ene est un algorithme qui permet de d´ eterminer la liste des nombres premiers appartenant ` a [[1,n]]. Le pseudo-code de ce crible s’´ ecrit comme suit :

Donn´ ees : N , entier sup´ erieur ou ´ egal ` a 1 R´ esultat : liste bool, liste de bool´ eens d´ ebut

liste bool ←− liste de N bool´ eens initialis´ es ` a Vrai;

Marquer comme Faux le premier ´ el´ ement de liste bool;

pour entier i ← 2 ` a √

N faire

si i n’est pas marqu´ e comme Faux dans liste bool alors

Marquer comme Faux tous les multiples de i diff´ erents de i dans liste bool ; fin

fin

retourner liste bool fin

Algorithme 1 : Crible d’´ Eratosth` ene

A la fin de l’ex´ ` ecution si un ´ el´ ement de liste_bool vaut Vrai alors le nombre cod´ e par l’indice consid´ er´ e est premier. Par exemple pour N=4 une impl´ ementation Python du crible retourne [False True True False].

o Q6 – Sachant que le langage Python traite les listes de bool´ eens comme une liste d’´ el´ ements de 32 bits chacun, quel est (approximativement) la valeur maximale de N pour laquelle liste_bool est stockable dans la m´ emoire vive de 4 Go ?

o Q7 – Quel facteur peut-on gagner sur la valeur maximale de N en utilisant une biblioth` eque permettant de coder les bool´ eens non pas sur 32 bits mais dans le plus petit espace m´ emoire possible pour ce type de donn´ ees (on demande de le pr´ eciser) ?

o Q8 – ´ Ecrire la fonction erato_iter(N) qui impl´ emente l’algorithme 1. Le param` etre N est un entier sup´ erieur ou ´ egal ` a 1.

o Q9 – Quelle est la complexit´ e algorithmique du crible d’´ Eratosth` ene en fonction de N ? On admettra que :

X

p<N,p premier

1

p ' ln(ln(N )) (1)

La r´ eponse devra ˆ etre justifi´ ee.

o Q10 – Quand on traite des nombres entiers il est int´ eressant d’exprimer la complexit´ e d’un algorithme non pas en fonction de la valeur N du nombre trait´ e mais de son nombre de chiffres n.

Donner une approximation du r´ esultat de la question pr´ ec´ edente en fonction de n en pr´ ecisant la base choisie.

II.b G´ en´ eration rapide de nombres premiers

L’approche syst´ ematique qui pr´ ec` ede est inefficace car elle revient ` a attendre d’avoir g´ en´ er´ e la liste

de tous les nombres premiers inf´ erieurs ` a une certaine valeur pour en choisir ensuite quelques uns au

hazard. Une meilleure id´ ee est d’utiliser des tests probabilistes de primalit´ e. Ces tests ne permettent

pas de garantir qu’un nombre est premier. Cependant, au sens probabiliste, si un nombre r´ eussit

un de ces tests alors la probabilit´ e qu’il ne soit pas premier est prouv´ ee ˆ etre inf´ erieure ` a un seuil calculable.

En suivant cette id´ ee, une nouvelle approche est la suivante : 1. g´ en´ erer un entier pseudo-al´ eatoire (voir ci-dessous).

2. v´ erifier si cet entier a de fortes chances d’ˆ etre premier.

3. recommencer tant qu’on n’a pas g´ en´ er´ e un entier probablement premier.

Pour g´ en´ erer un entier pseudo-al´ eatoire A on se base sur un certain nombre d’it´ erations de l’al- gorithme Blum Blum Shub, d´ ecrit comme suit. On initialise A ` a z´ ero au d´ ebut de l’algorithme et pour chaque it´ eration (i ≤ 1) on calcule :

x

= reste de la division euclidienne de x

par M (2) o` u M est le produit de deux nombres premiers quelconques et x

une valeur initiale nomm´ ee

« graine » choisie al´ etoirement. On utilise ici l’horloge de l’ordinateur comme source pour x

. Puis, pour chaque x

, s’il est impair, on additionne 2

` a A.

o Q11 – On r´ ep` ete (2) pour i parcourant [[0,N − 1]], quelle sera la valeur de A si x

est impair ` a chaque it´ eration ?

o Q12 – Compl´ eter (avec le nombre de ligne que vous jugerez n´ ecessaire) la fonction bbs(N) donn´ ee ci-dessous qui r´ ealise ces it´ erations. La graine est un entier repr´ esentant la fraction de secondes du temps courant, par exemple 1528287738.7931523 donne la graine 7931523. Le param` etre N est un entier non nul.

1 def bbs (N ) :

2 p1 = 24 3 7 5 7 6 3 3 p2 = 28 9 7 2 7 6 3

4 M = p1 ∗ p2

5 # c a l c u l e r l a g r a i n e 6 . . . ( `a compl ´e t e r )

7 x i = . . . # l e p r e m i e r x i r e ¸c o i t l a v a l e u r de l a g r a i n e

8 A = 0

9 f o r i in range(N ) :

10 i f . . . ( `a compl ´e t e r )# s i x i e s t i m p a i r

11 A += 2∗∗i

12 # c a l c u l e r l e n o u v e l x i 13 x i = . . . ( `a compl ´e t e r ) 14 return(A)

Le test de primalit´ e probabiliste le plus simple est le test de primalit´ e de Fermat. Ce test utilise la contrapos´ ee du petit th´ eor` eme de Fermat qu’on peut ´ evoquer comme suit : si a ∈ [[2,p − 1]] est premier et que le reste de la division euclidienne de a

par p vaut 1, alors il y a de « fortes » chances pour que p soit premier.

o Q13 – En combinant les r´ esultats du test de primalit´ e de Fermat pour a = 2, a = 3, a = 5 et a = 7, ´ ecrire une fonction premier_rapide(n_max) qui retourne un nombre al´ eatoire inf´ erieur strictement ` a n max qui a de fortes chances d’ˆ etre premier. Le param` etre n_max est un entier sup´ erieur ` a 12.

o Q14 – On souhaite caract´ eriser le taux d’erreurs de premier_rapide.

Ecrire une fonction ´ stats_bbs_fermat(N, nb) qui contrˆ ole pour nb nombres, inf´ erieurs ou ´ egaux

`

a N, g´ en´ er´ es par premier_rapide, qu’ils sont r´ eellement premiers. Cette fonction retourne le taux

relatif d’erreur ainsi que la liste des faux nombres premiers trouv´ es. Les param` etres N et nb sont

des entiers strictement positifs.

Partie III. Compter les nombres premiers

La question de la r´ epartition des nombres premiers a ´ et´ e ´ etudi´ ee par de nombreux math´ ematiciens, dont Euclide, Riemann, Gauss et Legendre. On ´ etudie dans cette partie les propri´ et´ es de la fonction π(n), qui renvoie le nombre de nombres premiers compris dans [[1,n]].

III.a Calcul de π(n) via un crible

o Q15 – ´ Ecrire une fonction Pi(N) qui calcule la valeur exacte de π(n) pour tout entier n de [[1,N ]].

Les nombres premiers sont d´ eduits de la liste liste_bool retourn´ ee par la fonction erato_iter de la question 8. On demande que Pi(N) retourne son r´ esultat sous la forme d’une liste de [n, π(n)].

Par exemple Pi(4) renvoie la liste [[1, 0], [2, 1], [3, 2], [4, 2]].

Un seul appel ` a erato_iter est autoris´ e et on exige une fonction dont la complexit´ e, en dehors de cet appel, est lin´ eaire en fonction de N. Le param` etre N est un entier sup´ erieur ` a 1.

Il a ´ et´ e prouv´ e que

< π(n) pour tout n > 5393. On souhaite v´ erifier cette in´ egalit´ e en se basant sur la fonction Pi(N) ´ ecrite question 15.

o Q16 – ´ Ecrire une fonction verif_Pi(N) qui retourne True si l’in´ egalit´ e est v´ erifi´ ee jusqu’` a N inclus, False sinon. Le param` etre N est un entier suppos´ e sup´ erieur ou ´ egal ` a 5393.

III.b Calcul d’une valeur approch´ ee de π(n)

Le calcul de π(n) d´ epend de la capacit´ e ` a calculer de mani` ere exhaustive tous les nombres premiers de [[1,N ]], or le temps n´ ecessaire ` a ce calcul devient rapidement tr` es grand lorsque N augmente.

Il existe par contre plusieurs m´ ethodes pour calculer une valeur approch´ ee de π(n). Une m´ ethode utilise la fonction logarithme int´ egral li, dont une repr´ esentation graphique est fournie figure 1, et qui est d´ efinie comme :

0.0 0.5 1.0 1.5 2.0 2.5

x 5

4 3 2 1 0 1 2

li(x)

Figure 1 – Allure de li sur [0,2.5]

li : R

\ {1} → R (3) x 7→

Z

0

dt ln(t)

Si x > 1, l’int´ egrale impropre doit ˆ etre interpr´ e- t´ ee comme sa valeur principale de Cauchy qui est d´ efinie comme :

li(x) = lim

ε→0⁺

Z

0

dt ln(t) +

Z

1+ε

dt ln(t)

(4) L’int´ erˆ et de li pour compter les nombres premiers vient de la propri´ et´ e suivante :

x→∞

lim

π(bxc)

li(x) = 1 (5)

On souhaite d´ evelopper un programme permettant de calculer une valeur approch´ ee de li. On

compare ensuite ses r´ esultats ` a une impl´ ementation de r´ ef´ erence qui est nomm´ ee ref_li, r´ eput´ ee

tr` es pr´ ecise.

Estimation de li par quadrature num´ erique

On choisit d’utiliser la m´ ethode des rectangles ` a droite. On appelle pas la base des rectangles. La figure 4 illustre cette m´ ethode appliqu´ ee au calcul de la valeur principale d´ efinie ´ equation (4).

Par souci de simplification on suppose que pas est choisi de mani` ere ` a ce que 1 et x soient multiples de pas et on utilise ε = pas dans l’´ equation (4).

o Q17 – La fonction qui est ´ evalu´ ee sur l’intervalle d’int´ egration est suppos´ ee avoir une complexit´ e constante quelles que soient ses valeurs d’entr´ ee. Quelle est la complexit´ e en temps de la m´ ethode des rectangles ` a droite ? On prendra soin d’expliciter en fonction de quelle variable d’entr´ ee cette complexit´ e est exprim´ ee.

o Q18 – Dans les mˆ emes conditions d’´ evaluation quelle est la complexit´ e en temps de la m´ ethode des rectangles centr´ ees (ou du point milieu) ? Donner aussi celle de la m´ ethode des trap` ezes.

o Q19 – ´ Ecrire une fonction inv_ln_rect_d(a, b, pas) qui calcule par la m´ ethode des rectangles

`

a droite une valeur approch´ ee de R

dt

ln(t)

avec une incr´ ement valant pas. On suppose dans cette question que a < b et que 1 n’appartient pas ` a l’intervalle [a,b] de sorte que la fonction int´ egr´ ee est d´ efinie et continue sur [a,b]

On consid` ere que le r´ eel b − a est un multiple du r´ eel pas.

Les param` etres a, b et pas sont des flottants.

o Q20 – ´ Ecrire une fonction li_d(x, pas) qui calcule une valeur approch´ ee de li(x) avec la m´ ethode des rectangles ` a droite en se basant sur inv_ln_rect_d. Si x = 1 la fonction renvoie −∞.

On rappelle qu’on suppose que pas est choisi de mani` ere ` a ce que 1 et x soient multiples de pas et qu’on utilise ε = pas dans l’´ equation (4). Les param` etres x et pas sont des flottants.

Analyse des r´ esultats de li_d

Apr` es avoir test´ e li_d on obtient plusieurs r´ esultats surprenants.

0.0 0.5 1.0 1.5 2.0 2.5

x 10²

10¹ 10⁰ 0 10⁰ 10¹ 10²

Écart relatif

Figure 2 – ´ Ecart relatif entre li_d (pas = 10

) et l’impl´ ementation de

r´ ef´ erence ref_li.

0.0 0.5 1.0 1.5 2.0 2.5

x 10⁵

10⁴ 10³ 10² 10¹ 10⁰

Écart absolu

Figure 3 – ´ Ecart absolu entre li_d (pas = 10

) et l’impl´ ementation de

r´ ef´ erence ref_li.

o Q21 – Expliquer le comportement de l’´ ecart relatif entre li_d et ref_li, illustr´ e figure 2 au

voisinage de x ' 1.4.

o Q22 – On constate un ´ ecart absolu important entre li_d et ref_li au del` a de x = 1, illustr´ e figure 3. Expliquer succintement d’o` u vient ce ph´ enom` ene. On ne demande pas une d´ emonstration math´ ematique rigoureuse mais un raisonnement qualitatif.

Pour r´ epondre ` a cette question on peut remarquer qu’au premier ordre

' −

quand ε → 0 et s’interroger sur la valeur que devrait avoir l’int´ egrale impropre de

sur un intervalle [1 − ε,1 + ε] avec ε 1. Une analyse g´ eom´ etrique de la figure 4 peut aussi s’av´ erer utile.

o Q23 – Proposer, en justifiant votre choix, une ou des modifications de l’algorithme utilis´ e afin d’´ eliminer le probl` eme constat´ e sur l’´ ecart absolu. Il n’est pas demand´ e d’´ ecrire le code mettant en œuvre ces propositions.

0.90 0.91 0.92 0.93 0.94 0.95 0.96 0.97 0.98 0.99 1.00 1.01 1.02 1.03 1.04 1.05 1.06 1.07 1.08 1.09 1.10 x

10

10

10

10

10 0

10

10

10

10

10

y

pas

ln(x)1

Points évalués pour les rectangles à droite

Figure 4 – Rectangles utilis´ es par la m´ ethode des rectangles ` a droite au voisinage de 1 afin de calculer la valeur principale de Cauchy introduite ´ equation (4). Les param` etres sont

pas = ε = 10

Estimation de li via Ei

L’approche par quadrature num´ erique n’est pas satisfaisante. Non seulement elle rend le temps

d’ex´ ecution de li_d prohibitif quand x augmente mais de plus l’utilisateur doit choisir un pas sans

r` egle claire ` a appliquer pour garantir une pr´ ecision donn´ ee. La fonction exponentielle int´ egrale Ei

permet de pallier ce probl` eme.

Ei : R

→ R (6) x 7→

Z

−∞

e

t dt

Pour le cas x > 0 on utilise la valeur principale de Cauchy telle que vue pour li.

Le lien entre li et Ei est :

li(x) = Ei(ln(x)) (7)

Afin d’´ evaluer num´ eriquement la valeur de Ei en un point on se base sur son d´ eveloppement (dit en s´ erie de Puiseux) sur R

:

Ei(x) = γ + ln(x) +

∞

X

k=1

x

k × k! (8)

Avec γ ' 0.577215664901 la constante d’Euler-Mascheroni.

Comme l’´ evaluation de la somme jusqu’` a l’infini est impossible on utilise en pratique la somme suivante :

Ei

(x) = γ + ln(x) +

n

X

k=1

x

k × k! (9)

Le choix de n se fait en comparant Ei

` a Ei

jusqu’` a ce qu’ils soient consid´ er´ es comme suffisament proches.

L’´ evaluation via un ordinateur de ce d´ eveloppement est num´ eriquement stable jusqu’` a x = 40, au d´ el` a les r´ esultats sont entach´ es d’erreurs de calcul et d’autres m´ ethodes doivent ˆ etre utilis´ ees.

o Q24 – ´ Ecrire une fonction li_dev(x) qui calcule li(x) en se basant sur Ei

et la fonction sont_proches de la question 2 (on pourra utiliser la fonction associ´ ee mˆ eme si la question n’a pas

´

et´ e trait´ ee). li_dev retourne False si :

• Ei

et Ei

ne peuvent pas ˆ etre consid´ er´ es comme proches au bout de MAXIT it´ erations.

• la valeur de x ne permet pas d’aboutir ` a un r´ esultat.

Prendre MAXIT = 100 se r´ ev` ele largement suffisant ` a l’usage.

On demande ` a ce que la complexit´ e dans le pire des cas soit O(MAXIT) sera refus´ e. Le param` etre x est un flottant quelconque.

Fin de l’´ epreuve.

Correction Concours Commmun Mines-Ponts 2019

P Corrig´ e-Q1

1 from math import s q r t , l o g , f l o o r , c e i l 2 l o g ( 0 . 5 )

3

4 # ou e n c o r e 5 import math a s m 6 m. l o g ( 0 . 5 )

P Corrig´ e-Q2

1 def s o n t p r o c h e s ( x , y ) : 2 a t o l = 1 e−5

3 r t o l = 1 e−8

4 return abs( x − y ) <= a t o l + abs( y ) ∗ r t o l

P Corrig´ e-Q3 mystere(1001, 10) retourne 3.

P Corrig´ e-Q4 C’est la partie enti` ere de log

(x) qui est aussi le nombre de chiffres moins un de la repr´ esentation en base b de x.

P Corrig´ e-Q5 On ne peut pas repr´ esenter 10

de mani` ere exacte car ce n’est pas une puissance de 2. Du coup on accumule les erreurs lors des additions successives sur x2.

P Corrig´ e-Q6 '

= 10

P Corrig´ e-Q7 On multiplie par 32 la valeur maximale de N.

P Corrig´ e-Q8

1 def e r a t o i t e r (N ) :

2 L = [ True ] ∗ N

3 L [ 0 ] = F a l s e # 1 n ’ e s t p a s p r e m i e r 4

5 # p a r e x e m p l e a v e c N=8, s q r t ( 8 ) ˜= 2 . 8 2 6 # r a n g e ( 1 , i n t ( s q r t ( 8 ) ) => 1 donc on r a t e 2 7 # r a n g e ( 1 , i n t ( c e i l ( s q r t ( 8 ) ) ) => 1 , 2 donc OK 8 f o r i in range( 1 , i n t( c e i l ( s q r t (N ) ) ) ) :

9 i f not L [ i ] :

10 continue

11 # pour b a r r e r a v e c un f o r

12 f o r k in range( 2 ∗ i + 1 , N, i + 1 ) : 13 # i = 1 => on c o d e l ’ e n t i e r 2

14 # on v e u t b a r r e r l e s i n d i c e s 3 , 5 , 7 , e t c 15 # c e q u i f a i t b i e n un p a s de i + 1

16 L [ k ] = F a l s e

17 return L

P Corrig´ e-Q9 Changer la valeur d’un ´ el´ ement dans une liste Python est en O(1).

Pour chaque nombre premier p trouv´ e on devra affecter

´ el´ ements dans la liste soit O(1) ∗

op´ erations donc ' O(N) ∗

op´ erations.

• Pour p = 2 on fait donc O(N ) ∗

op´ erations.

• Pour p = 3 on fait donc O(N ) ∗

op´ erations.

• ...

• Pour p = D

, avec D

le dernier premier inf´ erieur ` a √

N on fait donc O(N ) ∗

p

op´ erations.

Donc le nombre total d’op´ erations est :

O(N ) ∗ X

p<√

N ,p premier

1 p

Soit, en admettant le r´ esultat de l’´ enonc´ e, une complexit´ e en : O(N ) ∗ ln(ln( √

N)) = O(N ln(ln(N ))) P Corrig´ e-Q10 Dans une base b arbitraire n = blog

(N )c + 1.

D’o` u une complexit´ e en O(exp(n) ∗ ln(n)).

P Corrig´ e-Q11 2

− 1 P Corrig´ e-Q12

1 import t i m e 2 def bbs (N ) :

3 p1 = 24 3 7 5 7 6 3 4 p2 = 28 9 7 2 7 6 3

5 M = p1 ∗ p2

6 temps = t i m e . t i m e ( )

7 u s e c s = i n t( ( temps − f l o o r ( temps ) ) ∗ 1 e7 )

8 x i = u s e c s # l e p r e m i e r x i r e ¸c o i t l a v a l e u r de l a g r a i n e 9 # on p e u t a u s s i f a i r e ¸c a `a b a s e de s t r

10 # u s e c s = s t r ( temps ) . s p l i t ( ”. ”) 11 # x i = i n t ( u s e c s [ 1 ] )

12 A = 0

13 f o r i in range(N ) :

14 i f x i %2:

15 A += 2∗∗i

16 x i = ( x i ∗∗ 2 ) % M

17 return(A)

P Corrig´ e-Q13

1 def p r e m i e r r a p i d e ( n max ) :

2 # La d i f f i c u l t ´e e s t de c o m b i n e r l e 2∗∗N − 1 de b b s a v e c l e 3 # n max d ’ i c i .

4 # Comme l ’ ´e nonc ´e demande un nombre i n f ´e r i e u r s t r i c t e m e n t `a 5 # n max on n ’ a p a s de c a s p ´e n i b l e quand n max e s t de l a 6 # forme 2∗∗k , `a c e moment l `a N v a u d r a k e t b b s (N) s o r t i r a 7 # b i e n un nombre i n f ´e r i e u r s t r i c t e m e n t `a 2∗∗k .

8 N = i n t( c e i l ( l o g ( n max , 2 ) ) )

9 p = bbs (N)

10 while not (

11 2 ∗∗ ( p − 1 ) % p == 1 and

12 3 ∗∗ ( p − 1 ) % p == 1 and

13 5 ∗∗ ( p − 1 ) % p == 1 and

14 7 ∗∗ ( p − 1 ) % p == 1

15 ) :

16 p = bbs (N)

17 return p

P Corrig´ e-Q14

1 def s t a t s b b s f e r m a t (N, nb ) : 2 f a u x p r e m i e r s = [ ]

3 v r a i p r e m i e r = e r a t o i t e r (N) 4 f o r i in range( nb ) :

5 v a l = p r e m i e r r a p i d e (N)

6 i f not v r a i p r e m i e r [ v a l − 1 ] : 7 f a u x p r e m i e r s . append ( v a l )

8 return len( f a u x p r e m i e r s ) / nb , f a u x p r e m i e r s

P Corrig´ e-Q15

1 def Pi (N ) :

2 p r e m i e r s = e r a t o i t e r (N)

3 P i x = 0

4 r e t = [ ]

5 f o r i d x in range(N ) : 6 i f p r e m i e r s [ i d x ] :

7 P i x += 1

8 r e t . append ( [ i d x + 1 , P i x ] ) 9 return r e t

P Corrig´ e-Q16

1 def v e r i f P i (N ) :

2 v a l e u r s t e s t = Pi (N ) [ 5 3 9 2 : ] 3 f o r x , p i x in v a l e u r s t e s t : 4 i f p i x <= x / ( l o g ( x ) − 1 ) :

5 return F a l s e

6 return True

P Corrig´ e-Q17 O(n), n ´ etant le nombre de points, soit

−1. Le calcul de n n’est pas demand´ e.

P Corrig´ e-Q18 La mˆ eme complexit´ e pour tous ces algorithmes, eventuellement l’´ etudiant peut pr´ eciser que la constante multiplicative n’est pas la mˆ eme.

P Corrig´ e-Q19

1 def i n v l n r e c t d ( a , b , pas ) :

2 S = 0

3 # A t t e n t i o n `a u t i l i s e r round s i n o n x . 0 0 0 0 0 0 1 ou x . 9 9 9 9 9 9 9 4 # v o n t donner d e s r ´e s u l t a t s f a u x a v e c c e i l ( ) ou f l o o r ( ) 5 max n = i n t(round( ( b − a ) / pas ) )

6 f o r i in range( max n ) :

7 x i = a + ( i + 1 ) ∗ pas

8 S += 1/ l o g ( x i )

9 return S∗pas

P Corrig´ e-Q20

1 def l i d ( x , pas ) :

2 i f x == 1 :

3 return −f l o a t( ” i n f ” )

4 bmin = min( 1 − pas , x )

5 S = i n v l n r e c t d ( 0 , bmin , pas ) 6 i f x > 1 :

7 S += i n v l n r e c t d ( 1 + pas , x , pas )

8 return S

P Corrig´ e-Q21 Pour x ' 1.4 on a li(x) ' 0 donc il est normal que l’´ ecart relatif explose ´ etant donn´ e que l’´ ecart absolu est non nul.

P Corrig´ e-Q22 On se place toujours dans l’hypoth` ese simplificatrice o` u ε = pas et les approxi- mations sont faites au premier ordre.

Sur un intervalle [1 − ε,1 + ε] avec ε 1 , et en admettant que

' −

quand ε → 0 , l’int´ egrale impropre de

devrait ˆ etre nulle en premi` ere approximation.

Or l’algorithme des rectangles ` a droite utilise

comme dernier point avant x = 1 et

comme premier point apr` es x = 1. Donc les termes de part et d’autre de x = 1 ` a son voisinage ne s’annulent pas comme escompt´ e car ils ne sont pas r´ epartis sym´ etriquement, d’o` u l’augmentation de l’´ ecart absolu.

P Corrig´ e-Q23 L’important est de se rendre compte que l’erreur sur l’´ ecart absolu est intrin- s` eque ` a la m´ ethode de quadrature utilis´ ee et que diminuer le pas ne fait au mieux que diminuer le probl` eme mais ne le fait pas disparaˆıtre (en fait l’erreur est ind´ ependante du pas avec les hypoth` eses du sujet). Les rectangles ` a droite sont donc totalement inadapt´ es. On peut par exemple utiliser les trap` ezes, les rectangles centr´ es, voire combiner les rectangles ` a droite avant x = 1 avec les rectangles

`

a gauche apr` es. L’important est d’utiliser une m´ ethode qui ´ evalue des points sym´ etriquement de part et d’autre de x = 1.

P Corrig´ e-Q24

1 def l i d e v ( x ) :

2 # a t t e n t i o n on t r a v a i l l e s u r z=l o g ( x ) e t l a s ´e r i e n ’ e s t v a l a b l e que pour z > 0 3 i f x <= 1 or l o g ( x ) > 4 0 :

4 return F a l s e 5 z = l o g ( x )

6 MAXIT = 100

7 tmp = 1

8 e i = 0 . 5 7 7 2 1 5 6 6 4 9 0 1 + l o g ( z )

9 f o r k in range( 1 , MAXIT + 1 ) : # p l u s l i s i b l e comme ¸c a 10 tmp ∗= z / k

11 o l d = e i

12 e i += tmp / k

13 i f s o n t p r o c h e s ( e i , o l d ) :

14 return e i

15 return F a l s e