Livre Algorithmes

ALGOR I T H M E S
C O U R S D E M AT H M AT I Q U E S
PREMIRE ANNE
Exo7
Algorithmes
Ce recueil regroupe diffrents chapitres sur les mathmatiques en lien avec linformatique.
Sommaire
.
.
.
.
.
.
1
1
5
11
15
19
24
Zros des fonctions

1
La dichotomie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2
La mthode de la scante . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3
La mthode de Newton . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
29
29
34
37
Cryptographie
1
Le chiffrement de Csar . . . . . . . . . .
2
Le chiffrement de Vigenre . . . . . . . .
3
La machine Enigma et les cls secrtes
4
La cryptographie cl publique . . . . .
5
Larithmtique pour RSA . . . . . . . . .
6
Le chiffrement RSA . . . . . . . . . . . .
.
.
.
.
.
.
41
41
45
48
54
57
61
.
.
.
.
.
.
.
.
.
67
67
73
78
83
93
101
111
115
122
Algorithmes et mathmatiques
1
Premiers pas avec Python . . . . . . . . .
2
criture des entiers . . . . . . . . . . . . .
3
Calculs de sinus, cosinus, tangente . . . .
4
Les rels . . . . . . . . . . . . . . . . . . . .
5
Arithmtique Algorithmes rcursifs . . .
6
Polynmes Complexit dun algorithme
Calcul formel
1
Premiers pas avec Sage . . . . . . . . . .
2
Structures de contrle avec Sage . . . .
3
Suites rcurrentes et preuves formelles
4
Suites rcurrentes et visualisation . . .
5
Algbre linaire . . . . . . . . . . . . . . .
6
Courbes et surfaces . . . . . . . . . . . .
7
Calculs dintgrales . . . . . . . . . . . .
8
Polynmes . . . . . . . . . . . . . . . . . .
9
quations diffrentielles . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Chapitre
Algorithmes et mathmatiques
Vido
Vido
Vido
Vido
Vido
Vido
partie 1. Premiers pas avec Python

partie 2. Ecriture des entiers
partie 3. Calculs de sinus, cosinus, tangente
partie 4. Les rels
partie 5. Arithmtique Algorithmes rcursifs
partie 6. Polynmes Complexit d'un algorithme
1. Premiers pas avec Python

Dans cette partie on vrifie dabord que Python fonctionne, puis on introduira les boucles (for et while),
le test if ... else ... et les fonctions.
1.1. Hello world !

Pour commencer testons si tout fonctionne !
Travaux pratiques 1.
1. Dfinir deux variables prenant les valeurs 3 et 6.
2. Calculer leur somme et leur produit.
Voici quoi cela ressemble :
Code 1 (hello-world.py).
>>> a=3
>>> b=6
>>> somme = a+b
>>> print(somme)
9
>>> # Les rsultats
>>> print("La somme est", somme)
La somme est 9
>>> produit = a*b
>>> print("Le produit est", produit)
Le produit est 18
On retient les choses suivantes :
On affecte une valeur une variable par le signe gal =.
1. PREMIERS PAS AVEC Python 2
ALGORITHMES ET MATHMATIQUES
On affiche un message avec la fonction print().

Lorsque quune ligne contient un dise #, tout ce qui suit est ignor. Cela permet dinsrer des commentaires, ce qui est essentiel pour relire le code.
Dans la suite on omettra les symboles >>>. Voir plus de dtails sur le fonctionnement en fin de section.
1.2. Somme des cubes

1. Pour un entier n fix, programmer le calcul de la somme Sn = 13 + 23 + 33 + + n3 .
2. Dfinir une fonction qui pour une valeur n renvoie la somme n = 1 + 2 + 3 + + n.
3. Dfinir une fonction qui pour une valeur n renvoie Sn .
4. Vrifier, pour les premiers entiers, que Sn = (n )2 .
1.
Code 2 (somme-cubes.py (1)).
n = 10
somme = 0
for i in range(1,n+1):
somme = somme + i*i*i
print(somme)
Voici ce que lon fait pour calculer Sn avec n = 10.
On affecte dabord la valeur 0 la variable somme, cela correspond linitialisation S0 = 0.
Nous avons dfini une boucle avec linstruction for qui fait varier i entre 1 et n.
Nous calculons successivement S1 , S2 ,. . . en utilisant la formule de rcurrence Si = Si1 + i 3 . Comme
nous navons pas besoin de conserver toutes les valeurs des Si alors on garde le mme nom pour
toutes les sommes, chaque tape on affecte somme lancienne valeur de la somme plus i 3 :
somme = somme + i*i*i.
range(1,n+1) est lensemble des entiers {1, 2, . . . , n}. Cest bien les entiers strictement infrieurs
n + 1. La raison est que range(n) dsigne {0, 1, 2, . . . , n 1} qui contient n lments.
2. Nous savons que n = 1 + 2 + 3 + + n =
n(n+1)
2
donc nous navons pas besoin de faire une boucle :
def somme_entiers(n):
return n*(n+1)/2
Une fonction en informatique est similaire une fonction mathmatique, cest un objet qui prend en
entre des variables (dites variables formelles ou variables muettes, ici n) et retourne une valeur (un
n(n+1)
entier, une liste, une chane de caractres,... ici 2 ).
3. Voici la fonction qui retourne la somme des cubes :
def somme_cubes(n):
somme = 0
somme = somme + i**3

return somme
4. Et enfin on vrifie que pour les premiers entiers Sn =
n(n+1) 2
,
2
par exemple pour n = 12 :
n = 12
if somme_cubes(n) == (somme_entiers(n)**2):
print("Pour n=", n, "l'assertion est vraie.")
else:
print("L'assertion est fausse !")
On retient :
Les puissances se calculent aussi avec ** : 52 scrit 5*5 ou 5**2, 53 scrit 5*5*5 ou 5**3,...
Une fonction se dfinit par def ma_fonction(variable): et se termine par return resultat.
if condition: ... else: ... excute le premier bloc dinstructions si la condition est vraie ; si la
condition est fausse cela excute lautre bloc.
Exemple de conditions
a < b : a < b,
a <= b : a 6 b,
a == b : a = b,
a != b : a 6= b.
Attention ! Il est important de comprendre que a==b vaut soit vraie ou faux (on compare a et b) alors
quavec a=b on affecte dans a la valeur de b.
Enfin en Python (contrairement aux autres langages) cest lindentation (les espaces en dbut de chaque
ligne) qui dtermine les blocs dinstructions.
1.3. Calcul de au hasard

Nous allons voir quil est possible de calculer les premires dcimales de par la mthode de Monte-Carlo,
cest dire avec laide du hasard. On considre le carr de cot 1, le cercle de rayon 1 centr lorigine,
dquation x 2 + y 2 = 1, et la portion de disque dans le carr (voir la figure).
(0, 1)
(0, 0)
(1, 0)
1. Calculer laire du carr et de la portion de disque.
2. Pour un point (x, y) tir au hasard dans le carr, quelle est la probabilit que le point soit en fait
dans la portion de disque ?
3. Tirer un grand nombre de points au hasard, compter ceux qui sont dans la portion de disque.
4. En dduire les premires dcimales de .

Voici le code :
Code 6 (pi-hasard.py).
import random
# Module qui gnre des nombres alatoires
Tir = 0
NbTirDansLeDisque = 0
# Numro du tir
# Nombre de tirs dans le disque
while (Tir < 1000):

Tir = Tir + 1
# On tire au hasard un point (x,y) dans [0,1] x [0,1]
x = random.random()
y = random.random()
if (x*x+y*y <= 1):
# On est dans le disque
NbTirDansLeDisque = NbTirDansLeDisque + 1
MonPi = 4*NbTirDansLeDisque / Tir
print("Valeur exprimentale de Pi : %0.3f" %MonPi)
Commentaires :
Un petit calcul prouve que laire de la portion de disque est 4 , laire du carr est 1. Donc la probabilit
de tomber dans le disque est 4 .

Pour tirer un nombre au hasard on utilise une fonction random() qui renvoie un nombre rel de
lintervalle [0, 1[. Bien sr chaque appel de la fonction random() le nombre obtenu est diffrent !
Cette fonction nest pas connue par dfaut de Python, il faut lui indiquer le nom du module o elle se
trouve. En dbut de fichier on ajoute import random pour le module qui gre les tirages au hasard. Et
pour indiquer quune fonction vient dun module il faut lappeler par module.fonction() donc ici
random.random() (module et fonction portent ici le mme nom !).
La boucle est while condition: ... Tant que la condition est vrifie les instructions de la boucle
sont excutes. Ici Tir est le compteur que lon a initialis 0. Ensuite on commence excuter la boucle.
Bien sr la premire chose que lon fait dans la boucle est dincrmenter le compteur Tir. On continue
jusqu ce que lon atteigne 999. Pour Tir= 1000 la condition nest plus vraie et le bloc dinstructions
du while nest pas excut. On passe aux instructions suivantes pour afficher le rsultat.
chaque tir on teste si on est dans la portion de disque ou pas laide de lingalit x 2 + y 2 6 1.
Cette mthode nest pas trs efficace, il faut beaucoup de tirs pour obtenir le deux premires dcimales
de .
1.4. Un peu plus sur Python

Le plus surprenant avec Python cest que cest lindentation qui dtermine le dbut et la fin dun bloc
dinstructions. Cela oblige prsenter trs soigneusement le code.
Contrairement
dautres langages on na pas besoin de dclarer le type de variable. Par exemple lorsque
lon initialise une variable par x=0, on na pas besoin de prciser si x est un entier ou un rel.
Nous travaillerons avec la version 3 (ou plus) de Python, que lon appelle par python ou python3.
Pour savoir si vous avez la bonne version tester la commande 4/3. Si la rponse est 1.3333... alors
tout est ok. Par contre avec les versions 1 et 2 de Python la rponse est 1 (car il considrait que cest
quotient de la division euclidienne de deux entiers).
2. CRITURE DES ENTIERS
La premire faon de lancer Python est en ligne de commande, on obtient alors linvite >>> et on tape
les commandes.
Mais le plus pratique est de sauvegarder ses commandes dans un fichier et de faire un appel par
python monfichier.py
Vous trouverez sans problme de laide et des tutoriels sur internet !
Mini-exercices. 1. Soit le produit Pn = (1 12 ) (1 13 ) (1 41 ) (1 1n ). Calculer une valeur
approche de Pn pour les premiers entiers n.
2. Que vaut la somme des entiers i qui apparaissent dans linstruction for i in range(1,10).
Idem pour for i in range(11). Idem pour for i in range(1,10,2). Idem pour
for i in range(0,10,2). Idem pour for i in range(10,0,-1).
3. On considre le cube [0, 1] [0, 1] [0, 1] et la portion de boule de rayon 1 centre lorigine incluse
dans ce cube. Faire les calculs de probabilit pour un point tir au hasard dans le cube dtre en fait
dans la portion de boule. Faire une fonction pour le vrifier exprimentalement.
4. On lance deux ds. Exprimenter quelle est la probabilit que la somme soit 7, puis 6, puis 3 ? Quelle
est la probabilit que lun des deux ds soit un 6 ? davoir un double ? La fonction randint(a, b)
du module random retourne un entier k au hasard, vrifiant a 6 k 6 b.
5. On lance un d jusqu ce que lon obtienne un 6. En moyenne au bout de combien de lancer sarrtet-on ?
2. criture des entiers

Nous allons faire un peu darithmtique : le quotient de la division euclidienne //, le reste % (modulo) et
nous verrons lcriture des entiers en base 10 et en base 2. Nous utiliserons aussi la notion de listes et le
module math.
2.1. Division euclidienne et reste, calcul avec les modulo

La division euclidienne de a par b, avec a Z et b Z scrit :
a = bq + r
et
06r < b
o q Z est le quotient et r N est le reste.

En Python le quotient se calcule par : a // b. Le reste se calcule par a % b. Exemple : 14 // 3 retourne
4 alors que 14 % 3 (lire 14 modulo 3) retourne 2. On a bien 14 = 3 4 + 2.
Les calculs avec les modulos sont trs pratiques. Par exemple si lon souhaite tester si un entier est pair, ou
impair cela revient un test modulo 2. Le code est if (n%2 == 0): ... else: .... Si on besoin de
calculer cos(n 2 ) alors il faut discuter suivant les valeurs de n%4.
Appliquons ceci au problme suivant :
Combien y-a-t-il doccurrences du chiffre 1 dans les nombres de 1 999 ? Par exemple le chiffre 1
apparat une fois dans 51 mais deux fois dans 131.
Code 7 (nb-un.py).
NbDeUn = 0
for N in range(1,999+1):
ChiffreUnite = N % 10
ChiffreDizaine = (N // 10) % 10
ChiffreCentaine = (N // 100) % 10
if (ChiffreUnite == 1):
NbDeUn = NbDeUn + 1
if (ChiffreDizaine == 1):
NbDeUn = NbDeUn + 1
if (ChiffreCentaine == 1):
NbDeUn = NbDeUn + 1
print("Nombre d'occurences du chiffre '1' :", NbDeUn)
Commentaires :
Comment obtient-on le chiffre des units dun entier N ? Cest le reste modulo 10, do linstruction
ChiffreUnite = N % 10.
Comment obtient-on le chiffre des dizaines ? Cest plus dlicat, on commence par effectuer la division
euclidienne de N par 10 (cela revient supprimer le chiffre des units, par exemple si N = 251 alors
N // 10 retourne 25). Il ne reste plus qu calculer le reste modulo 10, (par exemple (N // 10) % 10
retourne le chiffre des dizaines 5.
Pour le chiffre des centaines on divise dabord par 100.
2.2. criture des nombres en base 10

Lcriture dcimale dun nombre, cest associer un entier N la suite de ses chiffres [a0 , a1 , . . . , an ] de sorte
que ai soit le i-me chiffre de N . Cest--dire
N = an 10n + an1 10n1 + + a2 102 + a1 10 + a0
et ai {0, 1, . . . , 9}
a0 est le chiffre des units, a1 celui des dizaines, a2 celui des centaines,...
1. crire une fonction qui partir dune liste [a0 , a1 , . . . , an ] calcule lentier N correspondant.
2. Pour un entier N fix, combien a-t-il de chiffres ? On pourra saider dune ingalit du type 10n 6
N < 10n+1 .
3. crire une fonction qui partir de N calcule son criture dcimale [a0 , a1 , . . . , an ].
Voici le premier algorithme :
Code 8 (decimale.py (1)).
def chiffres_vers_entier(tab):
N = 0
for i in range(len(tab)):
N = N + tab[i] * (10 ** i)
return N
La formule mathmatique est simplement N = an 10n + an1 10n1 + + a2 102 + a1 10 + a0 . Par exemple
chiffres_vers_entier([4,3,2,1]) renvoie lentier 1234.
Expliquons les bases sur les listes (qui sappelle aussi des tableaux)
En Python une liste est prsente entre des crochets. Par exemple pour tab = [4,3,2,1] alors on
accde aux valeurs par tab[i] : tab[0] vaut 4, tab[1] vaut 3, tab[2] vaut 2, tab[3] vaut 1.
Pour parcourir les lments dun tableau le code est simplement for x in tab, x vaut alors successivement 4, 3, 2, 1.
La longueur du tableau sobtient par len(tab). Pour notre exemple len([4,3,2,1]) vaut 4. Pour
parcourir toutes les valeurs dun tableau on peut donc aussi crire for i in range(len(tab)), puis
utiliser tab[i], ici i variant ici de 0 3.
La liste vide est seulement note avec deux crochets : []. Elle est utile pour initialiser une liste.
Pour ajouter un lment une liste tab existante on utilise la fonction append. Par exemple dfinissons
la liste vide tab=[], pour ajouter une valeur la fin de la liste on saisit : tab.append(4). Maintenant
notre liste est [4], elle contient un seul lment. Si on continue avec tab.append(3). Alors maintenant
notre liste a deux lments : [4, 3].
Voici lcriture dun entier en base 10 :
Code 9 (decimale.py (2)).
def entier_vers_chiffres(N):
tab = []
n = floor(log(N,10))
# le nombre de chiffres est n+1
tab.append((N // 10 ** i) % 10)
return tab
Par exemple entier_vers_chiffres(1234) renvoie le tableau [4, 3, 2, 1]. Nous avons expliqu tout ce
dont nous avions besoin sur les listes au-dessus, expliquons les mathmatiques.
Dcomposons N sous la forme [1, 10[ [10, 100[ [100, 1000[ [1 000, 10 000[ Chaque intervalle
est du type [10n , 10n+1 [. Pour N N il existe donc n N tel que 10n 6 N < 10n+1 . Ce qui indique que
le nombre de chiffres de N est n + 1.
Par exemple si N = 1234 alors 1 000 = 103 6 N < 104 = 10 000, ainsi n = 3 et le nombre de chiffres est
4.
Comment calculer n partir de N ? Nous allons utiliser le logarithme dcimal log10 qui vrifie log10 (10) =
1 et log10 (10i ) = i. Le logarithme est une fonction croissante, donc lingalit 10n 6 N < 10n+1
devient log10 (10n ) 6 log10 (N ) < log10 (10n+1 ). Et donc n 6 log10 (N ) < n + 1. Ce qui indique donc que
n = E(log10 (N )) o E(x) dsigne la partie entire dun rel x.
2.3. Module math
Quelques commentaires informatiques sur un module important pour nous. Les fonctions mathmatiques
ne sont pas dfinies par dfaut dans Python ( part |x| et x n ), il faut faire appel une librairie spciale : le
module math contient les fonctions mathmatiques principales.
abs(x)
|x|
x ** n
sqrt(x)
xn
p
x
exp(x)
exp x
log(x)
ln x logarithme nprien
log(x,10)
log x logarithme dcimal
cos(x), sin(x), tan(x)
cos x, sin x, tan x en radians
acos(x), asin(x), atan(x)
arccos x, arcsin x, arctan x en radians
floor(x)
partie entire E(x) :plus grand entier n 6 x (floor = plancher)
ceil(x)
plus petit entier n > x (ceil = plafond)
Comme on aura souvent besoin de ce module on lappelle par le code from math import *. Cela
signifie que lon importe toutes les fonctions de ce module et quen plus on na pas besoin de prciser
que la fonction vient du module math. On peut crire cos(3.14) au lieu math.cos(3.14).
Dans lalgorithme prcdent nous avions utilis le logarithme dcimal log(x,10), ainsi que la partie
entire floor(x).
2.4. criture des nombres en base 2

On dispose dune rampe de lumire, chacune des 8 lampes pouvant tre allume (rouge) ou teinte (gris).
On numrote les lampes de 0 7. On souhaite contrler cette rampe : afficher toutes les combinaisons
possibles, faire dfiler une combinaison de la gauche droite (la chenille), inverser ltat de toutes les
lampes,... Voyons comment lcriture binaire des nombres peut nous aider. Lcriture binaire dun nombre
cest son criture en base 2.
Comment calculer un nombre qui est crit en binaire ? Le chiffre des dizaines correspond 2 (au lieu de
10), le chiffre des centaines 4 = 22 (au lieu de 100 = 102 ), le chiffres des milliers 8 = 23 (au lieu de
1000 = 103 ),... Pour le chiffre des units cela correspond 20 = 1 (de mme que 100 = 1).
Par exemple 10011 b vaut le nombre 19. Car
10011 b = 1 24 + 0 23 + 0 22 + 1 21 + 1 20 = 16 + 2 + 1 = 19.
De faon gnrale tout entier N N scrit de manire unique sous la forme
N = an 2n + an1 2n1 + + a2 22 + a1 2 + a0
On note alors N = an an1 . . . a1 a0
et
ai {0, 1}
(avec un indice b pour indiquer que cest son criture binaire).
1. crire une fonction qui partir dune liste [a0 , a1 , . . . , an ] calcule lentier N correspondant lcriture
binaire an an1 . . . a1 a0 b .
2. crire une fonction qui partir de N calcule son criture binaire sous la forme [a0 , a1 , . . . , an ].
La seule diffrence avec la base 10 cest que lon calcule avec des puissances de 2.
Code 10 (binaire.py (1)).
def binaire_vers_entier(tab):
N = 0
for i in range(len(tab)):
N = N + tab[i] * (2 ** i)
return N
Idem pour le sens inverse o lon a besoin du logarithme en base 2, qui vrifie log2 (2) = 1 et log2 (2i ) = i.
def entier_vers_binaire(N):
tab = []
n = floor(log(N,2))
tab.append((N // 2 ** i) % 2)
return tab
Maintenant appliquons ceci notre problme de lampes. Si une lampe est allume on lui attribut 1, et si
elle est teinte 0. Pour une rampe de 8 lampes on code [a0 , a1 , . . . , a7 ] ltat des lampes.
Par exemple la configuration suivante :
21
22
23
24
25
26
27
28
est cod [1, 0, 0, 1, 0, 1, 1, 1] ce qui correspond au nombre binaire 11101001 b = 233.

1. Faire une boucle qui affiche toutes les combinaisons possibles (pour une taille de rampe donne).
2. Quelle opration mathmatique lmentaire transforme un nombre binaire an . . . a1 a0
an . . . a1 a0 0 b (dcalage vers la gauche et ajout dun 0 la fin) ?
en
3. Soit N 0 = an an1 . . . a1 a0 0 b (une criture avec n + 2 chiffres). Quelle est lcriture binaire de N 0
(mod 2n+1 ) ? (Cest une criture avec n + 1 chiffres.)
4. En dduire un algorithme qui pour une configuration donne de la rampe, fait permuter cycliquement
(vers la droite) cette configuration. Par exemple [1, 0, 1, 0, 1, 1, 1, 0] devient [0, 1, 0, 1, 0, 1, 1, 1].
5. Quelle opration mathmatique lmentaire permet de passer dune configuration son oppose (une
lampe teinte sallume, et rciproquement). Par exemple si la configuration tait [1, 0, 1, 0, 1, 1, 1, 0]
alors on veut [0, 1, 0, 1, 0, 0, 0, 1]. (Indication : sur cet exemple calculer les deux nombres correspondants et trouver la relation qui les lie.)
1. Il sagit dabord dafficher les configurations. Par exemple si lon a 4 lampes alors les configurations
sont [0, 0, 0, 0], [1, 0, 0, 0], [0, 1, 0, 0], [1, 1, 0, 0],. . . , [1, 1, 1, 1]. Pour chaque lampe nous avons deux
choix (allum ou teint), il y a n + 1 lampes donc un total de 2n+1 configurations. Si lon considre ces
configurations comme des nombres crits en binaire alors lnumration ci-dessus correspond compter
0, 1, 2, 3, . . . , 2n+1 1.
Do lalgorithme :
10
def configurations(n):
for N in range(2**(n+1)):
print(entier_vers_binaire_bis(N,n))
O entier_vers_binaire_bis(N,n) est similaire entier_vers_binaire(N), mais en affichant
aussi les zros non significatifs, par exemple 7 en binaire scrit 111 b , mais cod sur 8 chiffres on ajoute
devant des 0 non significatifs : 00000111 b .
2. En criture dcimale, multiplier par 10 revient dcaler le nombre initial et rajouter un zro. Par exemple
10 19 = 190. Cest la mme chose en binaire ! Multiplier un nombre par 2 revient sur lcriture un
dcalage vers la gauche et ajout dun zro sur le chiffre des units. Exemple : 19 = 10011 b et 2 19 = 38
donc 2 10011 b = 100110 b .
3. Partant de N = an an1 . . . a1 a0 b . Notons N 0 = 2N , son criture est N 0 = an an1 . . . a1 a0 0 b . Alors N 0
(mod 2n+1 ) scrit exactement an1 an2 . . . a1 a0 0 b et on ajoute an qui est le quotient de N 0 par 2n+1 .
Preuve : N 0 = an 2n+1 + an1 2n + + a0 2. Donc N 0 (mod 2n+1 ) = an1 2n + + a0 2. Donc N 0
(mod 2n+1 ) + an = an1 2n + + a0 2 + an .
4. Ainsi lcriture en binaire de N 0 (mod 2n+1 ) + an sobtient comme permutation circulaire de celle de N .
Do lalgorithme :
def decalage(tab):
N = binaire_vers_entier(tab)
n = len(tab)-1
NN = 2*N % 2**(n+1) + 2*N // 2**(n+1)
return entier_vers_binaire_bis(NN,n)
5. On remarque que si lon a deux configurations opposes alors leur somme vaut 2n+1 1 : par exemple
avec [1, 0, 0, 1, 0, 1, 1, 1] et [0, 1, 1, 0, 1, 0, 0, 0], les deux nombres associs sont N = 11101001 b et
N 0 = 00010110 b (il sagit juste de les rcrire de droite gauche). La somme est N + N 0 = 11101001 b +
00010110 b = 11111111 b = 28 1. Laddition en criture binaire se fait de la mme faon quen criture
dcimale et ici il ny a pas de retenue. Si M est un nombre avec n + 1 fois le chiffres 1 alors M + 1 = 2n+1 .
Exemple si M = 11111 b alors M + 1 = 100000 b = 25 ; ainsi M = 25 1. Donc loppos de N est
N 0 = 2n+1 1 N (remarquez que dans Z/(2n+1 1)Z alors N 0 N ).
Cela conduit :
def inversion(tab):
N = binaire_vers_entier(tab)
n = len(tab)-1
NN = 2**(n+1)-1 - N
return entier_vers_binaire_bis(NN,n)
Mini-exercices. 1. Pour un entier n fix, combien y-a-t-il doccurrences du chiffre 1 dans lcriture des
nombres de 1 n ?
2. crire une fonction qui calcule lcriture dcimale dun entier, sans recourir au log (une boucle while
est la bienvenue).
3. CALCULS DE SINUS, COSINUS, TANGENTE
11
3. crire un algorithme qui permute cycliquement une configuration de rampe vers la droite.
4. On dispose de n + 1 lampes, chaque lampe peut sclairer de trois couleurs : vert, orange, rouge (dans
cet ordre). Trouver toutes les combinaisons possibles. Comment passer toutes les lampes la couleur
suivante ?
5. Gnrer toutes les matrices 4 4 nayant que des 0 et des 1 comme coefficients. On codera une matrice
sous la forme de lignes [[1, 1, 0, 1], [0, 0, 1, 0], [1, 1, 1, 1], [0, 1, 0, 1]].
6. On part du point (0, 0) Z2 . A chaque pas on choisit au hasard un direction Nord, Sud, Est, Ouest.
Si on va au Nord alors on ajoute (0, 1) sa position (pour Sud on ajoute (0, 1) ; pour Est (1, 0) ;
pour Ouest (1, 0)). Pour un chemin dune longueur fixe de n pas, coder tous les chemins possibles.
Caractriser les chemins qui repassent par lorigine. Calculer la probabilit pn de repasser par lorigine.
Que se passe-t-il lorsque n + ?
7. crire une fonction, qui pour un entier N , affiche son criture en chiffres romains : M = 1000, D = 500,
C = 100, X = 10, V = 5, I = 1. Il ne peut y avoir plus de trois symboles identiques suivre.
3. Calculs de sinus, cosinus, tangente

Le but de cette section est le calcul des sinus, cosinus, et tangente dun angle par nous mme, avec une
prcision de 8 chiffres aprs la virgule.
3.1. Calcul de Arctan x

Nous aurons besoin de calculer une fois pour toute Arctan(10i ), pour i = 0, . . . , 8, cest--dire que lon
cherche les angles i ] 2 , 2 [ tels que tan i = 10i . Nous allons utiliser la formule :
Arctan x =
+
X
(1)k
k=0
x 2k+1
x3 x5 x7
=x
+
+
2k + 1
3
5
7
1. Calculer Arctan 1.
2. Calculer i = Arctan 10i (avec 8 chiffres aprs la virgule) pour i = 1, . . . , 8.
3. Pour quelles valeurs de i, lapproximation Arctan x ' x tait-elle suffisante ?
Code 15 (tangente.py (1)).
def mon_arctan(x,n):
somme = 0
for k in range(0,n+1):
if (k%2 == 0): # si k est pair signe +
somme = somme + 1/(2*k+1) * (x ** (2*k+1))
else:
# si k est impair signe somme = somme - 1/(2*k+1) * (x ** (2*k+1))
return somme
La srie qui permet de calculer Arctan x est une somme infinie, mais si x est petit alors chacun des termes
x 2k+1
1
1
(1)k 2k+1
est trs trs petit ds que k devient grand. Par exemple si 0 6 x 6 10
alors x 2k+1 6 102k+1
et

k x 2k+1
9
donc pour k > 4 nous aurons (1) 2k+1 < 10 . Chacun des termes suivants ne contribue pas aux 8
12
premiers chiffres aprs la virgule. Attention : il se pourrait cependant que la somme de beaucoup de
termes finissent par y contribuer, mais ce nest pas le cas ici (cest un bon exercice de le prouver).
Dans la pratique on calcule la somme un certain ordre 2k+1 jusqu ce que les 8 chiffres aprs la virgules
3
5
7
ne bougent plus. Et en fait on saperoit que lon a seulement besoin dutiliser Arctan x ' x x3 + x5 x7 .
Pour i > 4, Arctan x ' x donne dj 8 chiffres exacts aprs la virgule !
On remplit les valeurs des angles i obtenus dans une liste nomme theta.
3.2. Calcul de tan x

Le principe est le suivant : on connat un certain nombre dangles avec leur tangente : les angles i (calculs
ci-dessus) avec par dfinition tan i = 10i . Fixons un angle a [0, 2 ]. Partant du point M0 = (1, 0),
nous allons construire des points M1 , M2 , . . . , Mn jusqu ce que Mn soit ( peu prs) sur la demi-droite
y
correspondant langle a. Si Mn a pour coordonnes (x n , yn ) alors tan a = x nn . Langle pour passer dun
point Mk Mk+1 est lun des angles i .
Mn
Mn1
M2
M1
in
i2
i1
M0
Rappelons que si lon a un point M (x, y) alors la rotation centre lorigine et dangle envoie M (x, y)
sur le point N (x 0 , y 0 ) avec
0

0
x
cos sin
x
x = x cos y sin
cest--dire
0 =
y
sin
cos
y
y 0 = x sin + y cos
Pour un point M , on note M 0 le point de la demi-droite [ON ) tel que les droites (OM ) et (M M 0 ) soient
perpendiculaires en M .
M0
Mn
N
tan a '
yn
xn
yn
a
M
xn
13
1. (a) Calculer la longueur OM 0 .
(b) En dduire les coordonnes de M 0 .
(c) Exprimez-les uniquement en fonction de x, y et tan .
2. Faire une boucle qui dcompose langle a en somme dangles i ( une prcision de 108 ; avec un
minimum dangles, les angles pouvant se rpter).
3. Partant de M0 = (1, 0) calculer les coordonnes des diffrents Mk , jusquau point Mn (x n , yn ) corresy
pondant lapproximation de langle a. Renvoyer la valeur x nn comme approximation de tan a.
Voici les prliminaires mathmatiques :
OM
OM
Dans le triangle rectangle OM M 0 on a cos = OM 0 donc OM 0 = cos .
Dautre part comme la rotation dangle conserve les distances alors OM = ON . Si les coordonnes de
M 0 sont (x 00 , y 00 ) alors x 00 = cos1 x 0 et y 00 = cos1 y 0 .
Ainsi

00
x = cos1 x 0 = cos1 x cos y sin = x y tan

y 00 = cos1 y 0 = cos1 x sin + y cos = x tan + y
Autrement dit :
00

x
x
1
tan
00 =
y
y
tan
1
Voici une boucle simple pour dcomposer langle : on commence par retirer le plus grand angle 0 autant
de fois que lon peut, lorsque ce nest plus possible on passe langle 1 ,...
i = 0
while (a > precision):
while (a < theta[i]):
i = i+1
a = a - theta[i]
# boucle tant que la precision pas atteinte

# choix du bon angle theta_i soustraire
# on retire l'angle theta_i et on recommence
Ici precision est la prcision souhait (pour nous 109 ). Et le tableau theta contient les valeurs des
angles i .

x0
Posons x 0 = 1, y0 = 0 et M0 =
. Alors on dfinit par rcurrence Mk+1 = P(i ) Mk o P( ) =
y0

1
tan
. Les i sont ceux apparaissant dans la dcomposition de langle en somme de i , donc on
tan
1
connat tan i = 10i . Ainsi si lon passe dun point Mk Mk+1 par un angle i on a simplement :

x k+1 = x k yk 10i
yk+1 = x k 10i + yk
y
La valeur x nn est la tangente de la somme des angles i , donc une approximation de tan a.
Le code est maintenant le suivant.
def ma_tan(a):
precision = 10**(-9)
i = 0 ; x = 1 ; y = 0
while (a > precision):
while (a < theta[i]):
i = i+1
newa = a - theta[i]
newx = x - (10**(-i))*y
newy = (10**(-i))*x + y
x = newx
y = newy
a = newa
return y/x
14
# on retire l'angle theta_i

# on calcule le nouveau point
# on renvoie la tangente
Commentaires pour conclure :

En thorie il ne faut pas confondre prcision et nombre de chiffres exacts aprs la virgule. Par
exemple 0.999 est une valeur approche de 1 103 prs, mais aucun chiffre aprs la virgule nest exact.
Dans la pratique cest la prcision qui importe plus que le nombre de chiffres exacts.
Notez quel point les oprations du calcul de tan x sont simples : il ny a quasiment que des additions
effectuer. Par exemple lopration x k+1 = x k yk 10i peut tre fait la main : multiplier par 10i cest
juste dcaler la virgule droite de i chiffres, puis on additionne. Cest cet algorithme C O R D I C qui est
implment dans les calculatrices, car il ncessite trs peu de ressources. Bien sr, si les nombres sont
cods en binaire on remplace les 10i par 2i pour navoir qu faire des dcalages droite.
3.3. Calcul de sin x et cos x

Pour 0 6 x 6 2 , calculer sin x et cos x en fonction de tan x. En dduire comment calculer les sinus et
cosinus de x.
Solution : On sait cos2 + sin2 x = 1, donc en divisant par cos2 x on trouve 1 + tan2 x = cos12 x . On en dduit
que pour 0 6 x 6 2 cos x = p 1 2 . On trouve de mme sin x = p tan x 2 .
1+tan x
1+tan x
Donc une fois que lon a calcul tan x on en dduit sin x et cos x par un calcul de racine carre. Attention
cest valide car x est compris entre 0 et 2 . Pour un x quelconque il faut se ramener par les formules
trigonomtriques lintervalle [0, 2 ].
Mini-exercices. 1. On dispose de billets de 1, 5, 20 et 100 euros. Trouvez la faon de payer une somme
de n euros avec le minimum de billets.
2. Faire un programme qui pour nimporte quel x R, calcule sin x, cos x, tan x.
3. Pour t = tan 2x montrer que tan x =
x assez petit tan x ' x).
2t
.
1t 2
En dduire une fonction qui calcule tan x. (Utiliser que pour
4. Modifier lalgorithme de la tangente pour quil calcule aussi directement le sinus et le cosinus.
4. LES RELS
15
4. Les rels
Dans cette partie nous allons voir diffrentes faons de calculer la constante dEuler. Cest un nombre
assez mystrieux car personne ne sait si est un nombre rationnel ou irrationnel. Notre objectif est davoir
le plus de dcimales possibles aprs la virgule en un minimum dtapes. Nous verrons ensuite comment les
ordinateurs stockent les rels et les problmes que cela engendre.
4.1. Constante dEuler

Considrons la suite harmonique :
Hn =
et dfinissons
1
1 1 1
+ + + +
1 2 3
n
un = H n ln n.
Cette suite (un ) admet une limite lorsque n + : cest la constante dEuler.
1
, combien de dcimales exactes
1. Calculer les premires dcimales de . Sachant que un 2n
peut-on esprer avoir obtenues ?

1
1
. Sachant vn 48n
2. On considre vn = H n ln n + 21 + 24n
3 , calculer davantage de dcimales.
Code 18 (euler.py (1)).
def euler1(n):
somme = 0
for i in range(n,0,-1):
somme = somme + 1/i
return somme - log(n)
def euler2(n):
somme = 0
somme = somme + 1/i
return somme - log(n+1/2+1/(24*n))
Vous remarquez que la somme est calcule partir de la fin. Nous expliquerons pourquoi en fin de section.
4.2. 1000 dcimales de la constante dEuler

Il y a deux techniques pour obtenir plus de dcimales : (i) pousser plus loin les itrations, mais pour avoir
1000 dcimales de les mthodes prcdentes sont insuffisantes ; (ii) trouver une mthode encore plus
efficace. Cest ce que nous allons voir avec la mthode de Bessel modifie.
Soit
E(n)
E(n)
X nk 2
X nk 2
An
wn =
ln n avec An =
H k et Bn =
Bn
k!
k!
k=1
k=0
o = 3.59112147... est la solution de (ln 1) = 1 et E(x) dsigne la partie entire. Alors
C
|w n | 6 4n
e
4. LES RELS
16
o C est une constante (non connue).

1. Programmer cette mthode.
2. Combien ditrations faut-il pour obtenir 1000 dcimales ?
3. Utiliser le module decimal pour les calculer.
Voici le code :
def euler3(n):
alpha = 3.59112147
N = floor(alpha*n)
# Borne des sommes
A = 0 ; B = 0
H = 0
for k in range(1,N+1):
c = ( (n**k)/factorial(k) ) ** 2 # Coefficient commun
H = H + 1/k
# Somme harmonique
A = A + c*H
B = B + c
return A/B - log(n)
6 101N . On passe au log pour obtenir n >
On ne connat pas C mais ce nest pas si important. Moralement pour une itration de plus on
obtient ( peu prs) une dcimale de plus (cest--dire un facteur 10 sur la prcision !). Pour n > 800 on
obtient 1000 dcimales exactes de la constante dEuler :
Pour obtenir N dcimales il faut rsoudre linquation
N ln(10)+ln(C)
.
4
0,
57721566490153286060651209008240243104215933593992
14631447249807082480960504014486542836224173997644
60087352039481656708532331517766115286211995015079
05877553526733139925401296742051375413954911168510
67600172479537836759271351577226102734929139407984
93586796549725203621287922655595366962817638879272
10090151251959509222435014093498712282479497471956
45516989279230187739107294578155431600500218284409
28690001558193988042707411542227819716523011073565
93031005030863034185698032310836916400258929708909
C
e4n
35988057672348848677267776646709369470632917467495
92353625350033374293733773767394279259525824709491
84793745085705740029921354786146694029604325421519
28079842348775872050384310939973613725530608893312
30103417771778088154957066107501016191663340152278
68013243101047650596370394739495763890657296792960
46976318506676129063811051824197444867836380861749
60537724342032854783670151773943987003023703395183
83396734871765049194181230004065469314299929777956
85486825777364288253954925873629596133298574739302
Pour obtenir plus de dcimales que la prcision standard de Python, il faut utiliser le module decimal qui
permet de travailler avec une prcision arbitraire fixe.
4.3. Un peu de ralit

En mathmatique un rel est un lment de R et son criture dcimale est souvent infinie aprs la virgule :
par exemple = 3, 14159265 . . . Mais bien sr un ordinateur ne peut pas coder une infinit dinformations.
Ce qui se rapproche dun rel est un nombre flottant dont lcriture est :
1, 234567890123456789 e 123
|
{z
} | {z }
mantisse
123
exposant
pour 1, 234 . . . 10
. La mantisse est un nombre dcimal (positif ou ngatif) appartenant [1, 10[ et
lexposant est un entier (lui aussi positif ou ngatif). En Python la mantisse une prcision de 16 chiffres
aprs la virgule.
4. LES RELS
17
Cette ralit informatique fait que des erreurs de calculs peuvent apparatre mme avec des oprations
simples. Pour voir un exemple de problme faites ceci :
Poser x = 1016 , y = x + 1, z = y 1. Que vaut z pour Python ?
Comme Python est trs prcis nous allons faire une routine qui permet de limiter drastiquement le nombre
de chiffres et mettre en vidence les erreurs de calculs.
1. Calculer lexposant dun nombre rel. Calculer la mantisse.
2. Faire une fonction qui ne conserve que 6 chiffres dun nombre (6 chiffres en tout : avant + aprs la
virgule, exemple 123, 456789 devient 123, 456).
Voici le code :
Code 21 (reels.py (1)).
precision = 6
# Nombre de dcimales conserves
def tronquer(x):
n = floor(log(x,10))
# Exposant
m = floor( x * 10 ** (precision-1 - n)) # Mantisse
return m * 10 ** (-precision+1+n)
# Nombre tronqu
Comme on la dj vu auparavant lexposant se rcupre laide du logarithme en base 10. Et pour tronquer
un nombre avec 6 chiffres, on commence par le dcaler vers la gauche pour obtenir 6 chiffres avant la
virgule (123, 456789 devient 123456, 789) il ne reste plus qu prendre la partie entire (123456) et le
redcaler vers la droite (pour obtenir 123, 456).
Absorption
1. Calculer tronquer(1234.56 + 0.007).
2. Expliquer.
Chacun des nombres 1234, 56 et 0, 007 est bien un nombre scrivant avec moins de 6 dcimales mais leur
somme 1234, 567 a besoin dune dcimale de plus, lordinateur ne retient pas la 7-me dcimale et ainsi le
rsultat obtenu est 1234, 56. Le 0, 007 napparat pas dans le rsultat : il a t victime dune absorption.
limination
1. Soient x = 1234, 8777, y = 1212, 2222. Calculer x y la main. Comment se calcule la diffrence
x y avec notre prcision de 6 chiffres ?
2. Expliquer la diffrence.
Comme x y = 22, 6555 qui na que 6 chiffres alors on peut penser que lordinateur va obtenir ce rsultat. Il
nen est rien, lordinateur ne stocke pas x mais tronquer(x), idem pour y. Donc lordinateur effectue en fait
le calcul suivant : tronquer(tronquer(x)-tronquer(y)), il calcule donc 1234, 87 1212, 22 = 22, 65.
4. LES RELS
18
Quel est le problme ? Cest quensuite lutilisateur considre tort que le rsultat est calcul avec une
prcision de 6 chiffres. Donc on peut penser que le rsultat est 22, 6500 mais les 2 derniers chiffres sont une
pure invention.
Cest un phnomne dlimination. Lorsque lon calcule la diffrence de deux nombres proches, le rsultat a
en fait une prcision moindre. Cela peut tre encore plus dramatique avec lexemple = 1234, 5691234, 55
la diffrence est 0, 01900 alors que lordinateur retournera 0, 01000. Il y a presque un facteur deux, et on
aura des problmes si lon a besoin de diviser par .
Signalons au passage une erreur dinterprtation frquente : ne pas confondre la prcision daffichage
(exemple : on calcule avec 10 chiffres aprs la virgule) avec lexactitude du rsultat (combien de dcimales
sont vraiment exactes ?).
Conversion binaire dcimale
Enfin le problme le plus troublant est que les nombres flottants sont stocks en criture binaire et pas en
criture dcimale.
Effectuer les commandes suivantes et constater !
1. sum = 0 puis for i in range(10): sum = sum + 0.1. Que vaut sum ?
2. 0.1 + 0.1 == 0.2
et
0.1 + 0.1 + 0.1 == 0.3
3. x = 0.2 ; print("0.2 en Python = %.25f" %x)

La raison est simple mais nanmoins troublante. Lordinateur ne stocke pas 0, 1, ni 0, 2 en mmoire mais le
nombre en criture binaire qui sen rapproche le plus.
En criture dcimale, il est impossible de coder 1/3 = 0, 3333 . . . avec un nombre fini de chiffres aprs la
virgule. Il en va de mme ici : lordinateur ne peut pas stocker exactement 0, 2. Il stocke un nombre en
criture binaire qui sen rapproche le plus ; lorsquon lui demande dafficher le nombre stock, il retourne
lcriture dcimale qui se rapproche le plus du nombre stock, mais ce nest plus 0, 2, mais un nombre trs
trs proche :
0.2000000000000000111022302. . .
4.4. Somme des inverses des carrs

Voyons une situation concrte o ces problmes apparaissent.
1. Faire une fonction qui calcule la somme Sn =
1
12
1
22
1
32
+ +
1
.
n2
2. Faire une fonction qui calcule cette somme mais en utilisant seulement une criture dcimale 6
chiffres ( laide de la fonction tronquer() vue au-dessus).
3. Reprendre cette dernire fonction, mais en commenant la somme par les plus petits termes.
4. Comparez le deux dernires mthodes, justifier et conclure.
La premire fonction ne pose aucun problme et utilise toute la prcision de Python.
Dans la seconde on doit, chaque calcul, limiter notre prcision 6 chiffres (ici 1 avant la virgule et 5
aprs).
def somme_inverse_carres_tronq(n):
somme = 0
5. ARITHMTIQUE ALGORITHMES RCURSIFS
19
somme = tronquer(somme + tronquer(1/(i*i)))
return somme
Il est prfrable de commencer la somme par la fin :
def somme_inverse_carres_tronq_inv(n):
somme = 0
somme = tronquer(somme + tronquer(1/(i*i)))
return somme
Par exemple pour n = 100 000 lalgorithme somme_inverse_carres_tronq() (avec criture tronque,
somm dans lordre) retourne 1, 64038 alors que lalgorithme somme_inverse_carres_tronq_inv()
(avec la somme dans lordre inverse) on obtient 1, 64490. Avec une prcision maximale et n trs grand on
2
doit obtenir 1, 64493 . . . (en fait cest 6 ).
Notez que faire grandir n pour lalgorithme somme_inverse_carres_tronq() ny changera rien, il bloque
2 dcimales exactes aprs la virgule : 1, 64038 ! La raison est un phnomne dabsorption : on rajoute des
termes trs petits devant une somme qui vaut plus de 1. Alors que si lon part des termes petits, on ajoute
des termes petits une somme petite, on garde donc un maximum de dcimales valides avant de terminer
par les plus hautes valeurs.
Mini-exercices. 1. crire une fonction qui approxime la constante qui vrifie (ln 1) = 1. Pour cela
poser f (x) = x(ln x 1) 1 et appliquer la mthode de Newton : fixer u0 (par exemple ici u0 = 4) et
f (u )
un+1 = un f 0 (un ) .
n
2. Pour chacune des trois mthodes, calculer le nombre approximatif ditrations ncessaires pour obtenir
100 dcimales de la constante dEuler.
P2n
An
Cn
[(2k)!]3
1
1
3. Notons Cn = 4n
k=0 (k!)4 (16n)2 k . La formule de Brent-McMillan affirme = Bn Bn2 ln n + O( e8n )
o cette fois les sommations pour An et Bn vont jusqu E( n) avec = 4, 970625759 . . . la solution
de (ln 1) = 3. La notation O( e18n ) indique que lerreur est 6 eC8n pour une certaine constante C.
Mettre en uvre cette formule. En 1999 cette formule a permis de calculer 100 millions de dcimales.
Combien a-t-il fallu ditrations ?
4. Faire une fonction qui renvoie le terme un de la suite dfinie par u0 =
u100 ? Faire ltude mathmatique et commenter.
1
3
et un+1 = 4un 1. Que vaut
5. Arithmtique Algorithmes rcursifs

Nous allons prsenter quelques algorithmes lmentaires en lien avec larithmtique. Nous en profitons
pour prsenter une faon compltement diffrente dcrire des algorithmes : les fonctions rcursives.
5.1. Algorithmes rcursifs

Voici un algorithme trs classique :
Code 24 (recursif.py (1)).
def factorielle_classique(n):
20
produit = 1
produit = i * produit
return produit
Voyons comment fonctionne cette boucle. On initialise la variable produit 1, on fait varier un indice i de
1 n. chaque tape on multiplie produit par i et on affecte le rsultat dans produit. Par exemple si
n = 5 alors la variable produit sinitialise 1, puis lorsque i varie la variable produit devient 1 1 = 1,
2 1 = 2, 3 2 = 6, 4 6 = 24, 5 24 = 120. Vous avez bien sr reconnus le calcul de 5!
tudions un autre algorithme.
def factorielle(n):
if (n==1):
return 1
else:
return n * factorielle(n-1)
Que fait cet algorithme ? Voyons cela pour n = 5. Pour n = 5 la condition du si (if) nest pas vrifie donc on passe directement au sinon (else). Donc factorielle(5) renvoie comme rsultat :
5 * factorielle(4). On a plus ou moins progress : le calcul nest pas fini car on ne connat pas encore
factorielle(4) mais on sest ramen un calcul au rang prcdent, et on itre :
factorielle(5) = 5 * factorielle(4) = 5 * 4 * factorielle(3) = 5 * 4 * 3 * factorielle(2)

et enfin factorielle(5) = 5 * 4 * 3 * 2 * factorielle(1). Pour factorielle(1) la condition du if (n==1) est vrifie et alors factorielle(1)=1. Le bilan est donc que factorielle(5) = 5 * 4 * 3 *
cest bien 5!
Une fonction qui lorsque elle sexcute sappelle elle-mme est une fonction rcursive. Il y a une analogie
trs forte avec la rcurrence. Par exemple on peut dfinir la suite des factorielles ainsi :
u1 = 1
et
un = n un1 si n > 2.
Nous avons ici un = n! pour tout n > 1.

Comme pour la rcurrence une fonction rcursive comporte une tape dinitialisation (ici if (n==1): return 1
correspondant u1 = 1) et une tape dhrdit (ici return n * factorielle(n-1) correspondant
un = n un1 ).
On peut mme faire deux appels la fonction :
def fibonacci(n):
if (n==0) or (n==1):
return 1
else:
return fibonacci(n-1)+fibonacci(n-2)
Faites-le calcul de fibonacci(5). Voici la version mathmatique des nombres de Fibonacci.
F0 = 1, F1 = 1
Fn = Fn1 + Fn2
et
si n > 2.
On obtient un nombre en additionnant les deux nombres des rangs prcdents :

1
13
21
34
...
21
5.2. Lalgorithme dEuclide

Lalgorithme dEuclide est bas sur le principe suivant
si b|a alors pgcd(a, b) = b
sinon pgcd(a, b) = pgcd(b, a mod b)

1. Crer une fonction rcursive pgcd(a,b) qui calcule le pgcd.
2. On note pn la probabilit que deux entiers a, b tirs au hasard dans 1, 2, . . . , n soient premiers entre
eux. Faire une fonction qui approxime pn . Lorsque n devient grand, comparer pn et 62 .
Voici le code pour lalgorithme dEuclide rcursif. Notez quel point le code est succinct et pur !
Code 27 (arith.py (1)).
def pgcd(a,b):
if a%b == 0:
return b
else:
return pgcd(b, a%b)
Deux entiers a, b sont premiers entre eux ssi pgcd(a, b) = 1, donc voici lalgorithme :
def nb_premiers_entre_eux(n,nbtirages):
i = 1
nbpremiers = 0
while i <= nbtirages:
i = i+1
a = random.randint(1,n)
b = random.randint(1,n)
if pgcd(a,b)==1:
nbpremiers = nbpremiers + 1
return nbpremiers
On tire au hasard deux entiers a et b entre 1 et n et on effectue cette opration nbtirages fois.
Par exemple entre 1 et 1000 si lon effectue 10 000 tirage on trouve une probabilit mesure par
nbpremiers/nbtirages de 0, 60 . . . (les dcimales daprs dpendent des tirages).
Lorsque n tend vers + alors pn 62 = 0.607927 . . . et on dit souvent que : la probabilit que deux
entiers tirs au hasard soient premiers entre eux est 62 .
Commentaires sur les algorithmes rcursifs :
Les algorithmes rcursifs ont souvent un code trs court, et proche de la formulation mathmatique
lorsque lon a une relation de rcurrence.
Selon le langage ou la fonction programme il peut y avoir des problmes de mmoire (si par exemple
pour calculer 5! lordinateur a besoin de stocker 4! pour lequel il a besoin de stocker 3!...).
Il est important de bien rflchir la condition initiale (qui est en fait celle qui termine lalgorithme) et
la rcurrence sous peine davoir une fonction qui boucle indfiniment !
Il nexiste pas des algorithmes rcursifs pour tout (voir par exemple les nombres premiers) mais ils
apparaissent beaucoup dans les algorithmes de tris. Autre exemple : la dichotomie se programme trs
bien par une fonction rcursive.
22
5.3. Nombres premiers

Les nombres premiers offrent peu de place aux algorithmes rcursifs car il ny a pas de lien de rcurrence
entre les nombres premiers.
1. crire une fonction qui dtecte si un nombre n est premier ou pas en testant sil existe des entiers k
p
qui divise n. (On se limitera aux entiers 2 6 k 6 n, pourquoi ?).
2. Faire un algorithme pour le crible dEratosthne : crire tous les entiers de 2 n, conserver 2 (qui est
premier) et barrer tous les multiples suivants de 2. Le premier nombre non barr (cest 3) est premier.
Barrer tous les multiples suivants de 3,...
3. Dessiner la spirale dUlam : on place les nombres entiers en spirale, et on colorie en rouge les nombres
premiers.

..
5 4 3
.
6 1
7 8
2
9
11
10
p
p
1. Si n nest pas premier alors n = a b avec a, b > 2. Il est clair que soit a 6 n ou bien b 6 n (sinon
p
n = a b > n). Donc il suffit de tester les diviseurs 2 6 k 6 n. Do lalgorithme :
def est_premier(n):
if (n<=1): return False
k = 2
while k*k <= n:
if n%k==0:
return False
else:
k = k +1
return True
Notez quil vaut mieux crire la condition k*k <= n plutt que k <= sqrt(n) : il est beaucoup plus
rapide de calculer le carr dun entier plutt quextraire une racine carre.
Nous avons utilis un nouveau type de variable : un boolen est une variable qui ne peut prendre que
deux tats Vrai ou Faux (ici True or False, souvent cod 1 et 0). Ainsi est_premier(13) renvoie True,
alors que est_premier(14) renvoie False.
2. Pour le crible dEratosthne le plus dur est de trouver le bon codage de linformation.
def eratosthene(n):
liste_entiers = list(range(n+1)) # tous les entiers
liste_entiers[1] = 0
# 1 n'est pas premier
k = 2
# on commence par les multiples de 2
while k*k <= n:
if liste_entiers[k] != 0: # si le nombre k n'est pas barr
i = k
# les i sont les multiples de k
while i <= n-k:
23
i = i+k
liste_entiers[i] = 0 # multiples de k : pas premiers
k = k +1
liste_premiers = [k for k in liste_entiers if k !=0] # efface les 0
return liste_premiers
Ici on commence par faire un tableau contenant les entiers [0,1,2,3,4,5,6,7,8,9,10,11,12,13,...].
Pour signifier quun nombre nest pas premier ou remplace lentier par 0. Comme 1 nest pas un nombre
premier : on le remplace par 0. Puis on fait une boucle, on part de 2 et on remplace tous les autres
multiples de 2 par 0 : la liste est maintenant : [0,0,2,3,0,5,0,7,0,9,0,11,0,13,...]. Le
premiers nombre aprs 2 est 3 cest donc un nombre premier. (car sil na aucun diviseur autre que 1 et
lui-mme car sinon il aurait t ray). On garde 3 et remplace tous les autres multiples de 3 par 0. La
liste est maintenant : [0,0,2,3,0,5,0,7,0,0,0,11,0,13,...]. On itre ainsi, la fin on efface
les zros pour obtenir : [2,3,5,7,11,13,...].
3. Pour la spirale dUlam la seule difficult est de placer les entiers sur une spirale, voici le rsultat.
gauche le dbut de la spirale (de n = 1 37) en rouge les nombres premiers (en noir les nombres non
premiers) ; droite le motif obtenu jusqu de grandes valeurs (en blanc les nombres non premiers).
Mini-exercices. 1. crire une version itrative et une version rcursive pour les fonctions suivantes : (a)
la somme des carrs des entiers de 1 n ; (b) 2n (sans utiliser dexposant) ; (c) la partie entire dun
rel x > 0 ; (d) le quotient de la division euclidienne de a par b (avec a N, b N ) ; (e) le reste de
cette division euclidienne (sans utiliser les commandes % ni //).
2. crire une version itrative de la suite de Fibonacci.
3. crire une version itrative de lalgorithme dEuclide. Faire une version qui calcule les coefficients de
Bzout.
4. crire une fonction itrative, puis rcursive, qui pour un entier n renvoie la liste de ses diviseurs.
Dessiner une spirale dUlam, dont lintensit de la couleur dpend du nombre de diviseurs.
5. Une suite de Syracuse est dfinie ainsi : partant dun entier sil est pair on le divise par deux, sil est
impair on le multiplie par 3 et on ajoute 1. On itre ce processus. Quelle conjecture peut-on faire sur
cette suite ?
6. Dessiner le triangle de Pascal
1
2
Ensuite effacer tous les coefficients pairs (ou mieux : remplacer
les coefficients pairs par un carr blanc et les coefficients impairs par un carr rouge). Quelle figure
6. POLYNMES COMPLEXIT DUN ALGORITHME
24
reconnaissez-vous ?
6. Polynmes Complexit dun algorithme

Nous allons tudier la complexit des algorithmes travers lexemple des polynmes.
6.1. Quest-ce quun algorithme ?

Quest ce quun algorithme ? Un algorithme est une succession dinstructions qui renvoie un rsultat. Pour
tre vraiment un algorithme on doit justifier que le rsultat retourn est exact (le programme fait bien ce
que lon souhaite) et ceci en un nombre fini dtapes (cela renvoie le rsultat en temps fini).
Maintenant certains algorithmes peuvent tre plus rapides que dautres. Cest souvent le temps de calcul
qui est le principal critre, mais cela dpend du langage et de la machine utilise. Il existe une manire
plus mathmatique de faire : la complexit dun algorithme cest le nombre doprations lmentaires
effectuer.
Ces oprations peuvent tre le nombre doprations au niveau du processeur, mais pour nous ce sera le
nombre dadditions +, le nombre de multiplications effectuer. Pour certains algorithmes la vitesse
dexcution nest pas le seul paramtre mais aussi la taille de la mmoire occupe.
6.2. Polynmes
On code un polynme a0 + a1 X + + an X n sous la forme dune liste [a0 , a1 , . . . , an ].
1. crire une fonction correspondant la somme de deux polynmes. Calculer la complexit de cet
algorithme (en terme du nombre dadditions sur les coefficients, en fonctions du degr des polynmes).
2. crire une fonction correspondant au produit de deux polynmes. Calculer la complexit de cet
algorithme (en terme du nombre dadditions et de multiplications sur les coefficients).
3. crire une fonction correspondant au quotient et au reste de la division euclidienne de A par B o
B est un polynme unitaire (son coefficient de plus haut degr est 1). Majorer la complexit de cet
algorithme (en terme du nombre dadditions et de multiplications sur les coefficients).
1. La seule difficult est de grer les indices, en particulier on ne peut appeler un lment dune liste en
dehors des indices o elle est dfinie. Une bonne ide consiste commencer par dfinir une fonction
degre(poly), qui renvoie le degr du polynme (attention au 0 non significatifs).
Voici le code dans le cas simple o deg A = deg B :
Code 31 (polynome.py (1)).
def somme(A,B):
# si deg(A)=deg(B)
C = []
for i in range(0,degre(A)+1):
s = A[i]+B[i]
C.append(s)
Calculons sa complexit, on suppose deg A 6 n et deg B 6 n : il faut faire laddition des coefficients
ai + bi , pour i variant de 0 n : donc la complexit est de n + 1 additions (dans Z ou R).
25
Pm
Pn
Pm+n
2. Pour le produit il faut se rappeler que si A(X ) = i=0 ai X i , B(X ) = j=0 b j X j et C = A B = k=0 ck X k
P
alors le k-me coefficient de C est ck = i+ j=k ai b j . Dans la pratique on fait attention de ne pas
accder des coefficients qui nont pas t dfinis.
def produit(A,B):
C = []
for k in range(degre(A)+degre(B)+1):
s = 0
for i in range(k+1):
if (i <= degre(A)) and (k-i <= degre(B)):
s = s + A[i]*B[k-i]
C.append(s)
return C
Pour la complexit on commence par compter le nombre de multiplications (dans Z ou R). Notons
m = deg A et n = deg B. Alors il faut multiplier les m + 1 coefficients de A par les n + 1 coefficients de B :
il y a donc (m + 1)(n + 1) multiplications.
Comptons maintenant les additions : les coefficients de A B sont : c0 = a0 b0 , c1 = a0 b1 + a1 b0 ,
c2 = a2 b0 + a1 b1 + a2 b0 ,...
Nous utilisons lastuce suivante : nous savons que le produit A B est de degr m + n donc a (au plus)
m + n + 1 coefficients. Partant de (m + 1)(n + 1) produits, chaque addition regroupe deux termes, et
nous devons arriver m + n + 1 coefficients. Il y a donc (m + 1)(n + 1) (m + n + 1) = mn additions.
3. Pour la division euclidienne, le principe est de poser une division de polynme. Par exemple pour
A = 2X 4 X 3 2X 2 + 3X 1 et B = X 2 X + 1.
2X 4 X 3 2X 2 + 3X 1
X2 X + 1
2X 4 2X 3 + 2X 2
X 3 4X 2 + 3X 1
2X 2 + X 3
X3 X2 + X
3X 2 + 2X 1
3X 2 + 3X 3
X + 2
Alors on cherche quel monme P1 fait diminuer le degr de A P1 B, cest 2X 2 (le coefficient 2 est le
coefficient dominant de A). On pose ensuite R1 = A P1 B = X 3 4X 2 +3X 1, Q 1 = 2X 2 , on recommence
avec R1 divis par B, R2 = R1 P2 B avec P2 = X , Q 2 = Q 1 + P2 ,... On arrte lorsque deg R i < deg B.
def division(A,B):
Q = [0]
# Quotient
R = A
# Reste
while (degre(R) >= degre(B)):
P = monome(R[degre(R)],degre(R)-degre(B))
26
R = somme(R,produit(-P,B))
Q = somme(Q,P)
return Q,R
Cest une version un peu simplifie du code : o P = rn X deg Rdeg B et o il faut remplacer P par
[a0 , a1 , ...]. Si A, B Z[X ] alors le fait que B soit unitaire implique que Q et R sont aussi coefficients
entiers.
Quelle est la complexit de la division euclidienne ? chaque tape on effectue une multiplication de
polynmes (Pi B) puis une addition de polynme (R i Pi B) ; chaque tape le degr de R i diminue
(au moins) de 1. Donc il y a au plus deg A deg B + 1 tapes.
Mais dans la pratique cest plus simple que cela. La multiplication Pi B est trs simple : car Pi est
un monme Pi = pi X i . Multiplier par X i cest juste un dcalage dindice (comme multiplier par 10i en
criture dcimale) cest donc une opration ngligeable. Il reste donc multiplier les coefficients de B
par pi : il y a donc deg B + 1 multiplications de coefficients. La soustraction aussi est assez simple on
retire R i un multiple de B, donc on a au plus deg B + 1 coefficients soustraire : il y a chaque tape
deg B + 1 additions de coefficients.
Bilan : si m = deg A et n = deg B alors la division euclidienne seffectue en au plus (m n + 1)(m + 1)
multiplications et le mme nombre dadditions (dans Z ou R).
6.3. Algorithme de Karatsuba

Pour diminuer la complexit de la multiplication de polynmes, on va utiliser un paradigme trs classique
de programmation : diviser pour rgner . Pour cela, on va dcomposer les polynmes multiplier P et Q
de degrs strictement infrieurs 2n en
P = P1 + P2 X n
et
Q = Q1 + Q2 X n
avec les degrs de P1 , P2 , Q 1 et Q 2 strictement infrieurs n.

1. crire une formule qui rduit la multiplication des polynmes P et Q de degrs strictement infrieurs
2n en multiplications de polynmes de degrs strictement infrieurs n.
2. Programmer un algorithme rcursif de multiplication qui utilise la formule prcdente. Quelle est sa
complexit ?
3. On peut raffiner cette mthode avec la remarque suivante de Karatsuba : le terme intermdiaire de
P Q scrit
P1 Q 2 + P2 Q 1 = (P1 + P2 ) (Q 1 + Q 2 ) P1Q 1 P2Q 2
Comme on a dj calcul P1Q 1 et P2Q 2 , on change deux multiplications et une addition ( gauche)
contre une multiplication et quatre additions ( droite). crire une fonction qui ralise la multiplication
de polynmes la Karatsuba.
4. Trouver la formule de rcurrence qui dfinit la complexit de la multiplication de Karatsuba. Quelle
est sa solution ?
1. Il suffit de dvelopper le produit (P1 + X n P2 ) (Q 1 + X nQ 2 ) :
(P1 + X n P2 ) (Q 1 + X nQ 2 ) = P1Q 1 + X n (P1Q 2 + P2Q 1 ) + X 2n P2Q 2
On se ramne ainsi aux quatre multiplications P1Q 1 , P1Q 2 , P2Q 1 et P2Q 2 entre polynmes de degrs
strictement infrieurs n, plus deux multiplications par X n et X 2n qui ne sont que des ajouts de zros
en tte de liste.
27
2. On spare les deux tapes de lalgorithme : dabord la dcoupe des polynmes (dans laquelle il ne faut
pas oublier de donner n en argument car ce nest pas forcment le milieu du polynme, n doit tre le
mme pour P et Q). Le dcoupage P1,P2 = decoupe(P,n) correspond lcriture P = P1 + X n P2 .
def decoupe(P,n):
if (degre(P)<n): return P, [0]
else: return P[0:n], P[n:]
On a aussi besoin dune fonction produit_monome(P,n) qui renvoie le polynme X n P par un dcalage.
Voici la multiplication proprement dite avec les appels rcursifs et leur combinaison.
def produit_assez_rapide(P,Q):
p = degre(P) ; q = degre(Q)
if (p == 0): return [P[0]*k for k in Q]
if (q == 0): return [Q[0]*k for k in P]
n = (max(p,q)+1)//2
P1,P2 = decoupe(P,n)
Q1,Q2 = decoupe(Q,n)
P1Q1 = produit_assez_rapide(P1,Q1)
R1 = produit_monome(somme(P1Q2,P2Q1),n)
R2 = produit_monome(P2Q2,2*n)
return somme(P1Q1,somme(R1,R2))
#
#
#
#
Condition initiale: P=cst

Condition initiale: Q=cst
demi-degr
decoupages
# produits en petits degrs
# dcalages
# sommes
La relation de rcurrence qui exprime la complexit de cet algorithme est C(n) = 4C(n/2) + O(n) et elle
se rsout en C(n) = O(n2 ). Voir la question suivante pour une mthode de rsolution.
3.
def produit_rapide(P,Q):
p = degre(P) ; q = degre(Q)
if (p == 0): return [P[0]*k for k in Q] # Condition initiale: P=cst
if (q == 0): return [Q[0]*k for k in P] # Condition initiale: Q=cst
n = (max(p,q)+1)//2
# demi-degr
P1,P2 = decoupe(P,n)
# decoupages
Q1,Q2 = decoupe(Q,n)
P1Q1 = produit_rapide(P1,Q1)
# produits en petits degrs
P2Q2 = produit_rapide(P2,Q2)
PQ = produit_rapide(somme(P1,P2),somme(Q1,Q2))
R1 = somme(PQ,somme([-k for k in P1Q1],[-k for k in P2Q2]))
R1 = produit_monome(R1,n)
# dcalages
R2 = produit_monome(P2Q2,2*n)
return somme(P1Q1,somme(R1,R2))
# sommes
28
4. Notons C(n) la complexit de la multiplication entre deux polynmes de degrs strictement infrieurs
n. En plus des trois appels rcursifs, il y a des oprations linaires : deux calculs de degrs, deux
dcoupes en n/2 puis des additions : deux de taille n/2, une de taille n, une de taille 3n/2 et une de
taille 2n. On obtient donc la relation de rcurrence suivante :
C(n) = 3 C(n/2) + n
C(2` )
o = 15
2 . Une mthode de rsolution est de poser ` = 3` qui vrifie ` = `1 +
tire, puisque 0 = C(1) = 1,

`+1
` k
X
2
2
+1
` =
+ 0 = 3 1
3
3
k=1

2 `
3 .
Do on
puis pour n = 2` :
ln 3
ln 3
C(n) = C(2` ) = 3` ` = (3`+1 2`+1 ) + (1 )3` = O(3` ) = O(2` ln 2 ) = O(n ln 2 )

ln 3
La complexit de la multiplication de Karatsuba est donc O(n ln 2 ) ' O(n1.585 ).
6.4. Optimiser ses algorithmes

Voici quelques petites astuces pour acclrer lcriture ou la vitesse des algorithmes :
k ** 3 au lieu de k * k * k (cela conomise de la mmoire, une seule variable au lieu de 3) ;
k ** 2 <= n au lieu de k <= sqrt(n) (les calculs avec les entiers sont beaucoup plus rapides quavec
les rels) ;
x += 1 au lieu de x = x +1 (gain de mmoire) ;
a,b = a+b, a-b au lieu de newa = a+b ; newb = a-b ; a = newa ; b = newb (gain de mmoire, code plus court).
Cependant il ne faut pas que cela nuise la lisibilit du code : il est important que quelquun puisse relire et
modifier votre code. Le plus souvent cest vous mme qui modifierez les algorithmes qui vous avez crits et
vous serez ravi dy trouver des commentaires clairs et prcis !
Mini-exercices. 1. Faire une fonction qui renvoie le pgcd de deux polynmes.
un polynme P en une valeur
2. Comparer les complexits des deux mthodes suivantes pour valuer

n1
n
x 0 R : P(x 0 ) = a0 +a1 x 0 + +an1 x 0 +an x 0 et P(x 0 ) = a0 +x 0 a1 +x 0 a2 + +x 0 (an1 +an x 0 )
(mthode de Horner).
3. Comment trouver le maximum dune liste ? Montrer que votre mthode est de complexit minimale
(en terme du nombre de comparaisons).
4. Soit f : [a, b] R une fonction continue vrifiant f (a) f (b) 6 0. Combien ditrations de la mthode
de dichotomie sont ncessaires pour obtenir une racine de f (x) = 0 avec une prcision infrieure ?

n
5. Programmer plusieurs faons de calculer les coefficients du binme de Newton k et les comparer.
6. Trouver une mthode de calcul de 2n qui utilise peu de multiplications. On commencera par crire n
en base 2.
Auteurs du chapitre Rdaction : Arnaud Bodin

Relecture : Jean-Franois Barraud
Remerciements Lionel Rieg pour son tp sur lalgorithme de Karatsuba
Chapitre
Zros des fonctions

Vido partie 1. La dichotomie
Vido partie 2. La mthode de la scante
Vido partie 3. La mthode de Newton
Dans ce chapitre nous allons appliquer toutes les notions prcdentes sur les suites et les fonctions, la
recherche des zros des fonctions. Plus prcisment, nous allons voir trois mthodes afin de trouver des
approximations des solutions dune quation du type ( f (x) = 0).
1. La dichotomie
1.1. Principe de la dichotomie
Le principe de dichotomie repose sur la version suivante du thorme des valeurs intermdiaires :
Thorme 1.
Soit f : [a, b] R une fonction continue sur un segment.
Si f (a) f (b) 6 0, alors il existe ` [a, b] tel que f (`) = 0.
La condition f (a) f (b) 6 0 signifie que f (a) et f (b) sont de signes opposs (ou que lun des deux est nul).
Lhypothse de continuit est essentielle !
y
f (b) > 0
f (a) > 0
a
b
x
f (a) < 0
f (b) < 0
Ce thorme affirme quil existe au moins une solution de lquation ( f (x) = 0) dans lintervalle [a, b].
Pour le rendre effectif, et trouver une solution (approche) de lquation ( f (x) = 0), il sagit maintenant
de lappliquer sur un intervalle suffisamment petit. On va voir que cela permet dobtenir un ` solution de
lquation ( f (x) = 0) comme la limite dune suite.
ZROS DES FONCTIONS
1. LA DICHOTOMIE
30
Voici comment construire une suite dintervalles embots, dont la longueur tend vers 0, et contenant chacun
une solution de lquation ( f (x) = 0).
On part dune fonction f : [a, b] R continue, avec a < b, et f (a) f (b) 6 0.
Voici la premire tape de la construction : on regarde le signe de la valeur de la fonction f applique au
point milieu a+b
2 .
a+b
a+b
Si f (a) f ( 2 ) 6 0, alors il existe c [a, 2 ] tel que f (c) = 0.
a+b
a+b
a+b
Si f (a) f ( 2 ) > 0, cela implique que f ( 2 ) f (b) 6 0, et alors il existe c [ 2 , b] tel que f (c) = 0.
y
y
a
f ( a+b
2 )>0
f ( a+b
2 )<0
a
a+b
2
a+b
2
b
Nous avons obtenu un intervalle de longueur moiti dans lequel lquation ( f (x) = 0) admet une solution.
On itre alors le procd pour diviser de nouveau lintervalle en deux.
Voici le processus complet :
Au rang 0 :
On pose a0 = a, b0 = b. Il existe une solution x 0 de lquation ( f (x) = 0) dans lintervalle [a0 , b0 ].
Au rang 1 :
a +b
a +b
Si f (a0 ) f ( 0 2 0 ) 6 0, alors on pose a1 = a0 et b1 = 0 2 0 ,
a0 +b0
sinon on pose a1 = 2 et b1 = b.
Dans les deux cas, il existe une solution x 1 de lquation ( f (x) = 0) dans lintervalle [a1 , b1 ].
...
ba
Au rang n : supposons construit un intervalle [an , bn ], de longueur 2n , et contenant une solution x n
de lquation ( f (x) = 0). Alors :
a +b
a +b
Si f (an ) f ( n 2 n ) 6 0, alors on pose an+1 = an et bn+1 = n 2 n ,
a +b
sinon on pose an+1 = n 2 n et bn+1 = bn .
Dans les deux cas, il existe une solution x n+1 de lquation ( f (x) = 0) dans lintervalle [an+1 , bn+1 ].
chaque tape on a
an 6 x n 6 bn .
ba
2n
On arrte le processus ds que bn an =

est infrieur la prcision souhaite.
Comme (an ) est par construction une suite croissante, (bn ) une suite dcroissante, et (bn an ) 0 lorsque
n +, les suites (an ) et (bn ) sont adjacentes et donc elles admettent une mme limite. Daprs le
thorme des gendarmes, cest aussi la limite disons ` de la suite (x n ). La continuit de f montre que
f (`) = limn+ f (x n ) = limn+ 0 = 0. Donc les suites (an ) et (bn ) tendent toutes les deux vers `, qui est
une solution de lquation ( f (x) = 0).
1.2. Rsultats numriques pour
p
10
p
Nous allons calculer une approximation de 10. Soit la fonction f dfinie par f (x) = x 2 10, cest une
p
p
fonction continue sur R qui sannule en 10. De plus 10 est lunique solution positive de lquation
p
( f (x) = 0). Nous pouvons restreindre la fonction f lintervalle [3, 4] : en effet 32 = 9 6 10 donc 3 6 10
p
et 42 = 16 > 10 donc 4 > 10. En dautre termes f (3) 6 0 et f (4) > 0, donc lquation ( f (x) = 0) admet
ZROS DES FONCTIONS
1. LA DICHOTOMIE
31
p
une solution dans lintervalle [3, 4] daprs le thorme des valeurs intermdiaires, et par unicit cest 10,
p
donc 10 [3, 4].
p
p
Notez que lon ne choisit pas pour f la fonction x 7 x 10 car on ne connat pas la valeur de 10. Cest
ce que lon cherche calculer !
3
3.5
3.25
3.125
Voici les toutes premires tapes :

a +b
a +b
1. On pose a0 = 3 et b0 = 4, on a bien f (a0 ) 6 0 et f (b0 ) > 0. On calcule 0 2 0 = 3, 5 puis f ( 0 2 0 ) :

p
f (3, 5) = 3, 52 10 = 2, 25 > 0. Donc 10 est dans lintervalle [3; 3, 5] et on pose a1 = a0 = 3 et
a +b
b1 = 0 2 0 = 3, 5.
2. On sait donc que f (a1 ) 6 0 et f (b1 ) > 0. On calcule f (
et b2 = 3, 25.
a1 +b1
2 )
= f (3, 25) = 0, 5625 > 0, on pose a2 = 3
a +b
3. On calcule f ( 2 2 2 ) = f (3, 125) = 0, 23 . . . 6 0. Comme f (b2 ) > 0 alors cette fois f sannule sur le
a +b
a +b
second intervalle [ 2 2 2 , b2 ] et on pose a3 = 2 2 2 = 3, 125 et b3 = b2 = 3, 25.
ce stade, on a prouv : 3, 125 6
p
10 6 3, 25.
Voici la suite des tapes :

a0 = 3
a1 = 3
a2 = 3
a3 = 3, 125
a4 = 3, 125
a5 = 3, 15625
a6 = 3, 15625
a7 = 3, 15625
a8 = 3, 16015 . . .
b0 = 4
b1 = 3, 5
b2 = 3, 25
b3 = 3, 25
b4 = 3, 1875
b5 = 3, 1875
b6 = 3, 171875
b7 = 3, 164062 . . .
b8 = 3, 164062 . . .
Donc en 8 tapes on obtient lencadrement :

3, 160 6
p
10 6 3, 165
En particulier, on vient dobtenir les deux premires dcimales :
p
10 = 3, 16 . . .
1.3. Rsultats numriques pour (1, 10)1/12

Nous cherchons maintenant une approximation de (1, 10)1/12 . Soit f (x) = x 12 1, 10. On pose a0 = 1 et
b0 = 1, 1. Alors f (a0 ) = 0, 10 6 0 et f (b0 ) = 2, 038 . . . > 0.
ZROS DES FONCTIONS
1. LA DICHOTOMIE
a0 = 1
a1 = 1
a2 = 1
a3 = 1
a4 = 1, 00625
a5 = 1, 00625
a6 = 1, 00781 . . .
a7 = 1, 00781 . . .
a8 = 1, 00781 . . .
32
b0 = 1, 10
b1 = 1, 05
b2 = 1, 025
b3 = 1, 0125
b4 = 1, 0125
b5 = 1, 00937 . . .
b6 = 1, 00937 . . .
b7 = 1, 00859 . . .
b8 = 1, 00820 . . .
Donc en 8 tapes on obtient lencadrement :

1, 00781 6 (1, 10)1/12 6 1, 00821
1.4. Calcul de lerreur

La mthode de dichotomie a lnorme avantage de fournir un encadrement dune solution ` de lquation
( f (x) = 0). Il est donc facile davoir une majoration de lerreur. En effet, chaque tape, la taille lintervalle
contenant ` est divise par 2. Au dpart, on sait que ` [a, b] (de longueur b a) ; puis ` [a1 , b1 ] (de
ba
ba
longueur ba
2 ) ; puis ` [a2 , b2 ] (de longueur 4 ) ; ... ; [an , bn ] tant de longueur 2n .
Si, par exemple, on souhaite obtenir une approximation de ` 10N prs, comme on sait que an 6 ` 6 bn , on
N
N
obtient |` an | 6 |bn an | = ba
, il suffit de choisir n tel que ba
.
2n . Donc pour avoir |` an | 6 10
2n 6 10
Nous allons utiliser le logarithme dcimal :
ba
6 10N (b a)10N 6 2n
2n
log(b a) + log(10N ) 6 log(2n )
log(b a) + N 6 n log 2
n >
N + log(b a)
log 2
Sachant log 2 = 0, 301 . . ., si par exemple b a 6 1, voici le nombre ditrations suffisantes pour avoir une
prcision de 10N (ce qui correspond, peu prs, N chiffres exacts aprs la virgule).
1010 ( 10 dcimales)
10100 ( 100 dcimales)
101000 ( 1000 dcimales)
34 itrations
333 itrations
3322 itrations
Il faut entre 3 et 4 itrations supplmentaires pour obtenir une nouvelle dcimale.

Remarque.
En toute rigueur il ne faut pas confondre prcision et nombre de dcimales exactes, par exemple 0, 999 est
une approximation de 1, 000 103 prs, mais aucune dcimale aprs la virgule nest exacte. En pratique,
cest la prcision qui est la plus importante, mais il est plus frappant de parler du nombre de dcimales
exactes.
1.5. Algorithmes
Voici comment implmenter la dichotomie dans le langage Python. Tout dabord on dfinit une fonction f
(ici par exemple f (x) = x 2 10) :
ZROS DES FONCTIONS
1. LA DICHOTOMIE
33
Code 37 (dichotomie.py (1)).
def f(x):
return x*x - 10
Puis la dichotomie proprement dite : en entre de la fonction, on a pour variables a, b et n le nombre
dtapes voulues.
def dicho(a,b,n):
for i in range(n):
c = (a+b)/2
if f(a)*f(c) <= 0:
b = c
else:
a = c
return a,b
Mme algorithme, mais avec cette fois en entre la prcision souhaite :
def dichobis(a,b,prec):
while b-a>prec:
c = (a+b)/2
if f(a)*f(c) <= 0:
b = c
else:
a = c
return a,b
Enfin, voici la version rcursive de lalgorithme de dichotomie.
def dichotomie(a,b,prec):
if b-a<=prec:
return a,b
else:
c = (a+b)/2
if f(a)*f(c) <= 0:
return dichotomie(a,c,prec)
else:
return dichotomie(c,b,prec)
Mini-exercices. 1. la main, calculer un encadrement 0, 1 prs de
p
p
3
3. Idem avec 2.
2. Calculer une approximation des solutions de lquation x 3 + 1 = 3x.

3. Est-il plus efficace de diviser lintervalle en 4 au lieu den 2 ? ( chaque itration, la dichotomie
classique ncessite lvaluation de f en une nouvelle valeur a+b
2 pour une prcision amliore dun
facteur 2.)
4. crire un algorithme pour calculer plusieurs solutions de ( f (x) = 0).
ZROS DES FONCTIONS
2. LA MTHODE DE LA SCANTE
34
5. On se donne un tableau tri de taille N , rempli de nombres appartenant {1, . . . , n}. crire un
algorithme qui teste si une valeur k apparat dans le tableau et en quelle position.
2. La mthode de la scante
2.1. Principe de la scante
Lide de la mthode de la scante est trs simple : pour une fonction f continue sur un intervalle [a, b], et
vrifiant f (a) 6 0, f (b) > 0, on trace le segment [AB] o A = (a, f (a)) et B = (b, f (b)). Si le segment reste
au-dessus du graphe de f alors la fonction sannule sur lintervalle [a0 , b] o (a0 , 0) est le point dintersection
de la droite (AB) avec laxe des abscisses. La droite (AB) sappelle la scante. On recommence en partant
maintenant de lintervalle [a0 , b] pour obtenir une valeur a00 .
y
B
a0 a00
b
x
A00
Proposition 1.
Soit f : [a, b] R une fonction continue, strictement croissante et convexe telle que f (a) 6 0, f (b) > 0.
Alors la suite dfinie par
b an
a0 = a
et
an+1 = an
f (an )
f (b) f (an )
est croissante et converge vers la solution ` de ( f (x) = 0).
Lhypothse f convexe signifie exactement que pour tout x, x 0 dans [a, b] la scante (ou corde) entre
(x, f (x)) et (x 0 , f (x 0 )) est au-dessus du graphe de f .
y
(x 0 , f (x 0 ))
x0
(x, f (x))
Dmonstration. 1. Justifions dabord la construction de la suite rcurrente.

Lquation de la droite passant par les deux points (a, f (a)) et (b, f (b)) est
f (b) f (a)
y = (x a)
+ f (a)
ba
ZROS DES FONCTIONS
Cette droite intersecte laxe des abscisses en (a0 , 0) qui vrifie donc 0 = (a0 a)
ba
a0 = a f (b)
f (a) f (a).
f (b) f (a)
ba
35
+ f (a), donc
2. Croissance de (an ).
Montrons par rcurrence que f (an ) 6 0. Cest vrai au rang 0 car f (a0 ) = f (a) 6 0 par hypothse.
Supposons vraie lhypothse au rang n. Si an+1 < an (un cas qui savrera a posteriori jamais ralis),
alors comme f est strictement croissante, on a f (an+1 ) < f (an ), et en particulier f (an+1 ) 6 0. Sinon
an+1 > an . Comme f est convexe : la scante entre (an , f (an )) et (b, f (b)) est au-dessus du graphe de
f . En particulier le point (an+1 , 0) (qui est sur cette scante par dfinition an+1 ) est au-dessus du point
(an+1 , f (an+1 )), et donc f (an+1 ) 6 0 aussi dans ce cas, ce qui conclut la rcurrence.
Comme f (an ) 6 0 et f est croissante, alors par la formule an+1 = an
an+1 > an .
ban
f (b) f (an )
f (an ), on obtient que
3. Convergence de (an ).
La suite (an ) est croissante et majore par b, donc elle converge. Notons ` sa limite. Par continuit f (an )
f (`). Comme pour tout n, f (an ) 6 0, on en dduit que f (`) 6 0. En particulier, comme on suppose
ba
f (b) > 0, on a ` < b. Comme an `, an+1 `, f (an ) f (`), lgalit an+1 = an f (b) f n(a ) f (an )
devient la limite (lorsque n +) : ` = `
b`
f (b) f (`)
f (`), ce qui implique f (`) = 0.
Conclusion : (an ) converge vers la solution de ( f (x) = 0).
2.2. Rsultats numriques pour
p
10
Pour a = 3, b = 4, f (x) = x 2 10 voici les rsultats numriques, est aussi indique une majoration de
p
lerreur n = 10 an (voir ci-aprs).
a0 = 3
a1 = 3, 14285714285 . . .
a2 = 3, 16000000000 . . .
a3 = 3, 16201117318 . . .
a4 = 3, 16224648985 . . .
a5 = 3, 16227401437 . . .
a6 = 3, 16227723374 . . .
a7 = 3, 16227761029 . . .
a8 = 3, 16227765433 . . .
0 6 0, 1666 . . .
1 6 0, 02040 . . .
2 6 0, 00239 . . .
3 6 0, 00028 . . .
4 6 3, 28 . . . 105
5 6 3, 84 . . . 106
6 6 4, 49 . . . 107
7 6 5, 25 . . . 108
8 6 6, 14 . . . 109

Voici les rsultats numriques avec une majoration de lerreur n = (1, 10)1/12 an , avec f (x) = x 12 1, 10,
a = 1 et b = 1, 1
a0 = 1
0 6 0, 0083 . . .
a1 = 1, 00467633 . . . 1 6 0, 0035 . . .
a2 = 1, 00661950 . . . 2 6 0, 0014 . . .
a3 = 1, 00741927 . . . 3 6 0, 00060 . . .
a4 = 1, 00774712 . . . 4 6 0, 00024 . . .
a5 = 1, 00788130 . . . 5 6 0, 00010 . . .
a6 = 1, 00793618 . . . 6 6 4, 14 . . . 105
a7 = 1, 00795862 . . . 7 6 1, 69 . . . 105
a8 = 1, 00796779 . . . 8 6 6, 92 . . . 106
ZROS DES FONCTIONS
36
2.4. Calcul de lerreur

La mthode de la scante fournit lencadrement an 6 l 6 b. Mais comme b est fixe cela ne donne pas
dinformation exploitable pour |l an |. Voici une faon gnrale destimer lerreur, laide du thorme des
accroissements finis.
Proposition 2.
Soit f : I R une fonction drivable et ` tel que f (`) = 0. Sil existe une constante m > 0 telle que pour
tout x I, | f 0 (x)| > m alors
| f (x)|
pour tout x I.
|x `| 6
m
Dmonstration. Par lingalit des accroissement finis entre x et ` : | f (x) f (`)| > m|x `| mais f (`) = 0,
do la majoration.
p
Exemple 1 (Erreur pour 10).
Soit f (x) = x 2 10 et lintervalle I = [3, 4]. Alors f 0 (x) = 2x donc | f 0 (x)| > 6 sur I. On pose donc m = 6,
p
` = 10, x = an . On obtient lestimation de lerreur :
2
| f (an )| |an 10|
n = |` an | 6
=
m
6
p
|3,172 10|
Par exemple on a trouv a2 = 3, 16... 6 3, 17 donc 10 a2 6
= 0, 489.
6
p
|a82 10|
Pour a8 on a trouv a8 = 3, 1622776543347473 . . . donc 10 a8 6 6 = 6, 14 . . . 109 . On a en fait 7
dcimales exactes aprs la virgule.
Dans la pratique, voici le nombre ditrations suffisantes pour avoir une prcision de 10n pour cet exemple.
Grosso-modo, une itration de plus donne une dcimale supplmentaire.
1010 ( 10 dcimales)
10100 ( 100 dcimales)
101000 ( 1000 dcimales)
10 itrations
107 itrations
1073 itrations
Exemple 2 (Erreur pour (1, 10)1/12 ).

On pose f (x) = x 12 1, 10, I = [1; 1, 10] et ` = (1, 10)1/12 . Comme f 0 (x) = 12x 11 , si on pose de plus
m = 12, on a | f 0 (x)| > m pour x I. On obtient
n = |` an | 6
|an12 1, 10|
12
Par exemple a8 = 1.0079677973185432 . . . donc

|(1, 10)1/12 a8 | 6
|a812 1, 10|
12
= 6, 92 . . . 106 .
2.5. Algorithme
Voici lalgorithme : cest tout simplement la mise en uvre de la suite rcurrente (an ).
Code 41 (secante.py).
def secante(a,b,n):
for i in range(n):
a = a-f(a)*(b-a)/(f(b)-f(a))
return a
ZROS DES FONCTIONS
3. LA MTHODE DE NEWTON
Mini-exercices. 1. la main, calculer un encadrement 0, 1 prs de
37
p
p
3
3. Idem avec 2.

3. Calculer une approximation de la solution de lquation (cos x = 0) sur [0, ]. Idem avec (cos x =
2 sin x).
4. tudier lquation (exp(x) = ln(x)). Donner une approximation de la (ou des) solution(s) et une
majoration de lerreur correspondante.
3. La mthode de Newton
3.1. Mthode de Newton
La mthode de Newton consiste remplacer la scante de la mthode prcdente par la tangente. Elle est
dune redoutable efficacit.
Partons dune fonction drivable f : [a, b] R et dun point u0 [a, b]. On appelle (u1 , 0) lintersection
de la tangente au graphe de f en (u0 , f (u0 )) avec laxe des abscisses. Si u1 [a, b] alors on recommence
lopration avec la tangente au point dabscisse u1 . Ce processus conduit la dfinition dune suite rcurrente :
u0 [a, b]
et
un+1 = un
f (un )
.
f 0 (un )
Dmonstration. En effet la tangente au point dabscisse un a pour quation : y = f 0 (un )(x un ) + f (un ).
Donc le point (x, 0) appartenant la tangente (et laxe des abscisses) vrifie 0 = f 0 (un )(x un ) + f (un ).
f (u )
Do x = un f 0 (un ) .
n
f (un )
un
un+1
3.2. Rsultats pour

Pour calculer
p
10
a, on pose f (x) = x 2 a, avec f 0 (x) = 2x. La suite issue de la mthode de Newton est
dtermine par u0 > 0 et la relation de rcurrence un+1 = un

suite de Hron et que lon rcrit souvent
u2n a
2un .
Suite qui pour cet exemple sappelle
ZROS DES FONCTIONS
u0 > 0
38
1
a
.
un+1 =
un +
2
un
et
Proposition 3.
p
Cette suite (un ) converge vers a.
Pour le calcul de
p
10, on pose par exemple u0 = 4, et on peut mme commencer les calculs la main :
u0 = 4
u1 =
1
2
u2 =
1
2
1
2
u3 =
u0 +
10
u0
1
2
u1 +
10
u1
1
2
10
u2
216 401
68 432
u2 +
4+

13
4
10
4
= 13
= 3, 25
4
10
13
4
329
104
= 3, 1634 . . .
= 3, 16227788 . . .
u4 = 3, 162277660168387 . . .
p
Pour u4 on obtient 10 = 3, 1622776601683 . . . avec dj 13 dcimales exactes !
p
Voici la preuve de la convergence de la suite (un ) vers a.
Dmonstration.
u0 > 0
1. Montrons que un >
et
1
a
un +
un+1 =
.
2
un
a pour n > 1.
Tout dabord
u2n+1
1
a=
4
u2n + a
2
un
a=
2
2
1 (un a)
1
2
2
4
+
a
)
=
2au
(u
n
4u2n n
4
u2n
u2n+1
p
Donc
un+1 >
a > 0. Comme il est clair que pour tout n > 0, un > 0, on en dduit que pour tout n > 0,
a. (Notez que u0 lui est quelconque.)
2. Montrons que (un )n>1 est une suite dcroissante qui converge.
u
1
a
Comme un+1
=
1
+
, et que pour n > 1 on vient de voir que u2n > a (donc
2
2
un
n
pour tout n 6 1.
a
u2n
6 1), alors
un+1
un
6 1,
Consquence : la suite (un )n>1 est dcroissante et minore par 0 donc elle converge.
p
3. (un ) converge vers a.
Notons
` la limite de (un ). Alors un ` et un+1 `. Lorsque n + dans la relation un+1 =

1
a
1
a
2
,
on
obtient
`
=
`
+
u
+
n
2
2
` . Ce qui conduit la relation ` = a et par positivit de la suite,
p un
` = a.

Pour calculer (1, 10)1/12 , on pose f (x) = x 12 a avec a = 1, 10. On a f 0 (x) = 12x 11 . On obtient un+1 =
un
u12
n a
.
12u11
n
Ce que lon reformule ainsi :

u0 > 0
et

1
a
un+1 =
11un + 11 .
12
un
Voici les rsultats numriques pour (1, 10)1/12 en partant de u0 = 1.

u0 = 1
u1 = 1, 0083333333333333 . . .
u2 = 1, 0079748433368980 . . .
u3 = 1, 0079741404315996 . . .
u4 = 1, 0079741404289038 . . .
ZROS DES FONCTIONS
39
Toutes les dcimales affiches pour u4 sont exactes : (1, 10)1/12 = 1, 0079741404289038 . . .
3.4. Calcul de lerreur pour
p
10
Proposition 4. 1. Soit k tel que u1
a 6 k. Alors pour tout n > 1 :
n1
p
p
k 2
un a 6 2 a p
2 a
2. Pour a = 10, u0 = 4, on a :
p
un 10 6 8
1
24
2n1
Admirez la puissance de la mthode de Newton : 11 itrations donnent dj 1000 dcimales exactes aprs
la virgule. Cette rapidit de convergence se justifie grce au calcul de lerreur : la prcision est multiplie
par 2 chaque tape, donc chaque itration le nombre de dcimales exactes double !
1010 ( 10 dcimales)
10100 ( 100 dcimales)
101000 ( 1000 dcimales)
4 itrations
8 itrations
11 itrations
Dmonstration. 1. Dans la preuve de la proposition 3, nous avons vu lgalit :

p
p
(u2n a)2
p
p
(un a)2 (un + a)2
2
un+1 a =
donc (un+1 a)(un+1 + a) =
4u2n
4u2n
p
Ainsi comme un > a pour n > 1 :
p 2
p
p
p
p
1
1
a
1
1
1
6 (un a)2 p (1+1)2 = p (un a)2
un+1 a = (un a)2
1+
p
un
un+1 + a 4
2 a 4
2 a
p
Si k vrifie u1 a 6 k, nous allons en dduire par rcurrence, pour tout n > 1, la formule
n1
p
p
k 2
un a 6 2 a p
2 a
Cest vrai pour n = 1. Supposons la formule vraie au rang n, alors :
n1 2
n
p
p 2
p 2
p
1
1
k 2
k 2
un+1 a 6 p (un a) = p (2 a)
=2 a p
p
2 a
2 a
2 a
2 a
La formule est donc vrai au rang suivant.
p
p
2. Pour a = 10 avec u0 = 4 on a u1 = 3, 25. Comme 3 6 10 6 4 alors u1 10 6 u1 3 6 41 . On fixe
p
donc k = 14 . Toujours par lencadrement 3 6 10 6 4, la formule obtenue prcdemment devient
1 2n1
2n1
p
1
4
un a 6 2 4
=8
.
23
24
3.5. Algorithme
Voici lalgorithme pour le calcul de
le nombre n ditrations.
a. On prcise en entre le rel a > 0 dont on veut calculer la racine et
Code 42 (newton.py).
def racine_carree(a,n):
u=4
# N'importe qu'elle valeur > 0
for i in range(n):
ZROS DES FONCTIONS
40
u = 0.5*(u+a/u)
return u
En utilisant le module decimal le calcul de un pour n = 11 donne 1000 dcimales de
3,
16227766016837933199889354443271853371955513932521
87347284152840055148548856030453880014690519596700
53169295770904715764610443692578790620378086099418
31433612894979189026652954361267617878135006138818
78403231241795402218308045872844614600253577579702
26516760310484366977937569261557205003698949094694
40390727401978654372593964172600130699000095578446
86395193793704654765220632063686587197822049312426
85792513629646865114976752171234595592380393756251
99979613234340302185705218783667634578951073298287
p
10 :
68268575048527925944386392382213442481083793002951
15390334492165717925994065915015347411333948412408
28371711548406328552999118596824564203326961604691
62785804636831349524780311437693346719738195131856
82864402902440797789603454398916334922265261206779
21850007358348844643882731109289109042348054235653
31096267906944183361301813028945417033158077316263
05345411160935697982813245229700079888352375958532
25369855194955325099947038843990336466165470647234
51579452157716521396263244383990184845609357626020
Mini-exercices. 1. la calculette, calculer les trois premires tapes pour une approximation de
p
3
sous forme de nombres rationnels. Idem avec 2.
2. Implmenter la mthode de Newton, tant donnes une fonction f et sa drive f 0 .
4. Soit a > 0. Comment calculer 1a par une mthode de Newton ?
p
5. Calculer n de sorte que un 10 6 10` (avec u0 = 4, un+1 = 21 un +
a
un
Auteurs du chapitre Auteurs : Arnaud Bodin, Niels Borne, Laura Desideri

Dessins : Benjamin Boutin
, a = 10).
p
3,
Chapitre
Cryptographie
Vido
Vido
Vido
Vido
Vido
Vido
partie 1. Le chiffrement de Csar

partie 2. Le chiffrement de Vigenre
partie 3. La machine Enigma et les cls secrtes
partie 4. La cryptographie cl publique
partie 5. L'arithmtique pour RSA
partie 6. Le chiffrement RSA
1. Le chiffrement de Csar
1.1. Csar a dit...
Jules Csar a-t-il vraiment prononc la clbre phrase :
DOHD MDFWD HVW
ou bien comme le disent deux clbres Gaulois : Ils sont fous ces romains ! .
En fait Csar, pour ses communications importantes son arme, cryptait ses messages. Ce que lon appelle
le chiffrement de Csar est un dcalage des lettres : pour crypter un message, A devient D, B devient E, C
devient F ,...
A 7 D
B 7 E
C 7 F
...
W 7 Z
X 7 A Y 7 B
Z 7 C
Voici une figure avec lalphabet dorigine en haut et en rouge, en correspondance avec lalphabet pour le
chiffrement en-dessous et en vert.
Nous adopterons la convention suivante, en vert cest la partie du message laquelle tout le monde a accs
(ou qui pourrait tre intercept), cest donc le message crypt. Alors quen rouge cest la partie du message
confidentiel, cest le message en clair.
Pour prendre en compte aussi les dernires lettres de lalphabet, il est plus judicieux de reprsent lalphabet
sur un anneau. Ce dcalage est un dcalage circulaire sur les lettres de lalphabet.
CRYPTOGRAPHIE
1. LE CHIFFREMENT DE CSAR
42
Pour dchiffrer le message de Csar, il suffit de dcaler les lettres dans lautre sens, D se dchiffre en A, E en
B,...
Et la clbre phrase de Csar est :
ALEA JACTA EST
qui traduite du latin donne Les ds sont jets .
1.2. Des chiffres et des lettres

Il est plus facile de manipuler des nombres que des lettres, aussi nous passons une formulation mathmatique. Nous associons chacune des 26 lettres de A Z un nombre de 0 25. En termes mathmatiques,
nous dfinissons une bijection :

f : A, B, C, . . . , Z 0, 1, 2, . . . , 25
par
A 7 0
B 7 1
C 7 2
...
Z 7 25
Ainsi "A L E A" devient "0 11 4 0".

Le chiffrement de Csar est un cas particulier de chiffrement mono-alphabtique, cest--dire un chiffrement
lettre lettre.
Quel est lintrt ? Nous allons voir que le chiffrement de Csar correspond une opration mathmatique
trs simple. Pour cela, rappelons la notion de congruence et lensemble Z/26Z.
1.3. Modulo
Soit n > 2 un entier fix.
Dfinition 1.
On dit que a est congru b modulo n, si n divise b a. On note alors
a b (mod n).
Pour nous n = 26. Ce qui fait que 28 2 (mod 26), car 28 2 est bien divisible par 26. De mme
85 = 3 26 + 7 donc 85 7 (mod 26).
On note Z/26Z lensemble de tous les lments de Z modulo 26. Cet ensemble peut par exemple tre
reprsent par les 26 lments {0, 1, 2, . . . , 25}. En effet, puisquon compte modulo 26 :
0, 1, 2, . . . , 25,
puis
26 0, 27 1, 28 2, . . . ,
52 0, 53 1, . . .
et de mme 1 25, 2 24,...

Plus gnralement Z/nZ contient n lments. Pour un entier a Z quelconque, son reprsentant dans
{0, 1, 2, . . . , n 1} sobtient comme le reste k de la division euclidienne de a par n : a = bn + k. De sorte
que a k (mod n) et 0 6 k < n.
CRYPTOGRAPHIE
43
De faon naturelle laddition et la multiplication dentiers se transposent dans Z/nZ.

Pour a, b Z/nZ, on associe a + b Z/nZ.
Par exemple dans Z/26Z, 15 + 13 gale 2. En effet 15 + 13 = 28 2 (mod 26). Autre exemple : que vaut
133 + 64 ? 133 + 64 = 197 = 7 26 + 15 15 (mod 26). Mais on pourrait procder diffremment : tout
dabord 133 = 5 26 + 3 3 (mod 26) et 64 = 2 26 + 12 12 (mod 26). Et maintenant sans calculs :
133 + 64 3 + 12 15 (mod 26).
On fait de mme pour la multiplication : pour a, b Z/nZ, on associe a b Z/nZ.
Par exemple 3 12 donne 10 modulo 26, car 3 12 = 36 = 1 26 + 10 10 (mod 26). De mme :
3 27 = 81 = 3 26 + 3 3 (mod 26). Une autre faon de voir la mme opration est dcrire dabord
27 = 1 (mod 26) puis 3 27 3 1 3 (mod 26).
1.4. Chiffrer et dchiffrer

Le chiffrement de Csar est simplement une addition dans Z/26Z ! Fixons un entier k qui est le dcalage
(par exemple k = 3 dans lexemple de Csar ci-dessus) et dfinissons la fonction de chiffrement de Csar
de dcalage k qui va de lensemble Z/26Z dans lui-mme :

Ck :
Z/26Z Z/26Z
x 7 x+k
Par exemple, pour k = 3 : C3 (0) = 3, C3 (1) = 4. . .

Pour dchiffrer, rien de plus simple ! Il suffit daller dans lautre sens, cest--dire ici de soustraire. La fonction
de dchiffrement de Csar de dcalage k est

Dk :
Z/26Z Z/26Z
x 7 xk
En effet, si 1 a t chiffr en 4, par la fonction C3 alors D3 (4) = 4 3 = 1. On retrouve le nombre original.

Mathmatiquement, Dk est la bijection rciproque de Ck , ce qui implique que pour tout x Z/26Z :

Dk Ck (x) = x
En dautres termes, si x est un nombre, on applique la fonction de chiffrement pour obtenir le nombre
crypt y = Ck (x) ; ensuite la fonction de dchiffrement fait bien ce que lon attend delle Dk ( y) = x, on
retrouve le nombre original x.
Ck
Z/26Z
Z/26Z
Dk
Une autre faon de voir la fonction de dchiffrement est de remarquer que Dk (x) = Ck (x). Par exemple
C3 (x) = x + (3) x + 23 (mod 26).
Voici le principe du chiffrement : Alice veut envoyer des messages secrets Bruno. Ils se sont dabord mis
daccord sur une cl secrte k, par exemple k = 11. Alice veut envoyer le message "COUCOU" Bruno. Elle
transforme "COUCOU" en "2 14 20 2 14 20". Elle applique la fonction de chiffrement C11 (x) = x + 11
chacun des nombres : "13 25 5 13 25 5" ce qui correspond au mot crypt "NZFNZF". Elle transmet le mot
crypt Bruno, qui selon le mme principe applique la fonction de dchiffrement D11 (x) = x 11.
CRYPTOGRAPHIE
ALICE
BRUNO
COUCOU
NZFNZF
COUCOU
NZFNZF
Ck
2 14 20 2 14 20
44
Dk
13 25 5 13 25 5
13 25 5 13 25 5
2 14 20 2 14 20
Exemple 1.
Un exemple classique est le "rot13" (pour rotation par un dcalage de 13) :
C13 (x) = x + 13
et comme 13 13 (mod 26) alors D13 (x) = x + 13. La fonction de dchiffrement est la mme que la
fonction de chiffrement !
Exemple : dchiffrez le mot "PRFNE".
Notons ici deux points importants pour la suite : tout dabord nous avons naturellement considr un mot
comme une succession de lettres, et chaque opration de chiffrement et dchiffrement seffectue sur un bloc
dune seule lettre. Ensuite nous avons vu que chiffrer un message est une opration mathmatique (certes
sur un ensemble un peu spcial).
1.5. Espace des cls et attaque

Combien existe-t-il de possibilits de chiffrement par la mthode de Csar ? Il y a 26 fonctions Ck diffrentes,
k = 0, 1, . . . , 25. Encore une fois, k appartient Z/26Z, car par exemple les fonctions C29 et C3 sont
identiques. Le dcalage k sappelle la cl de chiffrement, cest linformation ncessaire pour crypter le
message. Il y a donc 26 cls diffrentes et lespace des cls est Z/26Z.
Il est clair que ce chiffrement de Csar est dune scurit trs faible. Si Alice envoie un message secret Bruno
et que Chlo intercepte ce message, il sera facile pour Chlo de le dcrypter mme si elle ne connat pas la
cl secrte k. Lattaque la plus simple pour Chlo est de tester ce que donne chacune des 26 combinaisons
possibles et de reconnatre parmi ces combinaisons laquelle donne un message comprhensible.
1.6. Algorithmes
Les ordinateurs ont rvolutionn la cryptographie et surtout le dcryptage dun message intercept. Nous
montrons ici, laide du langage Python comment programmer et attaquer le chiffrement de Csar. Tout
dabord la fonction de chiffrement se programme en une seule ligne :
Code 43 (cesar.py (1)).
def cesar_chiffre_nb(x,k):
return (x+k)%26
Ici x est un nombre de {0, 1, . . . , 25} et k est le dcalage. (x+k)%26 renvoie le reste modulo 26 de la somme
(x+k). Pour le dcryptage, cest aussi simple :
def cesar_dechiffre_nb(x,k):
return (x-k)%26
CRYPTOGRAPHIE
2. LE CHIFFREMENT DE VIGENRE
45
Pour chiffrer un mot ou un phrase, il ny a pas de problmes thoriques, mais seulement des difficults
techniques :
Un mot ou une phrase est une chane de caractres, qui en fait se comporte comme une liste. Si
mot est une chane alors mot[0] est la premire lettre, mot[1] la deuxime lettre... et la boucle
for lettre in mot: permet de parcourir chacune des lettres.
Pour transformer une lettre en un nombre, on utilise le code Ascii qui chaque caractre associe un
nombre, ord(A) vaut 65, ord(B) vaut 66... Ainsi (ord(lettre) - 65) renvoie le rang de la lettre
entre 0 et 25 comme nous lavons fix ds le dpart.
La transformation inverse se fait par la fonction chr : chr(65) renvoie le caractre A, chr(66) renvoie
B...
Pour ajouter une lettre une liste, faites maliste.append(lettre). Enfin pour transformer une liste
de caractres en une chane, faites "".join(maliste).
Ce qui donne :
def cesar_chiffre_mot(mot,k):
message_code = []
for lettre in mot:
nb = ord(lettre)-65
nb_crypte = cesar_chiffre_nb(nb,k)
lettre_crypte = chr(nb_crypte+65)
message_code.append(lettre_crypte)
message_code = "".join(message_code)
return(message_code)
#
#
#
#
#
#
#
Liste vide
Pour chaque lettre
Lettre devient nb de 0 25
Chiffrement de Csar
Retour aux lettres
Ajoute lettre au message
Revient chaine caractres
Pour lattaque on parcourt lintgralit de lespace des cls : k varie de 0 25. Noter que pour dcrypter les
messages on utilise ici simplement la fonction de Csar avec la cl k.
def cesar_attaque(mot):
for k in range(26):
print(cesar_chiffre_mot(mot,-k))
return None
2. Le chiffrement de Vigenre
2.1. Chiffrement mono-alphabtique
Principe
Nous avons vu que le chiffrement de Csar prsente une scurit trs faible, la principale raison est que
lespace des cls est trop petit : il y a seulement 26 cls possibles, et on peut attaquer un message chiffr en
testant toutes les cls la main.
Au lieu de faire correspondre circulairement les lettres, on associe maintenant chaque lettre une autre
lettre (sans ordre fixe ou rgle gnrale).
Par exemple :
A
F
B
Q
C
B
D
M
E
X
F
I
G
T
H
E
I
P
J
A
K
L
L
W
M
H
N
S
O
D
P
O
Q
Z
R
K
S
V
T
G
U
R
V
C
W
N
X
Y
Y
J
Z
U
CRYPTOGRAPHIE
46
Pour crypter le message

ETRE OU NE PAS ETRE TELLE EST LA QUESTION
on regarde la correspondance et on remplace la lettre E par la lettre X, puis la lettre T par la lettre G, puis
la lettre R par la lettre K...
Le message crypt est alors :
XGKX DR SX OFV XGKX GXWWX XVG WF ZRXVGPDS
Pour le dcrypter, en connaissant les substitutions, on fait lopration inverse.
Avantage : nous allons voir que lespace des cls est gigantesque et quil nest plus question dnumrer
toutes les possibilits.
Inconvnients : la cl retenir est beaucoup plus longue, puisquil faut partager la cl constitue des 26
lettres "FQBMX...". Mais surtout, nous allons voir que finalement ce protocole de chiffrement est assez
simple craquer .
Espace des cls

Mathmatiquement, le choix dune cl revient au choix dune bijection de lensemble A, B, . . . , Z vers le

mme ensemble A, B, . . . , Z . Il y a 26! choix possibles. En effet pour la lettre A de lensemble de dpart, il
y a 26 choix possibles (nous avions choisi F), pour B il reste 25 choix possibles (tout sauf F qui est dj
choisi), pour C il reste 24 choix... enfin pour Z il ne reste quune seule possibilit, la seule lettre non encore
choisie. Au final il y a : 26 25 24 2 1 soit 26! choix de cls. Ce qui fait environ 4 1026 cls. Il y
a plus de cls diffrentes que de grains de sable sur Terre ! Si un ordinateur pouvait tester 1 000 000 de cls
par seconde, il lui faudrait alors 12 millions dannes pour tout numrer.
Attaque statistique
La principale faiblesse du chiffrement mono-alphabtique est quune mme lettre est toujours chiffre de la
mme faon. Par exemple, ici E devient X. Dans les textes longs, les lettres napparaissent pas avec la mme
frquence. Ces frquences varient suivant la langue utilise. En franais, les lettres les plus rencontres sont
dans lordre :
ESAINTRULODCPMVQGFHBXJYZKW
avec les frquences (souvent proches et dpendant de lchantillon utilis) :
E
14.69%
S
8.01%
A
7.54%
I
7.18%
N
6.89%
T
6.88%
R
6.49%
U
6.12%
L
5.63%
O
5.29%
D
3.66%
Voici la mthode dattaque : dans le texte crypt, on cherche la lettre qui apparat le plus, et si le texte est
assez long cela devrait tre le chiffrement du E, la lettre qui apparat ensuite dans ltude des frquences
devrait tre le chiffrement du S, puis le chiffrement du A... On obtient des morceaux de texte clair sous la
forme dune texte trous et il faut ensuite deviner les lettres manquantes.
Par exemple, dchiffrons la phrase :
LHLZ HFQ BC HFFPZ WH YOUPFH MUPZH
On compte les apparitions des lettres :
H:6 F:4 P:3 Z:3
On suppose donc que le H crypte la lettre E, le F la lettre S, ce qui donne
*E** ES* ** ESS** *E ***SE ****E
Daprs les statistiques P et Z devraient se dcrypter en A et I (ou I et A). Le quatrime mot "HFFPZ",
pour linstant dcrypt en "ESS**", se complte donc en "ESSAI" ou "ESSIA". La premire solution semble
correcte ! Ainsi P crypte A, et Z crypte I. La phrase est maintenant :
*E*I ES* ** ESSAI *E ***ASE **AIE
CRYPTOGRAPHIE
47
En rflchissant un petit peu, on dcrypte le message :

CECI EST UN ESSAI DE PHRASE VRAIE
2.2. Le chiffrement de Vigenre

Blocs
Lespace des cls du chiffrement mono-alphabtique est immense, mais le fait quune lettre soit toujours
crypte de la mme faon reprsente une trop grande faiblesse. Le chiffrement de Vigenre remdie ce
problme. On regroupe les lettres de notre texte par blocs, par exemple ici par blocs de longueur 4 :
CETTE PHRASE NE VEUT RIEN DIRE
devient
CETT EPHR ASEN EVEU TRIE NDIR E
(les espaces sont purement indicatifs, dans la premire phrase ils sparent les mots, dans la seconde ils
sparent les blocs).
Si k est la longueur dun bloc, alors on choisit une cl constitue de k nombres de 0 25 : (n1 , n2 , . . . , nk ).
Le chiffrement consiste effectuer un chiffrement de Csar, dont le dcalage dpend du rang de la lettre
dans le bloc :
un dcalage de n1 pour la premire lettre de chaque bloc,
un dcalage de n2 pour la deuxime lettre de chaque bloc,
...
un dcalage de nk pour la k-me et dernire lettre de chaque bloc.
Pour notre exemple, si on choisit comme cl (3, 1, 5, 2) alors pour le premier bloc "CETT" :
un dcalage de 3 pour C donne F,
un dcalage de 1 pour E donne F,
un dcalage de 5 pour le premier T donne Y,
un dcalage de 2 pour le deuxime T donne V.
Ainsi "CETT" de vient "FFYV". Vous remarquez que les deux lettres T ne sont pas cryptes par la mme lettre
et que les deux F ne cryptent pas la mme lettre. On continue ensuite avec le deuxime bloc...
Mathmatiques
Llment de base nest plus une lettre mais un bloc, cest--dire un regroupement de lettres. La fonction de
chiffrement associe un bloc de longueur k, un autre bloc de longueur k, ce qui donne en mathmatisant
les choses :

Z/26Z Z/26Z Z/26Z Z/26Z Z/26Z Z/26Z
Cn1 ,n2 ,...,nk :
(x 1 , x 2 , . . . , x k ) 7 (x 1 + n1 , x 2 + n2 , . . . , x k + nk )
Chacune des composantes de cette fonction est un chiffrement de Csar. La fonction de dchiffrement est
juste Cn1 ,n2 ,...,nk .
Espace des cls et attaque
Il y a 26k choix possibles de cls, lorsque les blocs sont de longueur k. Pour des blocs de longueur k = 4 cela
en donne dj 456 976, et mme si un ordinateur teste toutes les combinaisons possibles sans problme,
il nest pas question de parcourir cette liste pour trouver le message en clair, cest--dire celui qui est
comprhensible !
Il persiste tout de mme une faiblesse du mme ordre que celle rencontre dans le chiffrement monoalphabtique : la lettre A nest pas toujours crypte par la mme lettre, mais si deux lettres A sont situes
CRYPTOGRAPHIE
3. LA MACHINE ENIGMA ET LES CLS SECRTES
48
la mme position dans deux blocs diffrents (comme par exemple "ALPH ABET") alors elles seront cryptes
par la mme lettre.
Une attaque possible est donc la suivante : on dcoupe notre message en plusieurs listes, les premires
lettres de chaque bloc, les deuximes lettres de chaque bloc... et on fait une attaque statistique sur chacun
de ces regroupements. Ce type dattaque nest possible que si la taille des blocs est petite devant la longueur
du texte.
2.3. Algorithmes
Voici un petit algorithme qui calcule la frquence de chaque lettre dune phrase.
Code 47 (statistiques.py).
def statistiques(phrase):
liste_stat = [0 for x in range(26)]
# Une liste avec des 0
for lettre in phrase:
# On parcourt la phrase
i = ord(lettre)-65
if 0 <= i < 26:
# Si c'est une vraie lettre
liste_stat[i] = liste_stat[i] + 1
return(liste_stat)
Et voici le chiffrement de Vigenre.
Code 48 (vigenere.py).
def vigenere(mot,cle):
message_code = []
k = len(cle)
i = 0
for lettre in mot:
nomb = ord(lettre)-65
nomb_code = (nomb+cle[i]) % 26
lettre_code = chr(nomb_code+65)
i=(i+1) % k
message_code.append(lettre_code)
message_code = "".join(message_code)
return(message_code)
# Cl est du type [n_1,...,n_k]

#
#
#
#
#
#
#
#
#
Longueur de la cl
Rang dans le bloc
Pour chaque lettre
Lettre devient nb de 0 25
Vigenre : on ajoute n_i
On repasse aux lettres
On passe au rang suivant
Ajoute lettre au message
Revient chaine caractres
3. La machine Enigma et les cls secrtes

3.1. Un secret parfait
Linconvnient des chiffrements prcdents est quune mme lettre est rgulirement chiffre de la mme
faon, car la correspondance dun alphabet un ou plusieurs autres est fixe une fois pour toutes, ce qui
fait quune attaque statistique est toujours possible. Nous allons voir quen changeant la correspondance
chaque lettre, il est possible de crer un chiffrement parfait !
Expliquons dabord le principe laide dune analogie : jai choisi deux entiers m et c tels que m + c = 100.
Que vaut m ? Cest bien sr impossible de rpondre car il y a plusieurs possibilits : 0 + 100, 1 + 99, 2 + 98,...
Par contre, si je vous donne aussi c alors vous trouvez m immdiatement m = 100 c.
CRYPTOGRAPHIE
49
Voici le principe du chiffrement : Alice veut envoyer Bruno le message secret M suivant :
ATTAQUE LE CHATEAU
Alice a dabord choisi une cl secrte C quelle a transmise Bruno. Cette cl secrte est de la mme longueur
que le message (les espaces ne comptent pas) et compose dentiers de 0 25, tirs au hasard. Par exemple
C:
[4, 18, 2, 0, 21, 12, 18, 13, 7, 11, 23, 22, 19, 2, 16, 9]
Elle crypte la premire lettre par un dcalage de Csar donn par le premier entier : A est dcal de 4 lettres
et devient donc E. La seconde lettre est dcale du second entier : le premier T devient L. Le second T est
lui dcal de 2 lettres, il devient V. Le A suivant est dcal de 0 lettre, il reste A... Alice obtient un message
chiffr X quelle transmet Bruno :
ELVALGW YL NEWMGQD
Pour le dcrypter, Bruno, qui connat la cl, na qu faire le dcalage dans lautre sens.
Notez que deux lettres identiques (par exemples les T) nont aucune raison dtre cryptes de la mme
faon. Par exemple, les T du message initial sont crypts dans lordre par un L, un V et un M.
Formalisons un peu cette opration. On identifie A avec 0, B avec 1, ..., Z avec 25. Alors le message crypt
X est juste la "somme" du message M avec la cl secrte C, la somme seffectuant lettre lettre, terme
terme, modulo 26.
Notons cette opration M C = X .
A
0
T
19
T
19
A
0
Q
16
U
20
E
4
L
11
E
4
C
2
H
7
A
0
T
19
E
4
A
0
U
20
18
21
12
18
13
11
23
22
19
16
4
E
11
L
21
V
0
A
11
L
6
G
22
W
24
Y
11
L
13
N
4
E
22
W
12
M
6
G
16
Q
3
D
Bruno reoit X et connat C, il effectue donc X C = M .

Pourquoi ce systme est-il inviolable ? Pour chacune des lettres, cest exactement le mme problme que
trouver m, sachant que m + c = x (o x = 100), mais sans connatre c. Toutes les possibilits pour m
pourraient tre juste. Et bien sr, ds que lon connat c, la solution est triviale : m = x c.
Il y a trois principes respecter pour que ce systme reste inviolable :
1. La longueur de la cl est gale la longueur du message.
2. La cl est choisie au hasard.
3. La cl ne sert quune seule fois.
Ce systme appel "masque jetable" ou chiffrement de Vernam est parfait en thorie, mais sa mise en uvre
nest pas pratique du tout ! Tout dabord il faut que la cl soit aussi longue que le message. Pour un message
court cela ne pose pas de problme, mais pour envoyer une image par exemple cela devient trs lourd.
Ensuite, il faut trouver un moyen sr denvoyer la cl secrte son interlocuteur avant de lui faire parvenir
le message. Et il faut recommencer cette opration chaque message, ou bien se mettre daccord ds le
dpart sur un carnet de cls : une longue liste de cls secrtes.
Pour justifier que ce systme est vraiment inviolable voici une exprience amusante : Alice veut envoyer
le message M ="ATTAQUE LE CHATEAU" Bruno, elle choisit la cl secrte C=[4, 18, 2, 0,...] comme
ci-dessus et obtient le message chiffr X ="ELVA..." quelle transmet Bruno.
Alice se fait kidnapper par Chlo, qui veut lobliger dchiffrer son message. Heureusement, Alice a anticip
les soucis : elle a dtruit le message M , la cl secrte C et a cr un faux message M 0 et une fausse cl
secrte C 0 . Alice fournit cette fausse cl secrte C 0 Chlo, qui dchiffre le message par lopration X C 0
CRYPTOGRAPHIE
50
et elle trouve le message bien inoffensif M 0 :

RECETTE DE CUISINE
Alice est innocente !
Comment est-ce possible ? Alice avait au pralable prpar un message neutre M 0 de mme longueur que
M et calcul la fausse cl secrte C 0 = X M 0 . Chlo a obtenu (par la contrainte) X et C 0 , elle dchiffre le
message ainsi
X C 0 = X (X M 0 ) = (X X ) M 0 = M 0
Chlo trouve donc le faux message.
Ici la fausse cl C 0 est :
[13, 7, 19, 22, 18, 13, 18, 21, 7, 11, 10, 14, 20, 24, 3, 25]
La premire lettre du message chiffr est un E, en reculant de 13 lettres dans lalphabet, elle se dchiffre en
R...
3.2. La machine Enigma

Afin de sapprocher de ce protocole de chiffrement parfait, il faut trouver un moyen de gnrer facilement
de longues cls, comme si elles avaient t gnres au hasard. Nous allons tudier deux exemples utiliss
en pratique la fin du sicle dernier, une mthode lectro-mcanique : la machine Enigma et une mthode
numrique : le D E S .
La machine Enigma est une machine lectro-mcanique qui ressemble une machine crire. Lorsque
quune touche est enfonce, des disques internes sont actionns et le caractre crypt sallume. Cette machine,
qui sert aussi au dchiffrement, tait utilise pour les communications de larme allemande durant la
seconde guerre mondiale. Ce que les Allemands ne savaient pas, cest que les services secrets polonais
et britanniques avaient russi percer les secrets de cette machine et taient capables de dchiffrer les
messages transmis par les allemands. Ce long travail dtudes et de recherches a ncessit tout le gnie
dAlan Turing et linvention de lanctre de lordinateur.
Nous symbolisons llment de base de la machine Enigma par deux anneaux :

Un anneau extrieur contenant lalphabet "ABCDE..." symbolisant le clavier de saisie des messages. Cet
anneau est fixe.
CRYPTOGRAPHIE
51
Un anneau intrieur contenant un alphabet dans le dsordre (sur la figure "GWQRU..."). Cet anneau est
mobile et effectue une rotation chaque touche tape au clavier. Il reprsente la cl secrte.
Voici, dans ce cas, le processus de chiffrement du mot "BAC", avec la cl de chiffrement "G" :
1. Position initiale. Loprateur tourne lanneau intrieur de sorte que le A extrieur et fixe soit en face du
G intrieur (et donc B en face de W).
2. Premire lettre. Loprateur tape la premire lettre du message : B, la machine affiche la correspondance
W.
3. Rotation. Lanneau intrieur tourne de 1/26me de tour, maintenant le A extrieur et fixe est en face
du W, le B en face du Q,...
4. Deuxime lettre. Loprateur tape la deuxime lettre du message A, la machine affiche la correspondance,
cest de nouveau W.
5. Rotation. Lanneau intrieur tourne de 1/26me de tour, maintenant le A extrieur et fixe est en face
du Q, le B en face du R, le C en face du U,...
6. Troisime lettre. Loprateur tape la troisime lettre du message C, la machine affiche la correspondance
U.
7. Rotation. Lanneau intrieur effectue sa rotation.
8. Message chiffr. Le message crypt est donc "WWU"
Cette mthode de chiffrement est identique un chiffrement de type Vigenre pour une cl de longueur 26.
Il y a 26 cls diffrents disposition avec un seul anneau intrieur et identifies par lettre de la position
initiale : G, W, Q... T correspondant aux alphabets : "GWQ...PT", "WQR...TG", "QRU...GW"...
CRYPTOGRAPHIE
52
En fait, la machine Enigma tait beaucoup plus sophistique, il ny avait pas un mais plusieurs anneaux
intrieurs. Par exemple pour deux anneaux intrieurs comme sur la figure : B senvoie sur W, qui senvoie
sur A ; la lettre B est crypte en A. Ensuite lanneau intrieur numro 1 effectue 1/26me de tour. La lettre
A senvoie sur W, qui senvoie sur A ; la lettre A est crypte en A. Lorsque lanneau intrieur numro 1 a fait
une rotation complte (26 lettres ont t tapes) alors lanneau intrieur numro 2 effectue 1/26me de
tour. Cest comme sur un compteur kilomtrique, lorsque le chiffre des kilomtres parcourt 0, 1, 2, 3, ..., 9,
alors au kilomtre suivant, le chiffre des kilomtres est 0 et celui des dizaines de kilomtres est augment
dune unit.
Sil y a trois anneaux, lorsque lanneau intrieur 2 a fait une rotation complte, lanneau intrieur 3 tourne
de 1/26me de tour. Il y a alors 263 cls diffrentes facilement identifiables par les trois lettres des positions
initiales des anneaux.
Il fallait donc pour utiliser cette machine, dabord choisir les disques (nos anneaux intrieurs) les placer
dans un certain ordre, fixer la position initiale de chaque disque. Ce systme tait rendu largement plus
complexe avec lajout de correspondances par fichage entre les lettres du clavier (voir photo). Le nombre de
cls possibles dpassait plusieurs milliards de milliards !
3.3. La ronde des chiffres : DES

La machine Enigma gnre mcaniquement un alphabet diffrent chaque caractre crypt, tentant de se
rapprocher dun chiffrement parfait. Nous allons voir une autre mthode, cette fois numrique : le DES. Le
DES (Data Encryption Standard) est un protocole de chiffrement par blocs. Il a t, entre 1977 et 2001, le
standard de chiffrement pour les organisations du gouvernement des tats-Unis et par extension pour un
grand nombre de pays dans le monde.
Commenons par rappeler que lobjectif est de gnrer une cl alatoire de grande longueur. Pour ne pas
avoir retenir lintgralit de cette longue cl, on va la gnrer de faon pseudo-alatoire partir dune
petite cl.
Voyons un exemple lmentaire de suite pseudo-alatoire.
Soit (un ) la suite dfinie par la donne de (a, b) et de u0 et la relation de rcurrence
un+1 a un + b (mod 26).
CRYPTOGRAPHIE
53
Par exemple pour a = 2, b = 5 et u0 = 6, alors les premiers termes de la suites sont :

6
17
13
15
23
25
11
19
17
13
Les trois nombres (a, b, u0 ) reprsentent la cl principale et la suite des (un )nN les cls secondaires.
Avantages : partir dune cl principale on a gnr une longue liste de cls secondaires. Inconvnients : la
liste nest pas si alatoire que cela, elle se rpte ici avec une priode de longueur 12 : 17, 13, 5, ..., 17, 13, 5, ...
Le systme DES est une version sophistique de ce processus : partir dune cl courte et doprations
lmentaires on crypte un message. Comme lors de ltude de la machine Enigma, nous allons prsenter
une version trs simplifie de ce protocole afin den expliquer les tapes lmentaires.
Pour changer, nous allons travailler modulo 10. Lorsque lon travaille par blocs, les additions se font bit par
bit. Par exemple : [1 2 3 4] [7 8 9 0] = [8 0 2 4] car (1 + 7 8 (mod 10), 2 + 8 0 (mod 10),...)
Notre message est coup en blocs, pour nos explications ce seront des blocs de longueur 8. La cl est de
longueur 4.
Voici le message (un seul bloc) : M = [1 2 3 4 5 6 7 8] et voici la cl : C = [3 1 3 2].
tape 0. Initialisation. On note M0 = M et on dcoupe M en une partie gauche et une partie droite
M0 = [G0 k D0 ] = [1 2 3 4 k 5 6 7 8]
tape 1. Premier tour. On pose
M1 = [D0 k C (G0 )]
o est une permutation circulaire.
On effectue donc trois oprations pour passer de M0 M1 :
1. On change la partie droite et la partie gauche de M0 :
M0 7 [5 6 7 8 k 1 2 3 4]
2. Sur la nouvelle partie droite, on permute circulairement les nombres :
7 [5 6 7 8 k 2 3 4 1]
3. Puis on ajoute la cl secrte C droite (ici C = [3 1 3 2]) :
7 [5 6 7 8 k 5 4 7 3] = M1
On va recommencer le mme processus. Cela revient appliquer la formule de rcurrence, qui partant de
Mi = [Gi k Di ], dfinit
Mi+1 = [Di k C (Gi )]
tape 2. Deuxime tour. On part de M1 = [5 6 7 8 k 5 4 7 3].
1. On change la partie droite et la partie gauche de M0 :
M0 7 [5 4 7 3 k 5 6 7 8]
2. Sur la nouvelle partie droite, on permute circulairement les nombres.
7 [5 4 7 3 k 6 7 8 5]
3. Puis on ajoute la cl secrte C droite.
7 [5 4 7 3 k 9 8 1 7] = M2
On peut dcider de sarrter aprs ce tour et renvoyer le message crypt X = M2 = [5 4 7 3 9 8 1 7].
Comme chaque opration lmentaire est inversible, on applique un protocole inverse pour dchiffrer.
Dans le vrai protocole du DES, la cl principale est de taille 64 bits, il y a plus de manipulations sur le
message et les tapes mentionnes ci-dessus sont effectues 16 fois (on parle de tours). chaque tour,
une cl diffrente est utilise. Il existe donc un prambule ce protocole : gnrer 16 cls secondaires (de
CRYPTOGRAPHIE
4. LA CRYPTOGRAPHIE CL PUBLIQUE
54
longueur 48 bits) partir de la cl principale, ce qui se fait selon le principe de la suite pseudo-alatoire
(un ) explique plus haut.
4. La cryptographie cl publique
Les Grecs pour envoyer des messages secrets rasaient la tte du messager, tatouaient le message sur son
crne et attendaient que les cheveux repoussent avant denvoyer le messager effectuer sa mission !
Il est clair que ce principe repose uniquement sur le secret de la mthode.
4.1. Le principe de Kerckhoffs

Cette mthode rudimentaire va lencontre du principe de Kerckhoffs. Le principe de Kerckhoffs snonce
ainsi :
La scurit dun systme de chiffrement ne doit reposer que sur la cl.
Cela se rsume aussi par :
Lennemi peut avoir connaissance du systme de chiffrement.
Voici le texte original dAuguste Kerckhoffs de 1883 La cryptographie militaire paru dans le Journal des
sciences militaires.
Il traite notamment des enjeux de scurit lors des correspondances :
Il faut distinguer entre un systme dcriture chiffr, imagin pour un change momentan
de lettres entre quelques personnes isoles, et une mthode de cryptographie destine rgler
pour un temps illimit la correspondance des diffrents chefs darme entre eux.
Le principe fondamental est le suivant :
Dans le second cas, [. . . ] il faut que le systme nexige pas le secret, et quil puisse sans
inconvnient tomber entre les mains de lennemi.
Ce principe est novateur dans la mesure o intuitivement il semble opportun de dissimuler le maximum
de choses possibles : cl et systme de chiffrement utiliss. Mais lobjectif vis par Kerckhoffs est plus
acadmique, il pense quun systme dpendant dun secret mais dont le mcanisme est connu de tous sera
test, attaqu, tudi, et finalement utilis sil savre intressant et robuste.
4.2. Factorisations des entiers

Quels outils mathmatiques rpondent au principe de Kerckoffs ?
Un premier exemple est la toute simple multiplication ! En effet si je vous demande combien font 5 7,
vous rpondez 35. Si je vous demande de factoriser 35 vous rpondez 5 7. Cependant ces deux questions
ne sont pas du mme ordre de difficult. Si je vous demande de factoriser 1591, vous aller devoir faire
plusieurs tentatives, alors que si je vous avais directement demand de calculer 37 43 cela ne pose pas de
problme.
Pour des entiers de plusieurs centaines de chiffres le problme de factorisation ne peut tre rsolu en
un temps raisonnable, mme pour un ordinateur. Cest ce problme asymtrique qui est la base de la
cryptographie RSA (que nous dtaillerons plus tard) : connatre p et q apporte plus dinformation utilisable
que p q. Mme si en thorie partir de p q on peut retrouver p et q, en pratique ce sera impossible.
Formalisons ceci avec la notion de complexit. La complexit est le temps de calculs (ou le nombre
doprations lmentaires) ncessaire pour effectuer une opration.
Commenons par la complexit de laddition : disons que calculer la somme de deux chiffres (par exemple
6 + 8) soit de complexit 1 (par exemple 1 seconde pour un humain, 1 milliseconde pour un ordinateur).
CRYPTOGRAPHIE
55
Pour calculer la somme de deux entiers n chiffres, la complexit est dordre n (exemple : 1234 + 2323, il
faut faire 4 additions de chiffres, donc environ 4 secondes pour un humain).
La multiplication de deux entiers n chiffres est de complexit dordre n2 . Par exemple pour multiplier
1234 par 2323 il faut faire 16 multiplications de chiffres (chaque chiffre de 1234 est multiplier par chaque
chiffre de 2323).
1
Par contre la meilleure mthode de factorisation connue est de complexit dordre exp(4n 3 ) (cest moins
que exp(n), mais plus que nd pour tout d, lorsque n tend vers +).
Voici un tableau pour avoir une ide de la difficult croissante pour multiplier et factoriser des nombres n
chiffres :
n
multiplication
factorisation
3
4
5
10
50
100
200
9
16
25
100
2 500
10 000
40 000
320
572
934
5 528
2 510 835
115 681 968
14 423 748 780
4.3. Fonctions sens unique

Il existe bien dautres situations mathmatiques asymtriques : les fonctions sens unique. En dautres
termes, tant donne une fonction f , il est possible connaissant x de calculer facilement f (x) ; mais
connaissant un lment de lensemble image de f , il est difficile ou impossible de trouver son antcdent.
Dans le cadre de la cryptographie, possder une fonction sens unique qui joue le rle de chiffrement na
que peu de sens. En effet, il est indispensable de trouver un moyen efficace afin de pouvoir dchiffrer les
messages chiffrs. On parle alors de fonction sens unique avec trappe secrte.
Prenons par exemple le cas de la fonction f suivante :
f : x 7 x 3 (mod 100).
Connaissant x, trouver y = f (x) est facile, cela ncessite deux multiplications et deux divisions.
Connaissant y image par f dun lment x ( y = f (x)), retrouver x est difficile.
Tentons de rsoudre le problme suivant : trouver x tel que x 3 11 (mod 100).
On peut pour cela :
soit faire une recherche exhaustive, cest--dire essayer successivement 1, 2, 3, ..., 99, on trouve alors :
713 = 357 911 11 (mod 100),
soit utiliser la trappe secrte : y 7 y 7 (mod 100) qui fournit directement le rsultat !
117 = 19 487 171 71 (mod 100).
La morale est la suivante : le problme est dur rsoudre, sauf pour ceux qui connaissent la trappe secrte.
(Attention, dans le cas de cet exemple, la fonction f nest pas bijective.)
4.4. Chiffrement cl prive

Petit retour en arrire. Les protocoles tudis dans les chapitres prcdents taient des chiffrements cl
prive. De faon image, tout se passe comme si Bruno pouvaient dposer son message dans un coffre fort
pour Alice, Alice et Bruno tant les seuls possder la cl du coffre.
CRYPTOGRAPHIE
56
BRUNO
ALICE
En effet, jusquici, les deux interlocuteurs se partageaient une mme cl qui servait chiffrer (et dchiffrer)
les messages. Cela pose bien sr un problme majeur : Alice et Bruno doivent dabord se communiquer la
cl.
BRUNO
ALICE
Cl C
Message M
Message M
Message crypt X
Chiffrement C
Dchiffrement D
4.5. Chiffrement cl publique

Les fonctions sens unique trappe donnent naissance des protocoles de chiffrement cl publique.
Lassociation cl et publique peut paratre incongrue, mais il signifie que le principe de chiffrement est
accessible tous mais que le dchiffrement ncessite une cl quil faut bien sr garder secrte.
BRUNO
ALICE
De faon image, si Bruno veut envoyer un message Alice, il dpose son message dans la bote aux lettres
dAlice, seule Alice pourra ouvrir sa bote et consulter le message. Ici la cl publique est symbolise par la
bote aux lettre, tout le monde peut y dposer un message, la cl qui ouvre la bote aux lettres est la cl
prive dAlice, que Alice doit conserver labri.
BRUNO
ALICE
Cl publique
Message M
Cl prive
Message M
Message crypt X
Chiffrement C
Dchiffrement D
5. LARITHMTIQUE POUR RSA 57
CRYPTOGRAPHIE
En prenant appui sur lexemple prcdent, si le message initial est 71 et que la fonction f de chiffrement est
connue de tous, le message transmis est 11 et le dchiffrement sera rapide si la trappe secrte 7 est connue
du destinataire.
Les paramtres dun protocole de chiffrement cl publique sont donc :
les fonctions de chiffrement et de dchiffrement : C et D,
la cl publique du destinataire qui va permettre de paramtrer la fonction C ,
la cl prive du destinataire qui va permettre de paramtrer la fonction D.
Dans le cadre de notre exemple Bruno souhaite envoyer un message Alice, ces lments sont :
C : x 7 x ? (mod 100) et D : x 7 x ? (mod 100),
3 : la cl publique dAlice qui permet de dfinir compltement la fonction de chiffrement :
C : x 7 x 3 (mod 100),
7 : la cl prive dAlice qui permet de dfinir compltement la fonction de dchiffrement :
D : x 7 x 7 (mod 100).
Dans la pratique, un chiffrement cl publique ncessite plus de calculs et est donc assez lent, plus lent
quun chiffrement cl prive. Afin de gagner en rapidit, un protocole hybride peut tre mis en place de la
faon suivante :
laide dun protocole de chiffrement cl publique, Alice et Bruno changent une cl,
Alice et Bruno utilise cette cl dans un protocole de chiffrement cl prive.
5. Larithmtique pour RSA

Pour un entier n, sachant quil est le produit de deux nombres premiers, il est difficile de retrouver les
facteurs p et q tels que n = pq. Le principe du chiffrement RSA, chiffrement cl publique, repose sur cette
difficult.
Dans cette partie nous mettons en place les outils mathmatiques ncessaires pour le calcul des cls publique
et prive ainsi que les procds de chiffrement et dchiffrement RSA.
5.1. Le petit thorme de Fermat amlior

Nous connaissons le petit thorme de Fermat
Thorme 1 (Petit thorme de Fermat).
Si p est un nombre premier et a Z alors
a p a (mod p)
et sa variante :
Corollaire 1.
Si p ne divise pas a alors
a p1 1 (mod p)
Nous allons voir une version amliore de ce thorme dans le cas qui nous intresse :
Thorme 2 (Petit thorme de Fermat amlior).
Soient p et q deux nombres premiers distincts et soit n = pq. Pour tout a Z tel que pgcd(a, n) = 1 alors :
a(p1)(q1) 1 (mod n)
CRYPTOGRAPHIE
On note (n) = (p 1)(q 1), la fonction dEuler. Lhypothse pgcd(a, n) = 1 quivaut ici ce que a ne
soit divisible ni par p, ni par q. Par exemple pour p = 5, q = 7, n = 35 et (n) = 4 6 = 24. Alors pour
a = 1, 2, 3, 4, 6, 8, 9, 11, 12, 13, 16, 17, 18, ... on a bien a24 1 (mod 35).
Dmonstration. Notons c = a(p1)(q1) . Calculons c modulo p :
c a(p1)(q1) (a(p1) )q1 1q1 1 (mod p)
o lon appliquer le petit thorme de Fermat : a p1 1 (mod p), car p ne divise pas a.
Calculons ce mme c mais cette fois modulo q :
c a(p1)(q1) (a(q1) ) p1 1 p1 1 (mod q)
o lon appliquer le petit thorme de Fermat : aq1 1 (mod q), car q ne divise pas a.
Conclusion partielle : c 1 (mod p) et c 1 (mod q).
Nous allons en dduire que c 1 (mod pq).
Comme c 1 (mod p) alors il existe Z tel que c = 1 + p ; comme c 1 (mod q) alors il existe Z
tel que c = 1 + q. Donc c 1 = p = q. De lgalit p = q, on tire que p|q.
Comme p et q sont premiers entre eux (car ce sont des nombres premiers distincts) alors par le lemme de
Gauss on en dduit que p|. Il existe donc 0 Z tel que = 0 p.
Ainsi c = 1 + q = 1 + 0 pq. Ce qui fait que c 1 (mod pq), cest exactement dire a(p1)(q1) 1
(mod n).
5.2. Lalgorithme dEuclide tendu

Nous avons dj tudi lalgorithme dEuclide qui repose sur le principe que pgcd(a, b) = pgcd(b, a (mod b)).
Voici sa mise en uvre informatique.
Code 49 (euclide.py (1)).
def euclide(a,b):
while b !=0 :
a , b = b , a % b
return a
On profite que Python assure les affectations simultanes, ce qui pour nous correspond aux suites

ai+1 = bi
bi+1 ai (mod bi )
initialise par a0 = a, b0 = b.
Nous avons vu aussi comment remonter lalgorithme dEuclide la main pour obtenir les coefficients
de Bzout u, v tels que au + bv = pgcd(a, b). Cependant il nous faut une mthode plus automatique pour
obtenir ces coefficients, cest lalgorithme dEuclide tendu.
On dfinit deux suites (x i ), ( yi ) qui vont aboutir aux coefficients de Bzout.
Linitialisation est :
x0 = 1
x1 = 0
y0 = 0
y1 = 1
et la formule de rcurrence pour i > 1 :

x i+1 = x i1 qi x i
yi+1 = yi1 qi yi
o qi est le quotient de la division euclidienne de ai par bi .

def euclide_etendu(a,b):
x = 1 ; xx = 0
CRYPTOGRAPHIE
y = 0 ; yy = 1
while b != 0 :
q = a // b
a , b = b , a % b
xx , x = x - q*xx , xx
yy , y = y - q*yy , yy
return (a,x,y)
Cet algorithme renvoie dabord le pgcd, puis les coefficients u, v tels que au + bv = pgcd(a, b).
5.3. Inverse modulo n

Soit a Z, on dit que x Z est un inverse de a modulo n si a x 1 (mod n).
Trouver un inverse de a modulo n est donc un cas particulier de lquation a x b (mod n).
Proposition 1. a admet un inverse modulo n si et seulement si a et n sont premiers entre eux.
Si au + nv = 1 alors u est un inverse de a modulo n.
En dautres termes, trouver un inverse de a modulo n revient calculer les coefficients de Bzout associs
la paire (a, n).
Dmonstration. La preuve est essentiellement une reformulation du thorme de Bzout :
pgcd(a, n) = 1
u, v Z
u Z
au + nv = 1
au 1 (mod n)
Voici le code :
def inverse(a,n):
c,u,v = euclide_etendu(a,n)
# pgcd et coeff. de Bzout
if c != 1 :
# Si pgcd diffrent de 1 renvoie 0
return 0
else :
return u % n
# Renvoie l'inverse
5.4. Lexponentiation rapide

Nous aurons besoin de calculer rapidement des puissances modulo n. Pour cela il existe une mthode
beaucoup plus efficace que de calculer dabord a k puis de le rduire modulo n. Il faut garder lesprit que
les entiers que lon va manipuler ont des dizaines voir des centaines de chiffres.
Voyons la technique sur lexemple de 511 (mod 14). Lide est de seulement calculer 5, 52 , 54 , 58 ... et de
rduire modulo n chaque fois. Pour cela on remarque que 11 = 8 + 2 + 1 donc
511 = 58 52 51 .
i
Calculons donc les 52 (mod 14) :

5 5 (mod 14)
52 25 11 (mod 14)
54 52 52 11 11 121 9 (mod 14)
58 54 54 9 9 81 11 (mod 14)
CRYPTOGRAPHIE
chaque tape est effectue une multiplication modulaire. Consquence :

511 58 52 51 11 11 5 11 55 11 13 143 3 (mod 14).
Nous obtenons donc un calcul de 511 (mod 14) en 5 oprations au lieu de 10 si on avait fait 5 5 5 .
Voici une formulation gnrale de la mthode. On crit le dveloppement de lexposant k en base 2 :
(k` , . . . , k2 , k1 , k0 ) avec ki {0, 1} de sorte que
k=
`
X
ki 2i .
i=0
On obtient alors
xk = x
P`
i=0
ki 2i
`
Y
i
(x 2 )ki .
i=0
Par exemple 11 en base 2 scrit (1, 0, 1, 1), donc, comme on la vu :

3
511 = (52 )1 (52 )0 (52 )1 (52 )1 .

Voici un autre exemple : calculons 17154 (mod 100). Tout dabord on dcompose lexposant k = 154 en
base 2 : 154 = 128 + 16 + 8 + 2 = 27 + 24 + 23 + 21 , il scrit donc en base 2 : (1, 0, 0, 1, 1, 0, 1, 0).
Ensuite on calcule 17, 172 , 174 , 178 , ..., 17128 modulo 100.
17 17 (mod 100)
172 17 17 289 89 (mod 100)
174 172 172 89 89 7921 21 (mod 100)
178 174 174 21 21 441 41 (mod 100)
1716 178 178 41 41 1681 81 (mod 100)
1732 1716 1716 81 81 6561 61 (mod 100)
1764 1732 1732 61 61 3721 21 (mod 100)
17128 1764 1764 21 21 441 41 (mod 100)
Il ne reste qu rassembler :
17154 17128 1716 178 172 41 81 41 89 3321 3649 21 49 1029 29 (mod 100)
On en dduit un algorithme pour le calcul rapide des puissances.
Code 52 (puissance.py).
def puissance(x,k,n):
puiss = 1
# Rsultat
while (k>0):
if k % 2 != 0 :
# Si k est impair (i.e. k_i=1)
puiss = (puiss*x) % n
x = x*x % n
# Vaut x, x^2, x^4,...
k = k // 2
return(puiss)
En fait Python sait faire lexponentiation rapide : pow(x,k,n) pour le calcul de a k modulo n, il faut donc
viter (x ** k) % n qui nest pas adapt.
CRYPTOGRAPHIE
6. LE CHIFFREMENT RSA 61
6. Le chiffrement RSA
Voici le but ultime de ce cours : la chiffrement RSA. Il est temps de relire lintroduction du chapitre
Arithmtique pour sapercevoir que nous sommes prts !
Pour crypter un message on commence par le transformer en un ou plusieurs nombres.

Les processus de chiffrement et dchiffrement font appel plusieurs notions :
On choisit deux nombres premiers p et q que lon garde secrets et on pose n = p q.
Le principe tant que mme connaissant n il est trs difficile de retrouver p et q (qui
sont des nombres ayant des centaines de chiffres).
La cl secrte et la cl publique se calculent laide de lalgorithme dEuclide et des
coefficients de Bzout.
Les calculs de cryptage se feront modulo n.
Le dchiffrement fonctionne grce une variante du petit thorme de Fermat.
Dans cette section, cest Bruno qui veut envoyer un message secret Alice. La processus se dcompose ainsi :
1. Alice prpare une cl publique et une cl prive,
2. Bruno utilise la cl publique dAlice pour crypter son message,
3. Alice reoit le message crypt et le dchiffre grce sa cl prive.
6.1. Calcul de la cl publique et de la cl prive

Choix de deux nombres premiers
Alice effectue, une fois pour toute, les oprations suivantes (en secret) :
elle choisit deux nombres premiers distincts p et q (dans la pratique ce sont de trs grand nombres,
jusqu des centaines de chiffres),
Elle calcule n = p q,
Elle calcule (n) = (p 1) (q 1).
Exemple 1.
p = 5 et q = 17
n = p q = 85
(n) = (p 1) (q 1) = 64
Vous noterez que le calcul de (n) nest possible que si la dcomposition de n sous la forme p q est connue.
Do le caractre secret de (n) mme si n est connu de tous.
Exemple 2.
p = 101 et q = 103
n = p q = 10 403
(n) = (p 1) (q 1) = 10 200
Choix dun exposant et calcul de son inverse
Alice continue :
elle choisit un exposant e tel que pgcd(e, (n)) = 1,
elle calcule linverse d de e module (n) : d e 1 (mod (n)). Ce calcul se fait par lalgorithme
dEuclide tendu.
CRYPTOGRAPHIE
Exemple 1.
Alice choisit par exemple e = 5 et on a bien pgcd(e, (n)) = pgcd(5, 64) = 1,
Alice applique lalgorithme dEuclide tendu pour calculer les coefficients de Bzout correspondant
pgcd(e, (n)) = 1. Elle trouve 5 13 + 64 (1) = 1. Donc 5 13 1 (mod 64) et linverse de e modulo
(n) est d = 13.
Exemple 2.
Alice choisit par exemple e = 7 et on a bien pgcd(e, (n)) = pgcd(7, 10 200) = 1,
Lalgorithme dEuclide tendu pour pgcd(e, (n)) = 1 donne 7 (1457) + 10 200 1 = 1. Mais
1457 8743 (mod (n)), donc pour d = 8743 on a d e 1 (mod (n)).
Cl publique
La cl publique dAlice est constitue des deux nombres :
n et e
Et comme son nom lindique Alice communique sa cl publique au monde entier.
Exemple 1. n = 85 et e = 5
Exemple 2. n = 10 403 et e = 7
Cl prive
Alice garde pour elle sa cl prive :
d
Alice dtruit en secret p, q et (n) qui ne sont plus utiles. Elle conserve secrtement sa cl prive.
Exemple 1. d = 13
Exemple 2. d = 8743
6.2. Chiffrement du message

Bruno veut envoyer un message secret Alice. Il se dbrouille pour que son message soit un entier (quitte
dcouper son texte en bloc et transformer chaque bloc en un entier).
Message
Le message est un entier m, tel que 0 6 m < n.
Exemple 1. Bruno veut envoyer le message m = 10.
Exemple 2. Bruno veut envoyer le message m = 1234.
CRYPTOGRAPHIE
Message chiffr
Bruno rcupre la cl publique dAlice : n et e avec laquelle il calcule, laide de lalgorithme dexponentiation
rapide, le message chiffr :
x me (mod n)
Il transmet ce message x Alice
Exemple 1. m = 10, n = 85 et e = 5 donc
x me (mod n) 105 (mod 85)
On peut ici faire les calculs la main :
102 100 15 (mod 85)
104 (102 )2 152 225 55 (mod 85)
x 105 104 10 55 10 550 40 (mod 85)
Le message chiffr est donc x = 40.
Exemple 2. m = 1234, n = 10 403 et e = 7 donc
x me (mod n) 12347 (mod 10 403)
On utilise lordinateur pour obtenir que x = 10 378.
6.3. Dchiffrement du message

Alice reoit le message x chiffr par Bruno, elle le dcrypte laide de sa cl prive d, par lopration :
m x d (mod n)
qui utilise galement lalgorithme dexponentiation rapide.
Nous allons prouver dans le lemme 1, que par cette opration Alice retrouve bien le message original m de
Bruno.
Exemple 1. c = 40, d = 13, n = 85 donc
x d (40)13 (mod 85).
Calculons la main 4013 (mod 85) on note que 13 = 8 + 4 + 1, donc 4013 = 408 404 40.
402 1600 70 (mod 85)
404 (402 )2 702 4900 55 (mod 85)
408 (404 )2 552 3025 50 (mod 85)
Donc
x d 4013 408 404 40 50 55 40 10 (mod 85)
qui est bien le message m de Bruno.
Exemple 2. c = 10 378, d = 8743, n = 10 403. On calcule par ordinateur x d (10 378)8743 (mod 10 403)
qui vaut exactement le message original de Bruno m = 1234.
CRYPTOGRAPHIE
6.4. Schma
n, e
d
x me (mod n)
- C
Bruno
?
- D
m x d (mod n)
Alice
Cls dAlice :
publique : n, e
prive : d
6.5. Lemme de dchiffrement

Le principe de dchiffrement repose sur le petit thorme de Fermat amlior.
Lemme 1.
Soit d linverse de e modulo (n).
Si x me (mod n) alors m x d (mod n).
Ce lemme prouve bien que le message original m de Bruno, chiffr par cl publique dAlice (e, n) en le
message x, peut-tre retrouv par Alice laide de sa cl secrte d.
Dmonstration. Que d soit linverse de e modulo (n) signifie d e 1 (mod (n)). Autrement dit, il
existe k Z tel que d e = 1 + k (n).
On rappelle que par le petit thorme de Fermat gnralis : lorsque m et n sont premiers entre eux
m(n) m(p1)(q1) 1 (mod n)
Premier cas pgcd(m, n) = 1.
Notons c me (mod n) et calculons x d :
x d (me )d med m1+k(n) m mk(n) m (m(n) )k m (1)k m (mod n)
Deuxime cas pgcd(m, n) 6= 1.
Comme n est le produit des deux nombres premiers p et q et que m est strictement plus petit que n alors
si m et n ne sont pas premiers entre eux cela implique que p divise m ou bien q divise m (mais pas les
deux en mme temps). Faisons lhypothse pgcd(m, n) = p et pgcd(m, q) = 1, le cas pgcd(m, n) = q et
pgcd(m, p) = 1 se traiterait de la mme manire.
tudions (me )d la fois modulo p et modulo q limage de ce que nous avons fait dans la preuve du
thorme de Fermat amlior.
modulo p : m 0 (mod p) et (me )d 0 (mod p) donc (me )d m (mod p),
modulo q : (me )d m(m(n) )k m(mq1 )(p1)k m (mod q).
Comme p et q sont deux nombres premiers distincts, ils sont premiers entre eux et on peut crire comme
dans la preuve du petit thorme de Fermat amlior que
(me )d m (mod n)
CRYPTOGRAPHIE
6.6. Algorithmes
La mise en uvre est maintenant trs simple. Alice choisit deux nombres premiers p et q et un exposant e.
Voici le calcul de la cl secrte :
Code 53 (rsa.py (1)).
def cle_privee(p,q,e) :
n = p * q
phi = (p-1)*(q-1)
c,d,dd = euclide_etendu(e,phi)
return(d % phi)
# Pgcd et coeff de Bzout

# Bon reprsentant
Le chiffrement dun message m est possible par tout le monde, connaissant la cl publique (n, e).
def codage_rsa(m,n,e):
return pow(m,e,n)
Seule Alice peut dchiffrer le message crypt x, laide de sa cl prive d.
def decodage_rsa(x,n,d):
return pow(x,d,n)
Pour continuer...
Bibliographie commente :
1. Histoire des codes secrets de Simon Singh, Le livre de Poche.
Les codes secrets raconts comme un roman policier. Passionnant. Idal pour les plus littraires.
2. Comprendre les codes secrets de Pierre Vigoureux, dition Ellipses.
Un petit livre trs clair et trs bien crit, qui prsente un panorama complet de la cryptographie sans
rentrer dans les dtails mathmatiques. Idal pour les esprits logiques.
3. Codage et cryptographie de Joan Gmez, dition Le Monde Images des mathmatiques. Un autre
petit livre trs clair et trs bien, un peu de maths, des explications claires et des encarts historiques
intressants.
4. Introduction la cryptographie de Johannes Buchmann, dition Dunod.
Un livre dun niveau avanc (troisime anne de licence) pour comprendre les mthodes mathmatiques
de la cryptographie moderne. Idal pour unifier les points de vue des mathmatiques avec linformatique.
5. Algbre - Premire anne de Liret et Martinais, dition Dunod.
Livre qui recouvre tout le programme dalgbre de la premire anne, trs bien adapt aux tudiants des
luniversit. Pas de cryptographie.
Auteurs du chapitre Arnaud Bodin, Franois Recher
Chapitre
Calcul formel
Vido
Vido
Vido
Vido
Vido
Vido
Vido
Vido
Vido
Vido
partie 1. Premiers pas avec Sage

partie 2. Structures de contrle avec Sage
partie 3. Suites rcurrentes et preuves formelles
partie 4. Suites rcurrentes et visualisation
partie 5. Algbre linaire
partie 6a. Courbes et surfaces
partie 6b. Courbes et surfaces
partie 7. Calculs d'intgrales
partie 8. Polynmes
partie 9. quations diffrentielles
1. Premiers pas avec Sage

Le calcul formel est un domaine charnire entre mathmatiques et informatique. Lobjectif de ce cours
est dobtenir des algorithmes efficaces afin de manipuler des objets mathmatiques abstraits tels que les
fonctions, les polynmes, les matrices, etc. notre niveau, le calcul formel ou symbolique sera synonyme
de mathmatiques effectives et efficaces.
1.1. Hello world !

Servons-nous dabord de Sage comme dune calculatrice :
1. Calculer 1 + 2 34 .
2. Calculer
22
33 .
3. Calculer cos( 6 ).
Voil les rsultats :
Code 56 (hello-world.sage).
sage: 1+2*3^4
163
sage: 22/33
2/3
sage: cos(pi/6)
1/2*sqrt(3)
1. PREMIERS PAS AVEC Sage 68
CALCUL FORMEL
On retient que :
Sage connat les oprations classiques +, , , /. La puissance a b scrit a^b ou a**b.
22
2
Sage fait des calculs exacts, il simplifie 33 en 3 , contrairement une banale calculatrice qui afficherait
0.6666 . . .
p3
Sage manipule les fonctions et les constantes usuelles : par exemple cos 6 = 2 .
Dans toute la suite, on omettra linvite de commande sage: . En fin de section vous trouverez davantage
dinformations sur la mise en place de Sage.
1.2. Calcul formel

Lutilisation dun systme de calcul symbolique conduit le mathmaticien un type de dmarche auquel il
nest traditionnellement pas habitu : lexprimentation !
1. Je me pose des questions.
2. Jcris un algorithme pour tenter dy rpondre.
3. Je trouve une conjecture sur la base des rsultats exprimentaux.
4. Je prouve la conjecture.
1. Que vaut le nombre complexe (1 i)k , pour k > 0 ?
2. Les nombres de la forme Fn = 2(2 ) + 1 sont-ils tous premiers ?
n
Nous pouvons faire des calculs avec les nombres complexes. En posant z = 1 i, on calcule successivement
la partie relle (par la commande real_part), la partie imaginaire (imag_part), le module (abs) et
largument (arg) de z 0 , z 1 , z 2 , . . ..
Code 57 (motiv-calcul-formel.sage (1)).
z = 1-I
for k in range(10):
print k, z^k, real_part(z^k), imag_part(z^k), abs(z^k), arg(z^k)
0
1
2
3
4
1
5
-I + 1
6
-2*I
7
-2*I - 2 8
-4
9
4*I - 4
8*I
8*I + 8
16
-16*I + 16
10
11
12
13
14
-32*I
-32*I - 32
-64
64*I - 64
128*I
z 4` = (1)` 22`
z 4`+1 = (1)` 22` (1 i)
z 4`+2 = (1)` 22`+1 ( i)
z 4`+3 = (1)` 22`+1 (1 i)
On remarque exprimentalement une structure assez simple. Par exemple pour passer de zk = (1 + i)k
p
zk+1 = (1 + i)k+1 le module est multipli par 2 alors que largument change de 4 . On en conjecture
p
p k ki
i
zk+1 = 2e 4 zk . Comme z0 = (1 i)0 = 1 alors on conjecture zk = 2 e 4 .
p
i
Passons la preuve : en crivant sous la forme module-argument z = 2e 4 , on obtient bien que z k =
p k ki
2 e 4 . On pourrait aussi obtenir une expression simple en discutant selon les valeurs de k modulo 8.
Le calcul formel permet aussi dviter de passer des annes essayer de montrer un rsultat qui savre faux
n
au final. Pierre de Fermat pensait que tous les nombres de la forme Fn = 22 + 1 taient premiers. Cent ans
plus tard, Euler calcule que F5 = 4 294 967 297 = 641 6 700 417 nest pas un nombre premier.
for n in range(8):
print n, factor(2^(2^n)+1)
CALCUL FORMEL
1.3. Calcul formel vs calcul numrique

Mme si Sage est conu pour le calcul symbolique, il sait aussi effectuer des calculs numriques. Bien que
non exact, le calcul numrique possde plusieurs avantages : il est plus rapide, souvent suffisant pour les
applications pratiques et peut aussi tre plus lisible.
Quelle est la limite de la suite dfinie par rcurrence :
p
u0 = 1
un+1 = 1 + un pour n > 0
Si on calcule formellement les premiers termes on trouve :
u0 = 1
p
u1 = 2
u2 =
p
1+ 2
u3 =
1+
p
1+ 2
u4 =
1+
1+
1+
p
2
Ce qui nclaire pas vraiment sur le comportement de la suite.

Code 59 (calcul-numerique.sage).
u = 1
for i in range(10):
u = sqrt(1 + u)
print(u)
print(numerical_approx(u))
Par contre au vu des approximations :
u0
u1
u2
u3
u4
u5
=
=
=
=
=
=
1
1.4142 . . .
1.5537 . . .
1.5980 . . .
1.6118 . . .
1.6161 . . .
on peut mettre plusieurs conjectures : la suite est croissante, elle est majore par 2 et converge. En poussant
les calculs, une approximation de la p
limite est 1.618033 . . . Les plus observateurs auront reconnu une
approximation du nombre dor = 1+2 5 , solution positive de lquation x 2 x 1. On renvoie un cours
danalyse pour la preuve que la suite (un ) converge effectivement vers .
1.4. Graphiques
La production de graphiques est un formidable outil qui permet de mettre en lumire des phnomnes
complexes.
Soit la fonction f (x) = sin(x) exp(x). Calculer les premiers polynmes de Taylor associs aux dveloppements limits de f en 0. Tracer leurs graphes. Quelles proprits des dveloppements limits cela
met-il en vidence ?
CALCUL FORMEL
Aprs avoir dfini la fonction f par f = sin(x)*exp(x), la commande taylor(f,x,0,n) renvoie

le DL de f en x = 0 lordre n, par exemple ici f (x) = x + x 2 + 13 x 3 + (x)x 3 , donc T1 (x) = x,
T2 (x) = x + x 2 , T3 (x) = x + x 2 + 13 x 3 .
La commande plot(f,(a,b)) trace le graphe de f sur lintervalle [a, b].
Il est perceptible que :
Les polynmes de Taylor sont une bonne approximation de la fonction au voisinage dun point.
Plus lordre du DL est lev, meilleure est lapproximation.
Lapproximation est seulement locale : loin du point considr (ici lorigine) les polynmes de Taylor
napprochent plus du tout la fonction.
Il est possible de tracer une grande varit de graphiques. Voici par exemple la courbe de Lissajous dquation

t 7 cos(3t), sin(4t) et le graphe de la fonction de deux variables dfinie par f (x, y) = cos(x y). Les
commandes sont :
parametric_plot((cos(3*t),sin(4*t)),(t,0,2*pi))
plot3d(cos(x*y),(x,-4,4),(y,-4,4))
Attention ! Il faut avoir au pralable dfinir les variables utilises : var('t') et var('x,y'). (En fait, seule
la variable x est dfinie par dfaut dans Sage.)
CALCUL FORMEL
1.5. Le calcul formel peut-il tout faire ?

Le calcul formel ne rsout malheureusement pas tous les problmes de mathmatique dun coup de baguette
magique !
1. Pouvez-vous calculer les solutions relles de x k x 1 = 0 pour les entiers k > 2 ?
2. Est-ce que Sage sait que toutes ces expressions sont nulles ?
210 1024
(x + 1)2 x 2 2x 1
sin2 (x) + cos2 (x) 1
1. La premire limitation est propre aux mathmatiques : on ne peut pas trouver une criture explicite des
solutions de toutes les quations. Pourpx 2 x p1 = 0 laide de la commande solve(x^2-x-1==0,x)
on trouve bien les deux solutions 1+2 5 et 12 5 . Par contre solve(x^5-x-1==0,x) ne renvoie pas
les solutions, mais il renvoie lquation qui dfinit les solutions (ce qui ne nous avance gure). Ce
nest pas ici un problme de Sage. En effet, il nest mathmatiquement pas possible dexprimer la
p p p
p
3
4
solution relle de x 5 x 1 = 0 laide de racines ( ,
,
,
, . . .). Cest seulement possible
jusquau degr 4. Par contre on obtient une approximation de la solution relle par la commande
find_root(x^5-x-1==0,-1,2) en prcisant que lon cherche la solution sur lintervalle [1, 2].
2. (a) Sans problme 2^10-1024 renvoie 0.
(b) Il est ncessaire de dvelopper pour trouver 0 : expand((x+1)^2-x^2-2*x-1).
(c) Il faut explicitement prciser de simplifier lexpression trigonomtrique : dabord f = sin(x)^2+cos(x)^2 - 1
puis on demande de simplifier f.simplify_trig() pour obtenir 0.
Il nest pas du tout vident pour un ordinateur de reconnatre les identits comme (a + b)2 = a2 + 2a b + b2
ou bien cos2 (x) + sin2 (x) = 1. Souvenez-vous dailleurs quil faut plusieurs annes dapprentissage pour
les assimiler. Lorsquil y a plusieurs critures dune mme expression, il nest pas non plus vident pour
lordinateur de savoir quelle forme est la plus adapte lutilisateur. Par exemple, selon le contexte, les trois
critures sont utiles : (a b)3 = (a b)(a2 2a b + b2 ) = a3 3a2 b + 3a2 b b3 . Il faudra donc guider le
logiciel de calcul formel avec les fonctions expand, factor, simplify...
Remarque.
Pour avoir une ide de la difficult identifier deux expressions, voici une reprsentation de la faon dont
les expressions (a + b)2 et a2 + 2a b + b2 sont stockes dans le logiciel.

+
a
2
b
(a + b)2

a

b
a2 + 2a b + b2
1.6. Un peu plus sur Sage

Ce cours na pas pour but dtre un manuel dutilisation du logiciel Sage. Vous trouverez sur internet des
tutoriels pour dmarrer et pour un usage avanc :
Site officiel de Sage
Il existe aussi un livre gratuit :
Calcul mathmatique avec Sage
CALCUL FORMEL
Une faon simple dobtenir de laide pour une commande Sage est dutiliser le point dinterrogation : ln?
(ou bien help(ln)). Vous y apprendrez que la fonction ln est le logarithme naturel.
Il y a deux faons dutiliser Sage :
En ligne de commande : vous obtenez une fentre avec linvite sage : puis vous tapez vos commandes (en
noubliant pas de faire une copie de votre travail dans un fichier texte du type mon_programme.sage).
Dans votre navigateur : partir de linvite sage: vous tapez notebook() pour obtenir une interface
complte et conviviale.
Voici une liste de fonctions usuelles :
abs(x)
|x|
x^n ou x**n
sqrt(x)
xn
p
x
exp(x)
exp x
ln(x) ou log(x)
ln x logarithme nprien
log(x,10)
log x logarithme dcimal
cos(x), sin(x), tan(x)
cos x, sin x, tan x en radians
arccos(x), arcsin(x), arctan(x)
arccos x, arcsin x, arctan x en radians
floor(x)
partie entire E(x) : plus grand entier n 6 x (floor = plancher)
ceil(x)
plus petit entier n > x (ceil = plafond)
Il existe des fonctions spcifiques qui manipulent les entiers, les vecteurs, les matrices, les polynmes, les
fonctions mathmatiques... Nous les dcouvrions au fil des chapitres.
La syntaxe de Sage est celle du langage Python. Il nest pas ncessaire de connatre ce langage, la syntaxe
sera introduite au fur et mesure. Cependant vous pourrez tudier avec profit le chapitre Algorithmes et
mathmatiques.
Pour linstant voici ce que lon retient de lexemple
for n in range(8):
print n, factor(2^(2^n)+1)
Une boucle for n in range(N): lindice n parcourt les entiers de 0 N 1.
Le bloc dinstructions suivant print n, factor(2^(2^n)+1) est donc excut successivement pour
n = 0, 1, . . . , N 1.
Les espaces en dbut de ligne (lindentation) sont essentielles car elles dlimitent le dbut et la fin dun
bloc dinstructions.
2. STRUCTURES DE CONTRLE AVEC Sage 73
CALCUL FORMEL
2. Structures de contrle avec Sage

2.1. Boucles
Boucle for (pour)
Pour faire varier un lment dans un ensemble on utilise linstruction "for x in ensemble:". Le bloc
dinstructions suivant sera successivement excut pour toutes les valeurs de x.
Code 61 (structures.sage (1)).
for x in ensemble:
premire ligne de la boucle
deuxime ligne de la boucle
...
dernire ligne de la boucle
instructions suivantes
Notez encore une fois que le bloc dinstructions excut est dlimit par les espaces en dbut de ligne. Un
exemple frquent est "for k in range(n):" qui fait varier k de 0 n 1.
Liste range (intervalle)
En fait range(n) renvoie la liste des n premiers entiers : [0,1,2,...,n-1]

Plus gnralement range(a,b) renvoie la liste [a,a+1,...,b-1]. Alors que range(a,b,c) effectue
une saut de c termes, par exemple range(0,101,5) renvoie la liste [0,5,10,15,...,100].
Une autre faon lgrement diffrente pour dfinir des listes dentiers est linstruction [a..b] qui renvoie
la liste des entiers k tels que a 6 k 6 b. Par exemple aprs linstruction for k in [-7..12]: lentier k
va prendre successivement les valeurs 7, 6, 5, ..., 1, 0, +1,... jusqu +12.
La boucle for permet plus gnralement de parcourir nimporte quelle liste, par exemple for x in [0.13,0.31,0.53,
fait prendre x les 4 valeurs de {0.13, 0.31, 0.53, 0.98}.
Boucle while (tant que)
while condition:
premire ligne de la boucle
deuxime ligne de la boucle
...
dernire ligne de la boucle
instructions suivantes
La boucle while excute le bloc dinstructions, tant que la condition est vrifie. Lorsque la condition nest
plus vrifie, on passe aux instructions suivantes.
Voici le calcul de la racine carre entire dun entier n :
n = 123456789
k = 1
while k*k <= n:
# l'entier dont on cherche la racine carre

# le premier candidat
# tant que le carr de k ne dpasse pas n
CALCUL FORMEL
k = k+1
print(k-1)
# on passe au candidat suivant

# la racine cherche
Lorsque la recherche est termine, k est le plus petit entier dont le carr dpasse n, par consquent la racine
carre entire de n est k 1.
Notez quutiliser une boucle tant que comporte des risques, en effet il faut toujours sassurer que la
boucle se termine. Voici quelques instructions utiles pour les boucles : break termine immdiatement la
boucle alors que continue passe directement litration suivante (sans excuter le reste du bloc).
Test if... else (si... sinon)
if condition:
premire ligne d'instruction
...
dernire ligne d'instruction
else:
autres instructions
Si la condition est vrifie, cest le premier bloc dinstructions qui est excut, si la condition nest pas vrifie,
cest le second bloc. On passe ensuite aux instructions suivantes.
2.2. Boolens et conditions

Boolens
Une expression boolenne est une expression qui peut seulement prendre les valeurs Vrai ou Faux
et qui sont codes par True ou False. Les expressions boolennes sobtiennent principalement par des
conditions.
Quelques conditions
Voici une liste de conditions :
a < b : teste lingalit stricte a < b,
a > b : teste lingalit stricte a > b,
a <= b : teste lingalit large a 6 b,
a >= b : teste lingalit large a > b,
a == b : teste lgalit a = b,
a <> b (ou a != b) : teste la non galit a 6= b.
a in B : teste si llment a appartient B.
Remarque. 1. Une condition prend la valeur True si elle est vraie et False sinon. Par exemple x == 2
renvoie True si x vaut 2 et False sinon. La valeur de x nest pas modifie pas le test.
2. Il ne faut surtout pas confondre le test dgalit x == 2 avec laffectation x = 2 (aprs cette dernire
instruction x vaut 2).
3. On peut combiner des conditions avec les oprateurs and, or, not. Par exemple : (n>0) and (not (is_prime(n))
est vraie si et seulement si n est strictement positif et non premier.
CALCUL FORMEL
1. Pour deux assertions logiques P, Q crire lassertion P = Q.
2. Une tautologie est une assertion vraie quelles que soient les valeurs des paramtres, par exemple
(P ou (non P)) est vraie que lassertion P soit vraie ou fausse. Montrer que lassertion suivante est
une tautologie :

non non (P et Q) et (Q ou R) et P et (non R)
Il faut se souvenir du cours de logique qui dfinit lassertion P = Q comme tant non (P) ou Q . Il
suffit donc de renvoyer : not(P) or Q.
Pour lexamen de la tautologie, on teste toutes les possibilits et on vrifie que le rsultat est vrai dans
chaque cas !
for P in {True, False}:

for Q in {True, False}:
for R in {True, False}:
print(not( (not(P and Q) and (Q or R)) and ( P and (not R) ) ))
2.3. Fonctions informatiques

Une fonction informatique prend en entre un ou plusieurs paramtres et renvoie un ou plusieurs rsultats.
def mafonction (mesvariables):

premire ligne d'instruction
...
dernire ligne d'instruction
return monresultat
Par exemple voici comment dfinir une fonction valeur absolue.
def valeur_absolue(x):
if x >= 0:
return x
else:
return -x
Par exemple valeur_absolue(-3) renvoie +3.
Il est possible dutiliser cette fonction dans le reste du programme ou dans une autre fonction. Noter aussi
quune fonction peut prendre plusieurs paramtres.
Par exemple que fait la fonction suivante ? Quel nom aurait t plus appropri ?
def ma_fonction(x,y):
resultat = (x+y+valeur_absolue(x-y))/2
return resultat
CALCUL FORMEL
On considre trois rels distincts a, b, c et on dfinit le polynme
(X a)(X b) (X b)(X c) (X a)(X c)
P(X ) =
+
+
1
(c a)(c b)
(a b)(a c)
(b a)(b c)
1. Dfinir trois variables par var('a,b,c'). Dfinir une fonction polynome(x) qui renvoie P(x).
2. Calculer P(a), P(b), P(c).
3. Comment un polynme de degr 2 pourrait avoir 3 racines distinctes ? Expliquez ! (Vous pourrez
appliquer la mthode full_simplify() votre fonction.)
2.4. Variable locale/variable globale

Il faut bien faire la distinction entre les variables locales et les variables globales.
Par exemple, quaffiche linstruction print(x) dans ce petit programme ?
x = 2
def incremente(x):
x = x+1
return x
incremente(x)
print(x)
Il faut bien comprendre que tous les x de la fonction incremente reprsentent une variable locale qui nexiste que dans cette fonction et disparat en dehors. On aurait tout aussi bien pu dfinir
def incremente(y): y = y+1 return y ou bien utiliser la variable truc ou zut. Par contre les x
des lignes x=2, incremente(x), print(x) correspondent une variable globale. Une variable globale
existe partout (sauf dans les fonctions o une variable locale porte le mme nom !).
En mathmatique, on parle plutt de variable muette au lieu de variable locale, par exemple dans
n
X
k2
k=0
k est une variable muette, on aurait pu tout aussi bien la nommer i ou x. Par contre il faut au pralable
avoir dfini n (comme une variable globale), par exemple n = 7 ou fixons un entier n ...
2.5. Conjecture de Syracuse

Mettez immdiatement en pratique les structures de contrle avec le travail suivant.
La suite de Syracuse de terme initial u0 N est dfinie par rcurrence pour n > 0 par :
(
un
si un est pair
un+1 = 2
3un + 1 si un est impair
1. crire une fonction qui, partir de u0 et de n, calcule le terme un de la suite de Syracuse.
2. Vrifier pour diffrentes valeurs du terme initial u0 , que la suite de Syracuse atteint la valeur 1 au
bout dun certain rang (puis devient priodique : ..., 1, 4, 2, 1, 4, 2, ...). crire une fonction qui pour
un certain choix de u0 renvoie le premier rang n tel que un = 1.
Personne ne sait prouver que pour toutes les valeurs du terme initial u0 , la suite de Syracuse atteint toujours
la valeur 1.
CALCUL FORMEL
Voici le code pour calculer le n-me terme de la suite.

Code 70 (suite-syracuse.sage (1)).
def syracuse(u0,n):
u = u0
for k in range(n):
if u%2 == 0:
u = u//2
else:
u = 3*u+1
return u
Quelques remarques : on a utilis une boucle for pour calculer les n premiers termes de la suite et aussi un
test if...else.
Linstruction u%2 renvoie le reste de la division de u par 2. Le boolen u%2 == 0 teste donc la parit de u.
Linstruction u//2 renvoie le quotient de la division euclidienne de u par 2.
Remarque.
Si a Z et n N alors
a%n est le reste de la division euclidienne de a par n. Cest donc lentier r tel que r a (mod n) et
0 6 r < n.
a//n est le quotient de la division euclidienne de a par n. Cest donc lentier q tel que a = nq + r et
0 6 r < n.
Il ne faut pas confondre la division de nombres rels : a/b et le quotient de la division euclidienne de deux
entiers : a//b. Par exemple 7/2 est la fraction 72 dont la valeur numrique est 3, 5 alors que 7//2 renvoie
3. On a 7%2 qui vaut 1. On a bien 7 = 2 3 + 1.
Pour notre cas u%2 renvoie le reste de la division euclidienne de u par 2. Donc cela vaut 0 si u est pair et 1
si u est impair. Ainsi u%2 == 0 teste si u est pair ou impair. Ensuite u = u//2 divise u par 2 (en fait cette
opration nest effectue que pour u pair).
Pour calculer partir de quel rang on obtient 1, on utilise une boucle while dont les instructions sont
excutes tant que u 6= 1. Donc par construction quand la boucle se termine cest que u = 1.
Code 71 (suite-syracuse.sage (2)).
def vol_syracuse(u0):
u = u0
n = 0
while u <> 1:
n = n+1
if u%2 == 0:
u = u//2
else:
u = 3*u+1
return n
CALCUL FORMEL
3. SUITES RCURRENTES ET PREUVES FORMELLES
78
3. Suites rcurrentes et preuves formelles

Commenons par un exemple. Aprs avoir dclar les deux variables a et b par var('a,b') alors la
commande
expand((a+b)^2-a^2-2*a*b-b^2)
renvoie 0. Ce simple calcul doit tre considr comme une preuve par ordinateur de lidentit (a + b)2 =
a2 + 2a b + b2 , sans quil y ait obligation de vrification. Cette preuve est fonde sur la confiance en
Sage qui sait manipuler les expressions algbriques. Nous allons utiliser la puissance du calcul formel, nous
seulement pour faire des exprimentations, mais aussi pour effectuer des preuves (presque) notre place.
Rappelons la dmarche que lon adopte :
1. Je me pose des questions.
2. Jcris un algorithme pour tenter dy rpondre.
3. Je trouve une conjecture sur la base des rsultats exprimentaux.
4. Je prouve la conjecture.
3.1. La suite de Fibonacci

La suite de Fibonacci est dfinie par les relations suivantes :
F0 = 0
F1 = 1
Fn = Fn1 + Fn2
pour n > 2.
1. Calculer les 10 premiers termes de la suite de Fibonacci.
2. Recherche dune conjecture. On cherche sil peut exister des constantes , , c R telles que

Fn = c n n
Nous allons calculer les constantes qui conviendraient.
(a) On pose Gn = n . Quelle quation doit satisfaire afin que Gn = Gn1 + Gn2 ?
(b) Rsoudre cette quation.
(c) Calculer c, , .
3. Preuve. On note H n =
p1
5

n n o =
p
1+ 5
2
et =
p
1 5
2 .
(a) Vrifier que Fn = H n pour les premires valeurs de n.

(b) Montrer laide du calcul formel que H n = H n1 + H n2 . Conclure.
1. Voici une fonction qui calcule le terme de rang n de la suite de Fibonacci en appliquant la formule de
rcurrence.
Code 72 (fibonacci.sage (1)).
def fibonacci(n):
if n == 0:
return 0
if n == 1:
return 1
F_n_2 = 0
F_n_1 = 1
for k in range(n-1):
F_n = F_n_1 + F_n_2
CALCUL FORMEL
79
F_n_2 = F_n_1
F_n_1 = F_n
return F_n
On affiche les valeurs de F0 F9 :
for n in range(10):
print fibonacci(n)
Ce qui donne :
0
13
21
34
2. (a) On pose Gn = n et on suppose que Gn = Gn1 +Gn2 . Cest--dire que lon veut rsoudre n = n1 +

n2 . Notons (E) cette quation X n = X n1 + X n2 , ce qui quivaut lquation X n2 X 2 X 1 = 0.
On carte la solution triviale X = 0, pour obtenir lquation X 2 X 1 = 0.
(b) On profite de Sage pour calculer les deux racines de cette dernire quation.
solutions = solve(x^2-x-1==0,x)
print(solutions)
var('phi,psi')
phi = solutions[1].rhs()
psi = solutions[0].rhs()
print 'phi : ',phi,' psi : ',psi
Les solutions sont fournies sous la forme dune liste que lon appelle solutions. On rcupre
chaque solution avec solutions[0] et solutions[1]. Par exemple solutions[1] renvoie
x == 1/2*sqrt(5) + 1/2. Pour rcuprer la partie droite de cette solution et la nommer ,
on utilise la fonction rhs() (pour right hand side) qui renvoie la partie droite dune quation (de
mme lhs(), pour left hand side renverrait la partie gauche dune quation).
On obtient donc les deux racines
p
1+ 5
=
2
et
p
1 5
=
.
2
n et n vrifient la mme relation de rcurrence que la suite de Fibonacci mais bien sr les valeurs
prises ne sont pas entires.
(c) Comme F1 = 1 alors c( ) = 1, ce qui donne c =
p1 .
5
La consquence de notre analysep est que si p

une formule Fn = c( n n ) existe alors les constantes sont
ncessairement c = p15 , = 1+2 5 , = 12 5 .
3. Dans cette question, nous allons maintenant montrer quavec ces constantes on a effectivement
1 1+p5 n 1p5 n
Fn = p
.
2
2
5
(a) On dfinit une nouvelle fonction conjec qui correspond H n , la conjecture que lon souhaite montrer.
On vrifie que lon a lgalit souhaite pour les premires valeurs de n.
CALCUL FORMEL
80
def conjec(n):
return 1/sqrt(5)*(phi^n-psi^n)
for n in range(10):
valeur = fibonacci(n)-conjec(n)
print expand(valeur)
(b) Nous allons montrer que Fn = H n pour tout n > 0 en saidant du calcul formel.
Initialisation. Il est clair que F0 = H0 = 0 et F1 = H1 = 1. On peut mme demander lordinateur
de le faire, en effet fibonacci(0)-conjec(0) et fibonacci(1)-conjec(1) renvoient tous
les deux 0.
Relation de rcurrence. Nous allons montrer que H n vrifie exactement la mme relation de
rcurrence que les nombres de Fibonacci. Encore une fois on peut le faire la main, ou bien
demander lordinateur de le faire pour nous :
var('n')
test = conjec(n)-conjec(n-1)-conjec(n-2)
print(test.simplify_radical())
Le rsultat est 0. Comme le calcul est valable pour la variable formelle n, il est vrai quel que soit
n > 0. Ainsi H n = H n1 + H n2 . Il a tout de mme fallu prciser Sage de simplifier les racines
carres avec la commande simplify_radical().
Conclusion. Les suites (Fn ) et (H n ) ont les mmes termes initiaux et vrifient la mme relation
de rcurrence. Elles ont donc les mmes termes pour chaque rang : pour tout n > 0, Fn = H n .
3.2. Lidentit de Cassini

A votre tour maintenant dexprimenter, conjecturer et prouver lidentit de Cassini.
Calculer, pour diffrentes valeurs de n, la quantit
Fn+1 Fn1 Fn2 .
Que constatez-vous ? Proposez une formule gnrale. Prouvez cette formule qui sappelle lidentit de
Cassini.
Notons pour n > 1 :
Cn = Fn+1 Fn1 Fn2 .
Aprs quelques tests, on conjecture la formule trs simple Cn = (1)n .
Voici deux preuves : une preuve utilisant le calcul formel et une autre la main.
Premire preuve laide du calcul formel.
On utilise la formule

p n
p n
1
1+ 5
1 5
Fn = p
2
2
5
et on demande simplement lordinateur de vrifier lidentit !
Code 77 (cassini.sage (1)).
def fibonacci_bis(n):
CALCUL FORMEL
81
return 1/sqrt(5)*( ((1+sqrt(5))/2)^n - ((1-sqrt(5))/2)^n )

Code 78 (cassini.sage (2)).
var('n')
cassini = fibonacci_bis(n+1)*fibonacci_bis(n-1)-fibonacci_bis(n)^2
print(cassini.simplify_radical())
Lordinateur effectue (presque) tous les calculs pour nous. Le seul problme est que Sage choue de peu
simplifier lexpression contenant des racines carres (peut-tre les versions futures feront mieux ?). En effet,
aprs simplification on obtient :
p
p
( 5 1)n ( 5 + 1)n
Cn = (1)n
.
22n
Il ne reste qu conclure la main. En utilisant lidentit remarquable (a b)(a + b) = a2 b2 , on obtient
p
p
p
n
( 5 1)( 5 + 1) = ( 5)2 1 = 4 et donc Cn = (1)n 242n = (1)n .
Seconde preuve Par rcurrence.
On souhaite montrer que lassertion
(Hn )
Fn2 = Fn+1 Fn1 (1)n
est vrai pour tout n > 1.

Pour n = 1, F12 = 12 = 1 0 (1)1 = F2 F0 (1)1 . H1 est donc vraie.
Fixons n > 1 et supposons Hn vraie. Montrons Hn+1 est vraie. On a :
2
= Fn+1 (Fn + Fn1 ) = Fn+1 Fn + Fn+1 Fn1 .
Fn+1
Par lhypothse Hn , Fn+1 Fn1 = Fn2 + (1)n . Donc

2
= Fn+1 Fn + Fn2 + (1)n = (Fn+1 + Fn )Fn (1)n+1 = Fn+2 Fn (1)n+1 .
Fn+1
Donc Hn+1 est vraie.

Conclusion, par le principe de rcurrence, pour tout n > 1, lidentit de Cassini est vrifie.
3.3. Une autre suite rcurrente double

Soit (un )nN la suite dfinie par
3
5
u0 = ,
u1 =
2
3
et
un = 1 + 4
un2 1
un1 un2
pour n > 2.
Calculer les premiers termes de cette suite. mettre une conjecture. La prouver par rcurrence.
Indication. Les puissances de 2 seront utiles...
Commenons par la partie exprimentale, le calcul des premires valeurs de la suite (un ) :
Code 79 (suite-recurrente.sage (1)).
def masuite(n):
if n == 0:
return 3/2
if n == 1:
return 5/3
u_n_2, u_n_1 = 3/2, 5/3
u_n = 1+4*(u_n_2-1)/(u_n_1*u_n_2)
CALCUL FORMEL
82
u_n_2, u_n_1 = u_n_1, u_n

return u_n
(Notez lutilisation de la double affectation du type x, y = newx, newy. Cest trs pratique comme par
exemple dans a, b = a+b, a-b et vite lintroduction dune variable auxiliaire.)
Cela permet de calculer les premiers termes de la suite (un ) :
5
9
17
33
65
3
2
3
5
9
17
33
Au vu des premiers termes, on a envie de dire que notre suite (un ) concide avec la suite (vn ) dfinie par :
2n+1 + 1
.
2n + 1
On dfinit donc une fonction qui renvoie la valeur de vn en fonction de n.
vn =
def conjec(n):
return (1+2^(n+1))/(1+2^n)
Pour renforcer notre conjecture, on vrifie que (un ) et (vn ) sont gales pour les 20 premiers termes :
for n in range(20):
print n,' ',masuite(n),' ',conjec(n)
Il est noter que lon peut calculer un pour des valeurs aussi grandes que lon veut de n mais que lon na
pas une formule directe pour calculer un en fonction de n. Lintrt de (vn ) est de fournir une telle formule.
Voici maintenant une preuve assiste par lordinateur. Notre conjecture dmontrer est : pour tout n > 0,
vn = un . Pour cela, on va prouver que vn et un concident sur les deux premiers termes et vrifient la mme
relation de rcurrence. Ce seront donc deux suites gales.
Initialisation. Vrifions que v0 = u0 et v1 = u1 . Il suffit de vrifier que conjec(0)-3/2 et
conjec(1)-5/3 renvoient tous les deux 0.
un2 1
Relation de rcurrence. Par dfinition (un ) vrifie la relation de rcurrence un = 1 + 4 un1
un2 . Dfinissons une fonction correspondant cette relation : partir dune valeur x (correspond un1 ) et y
y1
(correspondant un2 ) on renvoie 1 + 4 x y .
def recur(u_n_1,u_n_2):
return 1+4*(u_n_2-1)/(u_n_1*u_n_2)
On demande maintenant lordinateur de vrifier que la suite (vn ) vrifie aussi cette relation de
rcurrence :
var('n')
test = conjec(n)-recur(conjec(n-1),conjec(n-2))
print(test.simplify_rational())
v
n2
Le rsultat obtenu est 0. Donc vn vrifie pour tout n la relation vn = 1 + 4 vn1
vn2 .
CALCUL FORMEL
4. SUITES RCURRENTES ET VISUALISATION
83
Conclusion. Les suites (vn ) et (un ) sont gales aux rangs 0 et 1 et vrifient la mme relation de rcurrence
pour n > 2. Ainsi un = vn , pour tout n N. Les suites (un ) et (vn ) sont donc gales.
Notez quil a fallu guider Sage pour simplifier notre rsultat laide de la fonction simplify_rational
qui simplifie les fractions rationnelles.
Remarque.
Quelques commentaires sur les dernires lignes de code.
La commande var('n') est essentielle. Elle permet de rinitialiser la variable n en une variable formelle.
Souvenez-vous quauparavant n valait 19. Aprs linstruction var('n') la variable n redevient une
indtermine 'n' sans valeur spcifique.
Pour bien comprendre ce point, supposons que vous souhaitiez vrifier que (n + 2)3 = n3 +
6n2 + 12n + 8. Vous pouvez-bien sr le vrifier par exemple pour les vingts premiers rang n =
0, 1, 2, . . . , 19. Mais en dfinissant la variable formelle var('n') et laide de la commande
expand((n+2)^3-n^3-6*n^2-12*n-8)) le logiciel de calcul formel prouve directement que
lgalit est vrifie pour tout n. Si vous oubliez de rinitialiser la variable n en une variable formelle,
vous ne laurez vrifie que pour lunique valeur n = 19 !
4. Suites rcurrentes et visualisation
4.1. Visualiser une suite rcurrente

Fixons a R. Dfinissons une suite (un )nN par rcurrence :
u0 = a
et
un+1 = exp(un ) pour n > 0.
1. Calculer les premiers valeurs de la suite pour a = 1. crire une fonction qui renvoie ces premires
valeurs sous la forme dune liste.
2. Sur un mme graphique tracer le graphe de la fonction de rcurrence f (x) = exp(x), la bissectrice

( y = x) et la trace de la suite rcurrente, cest--dire la ligne brise joignant les points uk , f (uk ) ,

(uk+1 , uk+1 ) et uk+1 , f (uk+1 ) .
3. mettre plusieurs conjectures : la suite (ou certaines sous-suites) sont-elles croissantes ou dcroissantes ? Majores, minores ? Convergentes ?
4. Prouver vos conjectures.
CALCUL FORMEL
84
1. On dfinit la fonction f (x) = exp(x) par la commande f(x) = exp(-x).

Code 84 (suites-visual.sage (1)).
def liste_suite(f,terme_init,n):
maliste = []
x = terme_init
for k in range(n):
maliste.append(x)
x = f(x)
return maliste
Par exemple la commande liste_suite(f,-1,4) calcule, pour a = 1, les 4 premiers termes de la
suite (un ) ; on obtient la liste :
[-1, e, e^(-e), e^(-e^(-e))]

e
correspondant aux termes : u0 = 1, u1 = e, u2 = ee et u3 = ee , o lon note e = exp(1).

2. Nous allons maintenant calculer une liste de points. On dmarre du point initial (u0 , 0), puis pour chaque

rang on calcule deux points : uk , f (uk ) et uk+1 , uk+1 . Notez que chaque lment de la liste est ici un
couple (x, y) de coordonnes.
def liste_points(f,terme_init,n):
u = liste_suite(f,terme_init,n)
mespoints = [ (u[0],0) ]
mespoints.append( (u[k],u[k+1]) )
mespoints.append( (u[k+1],u[k+1]) )
return mespoints
Par exemple la commande liste_points(f,-1,3) calcule, pour a = 1, le point initial (1, 0) et les
3 premiers points de la visualisation de la suite (un ) ; on obtient la liste :
CALCUL FORMEL
85
[(-1, 0), (-1, e), (e, e), (e, e^(-e)), (e^(-e), e^(-e))]
Il ne reste plus qu tracer le graphe de la fonction et construire la suite en traant les segments reliant
les points.
def dessine_suite(f,terme_init,n):
mespoints = liste_points(f,terme_init,n)
G = plot(f,(x,-1,3))
# La fonction
G = G + plot(x,(x,-1,3)) # La droite (y=x)
G = G + line(mespoints) # La suite
G.show()
Par exemple la figure illustrant ce tp est construite par la commande dessine_suite(f,-1,10).
3. (et 4.) Passons la partie mathmatique. Pour simplifier ltude on va supposer a = 1. Donc u0 = 1
et u1 = f (u0 ) = exp(1) = e.
(a) La fonction f dfinie par f (x) = exp(x) est dcroissante. Donc la fonction g dfinie par g(x) =

f f (x) est croissante.
(b) La suite (u2n )nN des termes de rangs pairs est croissante. En effet : u2 = ee > 1 = u0 . Alors
u4 = f f (u2 ) > f f (u0 ) = u2 car f f = g est croissante. Puis par rcurrence u6 = f f (u4 ) >
f f (u2 ) = u4 ... La suite (u2n ) est croissante.
(c) Comme u2 > u0 et que f est dcroissante alors u3 6 u1 . On dmontre alors de la mme faon que la
suite (u2n+1 )nN des termes de rangs impairs est dcroissante.
(d) Enfin, toujours par la mme mthode et en partant de u0 6 u1 , on prouve que u2n 6 u2n+1 .
(e) La situation est donc la suivante :
u0 6 u2 6 6 u2n 6 6 u2n+1 6 6 u3 6 u1
La suite (u2n ) est croissante et majore par u1 , donc elle converge. Notons ` sa limite.
La suite (u2n+1 ) est dcroissante et minore par u0 , donc elle converge. Notons `0 sa limite.
(f) Par les thormes usuels danalyse, la suite (u2n ) converge vers un point fixe de la fonction g = f f ,
cest--dire une valeur x 0 vrifiant f f (x 0 ) = x 0 . Une tude de la fonction g (ou plus prcisment
de g(x) x) montrerait que g na quun seul point fixe. Voici le graphe de g.
Cela prouve en particulier que ` = `0 .

(g) Par ailleurs la fonction f admet un unique point fixe x 0 . Mais comme f (x 0 ) = x 0 alors lgalit

f f (x 0 ) = f x 0 = x 0 prouve que x 0 est aussi le point fixe de g.
CALCUL FORMEL
86
(h) Conclusion : la suite (u2n ) et la suite (u2n+1 ) convergent vers x 0 = ` = `0 . Ainsi la suite (un ) converge
vers x 0 le point fixe de f .
(i) Il ny a pas dexpression simple de la solution x 0 de lquation f (x) = x. La commande
solve(f(x)==x,x) renvoie seulement lquation. Par contre, on obtient une valeur numrique
approche par find_root(f(x)==x,0,1). On trouve x 0 = 0, 56714329041 . . .
4.2. Listes
Une liste est ce qui ressemble le plus une suite mathmatique. Une liste est une suite de nombres, de
points. . . ou mme de listes !
Une liste est prsente entre crochets : mesprems = [2,3,5,7,11,13]. On accde aux valeurs par
mesprems[i] ; mesprems[0] vaut 2, mesprems[1] vaut 3. . .
On parcourt les lments dune liste avec for p in mesprems:, p vaut alors successivement 2, 3, 5,
7. . .
Une premire faon de crer une liste est de partir de la liste vide, qui scrit [], puis dajouter un un des lments laide de la mthode append. Par exemple mespoints=[], puis
mespoints.append((2,3)), mespoints.append((7,-1)). La liste mespoints contient alors
deux lments (ici deux points) [ (2,3), (7,-1) ].
Pour n un entier fix. Composer les listes suivantes :
1. la liste des entiers de 0 n 1,
2. la liste des entiers premiers strictement infrieurs n,
3. la liste des 2p + 1, pour les premiers p strictement infrieurs n,
4. les 10 premiers lments de la liste prcdente,
5. la liste de pi + i, o (pi )i >0 sont les nombres premiers strictement infrieurs n (p0 = 2, p1 = 3,...),
6. la liste de 1 et 0 selon que le rang 0 6 k < n soit premier ou pas.
Une utilisation intelligente permet un code trs court et trs lisible. Il faut potasser le manuel afin de
manipuler les listes avec aisance.
1. entiers = range(n)
2. premiers = [k for k in range(n) if is_prime(k)]
3. doubles = [2*p+1 for p in premiers]
4. debut = doubles[0:10]
5. premiersplusrang = [premiers[i]+i for i in range(len(premiers))]
6. binaire = [zeroun(k) for k in range(n)] o zeroun(k) est une fonction dfinir qui renvoie 1 ou 0 selon que k est premier ou pas.
On peut aussi trier les listes, les fusionner...
4.3. Suites et chaos

On considre la fonction f dfinie sur x [0, 1] par
f (x) = r x(1 x)
Pour r fix et u0 [0, 1] fix, on dfinit une suite (un ) par

un+1 = f (un ).
0 6 r 6 4.
CALCUL FORMEL
87
1. Pour diffrentes valeurs de r et u0 fixes, tracer sur un mme graphique le graphe de f , la droite
dquation ( y = x) et la suite (un ). Essayez de conjecturer le comportement de la suite pour 0 < r 6 3,
p
p
3 < r 6 1 + 6, 1 + 6 < r < 4 et r = 4.
2. Pour u0 fix et M < N grands (par exemple M = 100, N = 200) tracer le diagramme de bifurcation
de f , cest--dire lensemble des points
(ui , r)
pour
3. (a) Montrer que les points fixes de f sont 0 et
M 6 i 6 N et 0 6 r 6 4
r1
r .
(b) Montrer que le point fixe 0 est rpulsif (cest--dire | f 0 (0)| > 1) ds que r > 1.
(c) Montrer que le point fixe
r1
r
est attractif (cest--dire | f 0 ( r1

r )| < 1) si et seulement si 1 < r < 3.
4. Cas 1 < r 6 3. Pour 0 < u0 < 1 la suite (un ) converge vers
r1
r .
On va prouver ce rsultat seulement dans le cas particulier r = 2 :

2
(a) Montrer que un+1 12 = 2 un 12 .
(b) Montrer que si |u0 12 | < k <
(c) Conclure.
5. Cas 3 < r < 1 +
1
2
alors |un 12 | < 12 (2k)2 .
p
6. La suite (un ) possde un cycle attracteur de priode 2.
(a) Dterminer les points fixes `1 et `2 de f f qui ne sont pas des points fixes de f .
(b) Montrer que f (`1 ) = `2 et f (`2 ) = `1 .
(c) laide du graphe de f f , vrifier graphiquement sur un exemple, que les suites (u2n ) et (u2n+1 )
sont croissantes ou dcroissantes partir dun certain rang et convergent, lune vers `1 , lautre
vers `2 .
p
6. Cas 1 + 6 < r < 3, 5699456 . . . La suite (un ) possde un cycle attracteur de priode 4, 8, 16...
Trouver de tels exemples.
7. partir de r > 3, 5699456 . . . la suite (un ) devient chaotique.
Le tp suivant sera consacr au cas r = 4.
1. Voici le comportement de diffrentes suites dfinies par le mme u0 = 0, 123 et pour r valant successivement r = 2, 2, r = 3, 2, r = 3, 57 et r = 4.
CALCUL FORMEL
88
On voit dabord une limite, puis la suite semble avoir deux limites cest--dire deux valeurs dadhrence,
puis 4 valeurs dadhrence. Pour r = 4 la situation semble chaotique.
2. Voici le code et le rsultat de lexcution bifurcation(f,0.102), o f(x,r) = r*x*(1-x).
Code 87 (suites-chaos.sage (1)).
def bifurcation(F,terme_init):
Nmin = 100
# On oublie Nmin premiers termes
Nmax = 200
# On conserve les termes entre Nmin et Nmax
epsilon = 0.005
# On fait varier r de epsilon chaque pas
r = 2.5
# r initial
mespoints = []
while r <= 4.0:
u = liste_suite(F(r=r),terme_init,Nmax) # On calcule la suite
for k in range(Nmin,Nmax):
mespoints = mespoints + [(u[k],r)]
r = r + epsilon
G = points(mespoints)
G.show()
CALCUL FORMEL
89
3. Voici le code pour les trois questions.

var('x,r')
f(x,r) = r*x*(1-x)
pts_fixes = solve(f==x,x)
ff = diff(f,x)
ff(x=0)
solve(abs(ff(x=(r-1)/r))<1,r)
#
#
#
#
(a) Points fixes

Drive
(b) f'(0)
(c) Condition point attractif
(a) Les deux points fixes fournis dans la liste pts_fixes sont 0 et
r1
r .
(b) On calcule la drive ff, on lvalue en 0, on trouve f 0 (0) = r. Ainsi si r > 1 alors | f 0 (0)| > 1 et le
point 0 est rpulsif.
(c) Par contre lorsque lon rsout linquation | f 0 ( r1
r )| < 1, la machine renvoie les conditions r > 1 et
r1
r < 3. Ainsi pour 1 < r < 3, le point fixe r est attractif.
4. On pose dabord r = 2, alors le point fixe est
r1
r
= 21 .
(a) Aprs simplification (r*u*(1-u) - 1/2) + 2*(u-1/2)^2 vaut 0. Autrement dit un+1
2(un 12 )2 , quelque soit un .
(b) Cest une simple rcurrence :

u
n+1
1
2
n+1
1
1 2
1
1
2n
=
2
u
= (2k)2 .
<
2
(2k)
n
2
2
2
2
6 0, 1, il existe k tel que |u0 12 | < k <

(c) Ainsi pour u0 =
point fixe 12 .
1
2
et la suite (un ) tend (trs trs) vite vers le
Avec r = 2, en quelques itrations le terme de la suite nest plus discernable de la limite
5. Voici le code pour les deux premires questions :

var('x,r')
f(x,r) = r*x*(1-x)
#
g = f(x=f(x,r))
#
pts_doubles = solve(g==x,x)
#
# Les deux nouveaux points fixes
ell1 = pts_doubles[0].rhs()
ell2 = pts_doubles[1].rhs()
f
g(x) = f(f(x))
(a) Points fixes de g
de g :
1
2
CALCUL FORMEL
eq = f(x=ell1)-ell2
eq.full_simplify()
90
# (b) l'image de ell1 est-elle ell2 ?

# Oui !
(a) On calcule les points fixes de g = f f . Il y en a quatre, mais deux dentre eux sont les points fixes
de f . Les deux nouveaux sont :
p
p
1 r + 1 r 2 2r 3
1 r + 1 + r 2 2r 3
`1 =
`2 =
2
r
2
r
(b) Bien sr `1 et `2 ne sont pas des points fixes pour f . Par contre, on vrifie que f (`1 ) = `2 et f (`2 ) = `1 .
p
(c) Voici les dessins pour r = 1 + 5 et u0 = 23 . La suite (u2n ), qui est vue comme suite rcurrente de
fonction g, est dcroissante vers `1 (figure de gauche). La suite (u2n+1 ), vue comme suite rcurrente
de fonction g, est croissante vers `2 (figure de droite).
La suite (un ), comme suite rcurrente de fonction f , possde le cycle (`1 , `2 ) comme cycle attracteur :
6. Voici un exemple de cycle de longueur 8 (r = 3, 56, u0 = 0, 35) :
7. Le cas r = 4 sera tudi dans le tp suivant.
CALCUL FORMEL
91

On sintresse au cas r = 4. On rappelle que
f (x) = r x(1 x)
u0 [0, 1]
et
un+1 = f (un )
(n > 0).
1. (a) Montrer que sin2 (2t) = 4 sin2 t (1 sin2 t).

(b) Montrer que pour u0 [0, 1], il existe un unique t [0, 2 ] tel que u0 = sin2 t.
(c) En dduire un = sin2 (2n t).
2. Pour t k =
2
2k +1
et u0 = sin2 t k , montrer que la suite (un ) est priodique de priode k.
3. La suite est instable.

(a) Pour k = 3, on pose t 3 =
pour tout n.
2
9 ,
u0 = sin2 t 3 . Calculer une valeur exacte (puis approche) de un ,
0 de u0 , que donne la suite des approximations (

(b) Partant dune valeur approche u
un ) dfinie par
la relation de rcurrence ?
4. La suite est partout dense.
On va construire u0 [0, 1] tel que, tout x [0, 1] peut tre approch daussi prs que lon veut par
un terme un de notre suite :

x u < .
x [0, 1] > 0 n N
n
Soit la constante binaire de Champernowne, forme de la juxtaposition des entiers en criture
binaire 1, 2, 3,. . . chiffres 0, 1, 00, 01, 10,... dont lcriture binaire est = 0, 0100011011 . . .
Soit u0 = sin2 ().
Soit x [0, 1[. Ce rel peut scrire x = sin2 (t) avec t [0, 1[ qui admet une criture binaire
t = 0, a1 a2 . . . a p . . ..

Pour > 0 fix, montrer quil existe n tel que x u < .
n
1. (a) On pose eq = sin(2*t)^2 - 4*sin(t)^2*(1-sin(t)^2) et eq.full_simplify() renvoie

0. Donc sin2 (2t) = 4 sin2 t (1 sin2 t), pour tout t R.
(b) Soit h(t) = sin2 t. On dfinit la fonction h = sin(t)^2, sa drive hh = diff(h,t) dont on
cherche les zros par solve(hh==0,t). La drive ne sannulant quen t = 0 et t = 2 . La fonction
h0 est strictement monotone sur [0, 2 ]. Comme h(0) = 0 et h( 2 ) = 1, pour chaque u0 [0, 1], il
existe un unique t [0, 2 ] tel que u0 = h(t).
(c) Pour u0 = sin2 t, on a
u1 = f (u0 ) = ru0 (1 u0 ) = 4 sin2 t (1 sin2 t) = sin2 (2t).
On montre de mme par rcurrence que un = sin2 (2n t).
2. Le code suivant calcule uk u0 . Sage sait calculer que cela vaut 0, pour k prenant la valeur 0, 1, 2,...
mais pas lorsque k est une variable. Le calcul la main est pourtant trs simple !
t = 2*pi/(2^k+1)
u_0 = sin(t)^2
u_k = sin(2^k*t-2*pi)^2
zero = u_k-u_0
zero.simplify_trig()
3. La suite est instable.
CALCUL FORMEL
(a) Pour k = 3 et t 3 =
Par exemple :
2
9 ,
92
la suite (uk ) est priodique de priode 3. Donc il suffit de calculer u0 , u1 , u2 .
2
u3p = u0 = sin
' 0,413 175 911 1 . . .
9
0 = 0,413 175 911 1 et calculons
(b) Partons de la valeur approche de u0 avec 10 dcimales exactes : u
les premiers termes de la suite. On en extrait :
2
0 ' 0,413 175 911 100

u
3 ' 0,413 175 911 698
u
6 ' 0,413 175 906 908
u
9 ' 0,413 175 945 232
u
12 ' 0,413 175 638 640
u
15 ' 0,413 178 091 373
u
18 ' 0,413 158 469 568
u
21 ' 0,413 315 447 870
u
24 ' 0,412 059 869 464
u
27 ' 0,422 119 825 829
u
30 ' 0,342 897 499 745
u
33 ' 0,916 955 513 784
u
36 ' 0,517 632 311 613
u
39 ' 0,019 774 022 431
u
Si lapproximation de dpart et tous les calculs taient exacts, on devrait obtenir u0 chaque ligne.
30 , le comportement de u
n na plus
On constate que lerreur augmente terme aprs terme, et aprs u
rien voir avec un . Lexplication vient de la formule un = sin2 (2n t), une erreur sur t, mme infime
au dpart, devient grande par multiplication par 2n .
4. La suite est partout dense.
La construction est assez jolie mais dlicate. (Il ne faut pas avoir peur de lcriture en base 2 qui nest
pas ici le point cl. Vous pouvez penser en base 10 pour mieux comprendre.)
Fixons > 0. Soit un entier p tel que 2p < . Lcriture binaire de t tant t = 0, a1 a2 . . . a p . . . la squence
a1 a2 . . . a p apparat quelque part dans la constante de Champernowne. Plus prcisment il existe un
entier n tel que 2n = . . . b2 b1 b0 , a1 a2 . . . a p . . . (on a fait apparatre la squence juste aprs la virgule
par dcalage de la virgule).
= 0, a1 a2 . . . a p . . . la partie
On va pouvoir oublier la partie entire m = . . . b2 b1 b0 N et on note
n
fractionnaire de , de sorte que 2 = m + .

|x un | = sin2 (t) sin2 (2n )

= sin2 (t) sin2 (2n m + )

car sin2 est -priodique
= sin2 (t) sin2 ()
6 |t |
par le thorme des accroissements finis
1
ont les mmes p premires dcimales
car t et
6 p
2
<
Conclusion : nimporte quel x est approch daussi prs que lon veut par la suite.
Pour en savoir plus :
La suite logistique et le chaos, Daniel Perrin.
tude dune suite rcurrente, Jean-Michel Ferrard.
CALCUL FORMEL
5. ALGBRE LINAIRE
93
5. Algbre linaire
Lalgbre linaire est la partie des mathmatiques qui soccupe des matrices et des structures vectorielles.
Beaucoup de problmes se ramnent ou sapprochent par des problmes linaires, pour lesquels il existe
souvent des solutions efficaces.
5.1. Oprations de base

Soient les matrices :
1 2 3
A = 1 0 1
0 1 0
B=
2 1 0
1 0 1
1
u=x
x2
v = 0
1
1. Calculer tous les produits possibles partir de A, B, u, v.

2. Calculer (A I)7 et en extraire le coefficient en position (2, 3).
3. Calculer A1 . Calculer la trace de A1 (cest--dire la somme des coefficients sur la diagonale).
1. On dfinit une matrice n lignes et p colonnes par la commande
matrix(n,p,[ [ligne1],[ligne2],... ])
Pour nous cela donne :
Code 91 (alglin.sage (1)).
A
B
I
u
v
=
=
=
=
=
matrix(3,3,[[1,2,3],[-1,0,1],[0,1,0]])
matrix(2,3,[[2,-1,0],[-1,0,1]])
identity_matrix(3)
matrix(3,1,[1,x,x^2])
matrix(3,1,[1,0,1])
On multiplie deux matrices par A*B. Cette opration est possible seulement si le nombre de colonnes de
A est gal au nombre de lignes de B. Les produits possibles sont donc ici : B A, A u, A v, B u, B v.
2. Ayant dfini la matrice identit I (par I = identity_matrix(3)), on calcule M = (A I)7 par
(A-I)^7, ce qui renvoie
16 46
11
(A I)7 = 25 73 153 .
32
57 137
Le coefficient en position (2, 3) dune matrice M est celui sur la deuxime ligne et la troisime colonne.
Donc ici cest 153. Une matrice A se comporte en Sage comme une liste double entre et on accde
aux coefficients par la commande A[i,j] (i pour les lignes, j pour les colonnes). Attention ! Les listes
tant indexes partir du rang 0, les indices i, j partent de 0. Le coefficient en position (2, 3) sobtient
donc par la commande :
((A-I)^7)[1,2]
Faites bien attention au dcalage des deux indices.
3. Linverse dune matrice A se calcule par A^-1 ou A.inverse(). Ce qui donne
1
3
1
4 4 2
1 .
A1 = 0 0
1
1
12
4
4
CALCUL FORMEL
5. ALGBRE LINAIRE
94
La trace se calcule par une simple somme des lments sur la diagonale principale :
sum( (A^-1)[i,i] for i in range(3) )

et vaut ici
14 .
Remarque. Noter encore une fois que pour une matrice de taille n et pour Sage les indices varient de 0
n 1.
On peut prciser le corps sur lequel on travaille, pour nous ce sera le plus souvent K = Q. Par exemple :
A = matrix(QQ, [[1,2],[3,4]]).
Avec Sage on peut aussi dfinir des vecteurs par vector([x1,x2,...,xn]). Un vecteur peut reprsenter soit un vecteur ligne, soit un vecteur colonne. On peut multiplier une matrice par un vecteur (
gauche ou droite).
Si on dfinit un vecteur, par exemple v = vector([1,2,3,4]) alors L = matrix(v) renvoie la
matrice ligne correspondante. C = L.transpose() renvoie la matrice colonne correspondante.
Pour une matrice A Mn (K) inversible et des vecteurs colonnes u, v n lignes on dfinit K par :
= 1 + v T A1 u.
La formule de Sherman-Morrison affirme que si 6= 0 alors
1
A1 uv T A1
T
A + uv
= A1
Prouver par le calcul formel cette formule pour les matrices de taille 2 2 et 3 3.
Connaissant linverse de A, cette formule permet de calculer moindre cot linverse dune dformation de
A par une matrice de rang 1. Le code ne pose pas de problme.
Code 92 (alglin.sage (2)).
var('a,b,c,d,x,y,xx,yy')
A = matrix(2,2,[[a,b],[c,d]])
u = matrix(2,1,[x,y])
v = matrix(2,1,[xx,yy])
alpha_matrice = 1 + v.transpose() * (A^-1) * u
alpha_reel = alpha_matrice[0,0]
B = ( A + u * v.transpose() )^-1
BB = A^-1 - 1/alpha_reel*( A^-1 * u * v.transpose() * A^-1 )
C = B - BB
for i in range(A.nrows()):
for j in range(A.ncols()):
print( "indices :",i,j,"coeff :", (C[i,j]).full_simplify() )
On commence par dfinir les coefficients qui seront nos variables (ici pour n = 2).
On calcule par la formule = 1 + v T A1 u, qui est une matrice de taille 1 1 (alpha_matrice),
identifie un rel (alpha_reel).
On calcule ensuite les termes de gauche (B) et droite (BB) de la formule prouver. Pour la matrice
C = B - BB, on vrifie (aprs simplification) que tous ses coefficients sont nuls. Ce qui prouve lgalit
cherche.
On pourrait galement obtenir directement le rsultat en demandant Sage :
C.simplify_rational()==matrix(2,2,0).

1
T 1
Pour une preuve la main et en toute dimension, multiplier A + uv T par A1 A uv A .
CALCUL FORMEL
5. ALGBRE LINAIRE
95
5.2. Rduction de Gauss, calcul de linverse

Le but de cette section est est de mettre en uvre la mthode de Gauss. Cette mthode est valable pour des
systmes linaires (ou des matrices) de taille quelconque, mais ici on se limite au calcul de linverse dune
matrice (qui est obligatoirement carre). Nhsitez pas dabord relire votre cours sur la mthode de Gauss.
1. Raliser trois fonctions qui transforment une matrice en fonction des oprations lmentaires sur les
lignes :
L i c L i avec c 6= 0 : on multiplie une ligne par un rel ;
L i L i + c L j : on ajoute la ligne L i un multiple dune autre ligne L j ;
L i L j : on change deux lignes.
2. laide de ces transformations lmentaires, transformer par la mthode de Gauss une matrice
inversible en une matrice chelonne (cest--dire ici, en partant dune matrice carre, obtenir une
matrice triangulaire suprieure).
3. Toujours laide de ces transformations et de la mthode de Gauss, transformer cette matrice
chelonne en une matrice chelonne et rduite (cest--dire ici, en partant dune matrice inversible,
obtenir lidentit).
4. La mthode de Gauss permet de calculer linverse dune matrice A :
Partant de A, on pose B = I la matrice identit.
Par la mthode de Gauss et des oprations lmentaires on transforme A en la matrice I.
On applique exactement les mmes transformations la matrice B.
Lorsque A sest transforme en I alors B sest transforme en A1 .
Modifier lgrement vos deux fonctions (issues des questions 2. et 3.) afin de calculer linverse dune
matrice.
Voici une matrice A, sa forme chelonne, sa forme chelonne rduite (lidentit), et son inverse :
3
1
1 2 3
1 2 3
1 0 0
4 4 2
0 2 4
0 1 0
1
A = 1 0 1
A1 = 0 0
1
1
0 1 0
0 0 2
0 0 1
12
4
4
1. Voici la fonction pour la deuxime opration : L i L i + c L j .
Code 93 (gauss.sage (1)).
def op2(A,i,j,c):
A[i,:] = A[i,:] + c*A[j,:]
return A
A[i,:] correspond la ligne i (les deux points signifiant de prendre tous les indices des colonnes).
Lorsque lon execute cette fonction sur une matrice A cela modifie la matrice (voir la remarque plus bas).
Pour viter cela on commence par faire une copie de A par AA = copy(A), puis on excute la fonction
sur cette copie, avec par exemple op2(AA,0,2,-1) pour lopration L0 L0 L2 .
Les autres oprations op1(A,i,c), op3(A,i,j) se dfinissent de manire analogue.
2. Il sagit de traduire la premire partie de la mthode de Gauss. Pour chaque colonne p en partant de la
plus gauche :
(a) on cherche un coefficient non nul dans cette colonne ;
(b) on place ce coefficient en position de pivot (p, p), en permutant deux lignes par la troisime opration
lmentaire ;
CALCUL FORMEL
5. ALGBRE LINAIRE
96
(c) on annule, un par un, les coefficients qui sont sous ce pivot, par des oprations lmentaires :
ai,p
L i L i + c L p o c = ap,p
.
def echelonne(A):
n = A.ncols() # taille de la matrice
for p in range(n): # pivot en A[p,p]
# a. On cherche un coeff non nul
i = p
while i < n and A[i,p] == 0:
i = i+1
if i >= n :
return matrix(n,n) # stoppe ici car pas inversible
# b. On place la ligne avec coeff non nul en position de pivot
A = op3(A,p,i)
# c. On soustrait la ligne du pivot aux lignes en dessous
for i in range(p+1,n):
c = -A[i,p]/A[p,p]
A = op2(A,i,p,c)
return A
3. Pour passer une forme rduite, on parcourt les colonnes en partant de la droite :
(a) on commence par multiplier la ligne du pivot pour avoir un pivot valant 1 ;
(b) on annule, un par un, les coefficients qui sont au-dessus de ce pivot.
def reduite(A):
n = A.ncols()
for p in range(n-1,-1,-1):
# a. On divise pour avoir un pivot valant 1
c = 1/A[p,p]
A = op1(A,p,c)
# b. On limine les coefficients au-dessus du pivot
for i in range(p-1,-1,-1):
c = -A[i,p]
A = op2(A,i,p,c)
return A
4. Pour calculer linverse, on dfinit deux nouvelles fonctions echelonne_bis(A,B) et reduite_bis(A,B)
qui renvoient chacune, deux matrices modifies de A et B. chaque fois que lon effectue une opration
sur A, on effectue la mme opration sur B. Par exemple, la dernire boucle de echelonne_bis contient
ai,p
la ligne A = op2(A,i,p,c) et la ligne B = op2(B,i,p,c). Cest bien le mme coefficient c = ap,p
pour les deux oprations. On obtient alors linverse comme ceci :
def inverse_matrice(A):
n = A.ncols()
B = identity_matrix(QQ,n)
CALCUL FORMEL
5. ALGBRE LINAIRE
97
A,B = echelonne_bis(A,B)
A,B = reduite_bis(A,B)
return B
Remarque.
Si on pose A = matrix( [[1,2],[3,4]] ), puis B = A, puis que lon modifie la matrice A par
A[0,0]= 7. Alors la matrice B est aussi modife !
Que se passe-t-il ?
A ne contient pas les coefficients de la matrice, mais ladresse o sont stocks ces coefficients (cest plus
lger de manipuler ladresse dune matrice que toute la matrice).
Comme A et B pointent vers la mme zone qui a t modifie, les deux matrices A et B sont modifies.
Pour pouvoir dfinir une copie de A, avec une nouvelle adresse mais les mmes coefficients, on crit
B = copy(A). Les modifications sur A ne changeront plus B.
5.3. Application linaire, image, noyau

Soit f : R3 R4 lapplication linaire dfinie par

x + 2z
x
5x + 2 y + 2z
f : y 7
2x + y .
z
x + y 2z
1. Expliciter la matrice A de f (dans les bases canoniques). Comment scrit alors lapplication f ?
2. Calculer une base du noyau de f . Lapplication linaire f est-elle injective ?
3. Calculer une base de limage de f . Lapplication linaire f est-elle surjective ?
1. La matrice associe est
1 0 2
5 2 2
A=
2 1 0 .
1 1 2
Lapplication linaire f tant alors dfinie par X 7 Y = AX . Voici limplmentation avec un exemple de
calcul.
Code 97 (matlin.sage (1)).
K
A
X
Y
=
=
=
=
QQ
matrix(K,4,3,[[1,0,2],[5,2,2],[2,1,0],[1,1,-2]])
vector(K,[2,3,4])
A*X
2. et 3. Le noyau sobtient par la commande right_kernel() et limage par la commande column_space()

car limage est exactement le sous-espace vectoriel engendr par les vecteurs colonnes de la matrice.
Ker = A.right_kernel()
Ker.basis()
Im = A.column_space()
CALCUL FORMEL
5. ALGBRE LINAIRE
98
Im.basis()
2
Le noyau est un espace vectoriel de dimension 1 dans R3 engendr par 4. Le noyau ntant pas
1
trivial, lapplication f nest pas injective.
Limage est un espace vectoriel de dimension 2 dans R4 , dont une base est :

1
0
1 2
, .
0 1
1
1
Limage ntant pas tout R4 , lapplication f nest pas non plus surjective.
On peut tester si un vecteur donn est dans un sous-espace. Si on pose par exemple X = vector(K,[1,5,2,1])
alors le test X in Im renvoie vrai. Ce vecteur est donc bien un lment de limage de f .
Attention ! Il ne faut pas utiliser directement les mthodes kernel() et image() car Sage prfre travailler
avec les vecteurs lignes et donc ces mthodes calculent le noyau gauche (cest--dire lensemble des X
tels que X A = 0) et limage gauche (cest--dire lensemble des Y = X A). Si vous souhaitez utiliser ces
mthodes pour calculer le noyau et limage avec notre convention habituelle (cest--dire droite) il faut le
faire sur la transpose de A :
AA = A.transpose()
Ker = AA.kernel()
Ker.basis()
Im = AA.image()
Im.basis()
5.4. Mthodes des moindres carrs

Si on veut rsoudre un systme linaire avec plus dquations que dinconnues alors il ny a pas de solution
en gnral. On aimerait pourtant parfois trouver ce qui sapproche le plus dune solution. Formalisons ceci :
soit A Mn,p (R) avec n > p une matrice coefficients rels, X un vecteur inconnu de taille p et B un vecteur
de taille n. Il ny a en gnral pas de solution X au systme AX = B, mais on aimerait que AX B soit le
plus proche du vecteur nul. Ainsi, une solution des moindres carrs est un vecteur X tel que kAX Bk soit
minimale, o la norme considre est la norme euclidienne. Cette solution des moindres carres est donne
par la formule :
X = (AT A)1 AT B
()
T
(si n > p et A est de rang maximal p, ce quon suppose, alors on peut montrer que la matrice A A est
inversible).

1. Rgression linaire. On considre les points (6, 0), (2, 1), (1, 2), (4, 4), (6, 4) . Trouver la droite
qui approche au mieux ces points (au sens des moindres carrs).
Indications. On pose f (x) = a + b x. On aimerait trouver a, b R tels que f (x i ) = yi pour tous les
points (x i , yi ) donns. Transformer le problme en un problme des moindres carrs : quel est le
vecteur inconnu X ? quelle est la matrice A ? quel est le second membre B ?
2. Interpolation polynomiale. Pour ces mmes points, quel polynme de degr 3 approche au mieux
CALCUL FORMEL
5. ALGBRE LINAIRE
99
ces points (au sens des moindres carrs).

Indication. Cette fois f (x) = a + b x + c x 2 + d x 3 .
Voici la droite demande ( gauche) ainsi que le polynme de degr 3 ( droite).
1. Bien sr les points ne sont pas aligns, donc il nexiste pas de droite passant par tous ces points. On
cherche une droite dquation y = a + b x qui minimise (le carr de) la distance entre les points et la
droite. Posons f (x) = a + b x.
Alors pour nos n points (x i , yi ) donns, on voudrait f (x i ) =
f (x 1 ) = y1
a + b x 1 = y1
f (x ) = y
a + bx = y
2
2
2
2
..
..
..
..
.
.
.
.
f (x n ) = yn
a + b x n = yn
yi .
1
1
.
..
1

x1
y1

x2 a
y2
= .
..
..
. b
xn
AX = B.
yn
On rsout (de faon non exacte) notre problme AX = B, par la formule des moindres carrs X =
(AT A)1 AT B. Comme X = ( ab ), on obtient lquation y = a + b x b de la droite des moindres carrs (voir
la figure ci-dessus).
La fonction moindres_carres rsout le problme gnral des moindres carrs. Il reste ensuite dfinir
la matrice A et le vecteur B en fonction de notre liste de points afin de trouver X . Le code est le suivant :
Code 100 (moindres_carres.sage (1)).
def moindres_carres(A,B):
return (A.transpose()*A)^-1 * A.transpose() * B
points = [(-6,0),(-2,1),(1,2),(4,4),(6,4)]
A = matrix([ [1,p[0]] for p in points ])
B = vector(p[1] for p in points)
X = moindres_carres(A,B)
2. Lide est la mme, mais cette fois les
c x2 + d x3 :
f (x 1 ) = y1
f (x ) = y
2
2
..
..
.
.
f (x n ) = yn
1 x1
1 x
2
. .
.. ..
1
xn
inconnues sont les coefficients de la fonction f (x) = a + b x +
a + b x 1 + c x 12 + d x 13
a + bx + c x2 + d x3
2
2
2
..
2
3
a + b xn + c xn + d xn

2
3
y1
x1 x1
a
2
3
x 2 x 2 b y2
..
..
..
c =
.
.
.
d
x2 x3
yn
n
=
=
y1
y2
..
.
yn
AX = B
Voici le code pour les mmes points et une interpolation polynomiale de degr d :
CALCUL FORMEL
5. ALGBRE LINAIRE
100
Code 101 (moindres_carres.sage (2)).
d
A
B
X
=
=
=
=
3
# degr
matrix([ [p[0]^k for k in range(d+1)] for p in points ])
vector(p[1] for p in points)
moindres_carres(A,B)
Pour conclure, voici la preuve de la formule () des moindres carrs. Caractrisons gomtriquement la
condition kAX Bk minimale . On note Im A limage de A, cest--dire le sous-espace vectoriel engendr
par les vecteurs colonnes de la matrice A. Notons p : Rn Rn la projection orthogonale sur Im A. Enfin,
notons Y = p(B) le projet orthogonal de B sur limage de A.
B
~
vp
p(B) = Y = AX
~
v1
ImA
Comme Y est dans limage de A alors il existe X tel que AX = Y et X est notre solution cherche. En effet,
cest lune des caractrisations du projet orthogonal : Y = p(B) est le point de Im A qui minimise la distance
entre B et un point de Im A.
Que Y soit le projet orthogonal de B sur Im A signifie que le vecteur B Y est orthogonal tout vecteur de
Im A :
AV | B Y = 0
V R p
AV | B AX = 0
T
V R p
(AV ) (B AX ) = 0
V T AT (B AX ) = 0
AT (B AX ) = 0
AT AX = AT B
X = (AT A)1 AT B
V R
V R p
pour Y = AX
p
car u | v = u T v
CALCUL FORMEL
6. COURBES ET SURFACES
101
6. Courbes et surfaces
La visualisation est une tape importante dans llaboration des preuves en mathmatiques. Lavnement
des logiciels de calcul formel possdant une interface graphique volue a rendu cette phase attrayante.
Nous allons explorer les possibilits graphiques offertes par Sage. Nous avons dj vu comment tracer les graphes de fonctions avec la commande plot (voir Premiers pas avec Sage ), par exemple
plot(sin(x)*exp(x),(x,-3,3)) trace le graphe de la fonction f (x) = sin(x) exp(x) sur lintervalle
[3, 3].
En plus des graphes de fonctions Sage sait tracer des courbes et des surfaces par dautres mthodes.
6.1. Courbes paramtres

La commande parametric_plot((f(t), g(t)), (t, a, b)) permet de tracer la courbe paramtre
plane donne par les points de coordonnes ( f (t), g(t)) lorsque le paramtre t varie dans lintervalle [a, b].
Commenons par la lemniscate de Bernoulli :
0.4
0.2
-1
-0.5
0.5
-0.2
-0.4
Code 102 (lemniscate-bernoulli.sage).
var('t')
x = sqrt(2)*cos(t)/(1+sin(t)^2)
y = sqrt(2)*cos(t)*sin(t)/(1+sin(t)^2)
G = parametric_plot((x, y), (t, 0, 2*pi))
G.show()
1. Tracer la spirale de Fermat dquation
p
x(t) = t cos t
p
y(t) = t sin t
t R+ .
CALCUL FORMEL
2. Tracer la courbe du papillon

(
x(t) = sin(t) exp(cos(t)) 2 cos(4t) sin5
t
12
y(t) = cos(t) exp(cos(t)) 2 cos(4t) sin5
t
12
102

t R.
Les commandes de trac possdent de nombreuses options, quon pourra dcouvrir grce la commande
help(parametric_plot). Par exemple :
Imposer un repre orthonorm : aspect_ratio = 1
Nombre de points pour le trac : plot_points = 500
Ne pas afficher les axes : axes = False
Afficher une grille : gridlines = True
Remplir lintrieur : fill = True
Couleur du trait : color = 'red', couleur du remplissage : fillcolor = 'orange'
6.2. Courbes en coordonnes polaires

Les courbes en coordonnes polaires sont traces grce la commande polar_plot(r(t),(t,a,b)),
qui produira lensemble des points de coordonnes polaires [r(t) : t] pour t variant dans lintervalle [a, b].
Voici le folium de Drer dquation r(t) = sin 2t , t R.
0.5
-1
-0.5
0.5
-0.5
Code 103 (durer-folium.sage).
var('t')
G = polar_plot(sin(t/2),(t,0,4*pi))
CALCUL FORMEL
103
G.show()

1. Tracer la courbe du Lituus dquation polaire
r(t)2 =
1
t
t R .
2. Tracer la cochlode dquation polaire

r(t) =
sin t
t
t R .
Indications : on peut dfinir deux graphes G1, G2 pour chacun des intervalles de dfinition. On superpose
les graphes avec G = G1 + G2, puis on les affiche avec G.show().
0.6
0.4
0.2
0.5
-3
-2
-1
-0.5
-0.2
0.2
0.4
0.6
0.8
-0.2
-0.4
-0.6
6.3. Courbes dfinies par une quation

Une courbe peut avoir plusieurs types de reprsentations, comme par exemple un cercle dquation paramtrique (cos t, sin t) ou dquation implicite x 2 + y 2 = 1. La commande
implicit_plot(f(x, y), (x, a, b), (y, c, d))
permet de tracer lensemble des couples (x, y) dans [a, b][c, d] qui sont solutions de lquation f (x, y) = 0.
Voici une autre courbe de papillon, cette fois algbrique.
Code 104 (butterfly-curve-algebraic.sage).
f(x,y) = x^6 + y^6 - x^2

G = implicit_plot(f, (x, -1.2, 1.2), (y, -1.2, 1.2))
G.show()
G.save('butterfly_curve_algebraic.png')
Noter comment il est possible de sauvegarder une image du trac dans un fichier externe.
CALCUL FORMEL
104
0.5
-0.5
-1
-1
-0.5
0.5

1. Dfinir une fonction qui renvoie la courbe dfinie par
y2 x3 + x + c = 0
en fonction du paramtre c R.
2. laide de la commande animate, raliser une animation qui affiche lvolution de la courbe pour
c [1, 1].
6.4. Courbes de lespace

La commande parametric_plot((x, y, z), (t, a, b)), (ou bien parametric_plot3d()) analogue celle de la dimension 2, trace la courbe paramtre de lespace donne par les points de coordonnes

x(t), y(t), z(t) lorsque le paramtre t varie dans lintervalle [a, b].
Tracer la courbe dArchytas dquation paramtrique :
x(t) = cos t
y(t) = cos t sin t
z(t) = cos t(1 cos t)

t 2 , + 2 .
Vous obtiendrez une figure quil est possible dorienter dynamiquement avec la souris. Voici quelques-unes
de ces vues.
CALCUL FORMEL
105
6.5. Surfaces
Dcouvrez, laide de lnonc suivant, les diffrentes mthodes pour tracer des surfaces avec Sage.
1. Tracer le graphe de la fonction f (x, y) = x 2 y 2 (x 2 + y 2 )3 dfinie sur (x, y) [1, 1] [1, 1].
Utiliser la fonction plot3d.
2. Tracer la surface dEnneper dfinie par lquation
3
2
2
2
y x2 1 2
y x2 2 2 2
8 2 2
2
+ z +
6
x +y + z +
= 0.
2z
9
3
4z
4
9
9
Utiliser la fonction implicit_plot3d.
3. Tracer la nappe paramtre dfinie par :
x(s, t) = t cos s
y(s, t) = s2 sin t
z(s, t) = cos t + sin t

s 0, 1 ,

t , + .
Utiliser la fonction parametric_plot3d.

4. Tracer la surface paramtre dfinie en coordonnes cylindriques par :
r( , z) = z 3 cos
[0, 2],
z [0, 2].
Utiliser la fonction cylindrical_plot3d.

5. Tracer la surface paramtre dfinie en coordonnes sphriques par
r( , ) = sin(2)
Utiliser la fonction spherical_plot3d.
[1, 2],
[0, ].
CALCUL FORMEL
6.6. tude dune courbe paramtre

tudier en dtail la courbe paramtre du plan dfinie par
x(t) = t 3 2t
y(t) = t 2 t
t R.
1. Tracer la courbe.
2. Trouver les points dintersection de la courbe avec laxe des ordonnes.
3. Trouver les points en lesquels la tangente est verticale, puis horizontale.
4. Trouver les coordonnes des points doubles.
106
CALCUL FORMEL
107
1. La courbe a lallure dune boucle.

2. On dfinit x = t^3-2*t et y = t^2-t. On obtient les valeurs de t correspondant aux points dintersection de la courbe avec laxe (x = 0) en rsolvant lquation x(t) = 0 : solve(x==0,t). On obtient
p
p
p
p
trois solutions t { 2, 0, + 2} correspondant aux trois points {(0, 2 + 2), (0, 0), (0, 2 2)}
3. On dfinit les fonctions drives x 0 (t) et y 0 (t) par xx = diff(x,t) et yy = diff(y,t), les valeurs
de t pour lesquelles la tangente la courbe est verticale sobtiennent en rsolvant lquation x 0 (t) = 0,
ce qui scrit solve(xx==0,t).
4. Trouver les points doubles est souvent un calcul dlicat (mme pour un logiciel de calcul formel). Il
sagit ici de rsoudre le systme dquations polynomiales :
x(s) = x(t)
s, t R.
y(s) = y(t)
Mais il faut exclure la solution vidente t = s. Algbriquement cela signifie que (s t) divise les polynmes
de deux variables x(s) x(t) et y(s) y(t). Autrement dit, il sagit de rsoudre :
x(s) x(t) = 0
st
s, t R.
y(s) y(t) = 0
st
p
p
Le code suivant fournit la solution (s, t) = 12 5 , 1+2 5 , il y a un unique point double ayant pour
coordonnes (1, 1).
Code 105 (courbe.sage).
var('s,t')
x = t^3-2*t
y = t^2-t
eqx = x.subs(t=s) - x
# Equation x(s)-x(t)
eqxs = (eqx/(s-t)).simplify_rational() # (x(s)-x(t))/(s-t)
eqy = y.subs(t=s) - y
# Equation y(s)-y(t)
eqys = (eqy/(s-t)).simplify_rational() # (y(s)-y(t))/(s-t)
points_double = solve([eqxs==0,eqys==0], s,t) # Solutions
CALCUL FORMEL
108
6.7. La projection strographique

Soit S la sphre centre lorigine de R3 et de rayon 1. On note N = (0, 0, 1) le ple Nord. Soit P le
plan quatorial dquation (z = 0). La projection strographique est lapplication : S \ {N } P
qui un point S de la sphre associe le point P = (N S) P dfini par lintersection de la droite (N S)
avec le plan P .
1. En crivant la relation N P = k N S et sachant que P P , trouver k et en dduire P.

Vrifier ainsi que lapplication est dfinie par :
: S \ {N } P
Dfinir la fonction correspondante avec Sage.
(x, y, z) =
x
y
,
1z 1z
2. Dfinir et vrifier que lapplication inverse est :
2
2X 2Y
,
,1
: P S \ {N }
(X , Y ) =

avec = 1 + X 2 + Y 2

3. crire une fonction qui dessine une courbe paramtre C 0 : x(t), y(t) , t [a, b] du plan P , et qui
dessine aussi limage inverse de la courbe sur la sphre, C = (C 0 ).
4. Vrifier graphiquement deux proprits fondamentales de la projection strographique :
(a) La projection strographique envoie les cercles de la sphre sur des cercles ou des droites du
plan.
(b) La projection strographique prserve les angles. En particulier, deux courbes qui se coupent
angle droit, senvoient sur deux courbes qui se coupent angle droit.

5. Soit C 0 la spirale logarithmique dquation e t cos t, e t sin t , t R. Tracer la loxodromie de la sphre
qui est C = (C 0 ).

1
4t, 6t + 2, 13t 2 6t . Montrer que son image C 0 =
6. Soit la courbe C S dfinie par 13t 2 6t+2
(C ) P est une droite, dont vous dterminerez une quation.
1.
Le vecteur N P est colinaire au vecteur N S, donc il existe k R tel que N P = k N S. Mais en plus on
veut que P P , cest--dire z P = 0. Ce qui permet de trouver k et den dduire P = N + k N S. On laisse

Sage faire les calculs :
Code 106 (stereographic.sage (1)).
var('x,y,z')
var('X,Y')
var('k')
N = vector([0,0,1])
# Variables de l'espace
# Variables du plan
# Les points N, S, P comme des vecteurs
CALCUL FORMEL
S = vector([x,y,z])
P = vector([X,Y,0])
V = (P-N)-k*(S-N)
eq = V[2]
sol = solve(eq==0,k)
k = sol[0].rhs()
P = N + k*(S-N)
#
#
#
#
#
109
Le vecteur NP - k NS
On veut la troisime coordonne nulle
Equation en k pour cette condition
Solution k
Le point P

y
1
x
On obtient k = 1z
, et alors si S = (x, y, z), P = 1z
, 1z , 0 . En identifiant les points du plan R2 , on
y
x
a ainsi prouv (x, y, z) = 1z
, 1z . Do la dfinition de la fonction :
def stereo(x,y,z):
X = x/(1-z)
Y = y/(1-z)
return X,Y
2. Voici la fonction :
def inverse_stereo(X,Y):
r = 1+X^2+Y^2
x = 2*X/r
y = 2*Y/r
z = 1-2/r
return x,y,z
On profite du fait que lon nous donne le candidat, pour se contenter de vrifier que cest bien la bijection

rciproque, cest--dire (X , Y ) = (X , Y ) pour tout (X , Y ) R2 . La composition scrit
newx,newy,newz = inverse_stereo(X,Y)
newX,newY = stereo(newx,newy,newz)
et comme on obtient newX = X et newY = Y, cela prouve le rsultat.
Il est possible de composer les fonctions de plusieurs variables, mais il faut rajouter une * devant la
fonction composer :
stereo(*inverse_stereo(X,Y)))
cela renvoie X,Y ce qui prouve bien (X , Y ) = (X , Y ). (Loprateur * devant une liste permet
de la dcompacter, par exemple *(2,5,7) sinterprte comme 2,5,7 qui peut alors tre pass en
argument une fonction.)

Pour prouver (x, y, z) = (x, y, z), il faudrait se souvenir que (x, y, z) S , donc x 2 + y 2 + z 2 = 1.
3. Voici comment tracer les courbes. La courbe du plan est trace comme une ligne polygonale, avec un
pas assez petit. Ensuite on calcule limage par de chacun de ces points.
def courbes(X,Y,a,b):
CALCUL FORMEL
110
XYtab = [ [X.subs(t=myt),Y.subs(t=myt),0] for myt in srange(a,b,0.1) ]

xyztab = [ inverse_stereo(coord[0],coord[1]) for coord in XYtab ]
G = sphere((0,0,0),1)
G = G + line(XYtab)
G = G + line(xyztab)
return G

Par exemple G = courbes(t^3,t^2,-2,2), trace la courbe du plan dquation paramtrique t 3 , t 2 ,
t [2, 2], ainsi que son image par la projection strographique inverse.
Voici le cas dun cercle et dune droite du plan qui se coupent angle droit, de mme que les cercles de
la sphres.
4. Voici une loxodromie de la sphre, courbe utilise par les navigateurs, car elle correspond une navigation
cap constant.
5. Pour x, y, z dfinis par la paramtrisation, on calcule limage par la projection strographique avec
CALCUL FORMEL
7. CALCULS DINTGRALES
111
X,Y = stereo(x,y,z), on noublie pas de simplifier laide de full_simplify(). Cela donne une
paramtrisation de limage, x(t) = 2t, y(t) = 3t + 1, qui est bien lquation dune droite.
7. Calculs dintgrales
7.1. Sage comme une super-calculatrice
Calculer la main les primitives des fonctions suivantes. Vrifier vos rsultats lordinateur.
1. f1 (x) = x 4 +
1
+ exp(x) + cos(x)
x2
2
2. f2 (x) = x sin(x )
3. f3 (x) =
p
1x 2
4. f4 (x) =
x4
x 2 1
n
1+x 2
1+x
5. f5 (x) = x ln x pour tout n > 0

Pour une fonction f , par exemple f(x) = x*sin(x^2) donne, la commande integral(f(x),x) renvoie une primitive de f . Le rsultat obtenu ici est -1/2*cos(x^2).
Quelques remarques :
La machine renvoie une primitive. Pour avoir lensemble des primitives, il faut bien entendu ajouter une
constante.
usuel, habituellement note ln.
La fonction log est la fonction logarithme nprien
R dx
integral(1/x,x) renvoie log(x) alors que
x = ln |x|. Sage omet les valeurs absolues, ce qui ne
lempche pas de faire des calculs exacts mme pour les valeurs ngatives. (En fait Sage travaille avec
le logarithme complexe.).
Souvent, pour intgrer des fractions rationnelles, on commence par crire la dcomposition en lments
simples. Cest possible avec la commande partial_fraction. Par exemple pour f = x^4/(x^2-1)
1
1
la commande f.partial_fraction(x) renvoie la dcomposition sur Q : f (x) = x 2 +1 12 x+1
+ 12 x1
.
Calculer la main et lordinateur les intgrales suivantes.
Z3
p
1 p
3
1. I1 =
x 2 + x + + x dx
x
1
Z 2
sin x(1 + cos x)4 dx
2. I2 =
3. I3 =
0
p
4. I4 =
Z
0
sin3 x dx
3
3x 3 2x 2 5x 6
dx
(x + 1)2 (x 2 + 1)
Par exemple integral(sin(x)^3,x,0,pi/6) renvoie
2
3
p
3 3
8 .
CALCUL FORMEL
112
7.2. Intgration par parties

Pour chaque n > 0, nous allons dterminer une primitive de la fonction
f n (x) = x n exp(x).
1. Sage connat-il directement la formule ?
2. Calculer une primitive Fn de f n pour les premires valeurs de n.
3. (a) mettre une conjecture reliant Fn et Fn1 .
(b) Prouver cette conjecture.
(c) En dduire une fonction rcursive qui calcule Fn .
4. (a) mettre une conjecture pour une formule directe de Fn .
(b) Prouver cette conjecture.
(c) En dduire une expression qui calcule Fn .
1. La commande integral(x^n*exp(x),x) renvoie le rsultat (-1)^n*gamma(n + 1, -x). Nous ne
sommes pas tellement avancs ! Sage renvoie une fonction spciale que lon ne connat pas. En plus (
lheure actuelle, pour la version 6.6), driver la primitive avec Sage ne redonne pas la mme expression
que f n .
2. Par contre, il ny a aucun problme pour calculer les primitives Fn pour les premires valeurs de n. On
obtient :
F0 (x) = exp(x)
F1 (x) = (x 1) exp(x)
F2 (x) = (x 2 2x + 2) exp(x)
F3 (x) = (x 3 3x 2 + 6x 6) exp(x)
F4 (x) = (x 4 4x 3 + 12x 2 24x + 24) exp(x)
F5 (x) = (x 5 5x 4 + 20x 3 60x 2 + 120x 120) exp(x)
3. (a) Au vu des premiers termes, on conjecture Fn (x) = x n exp(x) nFn1 (x). On vrifie facilement sur
les premiers termes que cette conjecture est vraie.
Sage ne sait pas (encore) vrifier formellement cette identit (avec n une variable formelle). La
commande suivante choue trouver 0 :
integral(x^n*exp(x),x) - x^n*exp(x) + n*integral(x^(n-1)*exp(x),x)

(b) Nous prouverons la validit de cette formule en faisant une intgration par parties (on pose par
exemple u = x n , v 0 = exp(x) et donc u0 = nx n1 , v = exp(x)) :
Fn (x) =

x exp(x) dx = x exp(x)
n
nx n1 exp(x) dx = x n exp(x) nFn1 (x).
(c) Voici lalgorithme rcursif pour le calcul de Fn utilisant la relation de rcurrence.

Code 111 (integrales-ipp (1)).
def FF(n):
if n==0:
return exp(x)
else:
return x^n*exp(x) - n*FF(n-1)
CALCUL FORMEL
113
4. Avec un peu de rflexion, on conjecture la formule

n
X
n!
Fn (x) = exp x
(1)nk x k
k!
k=0
o
n!
k!
= n(n 1)(n 2) (k + 1).
Pour la preuve, on pose Gn (x) = exp(x)

Gn (x) = exp(x)
Pn
k=0 (1)
nk n! k
k! x .
On a
n1
X
n!
(1)nk x k + exp(x)x n = nGn1 (x) + exp(x)x n .
k!
k=0
Ainsi Gn vrifie la mme relation de rcurrence que Fn . De plus G0 (x) = exp x = F0 (x). Donc pour tout
n, Gn = Fn .
On peut donc ainsi calculer directement notre intgrale par la formule :
exp(x)*sum((-1)^(n-k)*x^k*factorial(n)/factorial(k),k,0,n)
7.3. Changement de variable

Soit f une fonction dfinie sur un intervalle I et : J I une bijection de classe C 1 . La formule de
changement de variable pour les primitives est :
Z
Z

f (x) dx =
f (u) 0 (u) du.
La formule de changement de variable pour les intgrales, pour tout a, b I, est :
Z b
Z 1 (b)

f (x) dx =
f (u) 0 (u) du.
a
1 (a)

Z
1. Calcul de la primitive
1 x 2 dx.
p
1 x 2 et le changement de variable x = sin u, cest--dire on pose (u) = sin u.

(b) Calculer f (u) et 0 (u).

(c) Calculer la primitive de g(u) = f (u) 0 (u).
p
(d) En dduire une primitive de f (x) = 1 x 2 .
Z
dx
2. Calcul de la primitive
1/3 .
1 + x+1
x
(a) Poser f (x) =
(a) Poser le changement de variable dfini par lquation u3 =
x+1
x .
(b) En dduire le changement de variable (u) et 1 (x).

3. crire une fonction integrale_chgtvar(f,eqn) qui calcule une primitive de f (x) par le changement de variable dfini par lquation eqn reliant u et x.
Z
En dduire
(cos x + 1)n sin x dx, en posant u = cos x + 1.
4. Mme travail avec integrale_chgtvar_bornes(f,a,b,eqn) qui calcule lintgrale de f (x) entre

a et b par changement de variable.
Z 4
dx
En dduire
, en posant u = tan x.
2
0 2 + sin x
p
1. (a) La fonction est f (x) = 1 x 2 et on pose la fonction (u) = sin u, cest--dire que lon espre que
le changement de variable x = sin u va simplifier le calcul de lintgrale :
f = sqrt(1-x^2)
phi = sin(u)
CALCUL FORMEL
114

p
(b) On obtient f (u) en substituant la variable x par sin u : cela donne f (u) = 1 sin2 u =
p
cos2 u = | cos u|. Ce qui sobtient par la commande frondphi = f(x=phi) (puis en simplifiant).
(Notez que Sage oublie les valeurs absolues, car il calcule en fait la racine carre complexe et pas
relle. Ce sera heureusement sans consquence pour la suite. En effet pour que f (x) soit dfinie, il
faut x [1, 1], comme x = sin u alors u [ 2 , 2 ] et donc cos u > 0.) Enfin 0 (u) = cos u sobtient
par dphi = diff(phi,u).
R

1+cos(2u)
sin(2u)
(c) On pose g(u) = f (u) 0 (u) = cos2 u =
. Donc g(u) du = 2u + 4 .
2
(d) Pour obtenir une primitive de f , on utilise la formule de changement de variable :
Z
Z
Z
p
u sin(2u)
1 x 2 dx =
f (x) dx = g(u) du = +
.
2
4
Mais il ne faut pas oublier de revenir la variable x, Comme x = sin u alors u = arcsin x, donc
Z
p
arcsin x sin(2 arcsin x)
1 x 2 dx =
+
.
2
4
Les commandes sont donc G = integral(g,u) puis F = G(u = arcsin(x)) donne la primitive
recherche. Aprs simplification de sin(2 arcsin x), on obtient :
Z
p
arcsin x x p
1 x 2 dx =
+
1 x 2.
2
2
R
x+1
dx
3
2. Pour calculer la primitive
1/3 , lnonc nous recommande le changement de variable u =
x . La
1+( x+1
)
x
seule difficult supplmentaire est quil faut exprimer x en fonction de u et aussi u en fonction de x. Pour
cela on dfinit lquation u^3 == (x+1)/x reliant u et x : eqn = u^3 == (x+1)/x. On peut maintenant rsoudre lquation afin dobtenir (u) (x en fonction de u) : phi = solve(eqn,x)[0].rhs()
et 1 (x) (u en fonction de x) : phi_inv = solve(eqn,u)[0].rhs(). Le reste se droule comme
prcdemment.
3. On automatise la mthode prcdente :
Code 112 (integrales-chgtvar (1)).
def integrale_chgtvar(f,eqn):
phi = solve(eqn,x)[0].rhs()
phi_inv = solve(eqn,u)[0].rhs()
frondphi = f(x=phi)
dphi = diff(phi,u)
g = frondphi*dphi
g = g.simplify_full()
G = integral(g,u)
F = G(u = phi_inv)
F = F.simplify_full()
return F
Ce qui sutilise ainsi :
Code 113 (integrales-chgtvar (2)).
f = (cos(x)+1)^n*sin(x)
eqn = u == cos(x)+1
integrale_chgtvar(f,eqn)
#
#
#
#
#
x en fonction de u : fonction phi(u)=x

u en fonction de x : inverse de phi : phi_inv(x
la fonction f(phi(u))
sa drive
la nouvelle fonction g(u)
# g doit tre plus facile intgrer

# on revient la variable x
CALCUL FORMEL
8. POLYNMES
115
Et montre que
Z
(cos x + 1)n sin x dx =
1
(cos x + 1)n+1 .
n+1
4. Pour la formule de changement de variable des intgrales, on adapte la procdure prcdente en calculant
R 1 (b)
lintgrale 1 (a) g(u) du.
Pour cela on calcule 1 (a) (par a_inv = phi_inv(x=a)) et 1 (b) (par b_inv = phi_inv(x=b)).
R dx
1
Pour calculer 04 2+sin
(x) = tan x. Nous
2 , on pose u = tan x. Donc x = (u) = arctan u et u =
x
1
1
avons 0 (u) = 1+u
(a) = tan 0 = 0 et comme b =
2 . Dautre part, comme a = 0 alors
1
(b) = tan 4 = 1. Ainsi la formule de changement de variable :
Z b
Z 1 (b)

f (x) dx =
f (u) 0 (u) du
I=
alors
1 (a)
devient
1
2 + sin x
2
dx =
1
du.
2 + sin (arctan u) 1 + u2
2
u
1+u2
Mais sin (arctan u) =

donc
Z1
Z1

p 1
p
1
1
1
du
6
1
6
.
I=
du
=
du
=
=
arctan
arctan
p
p
2
2
2
u
2
2
6
6
0 2 + 1+u2 1 + u
0 2 + 3u
0
2
Ce que lordinateur confirme !
8. Polynmes
8.1. Manipuler les polynmes
Soient P(X ) = X 4 3X 2 1, Q(X ) = (X + 1)4 des polynmes de Q[X ]. Aprs avoir dclar lanneau des
polynmes Q[X ] par R.<X> = QQ[] (o QQ dsigne le corps des rationnels), rpondre aux questions
suivantes :
1. Est-ce que deg(P Q) = deg P + deg Q ?
2. Est-ce que deg(P Q) = max(deg P, deg Q) ?
3. Dvelopper Q. Quel est le coefficient devant X 3 ?
4. Quel est le quotient de la division euclidienne de P par (X + 1)2 ? Et le reste ?
5. Quelles sont les racines de Q ? Et celles de P ?
1. (et 2.) La commande degree() permet dobtenir le degr ; ainsi, aprs avoir dclar lanneau de
polynmes Q[X ] et avoir dfini les deux polynmes P et Q, on teste les galits sur les degrs.
Code 114 (intro-polynome.sage (1)).
R.<X> = QQ[]
P = X^4-3*X^2-1
Q = (X+1)^4
(P*Q).degree() == P.degree() + Q.degree()
(P-Q).degree() == max(P.degree(),Q.degree())
CALCUL FORMEL
8. POLYNMES
116
La premire galit est vraie, par contre la seconde est fausse (il ny a pas toujours galit des degrs).
Les noncs vrais en toute gnralit pour des polynmes non nuls sont :
deg(P Q) = deg P + deg Q
et
deg(P + Q) 6 max(deg P, deg Q)
3. On dveloppe un polynme par expand(Q). On rcupre les coefficients comme si le polynme tait
une liste : Q[k] renvoie le coefficient ak devant X k .
4. On obtient le quotient et le reste comme avec les entiers. Le quotient P // (X+1)^2 vaut X 2 2X . Le
reste P % (X+1)^2 vaut 2X 1.
5. La question est ambige ! Il faut prciser dans quel ensemble on cherche les racines. Est-ce dans Q, R ou
C ? Souhaitons-nous une racine exacte ou approche ?
P.roots() : renvoie les racines du corps de base (ici Q). Renvoie ici une liste vide car P na pas de
racines rationnelles.
Q.roots() renvoie [(-1, 4)] car 1 est une racine de multiplicit 4.
P.roots(QQbar) : racines exactes dans C (pour un polynme coefficients dans Q). Ici renvoie deux
racines relles et deux racines imaginaires pures : -1.817354021023971?, 1.817354021023971?,
-0.5502505227003375?*I, 0.5502505227003375?*I. Le point dinterrogation en fin dcriture
signifie que Sage calcule avec les valeurs exactes, mais naffiche que les premires dcimales.
P.roots(RR) : racines relles approches : -1.81735402102397, 1.81735402102397. On quitte
donc la rsolution formelle pour une rsolution numrique approche.
P.roots(CC) : racines complexes approches.
Pour un polynme P C[X ] et un rel r > 0, tracer limage par P du cercle centr lorigine de C et
de rayon r.
Faites varier r (ou mieux faites une animation). En quoi cela illustre-t-il le thorme de dAlembertGauss ?
Application P(X ) = X 4 X 3 + X 2 i X + 1 C[X ].
Voici quelques images de lanimation pour des valeurs de r valant successivement : r0 = 0.5, r1 = 0.6176 . . .,
r2 = 0.9534 . . ., r3 = 1.2082 . . ., r4 = 1.4055 . . . et r5 = 1.5.
CALCUL FORMEL
8. POLYNMES
117
Quand la courbe C r passe-t-elle par lorigine ? La courbe passe par lorigine sil existe un nombre complexe
r ei t tel que P(r ei t ) = 0 autrement dit lorsque P admet une racine de module r. Daprs le thorme de
dAlembert-Gauss un polynme de degr n a au plus n racines. Alors il y a au plus n valeurs r1 , . . . , rn pour
lesquelles C ri passe par lorigine. Pour notre exemple de degr 4, il y a 4 racines, qui conduisent ici 4
modules distincts, r1 , . . . , r4 .
Voici comment procder :
On commence par dfinir lanneau C[X ] par R.<X> = CC[]. Les calculs seront donc des calculs approchs avec des nombres complexes. Notre polynme P est dfini par P = X^4-X^3+X^2-I*X+1.
Le cercle de rayon r est lensemble des complexes de la forme r ei t pour t [0, 2]. La courbe C r
cherche est donc lensemble

C r = P(r ei t ) | t [0, 2] .
Voici la fonction qui renvoie ce trac :
def plot_image_cercle(P,r):
var('t')
zreal = P(r*exp(I*t)).real()
zimag = P(r*exp(I*t)).imag()
G = parametric_plot( (zreal,zimag), (t,0,2*pi) )
return G
Une animation est une juxtaposition dimages. On la dfinit par :
A = animate( [plot_image_cercle(P,r) for r in srange(0.5,1.5,0.05)] )

puis on laffiche par A.show().
Remarque.
Par dfaut Sage fait les calculs dans un ensemble appel SR (Symbolic Ring). Dans cet ensemble vous
pouvez dfinir des expressions polynomiales et en trouver les racines. Laccs aux fonctions spcifiques aux
polynmes (comme le degr, les coefficients,...) est un peu diffrent. Voici comment dclarer un polynme,
rcuprer son degr ainsi que le coefficient devant X 2 :
var('X')
P = X^4-3*X^2-1
P.degree(X)
P.coefficient(X,2)
8.2. Algorithme de Horner

Lalgorithme de Horner permet dvaluer rapidement un polynme P en une valeur . Voyons comment il
fonctionne la main avec lexemple de P(X ) = X 5 + X 4 5X 3 3X 2 et = 2.
Sur la premire ligne du tableau, on crit les coefficients de P, an , an1 , . . . , a1 , a0 . On reporte en troisime
ligne premire colonne, an , le coefficient dominant de P. On multiplie ce nombre par , on lcrit en deuxime
ligne, deuxime colonne, puis on ajoute an1 que lon crit en troisime ligne, deuxime colonne. Et on
recommence. chaque tape, on multiplie le dernier nombre obtenu par et on lui ajoute un coefficient de
P. Le dernier nombre obtenu est P().
CALCUL FORMEL
ak
8. POLYNMES
=2
bk
+ak
+ak
118
Ici le dernier nombre est 0, donc P(2) = 0. Conclusion : 2 est racine de P.

Avec le mme polynme et = 1 le tableau se complte ainsi :
ak
= 1
bk
ce qui implique P(1) = 6.

Le travail faire suivant formalise cette procdure et montre que lalgorithme de Horner permet des calculs
efficaces avec les polynmes.
On fixe un corps K, et K. Soit P(X ) = an X n + an1 X n1 + + ak X k + + a1 X + a0 K[X ].
On pourra prendre pour les applications P(X ) = X 5 + X 4 5X 3 3X 2 et = 2, puis = 1.
1. Compter et comparer le nombre de multiplications ncessaires dans K pour calculer P(), par :
(a) le calcul direct :
P() = an n + an1 n1 + + ak k + + a1 + a0 ,
(b) lalgorithme de Horner :
P() =

(an + an1 ) + an2 + + a1 + a0 .
(c) crire une fonction qui calcule P() par lalgorithme de Horner.
2. On formalise le calcul prcdent en dfinissant la suite :
bn = an
puis pour
n 1 > k > 0 : bk = bk+1 + ak .
(a) Montrer que dans la division euclidienne de P(X ) par X qui scrit :
P(X ) = (X )Q(X ) + P()
le reste P() est gal b0 et le quotient Q(X ) est gal au polynme bn X n1 + + b2 X + b1 dont
les coefficients sont les bk pour k > 1.
Indications. Pour ce faire dvelopper (X )Q(X ) et retrouver pour les coefficients de Q la mme
relation de rcurrence que celle dfinissant la suite des bk .
(b) Modifier votre fonction afin quelle calcule la suite (bn , bn1 , . . . , b1 , b0 ) et quelle renvoie le
quotient Q et le reste b0 = P().
(c) crire une fonction qui calcule lexpression dun polynme P(X ) dans la base des (X )k ,
cest--dire calculer les ck K tels que :
P(X ) = cn (X )n + cn1 (X )n1 + + c1 (X ) + c0 .
1. (a) Le calcul dun monme ak k de degr k ncessite k multiplications, donc pour calculer P() il faut
n(n+1)
n + (n 1) + + k + + 1 + 0 = 2 multiplications (et n additions).
CALCUL FORMEL
8. POLYNMES
119
(b) La mthode de Horner

P() =

(an + an1 ) + an2 + + a1 + a0 .
ncessite seulement n multiplications (et n additions). On passe dun cot dordre 12 n2 un cot
dordre n ; le gain est donc norme.
(c) Pour limplmentation, on note que la formule de rcurrence se fait pour des indices k allant en
dcroissant.
Code 117 (horner.sage (1)).
def eval_horner(P,alpha):
n = P.degree()
val = P[n]
for k in range(n-1,-1,-1):
val = alpha*val + P[k]
return val
2. (a) On note la division euclidienne de P(X ) par X sous la forme P(X ) = (X )Q(X )+R. Le polynme
Q est de degr n 1 et on le note Q(X ) = bn0 X n1 + + bk0 X k1 + + b20 X + b10 (on veut montrer
bk0 = bk ). Le reste R est de degr strictement infrieur deg(X ) = 1 donc R est un polynme
constant. En valuant lgalit de la division euclidienne en , on a immdiatement P() = R, que
lon note pour linstant b00 .
Lgalit P(X ) = (X )Q(X ) + R scrit :

P(X ) = (X ) bn0 X n1 + + bk0 X k1 + + b20 X + b10 + b00 .
On dveloppe le terme de droite et on regroupe les monmes de mme degr :
0
0
P(X ) = bn0 X n + (bn1
bn0 )X n1 + + (bk0 bk+1
)X k + + (b10 b20 )X + (b00 b10 )
On identifie coefficient par coefficient :
bn0 = an
bn1 bn0 = an1
0
0
b
b
= ak
k
k+1
0
0
b0 b1 = a0
donc
bn0
bn10
bk0
b00
=
=
an
bn0 + an1
0
bk+1
+ ak
b10 + a0
Les suites (bk0 ) et (bk ) sont dfinies par le mme terme initial an et la mme relation de rcurrence,
elles sont donc gales.
(b) On modifie lgrement le code prcdent. La suite (bn , bn1 , . . . , b1 ) donne les coefficients de Q
(attention au dcalage) et b0 donne le reste qui nest autre que P().
def division_horner(P,alpha):
n = P.degree()
if n <= 0: return 0,P
b = [None] * (n+1)
# Liste triviale de longueur n+1
b[n] = P[n]
for k in range(n-1,-1,-1):
b[k] = alpha*b[k+1] + P[k]
Q = sum( b[k+1]*X^k for k in range(0,n) )
R = b[0]
CALCUL FORMEL
8. POLYNMES
120
return Q,R
Pour notre polynme P(X ) = X 5 + X 4 5X 3 3X 2 et = 2, lappel de la fonction dfinie
ci-dessus : division_horner(P,alpha) renvoie un reste R nul et un quotient Q(X ) = X 4 +
3X 3 + X 2 + 2X + 1. Ce qui signifie que X 2 divise P(X ), ou encore P(2) = 0.
Pour ce mme polynme et = 1, la commande division_horner(P,alpha) renvoie
Q(X ) = X 4 5X 2 + 5X 8 et un reste R = 6.
(c) On obtient les ck comme restes de divisions euclidiennes successives par X . On commence par
la division euclidienne de P(X ) par X . On a vu comment calculer le quotient Q 1 et le reste
b0 = P(). En valuant lexpression P(X ) = cn (X )n + + c1 (X ) + c0 en on voit que lon a
aussi c0 = P() donc c0 est le reste de la premire division par X .
On a donc P(X ) = (X )Q 1 (X ) + c0 . On recommence en divisant Q 1 par X , on obtient un

quotient Q 2 et un reste qui va tre c1 . Donc P(X ) = (X ) (X )Q 2 + c1 + c0 .
On continue ainsi de suite jusqu ce que le quotient soit nul (au bout de n + 1 tapes), on a alors

P(X ) = (cn (X ) + cn1 )(X ) + cn2 (X ) + c1 (X ) + c0
soit en dveloppant :
P(X ) = cn (X )n + + c1 (X ) + c0
Le code suivant renvoie les coefficients (c0 , c1 , . . . , cn ).
def developpe_horner(P,alpha):
Q = P
coeff = []
while Q != 0:
Q,R = division_horner(Q,alpha)
coeff.append(R)
return coeff
Pour P(X ) = X 5 + X 4 5X 3 3X 2 et = 2, la commande developpe_horner(P,alpha)
renvoie la liste [0, 49, 74, 43, 11, 1], ce qui signifie :
P(X ) = 1 (X 2)5 + 11 (X 2)4 + 43 (X 2)3 + 74 (X 2)2 + 49 (X 2).
Pour le mme polynme et = 1, la fonction renvoie [6, -17, 11, 1, -4, 1], donc
P(X ) = 1 (X + 1)5 4 (X + 1)4 + 1 (X + 1)3 + 11 (X + 1)2 17 (X 2) + 6.
8.3. Interpolation de Lagrange

Thorme 1 (Interpolation de Lagrange).
Soient (x i , yi ), i = 0, . . . , n, une suite de n + 1 points, dabscisses deux deux distinctes. Il existe un unique
polynme P de degr infrieur ou gal n tel que
P(x i ) = yi
pour i = 0, . . . , n.
En particulier, pour toute fonction f continue sur un intervalle contenant x 0 , . . . , x n , il existe un unique
polynme P de degr infrieur ou gal n tel que
P(x i ) = f (x i )
pour i = 0, . . . , n.
CALCUL FORMEL
8. POLYNMES
121

1. Montrer lunicit du polynme P dans le thorme dinterpolation de Lagrange.
2. Pour lexistence, tant donns x 0 , . . . , x n , on dfinit les polynmes de Lagrange L0 , L1 , . . . , L n :
Y X xj
L i (X ) =
x xj
j6=i i
Montrer que le polynme :
P(X ) =
n
X
yi L i (X )
i=0
rpond au problme : P(x i ) = yi (i = 0, . . . , n) et deg P 6 n.

3. crire une fonction qui, tant donne une liste de points, renvoie le polynme dinterpolation P.
4. Interpoler la fonction dfinie par f (x) = sin(2x)ex sur lintervalle [0, 2], avec une subdivision
rgulire de n + 1 points. Tracer les graphes de la fonction f et des polynmes dinterpolation
correspondant diffrentes valeurs de n.
1
5. Faire le mme travail avec la fonction dfinie par f (x) = 1+8x
2 sur lintervalle [1, 1], avec une
subdivision rgulire de n + 1 points. Quel problme apparat ? Cest le phnomne de Runge.
1. Supposons que P et Q soient deux polynmes de degr 6 n vrifiant tous les deux P(x i ) = yi . Alors le
polynme P Q vrifie (P Q)(x i ) = 0, i = 0, . . . , n. Ainsi P Q est un polynme de degr infrieur n
ayant n + 1 racines. Daprs le thorme de dAlembert-Gauss, cest ncessairement le polynme nul.
Ainsi P Q = 0, donc P = Q.
2. Les polynmes L i sont de degr exactement n et sont dfinis de sorte que
L i (x i ) = 1 et L i (x j ) = 0 pour j 6= i.
Pn
Il est alors clair que P(X ) = j=0 y j L j (X ) est aussi de degr infrieur n et vrifie pour i = 0, . . . , n :
P(x i ) =
n
X
y j L j (x i ) = yi L i (x i ) = yi .
j=0
3. On commence par dfinir :

R.<X> = RR[] : lanneau de polynmes (les coefficients sont des rels approchs) ;
f = sin(2*pi*x)*exp(-x) : la fonction ;
liste_points = [ (2*i/n, f(x=2*i/n)) for i in range(n+1) ] : une liste de points
du graphe de f .
La fonction suivante renvoie le polynme interpolateur dune liste de points.
Code 120 (interpolation.sage).
def interpolation_lagrange(liste_points):
n = len(liste_points)-1
allx = [p[0] for p in liste_points] # Abscisses
ally = [p[1] for p in liste_points] # Ordonnes
liste_lagrange = []
for i in range(n+1):
A = prod(X-x for x in allx if x != allx[i])
# Numrateur
B = prod(allx[i]-x for x in allx if x != allx[i]) # Dnominateur
L = A/B
# Polynme de Lagrange
liste_lagrange.append(L)
# Le polynme interpolateur :
lagrange = sum( liste_lagrange[i]*ally[i] for i in range(n+1) )
CALCUL FORMEL
9. QUATIONS DIFFRENTIELLES
122
return lagrange
4. Voici les tracs (en rouge la fonction, en bleu le polynme) pour linterpolation de f (x) = sin(2x)ex
avec n = 3, 4, 5, 6, 7, 8. Pour n = 4, le polynme est le polynme nul. partir de n = 8, il devient difficile
de distinguer le graphe de la fonction, du graphe du polynme.
1
5. Voici linterpolation de f (x) = 1+8x
2 pour n = 7, 10, 18. La zone centrale de la courbe est bien interpole
mais autour de 1 et +1, des bosses apparaissent. Ces bosses deviennent de plus en plus grandes en
se dcalant vers les extrmits. Il y a convergence simple mais pas convergence uniforme. Pour viter ce
phnomne, il faudrait mieux choisir les x i .
9. quations diffrentielles
9.1. quations diffrentielles y 0 = f (x, y)
La commande desolve permet de rsoudre formellement des quations diffrentielles. Consultez la
documentation, accessible par help(desolve).
1. (a) Rsoudre lquation diffrentielle :
y 0 = y + x + 1.
Il sagit donc de trouver toutes les fonctions x 7 y(x) drivables, telles que y 0 (x) = y(x) + x + 1,
pour tout x R.
(b) Rsoudre lquation diffrentielle avec condition initiale :
y0 = y + x + 1
et
y(0) = 1.
2. (a) Rsoudre sur R+ lquation diffrentielle :

x 2 y 0 = (x 1) y.
CALCUL FORMEL
123
(b) Trouver la solution vrifiant y(1) = 2.

(c) Peut-on trouver une solution sur R ?
3. Calculer la fonction logistique y(x), solution de lquation diffrentielle
y 0 = y(1 y) 1.
1.
Code 121 (equadiff-intro.sage (1)).
var('x')
y = function('y',x)
yy = diff(y,x)
desolve(yy == y+x+1, y)
desolve(yy == y+x+1, y, ics=[0,1])
(a) On commence par dclarer la variable x. On dfinit une fonction x 7 y(x) ainsi que sa drive
y 0 (x) par diff(y,x). On prendra ici la convention de noter y 0 par yy. Lquation diffrentielle
y 0 = y + x + 1 scrit donc yy == y+x+1. On lance la rsolution de lquation diffrentielle par la
fonction desolve, avec pour argument lquation diffrentielle rsoudre, ainsi que la fonction
inconnue, qui est ici y. Sage renvoie :
-((x + 1)*e^(-x) - _C + e^(-x))*e^x
_C dsigne une constante. Aprs simplification vidente, les solutions sont les :
y(x) = x 2 + C exp(x)
C R.
(b) Il est possible de prciser une condition initiale grce largument optionnel ics (voir la dernire
ligne du code ci-dessus), ici on spcifie donc que lon cherche la solution vrifiant y(0) = 1. Lunique
solution est alors : y(x) = x 2 + 3 exp(x), cest--dire C = 3.
2.
equadiff = x^2*yy
assume(x>0)
desolve(equadiff,
desolve(equadiff,
forget()
assume(x<0)
desolve(equadiff,
== (x-1)*y
y)
y, ics=[1,2])
y)
(a) En se restreignant R+ (x > 0), on trouve y(x) = C x exp( 1x ), C R.

(b) La solution vrifiant y(1) = 2 est y(x) = 2x exp( 1x 1), cest--dire C = 2 exp( 1e ).
(c) Sur R (x < 0), les solutions sont aussi de la forme y(x) = C x exp( 1x ).
La seule solution dfinie sur R est donc la fonction nulle y(x) = 0 (et C = 0). En effet si C 6= 0 il ny
a pas de limite finie en 0.
3.
CALCUL FORMEL
124
equadiff = yy == y*(1-y) - 1
sol_impl = desolve(equadiff, y)
sol = solve(sol_impl,y)
Sage ne rsout pas directement cette quation diffrentielle. En effet, il renvoie une quation vrifie
par y :

2p
1p
3 arctan
3 2 y (x) 1 = C + x.
3
3
On demande alors Sage de rsoudre cette quation, pour obtenir :
p
p
p
1
3
3
3
y (x) =
tan
C+
x + .
2
2
2
2
(1)
(2)
Lquation (1) a lavantage dtre valide quel que soit x, alors que pour lquation (2) il faudrait prciser
lintervalle de dfinition.
9.2. Interprtation gomtrique

Les courbes intgrales dune quation diffrentielle y 0 = f (x, y) sont les graphes des solutions de cette
quation.
chaque point dune courbe intgrale, on associe un vecteur tangent. Si y(x) est une solution de
lquation diffrentielle alors au point (x, y(x)) la tangente est porte par le vecteur (x 0 , y 0 (x)). Dune
part x 0 = 1 et dautre part comme y est solution de lquation diffrentielle alors y 0 (x) = f (x, y). Ainsi

un vecteur tangent en (x, y) est 1, f (x, y) .
Le champ de vecteurs associ lquation diffrentielle y 0 = f (x, y) est, en chaque point (x, y) du plan,
le vecteur 1, f (x, y) .
Voici ce qui signifie gomtriquement rsoudre une quation diffrentielle. partir dun champ de
vecteur, cest--dire la donne dun vecteur attach chaque point du plan, il sagit de trouver une courbe
intgrale, cest--dire une courbe qui en tout point est tangente aux vecteurs.
Comme on ne soccupera pas de la norme des vecteurs, la donne dun champ de vecteur revient ici
associer chaque point, la pente de la tangente au graphe dune solution passant par ce point.
Nous allons tudier graphiquement lquation diffrentielle
y 0 = x y.
1. Reprsenter le champ de vecteurs associ cette quation diffrentielle.
2. (a) Rsoudre lquation.
(b) Tracer, sur un mme graphe, les courbes intgrales correspondant aux solutions dfinies par
y(0) = k, pour diffrentes valeurs de k R.
(c) Que remarquez-vous ? Quel thorme cela met-il en vidence ?
3. Tracer quelques isoclines de cette quation diffrentielle.
CALCUL FORMEL
125
Les isoclines de lquation diffrentielle y 0 = f (x, y) sont les courbes sur lesquelles la tangente dune courbe
intgrale a une pente donne c, cest--dire quune isocline est un ensemble

(x, y) R2 | f (x, y) = c .
ne pas confondre avec les solutions ! En chaque point dune isocline, la solution passant par ce point croise
cette isocline avec une pente c.
Voici quelques graphes :
Le champ de vecteurs (en rouge).
Les courbes intgrales (en bleu).
Le champ de vecteurs superpos aux courbes intgrales : les vecteurs sont bien tangents aux courbes
intgrales.
Les isoclines (en vert). Pour une isocline fixe, vrifier que chaque intersection avec les courbes intgrales
se fait en des points o la tangente a toujours la mme pente.
1. Voici comment tracer le champ de vecteurs associ y 0 = f (x, y).

Code 124 (equadiff-courbe.sage (1)).
def champ_vecteurs(f,xmin,xmax,ymin,ymax,delta):
G = Graphics()
for i in srange(xmin, xmax, delta):
for j in srange(ymin, ymax, delta):
pt = vector([i,j])
v = vector([1,f(u=i,v=j)])
G = G + arrow(pt,pt+v)
return G
Les variables de la fonction f sont ici u et v pour ne pas interfrer avec la variable x et la fonction y.
Nhsitez pas renormaliser les vecteurs v, (par exemple en v/10) pour plus de lisibilit.
En fait la fonction plot_vector_field, prdfinie dans Sage, trace aussi les champs de vecteurs.
CALCUL FORMEL
126
2. (a) Les solutions de lquation sont les

x2
y(x) = C exp
2

o
C R.
(b) Le code suivant rsout lquation diffrentielle et trace la solution avec la condition initiale y(0) = k,
pour k variant de ymin ymax avec un pas de delta.
Code 125 (equadiff-courbe.sage (2)).
def courbes_integrales(equadiff,a,b,kmin,kmax,delta):
G = Graphics()
for k in srange(kmin, kmax, delta):
sol = desolve(equadiff, y, ics=[0,k])
G = G + plot(sol, (x, a, b))
return G
(c) Les courbes intgrales forment une partition de lespace : par un point il passe exactement une courbe
intgrale. Cest une consquence du thorme dexistence et dunicit de Cauchy-Lipschitz.
3. Les isoclines sont dfinies par lquation f (x, y) = c. Elles se tracent par la commande
implicit_plot(f-c, (x,xmin,xmax), (y,ymin, ymax))
Ici les isoclines ont pour quation x y = c, ce sont donc des hyperboles.
9.3. quations diffrentielles du second ordre

Lquation diffrentielle
k
x(t) = 0
m
correspond au mouvement dune masse m attache un ressort de constante k > 0 et des frottements
f > 0.
x 00 (t) + f x 0 (t) +
Rsoudre et tracer les solutions pour diffrentes valeurs de f > 0 (prendre k = 1, m = 1), avec les
conditions initiales :
x(0) = 1
et
x 0 (0) = 0.
Pour une valeur de f , lquation se rsout par :
desolve(diff(x,t,2) + f*diff(x,t) + k/m*x(t) == 0, x, ics=[0,1,0])

Voici les solutions pour f = 0, f = 1, f = 2 :
CALCUL FORMEL
Cas f = 0. Il ny a pas de frottement. Lquation diffrentielle scrit x 00 +

alors lquation est juste x 00 + x = 0 dont les solutions sont de la forme
x(t) = cos t + sin t
k
mx
127
= 0. Pour k = 1, m = 1
, R.
Avec les conditions initiales x(0) = 1 et x 0 (0) = 0, lunique solution est

x(t) = cos t.
Il sagit donc dun mouvement priodique.
Cas 0 < f < 2. Les frottements sont faibles. Par exemple pour f = 1 la solution est
p
p
p
1
3
3
3
sin
t + cos
t
e 2 t .
3
2
2
Il sagit dun mouvement amorti oscillant autour de la position dorigine x = 0.
Cas f > 2. Les frottements sont forts. Par exemple pour f = 2 la solution est
x(t) = (t + 1)et .
Il ny a plus doscillations autour de la position dorigine.
Auteurs du chapitre
Arnaud Bodin, Niels Borne, Franois Recher
Daprs un cours de calcul formel de Sad Belmehdi, Jean-Paul Chehab, Bernard Germain-Bonne, Franois
Recher donn luniversit Lille 1.
Relu par Marc Mezzarobba et Paul Zimmermann.
Les auteurs
Ce livre est diffus sous la licence Creative Commons BY-NC-SA 3.0 FR. Sur le site Exo7 vous pouvez le
tlcharger gratuitement et aussi rcuprer les fichiers sources.
Version 0.1 Juin 2016

Livre Algorithmes

Hochgeladen von

Dokumentinformationen

Copyright

Verfügbare Formate

Dieses Dokument teilen

Dokument teilen oder einbetten

Freigabeoptionen

Stufen Sie dieses Dokument als nützlich ein?

Sind diese Inhalte unangemessen?

Copyright:

Verfügbare Formate

Livre Algorithmes

Hochgeladen von

Copyright:

Verfügbare Formate

ALGOR I T H M E S

Zros des fonctions

partie 1. Premiers pas avec Python

1. Premiers pas avec Python

1.1. Hello world !

1. PREMIERS PAS AVEC Python 2

On affiche un message avec la fonction print().

1.2. Somme des cubes

donc nous navons pas besoin de faire une boucle :

Code 3 (somme-cubes.py (2)).

1. PREMIERS PAS AVEC Python 3

somme = somme + i**3

par exemple pour n = 12 :

Code 5 (somme-cubes.py (4)).

1.3. Calcul de au hasard

1. PREMIERS PAS AVEC Python 4

4. En dduire les premires dcimales de .

# Module qui gnre des nombres alatoires

while (Tir < 1000):

de tomber dans le disque est 4 .

1.4. Un peu plus sur Python

2. CRITURE DES ENTIERS

2. criture des entiers

2.1. Division euclidienne et reste, calcul avec les modulo

o q Z est le quotient et r N est le reste.

2. CRITURE DES ENTIERS

2.2. criture des nombres en base 10

2. CRITURE DES ENTIERS

Code 9 (decimale.py (2)).

2.3. Module math

2. CRITURE DES ENTIERS

log x logarithme dcimal

cos(x), sin(x), tan(x)

cos x, sin x, tan x en radians

acos(x), asin(x), atan(x)

arccos x, arcsin x, arctan x en radians

partie entire E(x) :plus grand entier n 6 x (floor = plancher)

plus petit entier n > x (ceil = plafond)

2.4. criture des nombres en base 2

(avec un indice b pour indiquer que cest son criture binaire).

2. CRITURE DES ENTIERS

Code 10 (binaire.py (1)).

est cod [1, 0, 0, 1, 0, 1, 1, 1] ce qui correspond au nombre binaire 11101001 b = 233.

2. CRITURE DES ENTIERS

Code 12 (binaire.py (3)).

3. CALCULS DE SINUS, COSINUS, TANGENTE

3. Calculs de sinus, cosinus, tangente

3.1. Calcul de Arctan x

3. CALCULS DE SINUS, COSINUS, TANGENTE

3.2. Calcul de tan x

3. CALCULS DE SINUS, COSINUS, TANGENTE

# boucle tant que la precision pas atteinte

3. CALCULS DE SINUS, COSINUS, TANGENTE

# on retire l'angle theta_i

Commentaires pour conclure :

3.3. Calcul de sin x et cos x

En dduire une fonction qui calcule tan x. (Utiliser que pour

4.1. Constante dEuler

Code 18 (euler.py (1)).

4.2. 1000 dcimales de la constante dEuler

o C est une constante (non connue).

4.3. Un peu de ralit

0.1 + 0.1 + 0.1 == 0.3

3. x = 0.2 ; print("0.2 en Python = %.25f" %x)