Poly TP

TP d’Informatique
et Algorithmique
H2B 2023/2024 – Lycée Carnot
Matthias Gorny
www.matthiasgorny.fr
Table des matières
Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
0 Révisions de première année . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
1 Variables aléatoires à densité avec Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
2 Statistiques bivariées . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
3 Fonctions de plusieurs variables – Première partie . . . . . . . . . . . . . . . . . . . . . . . . 29
4 Convergences et approximations de variables aléatoires . . . . . . . . . . . . . . . . . . . . . 40
5 Fonctions de deux variables – Deuxième partie . . . . . . . . . . . . . . . . . . . . . . . . . . 51
6 Estimation ponctuelle et par intervalle de confiance . . . . . . . . . . . . . . . . . . . . . . . 55

Introduction
I Ouvrir votre compte utilisateur
Lors de votre inscription au lycée Carnot, un compte informatique à votre nom a été créé. Votre login est composé
de la première lettre de votre prénom, suivi de votre nom (en minuscule et sans espace). Votre mot de passe par
défaut est votre date de naissance sous la forme : jjmmaaaa.
Une fois connecté sur votre compte, créez un dossier intitulé H2B_TPInfo. A chaque TP, on créera un nouveau
fichier au nom adéquat.
Démarrez le logiciel Pyzo ou Spyder.
II Environnement de travail
Le langage de programmation officiel du programme de Mathématiques Approfondies en ECG est Python.
Une fois Python installé, on peut utiliser un environnement de travail (IDE pour Integrated Development
Environment) plus « convivial » que celui installé automatiquement. Il en existe plusieurs et, cette année, nous
utiliserons Pyzo 1 ou Spyder. Le fonctionnement et l’interface de ces deux environnements sont essentiellement
les mêmes.
Lorsqu’on lance Pyzo ou Spyder, une fenêtre apparaît composée de plusieurs sous-fenêtres dont la console et
l’éditeur.
1. Car c’est celui que j’utilise, « moi personnellement » (mais rien ne vous empêche d’en utiliser un autre chez vous). Pour installer
Pyzo sur votre ordinateur personnel, rendez-vous à cette page : https://pyzo.org/start.html
Sur mon site, vous trouverez un guide d’installation.
Lycée Carnot – H2B 3 Matthias Gorny

1. La console (ou shell) est la zone où l’on tape les commandes. Le symbole >>> signifie que l’ordinateur
attend une instruction. On peut alors saisir une commande et appuyer sur la touche Entrée pour que cette
commande soit interprétée.
• On peut écrire plusieurs instructions sur une même ligne en les séparant d’un point virgule.
• L’usage des touches fléchées ↑ et ↓ fait apparaitre les commandes précédemment tapées.
2. L’éditeur est la zone dans laquelle nous allons principalement travailler. En effet, la console est vite limitée
lorsqu’on veut écrire des programmes faisant plus d’une ligne ou lorsqu’on doit en utiliser plusieurs en même
temps. On crée alors des fichiers (au format .py) dans lesquels on écrit les différentes commandes.
• On peut séparer un fichier en différentes parties appelées cellules, en utilisant la commande #%%. On peut écrire
un titre et un trait est tracé automatiquement. C’est particulièrement utile pour séparer les exercices.
• Il est important de penser à enregistrer régulièrement ses fichiers, en utilisant le raccourci Ctrl + S .
3. On peut ouvrir plusieurs fichiers .py en même temps qui s’organisent en onglets. Pour accéder à un fichier
déjà ouvert, il suffit de cliquer sur son onglet.
4. Le navigateur de fichier est une zone où l’on peut accéder aux différents fichiers Python enregistrés dans
l’ordinateur. On peut notamment les ouvrir en double-cliquant dessus. En cliquant sur Tools en haut de
l’écran, on peut ouvrir d’autres fenêtres comme l’historique des commandes utilisées par exemple.
5. Le menu File regroupe des fonctions utiles : création d’un nouveau fichier (New ), ouverture d’un fichier
(Open...), sauvegarde (Save), etc.
6. Une fois un programme terminé, il faut l’exécuter dans la console. Il y a différentes façon d’exécuter qui
sont regroupées dans le menu Run :
• Cliquer sur Execute selection exécute les lignes de codes sélectionnées.
• Cliquer sur Execute cell exécute tout le contenu de la cellule sur laquelle on vient de cliquer. Un raccourci est
Ctrl + Entrée .
• Cliquer sur Execute file exécute tout le contenu du fichier. Un raccourci est Ctrl + E .
7. Les icônes en haut de la console permettent d’interrompre un code en cours d’exécution (pratique pour les
boucles while qui s’avèrent infinies) ou de redémarrer la console en cas de bug.

Feuille de TP no 0
Révisions de première année
I Commandes et structures de bases

Exercice 1 – Renversement d’une liste. (H) Écrire une fonction qui prend en argument une liste et qui renvoie
la liste dans laquelle les éléments sont listés dans l’autre sens (du dernier de la liste d’entrée au premier de la liste
d’entrée).
Exercice 2 – Somme, produit, sommes cumulées, moyenne, variance, écart type. (H)
1) Écrire une fonction qui prend en argument une liste de réels et renvoie la somme des éléments (sans utiliser
np.sum).
2) Écrire une fonction qui prend en argument une liste de réels et renvoie le produit des éléments (sans utiliser
np.prod).
3) Écrire une fonction qui prend en argument une liste de réels et renvoie la liste des sommes cumulées des
éléments (sans utiliser np.cumsum).
4) Écrire une fonction qui prend en argument une liste de réels et renvoie la moyenne des éléments (sans utiliser
np.mean).
5) Écrire une fonction qui prend en argument une liste de réels et renvoie la variance des éléments (sans utiliser
np.var).
6) Écrire une fonction qui prend en argument une liste de réels et renvoie l’écart type des éléments (sans utiliser
np.std).
Exercice 3 – Recherche du nombre d’occurrences. (H) Écrire une fonction qui prend en argument une liste
et une variable et qui renvoie le nombre d’occurrences de la variable dans la liste.
Exercice 4 – Recherche du max et du min. (HH)

1) Écrire une fonction qui prend en argument une liste de réels et qui renvoie le maximum de la liste (sans
utiliser np.max), ainsi que le plus petit indice où se trouve le maximum.
Indications : le premier élément de la liste est le maximum provisoire. Ensuite on parcourt la liste de gauche
à droite et, dès qu’on trouve un élément strictement plus grand que le maximum provisoire, celui-ci devient
le nouveau maximum provisoire.
2) Écrire une fonction qui prend en argument une liste de réels et qui renvoie le minimum de la liste (sans
utiliser np.min), ainsi que le plus petit indice où se trouve le minimum.
3) Tester ces fonctions avec la liste L=[rd.binomial(15,0.3) for k in range(20)].
4) Modifier ces fonctions pour qu’elles renvoient la liste de tous les indices où se trouvent le maximum et le
minimum respectivement. Les tester avec la liste de la question précédente.
II Suites, sommes, produits

Exercice 5 – Classique : factorielle. (H) Écrire une fonction qui prend en argument un entier naturel et renvoie
sa factorielle.
Exercice 6 – Classique : coefficients binomiaux. (H) Écrire une fonction qui prend en argument deux entiers
naturels n et p et qui renvoie np (avec la convention que np = 0 si p > n).

Cette fonction ne devra pas utiliser de fonction factorielle.

Exercice 7. (H) On considère la suite (un )n∈N définie par u0 = 1 et
(n − 2)un + 2
∀n ∈ N, un+1 = .
un + n
1) Construire une fonction en Python qui prend en argument un entier naturel N et qui renvoie uN .
2) Construire une fonction en Python qui prend en argument un entier naturel N et qui représente graphiquement
u0 , u1 , . . . , uN . La tester pour N = 50. Que peut-on conjecturer ? Que peut-on superposer à la courbe pour
améliorer la conjecture ?
Exercice 8. (HH) Soient a et b deux réels. On considère la suite (un )n∈N définie par u0 = a, u1 = b et
un+1
∀n ∈ N, un+2 = + e−un .
2
1) Recopier et compléter la fonction Python ci-dessous pour qu’elle prenne en argument les réels a et n et un
entier naturel N et renvoie uN .
1 d e f S u i t e ( a , b , N) :
2 u=............
3 v=............
4 f o r n i n r a n g e (N) :
5 aux = . . . . . . . . . . . .
6 u=v
7 v=..............
8 return . . . . . . . . . . . . .
2) Comment peut-on remplacer les lignes 5,6,7 par une seule ligne ?
3) Construire une fonction en Python qui prend en argument les réels a et n et un entier naturel N et qui
représente graphiquement u0 , u1 , . . . , uN . La tester pour N = 50 et pour plusieurs valeurs de a et b. Que
peut-on conjecturer ?
Exercice 9 – Nombres de Bell. On pose B0 = 1 et

n
X n
∀n ∈ N, Bn+1 = Bk .
k
k=0
1) (HH) Recopier et compléter le programme ci-dessous pour qu’il prenne en entrée un entier naturel N non
nul et pour qu’il renvoie la liste des entiers B0 , . . . , BN .
1 import . . . . . . . . . . . . . . . . . . . . . . .
2 d e f B e l l (N) :
3 B=np . z e r o s (N+1)
4 B[ 0 ] = 1
5 Facto =[]
6 f o r n i n r a n g e (N) :
7 #U t i l i s a t i o n de l a f o r m u l e de P a s c a l p o u r f o r m e r l a
8 # l i s t e d e s ( p p a r m i n ) p o u r t o u t p de 0 à n
9 Temp=F a c t o + [ 1 ]
10 f o r p i n r a n g e ( n−1) :
11 Temp [ p + 1 ] = . . . . . . . . . . . . . . . . . . . . . . . . . . . .
12 F a c t o=Temp
13 #C a l c u l de B_( n+1)
14 .............................
15 .............................
16 .............................
17 B [ n+1]=S
18 return B
2) (HHH) On appelle partition d’un ensemble E, toute famille de parties non vides deux à deux disjoints dont
la réunion est E tout entier. Montrer que, pour tout n ∈ N∗ , Bn est le nombre de partitions de J1 ; nK.
On raisonnera par récurrence. Pour tout n ∈ N et k ∈ J0 ; nK, on pourra introduire Ek l’ensemble des
partitions de J1 ; n + 1K pour lesquelles la partie contenant n + 1 est de cardinal k + 1.

III Analyse numérique
1) Dichotomie
e−x
Exercice 10 – D’après EDHEC 2016. (HH) Soit f : x ∈ R∗+ 7−→ .
x
1) Étudier les variations de la fonction g : x 7−→ e−x − x2 sur R+ .
2) Montrer que l’équation f (x) = x, d’inconnue x ∈ R∗+ , admet une unique solution que l’on notera α.
3) Montrer que e−1 < α < 1.
4) Compléter le script Python suivant qui affiche une valeur approchée de α à 10−3 près :
1 import . . . . . . . . . . . . . . . . . . .
2 def g( x ) :
3 return . . . . . . . . . . . . . . .
4 a=...........
5 b=...........
6 while . . . . . . . . . . . . . . . . . . . .
7 c=(a+b ) /2
8 i f g ( c ) >0:
9 ...........
10 else :
11 ...........
12 p r i n t ( ’ Une v a l e u r a p p r o c h é e de a l p h a e s t ’+s t r ( . . . . . . ) )
t −1/t
Exercice 11 – D’après HEC 2020. (HH) Soit f : t ∈ ]0 ; 1[ 7−→ e .
1−t
1) Montrer que f est prolongeable en une fonction continue sur [0 ; 1[.
2) Montrer que f , ainsi prolongée, est bijective de [0 ; 1[ sur un intervalle I à préciser.
3) On cherche à représenter graphiquement f −1 sur I à l’aide de Python.
a) Première méthode : avec un algorithme de dichotomie. Recopier et compléter le script Python suivant
pour qu’il affiche une représentation graphique de f −1 sur [0 ; f (0, 95)].
1 import . . . . . . . . . . . . . . . . . . .
2 import . . . . . . . . . . . . . . . . . . .
3 #I m p l é m e n t a t i o n de f
4 def f ( t ) :
5 if . . . . . . . . .
6 return . . . . . . . . .
7 else :
8 return . . . . . . . . .
9
10 #I m p l é m e n t a t i o n de l a r é c i p r o q u e de f
11 def Inv_f ( x ) :
12 a=0
13 b =0.95
14 while . . . . . . . . . . . . ..
15 c=(a+b ) /2
16 i f f ( c )>x :
17 ........... ..
18 else :
19 ........... ..
20 return . . . . . . . . . . . ..
21
22 #Trac é de l a f o n c t i o n
23 X=...........................
24 Y=...........................
25 p l t . p l o t (X , Y)
26 p l t . show ( )
b) Deuxième méthode : en se rappelant que la courbe de f −1 s’obtient facilement via une transformation
géométrique de la courbe de f .
4) Conjecturer le domaine sur lequel l’application f −1 est dérivable. Prouver cette conjecture.

2) Méthode des rectangles
Soient n ∈ N∗ , a ∈ R et b ∈ R. On rappelle que :
• Approximation dans le cas C 1 (non exigible mais on l’a démontré l’an passé) : si f est une fonction de
classe C 1 sur un segment [a ; b] et si Sn (f ) désigne une somme de Riemann à n pas constant associée à f
sur [a ; b], alors
Z b
(b − a)2
Sn (f ) − f (t) dt 6 max |f 0 |.
a 2n [a ;b]
• Approximation dans le cas monotone (non exigible mais on le retrouve facilement par comparaison série/in-
tégrale, cf. cours de Python de première année) : si f est une fonction monotone sur [a ; b], alors
n Z b
(b − a) f (b) − f (a)

b−aX b−a
f a+k − f (t) dt 6 .
n n a n
k=1
La somme ci-dessus est la somme de Riemann à droite associée à f sur [a ; b]. C’est encore vrai si on la
remplace par la somme de Riemann à gauche.
4
Exercice 12 – « Vraie » vitesse de convergence. Soit f : x 7−→ . Pour tout n ∈ N∗ , notons Sn (f ) la
1 + x2
somme de Riemann à droite associée à f sur [a ; b].
Z 1
1) Calculer I = f (x) dx.
0
2) Écrire une fonction qui prend en argument un entier naturel non nul n et qui renvoie Sn (f ).
3) Soit ε > 0. Déterminer n ∈ N tel que Sn (f ) soit une approximation de I à ε près.
On utilisera le fait que f est C 1 puis le fait que f est monotone. Laquelle donne le plus petit n ?
4) Écrire une fonction qui prend en argument ε et qui renvoie le plus petit n tel que Sn (f ) soit une approximation
de I à ε près (pourquoi le programme s’arrête-t-il au fait ?). Comparer avec les valeurs trouvées à la question
précédente.
On utilisera une approximation de I fournie par l’ordinateur (on sait alors que, si n est une des valeurs
obtenues à la question précédente, Sn (f ) est une approximation de I à ε près et le but de cette question
est de déterminer si l’approximation était déjà bonne pour un plus petit n).
5) a) Justifier que
8S4n (f ) − 6S2n (f ) + Sn (f )
un (f ) = 2S2n (f ) − Sn (f ) −−−−−→ I et vn (f ) = −−−−−→ I.
n→+∞ 3 n→+∞
b) Écrire un programme qui prend en argument ε et qui renvoie le plus petit n tel que un (f ) soit une
approximation de I à ε près. Comparer avec les valeurs trouvées précédemment.
c) Écrire un programme qui prend en argument ε et qui renvoie le plus petit n tel que vn (f ) soit une
approximation de I à ε près. Comparer avec les valeurs trouvées. précédemment.
Exercice 13. (HHH) Le but de cet exercice est de démontrer que, en gardant les notations de l’exercice précédent,
les convergences de (un (f ))n>1 et (vn (f ))n>1 vers I sont en effet bien plus rapides que celle de (Sn (f ))n>1 . On
fait pour cela l’hypothèse que f est une fonction quelconque de classe C 4 sur un segment [a ; b] avec a < b. Pour
b−a
tout k ∈ J1 ; 4K, on note Mk = sup f (k) . On se donne n ∈ N∗ et, pour tout i ∈ J0 ; nK, on pose xi = a + i .
[a ;b] n
b−a
1) a) Pour tout i ∈ J0 ; nK, justifier que |f (xi+1 ) − f (xi )| 6 M1 .
n
(b − a)2
b) En déduire que |I − Sn (f )| 6 M1 .
2n
2) Soit [α ; β] un segment inclus dans [a ; b]. On introduit :
Z x
(x − α)(f (x) − f (α)
p : x 7−→ f (t) dt − (x − α)f (α) et q : x 7−→ p(x) − .
α 2

a) Calculer les deux premières dérivées de p et q.
b) A l’aide d’inégalité de Taylor-Lagrange, montrer que
β
(β − α)(f (β) − f (α) (β − α)3
Z
f (t) dt − (β − α)f (α) − 6 M2 .
α 2 4
c) En déduire que
(b − a)(f (b) − f (a)) (b − a)3
I − Sn (f ) − 6 M2 .
2n 4n2
3) Soit [α ; β] un segment inclus dans [a ; b]. On introduit de plus :
(x − α)2 (f 0 (x) − f 0 (α))

r : x 7−→ q(x) + .
12
En procédant de la même manière qu’à la question précédente, établir que
(b − a)(f (b) − f (a)) (b − a)2 (f 0 (b) − f 0 (a)) (b − a)5

I − Sn (f ) − + 6 M4 .
2n 12n2 72n4
1
4) A l’aide des résultats précédents, déterminer le développement asymptotique en à l’ordre 3 de Sn (f )
n
lorsque n tend vers +∞. Cela consiste à trouver des réels A, B, C et D tels que

B C D 1
Sn (f ) = A + + 2 + 3 + o .
+∞ n n n n3
1
5) En déduire les développements asymptotiques en à l’ordre 3 de un (f ) et vn (f ) lorsque n tend vers +∞.
n
Conclure.
2
e−t /2
Exercice 14 – Implémentation de Φ. (HH) Notons ϕ : t 7−→ √ la densité d’une variable aléatoire de loi
N (0, 1) et Φ sa fonction de répartition. 2π
1
1) Justifier que ϕ est de classe C 1 sur R et que ϕ0 est bornée par √ sur R.
2πe
Z x
1
2) Montrer que, pour tout x ∈ R, Φ(x) = + ϕ(t) dt.
2 0
3) Écrire une fonction, appelée Phi, qui prend en argument un réel x et qui renvoie une valeur approchée de
Φ(x) à 10−3 près à l’aide de la méthode des rectangles.
IV Matrices
Exercice 15. (H) Écrire une fonction en Python qui prend en argument une matrice A, un vecteur colonne B
ayant autant de ligne que A a de colonnes, deux entiers naturels i, j (indices possibles pour les lignes de A) et
deux réels α et β et qui fait l’opération élémentaire Li ← αLi + βLj sur les matrices A et B.
Cette fonction ne renverra rien si α 6= 0 mais renverra le message « le pivot est nul » si α est nul.
Exercice 16 – Bon courage sans Python. (HH) Résoudre le système suivant, d’inconnues x, y, z réelles, à
l’aide de la méthode du pivot de Gauss implémentée avec Python.

−45x − 11y + 22z = −1
−32x − 16y + 20z = −4
−13x + 24y − 10z = 5

On utilisera l’exercice précédent et on vérifiera ensuite avec la commande al.solve.

Exercice 17 – Codage matriciel d’un endomorphisme défini à l’aide de polynômes. (HHH)
1) Soit n ∈ N. En Python, on représentera un polynôme P de degré inférieur ou égal à n par le vecteur ligne
(de type numpy et non une liste) égal aux coordonnées de P dans la base canonique de Rn [X].
Par exemple :
— Si n = 3, P=np.array([0,1,2,-1]) implémente le polynôme P = X + 2X 2 − X 3 .
— Si n = 4, P=np.array([1,0,0,-1,0]) implémente le polynôme P = 1 − X 3 .
√
— Si n = 5, alors on implémente P = 7 − X + 2X 3 − 9X 4 par
P=np.array([7,-1,0,2**(1/2),-9,0]).
Ainsi si P et Q sont deux polynômes de Rn [X] implémentés par P et Q respectivement et si a est un réel
implémenté par a, alors a*P+Q implémente aP + Q. C’est moins immédiat pour les autres opérations (ne
serait-ce que par défaut de stabilité) et c’est que nous allons voir.
a) Recopier et compléter la fonction ci-dessous afin qu’elle prenne en argument un polynôme implémenté
en liste ou vecteur ligne et renvoie sa dérivée sous forme de vecteur ligne.
1 import . . . . . . . . . . . . . . . . . . . .
2 d e f D e r i v (P) :
3 n=..........
4 Q=np . z e r o s ( n )
5 f o r i i n r a n g e ( n−1) :
6 Q[ i ] = . . . . . . . . . . . . .
7 return Q
b) Recopier et compléter la fonction ci-dessous afin qu’elle prenne en argument un entier naturel non
nul k et un polynôme P implémenté en vecteur ligne et renvoie X k P implémenté en Python (par un
vecteur ayant k coordonnée de plus, n’est-ce pas ?).
1 d e f MultX (P , k ) :
2 n=.............
3 Q=np . z e r o s ( n+k )#On t r a v a i l l e d a n s R_{n+k } [ X ]
4 f o r i in range ( . . . . , . . . . ) :
5 Q[ i ] = . . . . . . . . . . . . .
6 return Q
c) Écrire une fonction en Python qui prend en argument deux entiers naturels n et k avec k 6 n et qui
implémente le polynôme X k de Rn [X] en vecteur ligne.
2) Soit n ∈ N∗ . On considère l’application fn : P ∈ Rn [X] 7−→ nXP + (1 − X 2 )P 0 .
a) Montrer que fn est un endomorphisme de Rn [X].
b) A l’aide des fonctions Python précédentes, construire une fonction en Python qui prend en argument
un entier naturel non nul n et un polynôme P de Rn [X] implémenté en vecteur ligne et renvoie fn (P ).
Attention avant de sommer les trois polynômes de fn (P ) car les fonctions définies précédemment
vont fournir des polynômes de Rn+1 [X], Rn [X] et Rn+2 [X] respectivement (il faudra donc enlever les
coordonnées superflues).
c) Recopier et compléter la fonction ci-dessous afin qu’elle prenne en argument un entier naturel non nul
n et qu’elle renvoie la matrice de fn dans la base canonique de Rn [X].
1 d e f Mat_f ( n ) :
2 A = . . . . . . . . . . . . . . . . . . . . . #M a t r i c e c a r r é e n u l l e d ’ o r d r e n+1
3 #On va c o n s t r u i r e l a t r a n s p o s é e de l a m a t r i c e
4 f o r k i n r a n g e ( n+1) :
5 A[ k , : ] = . . . . . . . . . . . .
6 r e t u r n . . . . . . . . . . . . . . . . #La t r a n s p o s é e de A
d) Pour n ∈ J1 ; 10K, déterminer les valeurs propres et vecteurs propres de fn à l’aide de Python et de la
commande al.eig. Que peut-on conjecturer quant à la diagonalisabilité de f ?
e) Montrer que, pour tous n ∈ N et k ∈ J0 ; nK, (X − 1)k (X + 1)n−k est un vecteur propre de fn . Prouver
alors la conjecture de la question précédente.

V Probabilités discrètes
Exercice 18. Une urne contient 1 boule jaune, 2 boules rouges et 4 boules bleues.
1) On effectue le tirage d’une boule dans l’urne. Écrire un programme en Python qui simule cette expérience
et qui affiche à l’écran la couleur de la boule tirée.
Pour simplifier la simulation, on pourra supposer que la boule jaune est numérotée 1, que les boules rouges
sont numérotées 2 et 3 et que les boules bleues sont numérotées 4,5,6 et 7.
2) Soit n un entier naturel non nul. On effectue n tirages d’une boule dans l’urne, avec remise de la boule tirée
avant chaque tirage. On note X la variable aléatoire égale au nombre de boules rouges obtenues au cours
de cette expérience.
a) Écrire une fonction qui prend en entrée n, qui simule l’expérience aléatoire décrite et qu’elle renvoie
une réalisation de X.
Dans un premier temps, on pourra utiliser une boucle for. Puis on pourra simplifier en utilisant la
commande np.sum(A<x) , où A est un vecteur et x un réel. En effet, lorsqu’on effectue des opérations
algébriques sur True et False, Python les assimile respectivement à 1 et 0.
b) Déterminer la loi de X. Préciser son espérance et sa variance.
3) On considère désormais l’expérience suivante : on tire une boule dans l’urne avec remise jusqu’à obtenir une
boule jaune. On note N la variable aléatoire égale au nombre de tirages effectuée et Y la variable aléatoire
égale au nombre de boules bleues obtenues au cours de cette expérience.
a) Compléter la fonction Python suivante afin qu’elle simule cette expérience et qu’elle renvoie des
réalisations de N et Y .
1 import . . . . . . . . . . . . . . . . . . .
2 def simul () :
3 T=r d . random ( )
4 N=1; Y=0
5 i f T>3/7:
6 ...................
7 while . . . . . . . . . . . . . . . .
8 T=r d . random ( )
9 ................
10 i f T>3/7:
11 .............
12 r e t u r n N, Y
b) Déterminer la loi de N . Préciser son espérance et sa variance.

c) Déterminer la loi du couple (N, Y ).
d) Calculer la probabilité P(Y = 0).
4) Expliquer ce que fait le script Python ci-dessous. Plus précisément que contient la variable S ?
1 i m p o r t numpy a s np
2 import m a t p l o t l i b . pyplot as p l t
3 Nexp =10000
4 L=[]
5 f o r k i n r a n g e ( Nexp ) :
6 [ N, Y]= s i m u l ( )
7 L . append (Y)
8 M=np . cumsum ( L ) / np . a r r a y ( r a n g e ( 1 , Nexp+1) )
9 p l t . p l o t ( r a n g e ( 1 , Nexp+1) ,M)
10 p l t . show ( )
Éxécuter-le plusieurs fois. Que peut-on conjecturer ? Sur quel résultat théorique s’appuie-t-on pour faire
cette conjecture ?
5) Montrer la conjecture à l’aide de la formule de transfert.

Exercice 19 – D’après ECRICOME 2019.
Une urne contient initialement une boule blanche et une boule noire. On effectue une succession de tirages d’une
boule dans cette urne. Après chaque tirage, on remet la boule tirée dans l’urne, et on rajoute dans l’urne une boule
de couleur opposée à celle qui vient d’être tirée. On suppose que cette expérience est modélisée par un espace
probabilisé (Ω, A, P). Pour tout k ∈ N, on note Xk le nombre de boules blanches présentes dans l’urne juste avant
le (k + 1)ième tirage. En particulier, on a X0 = 1. On admet que pour tout entier k, Xk est une variable aléatoire
de (Ω, A, P).
1) Soit k ∈ N.
a) Déterminer Xk (Ω).
b) Pour tous i ∈ Xk+1 (Ω) et j ∈ Xk (Ω), déterminer P[Xk =j] (Xk+1 = i).
On distinguera différents cas selon les valeurs relatives de i et j.
c) En déduire que
i 3+k−i
∀i ∈ J2 ; k + 1K, P(Xk+1 = i) = P(Xk = i) + P(Xk = i − 1).
k+2 k+2
1
d) Montrer que P(Xk = 1) = .
(k + 1)!
e) Déterminer la valeur de P(Xk = k + 1).
2) Que renvoie la fonction Python suivante pour un entier k non nul implémenté en Python par k ?
1 i m p o r t numpy . random a s r d
2 def mystere ( k ) :
3 n=1
4 b=1
5 f o r i in range ( k ) :
6 r=r d . r a n d i n t ( 1 , n+b+1)
7 i f r>n :
8 n=n+1
9 else :
10 b=b+1
11 return b
3) Écrire une fonction Python d’en-tête appelée loi_exp qui prend en argument deux entiers strictement
positifs k et N , qui effectue N simulations de k tirages successifs dans l’urne et qui retourne un vecteur LE
qui contient une estimation de la loi de Xk (c’est-à-dire que pour chaque i ∈ J1 ; k + 1K, LE[i − 1] contient
la fréquence d’apparition de l’événement [Xk = i] au cours des N simulations). On justifiera cette approche
en citant un théorème du cours.
On pourra utiliser la fonction mystere.
4) Recopier et compléter la fonction suivante afin qu’elle prenne en entrée un entier strictement positif n et
qu’elle retourne un vecteur qui contient la loi théorème de Xn .
2 def loi_theo (n) :
3 M=np . z e r o s ( [ n+1,n +1])
4 M[ 0 , 0 ] = 1
5 M[ 1 , 0 ] = 1 / 2
6 M[ 1 , 1 ] = 1 / 2
7 f o r k in range (1 , n) :
8 M[ k + 1 , 0 ] = . . . . . . . . . . . . . . . . . . . . . . . . . .
9 f o r i i n r a n g e ( 2 , k+2) :
10 M[ k +1 , i − 1 ] = . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
11 M[ k +1 , k + 1 ] = . . . . . . . . . . . . . . . . . . . . . . . . . .
12 return . . . . . . . . . . . . . . . . . . . . . . . . . .
5) Un étudiant nous propose comme loi de X5 le résultat suivant :

k 1 2 3 4 5 6
P(X5 = k) 0.001368 0.079365 0.419434 0.418999 0.079454 0.00138
A-t-il utilisé loi_exp ou bien loi_theo ?

6) Pour différentes valeurs de n, superposer le diagramme à barres de la loi théorique et le digramme à barres
de N = 10000 réalisations de l’expérience.
Si X et Y sont des vecteurs de même taille, la commande plt.bar(X,Y) construit un diagramme à barre
dont les abscisses des barres sont les coordonnées de X et la hauteur des barres les coordonnées de Y. On
peut ajouter une option de couleur comme pour plt.plot(X,Y) et une option pour changer la largeur des
barres (essayez width=0.4 pour l’un des deux diagramme).
Exercice 20 – D’après les oraux ESCP 1999 et 2001. (HH) Une urne contient n boules numérotées de 1 à
n. On prélève au hasard ces n boules une par une et sans remise. A la suite de l’expérience, on note, pour tout
i ∈ J1 ; nK, ui le numéro de la boule obtenue au cours du iième tirage. Pour tout i ∈ J2 ; nK, on dit qu’il y a un
record en i si l’on a ui > max{u1 , . . . , ui−1 }. D’autre part, on convient qu’il y a systématiquement un record à
l’instant 1.
1) Calculer, pour tout i ∈ J1 ; nK, la probabilité ri qu’il y ait un record à l’instant i.
On pourra commencer par calculer, pour tout k ∈ Ji ; nK, la probabilité qu’il y ait un record au iième tirage
en tirant la boule numérotée k lors de ce tirage. On pourra utiliser, en la redémontrant, la formule de Pascal
généralisée :
n
∗
X j−1 n
∀n ∈ N , ∀p ∈ J1 ; nK, = .
p−1 p
j=p
2) Calculer les probabilités que, durant la totalité des tirages, on assiste exactement à :
a) un seul record.
b) n records.
c) deux records.
3) On considère la fonction Python ci-dessous :
2 def Tirages (n) :
3 L= l i s t ( r a n g e ( n ) )
4 T= [ ]
5 f o r k in range (n) :
6 i=r d . r a n d i n t ( n−k )
7 x=L . pop ( i )#R e n v o i e e t e n l è v e L [ i ]
8 T . append ( x )
9 S=1
10 m=T [ 0 ]
11 f o r k in range (1 , n) :
12 i f T [ k]>m:
13 m=T [ k ]
14 S=S+1
15 r e t u r n T, S
Expliquer ce que représentent les variables T,m,S ? Après exécution de cette fonction pour un n quelconque,
qu’est-il affiché à l’écran ?
4) Après exécution de la fonction suivante,
3 N=100
4 n=1000
5 E=[1]
6 f o r k i n r a n g e ( 2 , n+1) :
7 S=0
8 f o r i i n r a n g e (N) :
9 S=S+T i r a g e s ( k ) [ 1 ]
10 E . append ( S/N)
11 p l t . p l o t ( r a n g e ( 1 , n+1) , E , ’+ ’ )
12 H=np . cumsum ( [ 1 / i f o r i i n r a n g e ( 1 , n+1) ] )
13 p l t . p l o t ( r a n g e ( 1 , n+1) ,H)
14 p l t . show ( )
on obtient le graphique suivant :

8
0 200 400 600 800 1,000
Interpréter le graphique puis justifier vos observations.

On pourra introduire, pour tout i ∈ J2 ; nK, la variable aléatoire Xi qui prend la valeur 1 s’il y a un record à
l’instant i et 0 sinon.

Feuille de TP no 1
Variables aléatoires à densité avec Python
I Représentation graphique des lois à densité usuelles

Exercice 1 – Représentation de lois uniformes. (H)
1) Écrire une fonction qui prend en argument deux réels a et b tels que a < b et qui trace la densité d’une
variable aléatoire de loi U([a ; b]) sur l’intervalle [a − 1 ; b + 1].
2) Écrire une fonction qui prend en argument deux réels a et b tels que a < b et qui trace la fonction de
répartition d’une variable aléatoire de loi U([a ; b]) sur l’intervalle [a − 1 ; b + 1].
3) Tester les fonctions précédentes pour quelques valeurs de a et b.
Exercice 2 – Représentation de lois exponentielles. (H)

1) Soient a > 0 et X une variable aléatoire de loi E(a). Déterminer ta ∈ R (le plus petit possible) tel que
P(X > ta ) 6 10−3 .
2) Écrire une fonction qui prend en argument a > 0 et qui trace la densité d’une variable aléatoire de loi E(a)
sur l’intervalle [−1 ; ta ].
3) Écrire une fonction qui prend en argument a > 0 et qui trace la fonction de répartition d’une variable
aléatoire de loi E(a) sur l’intervalle [−1 ; ta ].
4) Tester les fonctions précédentes pour quelques valeurs de a.
Exercice 3 – Représentation de lois normales. (H)

1) Écrire une fonction qui prend en argument m ∈ R et σ 2 > 0 et qui trace la densité d’une variable aléatoire
de loi N (m, σ 2 ) sur l’intervalle [m − 4σ ; m + 4σ].
2) a) Exprimer la fonction de répartition d’une variable aléatoire de loi N (m, σ 2 ) en fonction de Φ.
b) Écrire une fonction qui prend en argument m ∈ R et σ 2 > 0 et qui trace la fonction de répartition
d’une variable aléatoire de loi N (m, σ 2 ) sur l’intervalle [m − 4σ ; m + 4σ].
On utilisera la fonction Phi implémentée dans le TP précédent ou bien la fonction ndtr de la
bibliothèque scipy.special (importée sous le nom sp par exemple).
3) Tester les fonctions précédentes pour quelques valeurs de m et σ 2 .
Exercice 4 – Représentation de lois gamma. (HH)

1) Écrire une fonction qui prend en argument un entier naturel n non nul et qui trace la densité d’une variable
aléatoire de loi γ(n) sur l’intervalle [−1 ; 5n].
2) Écrire une fonction qui prend en argument un entier naturel n supérieure ou égale à 2 (pour n = 1, voir cf.
exercice 2) et qui trace la fonction de répartition d’une variable aléatoire de loi γ(n) sur l’intervalle [−1 ; 5n].
On utilisera la méthode des rectangles.
3) Tester les fonctions précédentes pour quelques valeurs de n.

II Simulation de variables aléatoires à densité
1) Utilisation de numpy.random
Soient a, b, λ, m, σ 2 , ν des réels tels que a < b, λ > 0, σ 2 > 0 et µ > 0. On les implémente en Python dans les
variables a,b,lam,m,s2,mu respectivement. La commande :
• (b-a)*rd.random()+a simule une variable aléatoire de loi U([a ; b]).
• np.exponential(1/lam) simule une variable aléatoire de loi E(λ).
• np.normal(m,s2**(1/2)) simule une variable aléatoire de loi N (m, σ 2 ).
• np.gamma(n,1) simule une variable aléatoire de loi γ(ν).
Exercice 5 – « Vérification » des simulations. (HH)

1) Écrire une fonction qui prend en argument des réels a et b (avec a < b), qui simule un échantillon de 10000
variables aléatoires de loi U([a ; b]) en utilisant rd.random, qui trace l’histogramme empirique renormalisé
de cet échantillon et qui lui superpose le graphe d’une densité d’une variable de loi U([a ; b]). Tester avec
plusieurs valeurs de a et b.
2) Écrire une fonction qui prend en argument un réel strictement positif a, qui simule un échantillon de 10000
variables aléatoires de loi E(a) en utilisant rd.exponential, qui trace l’histogramme empirique renormalisé
de cet échantillon et qui lui superpose le graphe d’une densité d’une variable de loi E(a). Tester avec
plusieurs valeurs de a.
3) Écrire une fonction qui prend en argument deux réels m et σ 2 avec σ 2 > 0, qui simule un échantillon
de 10000 variables aléatoires de loi N (m, σ 2 ) en utilisant rd.normal, qui trace l’histogramme empirique
renormalisé de cet échantillon et qui lui superpose le graphe d’une densité d’une variable de loi N (m, σ 2 ).
Tester avec plusieurs valeurs de m et σ 2 .
4) Écrire une fonction qui prend en argument un entier naturel strictement positif n, qui simule un échantillon de
10000 variables aléatoires de loi γ(n) en utilisant rd.gamma, qui trace l’histogramme empirique renormalisé
de cet échantillon et qui lui superpose le graphe d’une densité d’une variable de loi γ(n). Tester avec
plusieurs valeurs de n.
Exercice 6 – Somme de loi exponentielles. (HH)

1) Écrire une fonction en Python qui prend en argument un entier naturel n non nul et qui renvoie la somme
de n variables aléatoire de lois E(1).
2) Pour différentes valeurs de n, exécuter 10000 fois cette fonction, construire l’histogramme empirique
renormalisé de ces réalisations et lui superposer le graphe d’une densité d’une variable aléatoire de loi γ(n).
Exercice 7. (HH) On dispose d’un bâton d’un mètre. On le casse en deux morceaux en choisissant le point de
cassure au hasard (uniformément). On note X la longueur du plus petit morceau et Y la longueur du plus grand
morceau.
1) a) Écrire une fonction qui prend en argument N ∈ N∗ et qui renvoie un vecteur (une matrice ligne et non
pas une liste) contenant N réalisations indépendantes de X.
b) Tracer l’histogramme empirique renormalisé de 10000 réalisations de X. Que peut-on conjecturer ?
c) Recopier et exécuter le script suivant :
3 N=10000
4 X=SimulX (N)
5 T=np . l i n s p a c e ( 0 , 1 , 1 0 0 0 )
6 F=[]
7 f o r t in T:
8 F . append ( np . sum (X<=t ) /N)
9 p l t . p l o t (T , F )
10 p l t . show ( )
Que fait ce script (en particulier que font les lignes 7 et 8) ? Que peut-on conjecturer de nouveau ?

d) Prouver la conjecture.
2) a) Tracer l’histogramme empirique renormalisé de 10000 réalisations de Z = X/Y .
b) Déterminer la fonction de répartition de Z puis une densité de Z.
c) Superposer le graphe de cette densité à l’histogramme de la question a.
d) Superposer le graphe fonction de répartition empirique (qu’est ce qu’on peut entendre par là ?) de cet
échantillon et le graphe de la fonction de répartition de Z ? Qu’observe-t-on ?
Exercice 8 – Fonction de répartition empirique. (HH) Soit (Xn )n>1 une suite de variables aléatoires
indépendantes de même loi définies sur un espace probabilisé (Ω, A, P). Pour tout n ∈ N∗ , on appelle fonction de
répartition empirique de l’échantillon (X1 , . . . , Xn ) la fonction
n
card({i ∈ J1 ; nK | Xi (ω) 6 t}) 1X
Fn : (ω, t) ∈ Ω × R 7−→ = 1Xi (ω)6t .
n n
i=1
Autrement dit, pour tous ω ∈ Ω et t ∈ R, Fn (ω, t) est la proportion de variables aléatoires de l’échantillon qui
sont à valeurs inférieures ou égales à t.
1) À l’aide des exemples de l’exercice précédent, construire une fonction qui prend en argument un vecteur
(implémentant un échantillon) et qui trace la courbe de la fonction de répartition empirique de cet échantillon.
2) Pour plusieurs choix de paramètre, tester cette fonction avec un vecteurs de 10000 réalisations de variables
aléatoires indépendantes de loi exponentielle et lui superposer la courbe de la fonction de répartition
théorique.
3) Pour plusieurs choix de paramètres, tester cette fonction avec un vecteurs de 10000 réalisations de variables
aléatoires indépendantes de loi binomiale et lui superposer la courbe de la fonction de répartition théorique.
4) Comment expliquer que ces courbes se superposent ?
2) Utilisation de la méthode d’inversion

Exercice 9 – Méthode d’inversion de la fonction de répartition. (HHH) Soit X une variable aléatoire réelle
admettant une densité. On suppose qu’il existe a ∈ R ∪ {−∞} et b ∈ R ∪ {+∞} tels que a < b et :
• la fonction de répartition F de X est strictement croissante sur ]a ; b[,
• P(X ∈ ]a ; b[) = 1.
On se donne U une variable aléatoire de loi U([0 ; 1]).
1) a) Calculer les limites de F en a et b dans le cas où ce sont des réels.
b) Justifier que F est une bijection de ]a ; b[ sur ]0 ; 1[.
2) a) On pose Y = F −1 (U ). Déterminer la fonction de répartition de Y .
b) En déduire une méthode pour simuler la variable aléatoire X.
3) Écrire une fonction qui prend en argument a > 0 et qui simule une variable aléatoire de loi E(a) avec la
méthode d’inversion.
1
4) On dit qu’une variable aléatoire suit une loi de Laplace si elle admet pour densité la fonction x 7−→ e−|x| .
2
a) Montrer que la fonction de répartition d’une variable de loi de Laplace satisfait aux hypothèses de
l’énoncé avec a = −∞ et b = +∞ et que sa bijection réciproque est :

ln(2x) si x ∈ ]0 ; 1/2]
x 7−→
− ln(2(1 − x)) si x ∈ ]1/2 ; 1[
b) Écrire une fonction sans argument qui simule une variable aléatoire de loi de Laplace avec la méthode
d’inversion.
5) a) Écrire une fonction sans argument et qui simule une variable aléatoire de loi de Cauchy, c’est-à-dire de
1
densité x 7−→ .
π(1 + x2 )
b) Soit (Xi )i>1 est une suite de variables aléatoires indépendantes et de loi de Cauchy. Recopier, compléter
n
!
1X
et exécuter le script suivant afin qu’il représente les 10000 premières valeurs de la suite Xi .
n
k=1 n>1

1 .............................
2 .............................
3 .............................
4 L=[]
5 S=0
6 f o r n in range (1 ,10001) :
7 X = . . . . . . . . . . . . . . . . . . #S i m u l e une Cauchy
8 S=..................
9 L . append ( . . . . . . . . . . . )
10 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . #T r a c e
11 p l t . show ( )
Que remarque-t-on ? Comment l’expliquer ?

6) On se donne maintenant X une variable aléatoire à densité mais on ne suppose plus rien sur sa fonction de
répartition. Pour tout x ∈ ]0 ; 1[, on introduit l’ensemble Ix = {t ∈ R | F (t) > x}.
a) Soit x ∈ ]0 ; 1[. Montrer que Ix admet une borne inférieure. On la note1 G(x).
b) Montrer que G(x) ∈ Ix puis que Ix = [G(x) ; +∞[.
On pourra utiliser, après l’avoir démontré, le fait que G(x) est limite d’une suite d’éléments de Ix .
c) Montrer que, pour tous x ∈ ]0 ; 1[ et t ∈ R, G(x) 6 t ⇐⇒ F (t) > x.
d) En déduire que, si U ,→ U(]0 ; 1[), alors les variables aléatoires X et G(U ) ont la même loi.
3) Retour sur la simulation de lois discrètes

Exercice 10 – Lois géométriques à partir de lois exponentielles. (HH)
1) Soit Xa ,→ E(a) avec a > 0. Déterminer la loi de Ya = bXa c + 1.
2) En déduire une méthode de simulation d’une variable aléatoire de loi géométrique de paramètre p ∈ ]0 ; 1[
en utilisant une simulation d’une variable aléatoire de loi exponentielle (à l’aide de la méthode d’inversion
par exemple).
3) Écrire une fonction qui prend en argument p ∈ ]0 ; 1[, qui trace le diagramme à barres empirique d’un
échantillon de 10000 simulations de lois géométriques obtenues via cette méthode, et lui superpose le
diagramme à barre théorique d’une loi G(p). La tester pour différentes valeurs de p.
Exercice 11 – Simulation de lois de Poisson. (HH) Soit λ ∈ R∗+ . On se donne (Ui )i>1 une suite de variables
aléatoires indépendantes et de même loi U(]0 ; 1]). On considère la variable aléatoire
Y = min{n ∈ N | U1 U2 . . . Un+1 6 e−λ }.
1) Pour tout i ∈ N∗ , on pose Fi = − ln(Ui ). Quelle est la loi de Fi ?

2) En déduire la loi de Sn = F1 + · · · + Fn pour tout n ∈ N∗ .
3) Calculer P(Y > n) pour tout n ∈ N∗ .
4) En déduire que Y suit une loi de Poisson de paramètre λ. Commenter en réécrivant Y à l’aide des Fi , i > 1.
5) Compléter la fonction suivante afin qu’elle prenne en argument λ et renvoie la valeur d’une réalisation d’une
variable aléatoire de loi P(λ).
1 ............................
2 d e f P o i s s o n ( lam ) :
3 n=0
4 P=r d . random ( )
5 while . . . . . . . . . . . . . .
6 ...........
7 return n
1. Si t < G(x), alors t ∈/ Ix donc F (t) < x. En faisant tendre t vers G(x), et par continuité de F en G(x) (c’est la fonction de
répartition d’une variable à densité) on obtient F (G(x)) 6 x. Comme G(x) ∈ Ix , on en déduit que F (G(x)) = x. Ainsi G(x) est le
plus petit antécédent de x. Si F est bijective alors il s’agit de F −1 (x). Lorsque F n’est pas bijective, comme elle est croissante, elle
possède des paliers et on prend alors la borne inférieure du palier.

Exercice 12 – D’après concours. (HHH) On considère une suite de variables aléatoires (Xn )n>1 , définies sur
un espace probabilisé (Ω, A, P) et qui sont mutuellement indépendantes et identiquement distribuées selon une loi
X n
∗
exponentielle de paramètre λ ∈ R+ . Pour tout n ∈ N, on note Sn = Xk , avec la convention S0 = 0.
k=1
Enfin, pour tout t ∈ R∗+ ,
on note Nt la variable aléatoire égale à la plus grande valeur de n pour laquelle Sn est
inférieure ou égale à t, c’est-à-dire :
∀ω ∈ Ω, Nt (ω) = sup {n ∈ N | Sn (ω) 6 t}.
Par convention, si l’ensemble écrit ci-dessus n’est pas fini, Nt prend la valeur −1.
Voici un exemple de réalisation de Nt en fonction de t :
Nt 3
0 t
S1 S2 S3
X1 X2 X3
1) Pour tout t ∈ R∗+ , montrer que P (Nt = 0) = e−λt .

2) Pour tout n ∈ N∗ , déterminer une densité de la variable aléatoire λSn .
3) Soit t ∈ R∗+ . +∞
\
a) Comparer les événements [Nt = −1] et [Sn 6 t].
n=1
b) Montrer que, pour tout x ∈ R∗+ ,
x
un−1 −u
Z
lim e du = 0.
n→+∞ 0 (n − 1)!
c) En déduire que P(Nt = −1) = 0.

d) Établir que, pour tout n ∈ N, P(Nt > n) = P(Sn 6 t).
4) Soient t ∈ R∗+ et n ∈ N.
a) Montrer que P([Nt = n]) = P([Sn 6 t] ∩ [Sn+1 > t]).
b) En déduire que
λt λt
un−1 −u un −u
Z Z
P (Nt = n) = e du − e du.
0 (n − 1)! 0 n!
c) En intégrant par parties une des intégrales ci-dessus, montrer que
(λt)n −λt
∀n ∈ N∗ , P (Nt = n) = e .
n!
Quelle est la loi de Nt ?
5) a) Écrire une fonction Python d’en-tête def simulation_S(n,lam): renvoyant une réalisation de Sn .
b) Écrire une fonction Python d’en-tête def simulation_N(t,lam): renvoyant une réalisation de Nt .
c) Compléter la fonction en Python evolution_S afin qu’elle renvoie toutes les valeurs S1 , S2 , . . . , Sn
tant que Sn 6 t.

1 ............................
2 d e f e v o l u t i o n _ S ( t , lam ) :
3 L=[]
4 S=........................
5 while . . . . . . . . . . . . . . . . . . . .
6 L . append ( S )
7 S=S + . . . . . . . . . . . . . . . . . .
8 return . . . . . . . . . . . . . . . . . . .
d) On a commencé à écrire une fonction Python ci-dessous. Dans ce script, on implémente par S la
liste constituée de S1 , . . . , Sn (où n est le plus grand entier tel que Sn 6 T ) et on souhaite tracer
l’évolution de Nt du temps t = 0 au temps t = T de la même manière que sur la figure de la page
précédente.
2 d e f trace_N (T , lam ) :
3 S=e v o l u t i o n _ S (T , lam )
4 n=l e n ( S )
5 plt . plot ([0 ,S [0]] ,[0 ,0])
6 f o r i in range (1 , n) :
7 .....................
8 p l t . show ( )
Par laquelle des instructions suivantes faut-il compléter la ligne manquante ?

(i) plt.plot([i-1,i],[S[i-1],S[i-1]]) (ii) plt.plot([i,i+1],[S[i],S[i+1]])
(iii) plt.plot([S[i],S[i+1]],[i,i]) (iv) plt.plot([S[i-1],S[i]],[i,i])
e) Un étudiant exécute le script précédent pour T = 7 et λ = 1 et obtient la figure suivante :
Nt 6
5.5
5
4.5
4
3.5
3
2.5
2
1.5
1
0.5
0 t
0 0.5 1 1.5 2 2.5 3 3.5 4 4.5 5 5.5 6 6.5 7
Que valent dans ce cas N3,2 et N5,5 ? Donner une valeur approximative de S2 et de X4 .
Exercice 13 – Simulation de lois finies quelconques. (HH) Soit X une variable aléatoire finie définie
sur un espace probabilisé (Ω, A, P). On suppose que X(Ω) = {x1 , . . . , xn } et, pour tout i ∈ J1 ; nK, on note
k
X
pi = P(X = xi ). Pour tout k ∈ J1 ; nK, notons fk = pi . On pose f0 = 0.
i=1
1) Soit U une variable aléatoire de loi U(]0 ; 1[). Montrer que, pour tout k ∈ J1 ; nK, P(fk−1 < U 6 fk ) = pk .
2) En déduire une méthode de simulation de X à l’aide de U .
3) Soit P une liste implémentée en Python. Que font les commandes suivantes ?
1 F=np . cumsum (P)

2 np . sum ( F<r d . random ( ) )
4) En déduire une fonction qui prend en entrée une liste implémentant x1 , . . . , xn et une liste implémentant
p1 , . . . , pn et qui simule X.

Feuille de TP no 2
Statistiques bivariées
I Introduction
Dans une population donnée, on peut souhaiter étudier simultanément deux caractères X et Y . Par exemple :
• la taille X et le poids Y d’un individu en France.
• la note X en maths et la note Y en HGG d’un élève au concours HEC.
• la température X et le taux d’humidité Y un jour donné à Paris.
• la densité X de population et le taux de criminalité Y dans une ville.
Nous supposerons (comme dans les exemples ci-dessus) que les caractères étudiés sont quantitatifs. On peut alors
s’intéresser aux propriétés de chacun des deux caractères pris séparément (on parle de statistiques univariées), mais
aussi au lien entre ces 2 caractères (on parle statistiques bivariées). En particulier, on peut penser que l’une des
variables, Y par exemple, est une cause de l’autre, par exemple X. On dit alors que X est la variable explicative
et Y est la variable à expliquer. Dans le cas où X est explicative et Y à expliquer, on tentera d’exprimer Y en
fonction de X en commençant par tracer le nuage des points de Y en fonction de X pour deviner la relation
entre ces données.
Pour cela, on commence par faire un relevé statistique : on prélève sur la population initiale un échantillon de
taille n ∈ N∗ (ou sur la population entière lorsque cela est possible) et on note les valeurs des variables X et Y
observées sur ces n individus. On dispose alors d’une série statistique double, noté ( (x1 , y1 ), . . . , (xn , yn ) ) où,
pour tout k ∈ J1 ; nK, le caractère X (resp. Y ) de l’individu no k vaut xk (resp. yk ). On note x = (x1 , . . . , xn ) et
y = (y1 , . . . , yn ).
On suppose que les données x1 , . . . , xn sont implémentées en Python dans une liste ou un vecteur X et que
y1 , . . . , yn sont implémentées en Python dans une liste ou un vecteur Y.
On munit l’espace euclidien Rn de son produit scalaire canonique noté h · , · i et de sa norme euclidienne associée
notée k · k.
II Modèle de régression
1) Nuage de points
Définition. Le nuage de points associé à la série statistique ( (x1 , y1 ), . . . , (xn , yn ) ) est l’ensemble des points
du plan R2 de coordonnées (x1 , y1 ), (x2 , y2 ), · · · , (xn , yn ).
La commande Python est la suivante :

2 p l t . p l o t (X , Y , ’ x ’ )
3 p l t . show ( )
Exemple : Si les données sont implémentées dans
X=[0.06,0.9,1.47,1.56,1.84,2.77,2.83,4.86,5.26,5.38,6.1,6.2,
7.34,7.9,8.32,8.32,9.22,9.32,9.44,9.66]
Y=[0.89,1.34,1.82,1.55,0.38,0.48,2.12,1.57,2.68,3.2,2.8,0.14,
3.33,4.71,2.92,4.21,4.98,2.42,3.9,4.5],

alors le nuage de points correspondant est :
L’examen du nuage de points permet de faire des constatations qualitatives :

• Est-il concentré ou dispersé ?
• Relève-t-on une tendance (variations dans le même sens, courbe particulière, etc.) ?
• Y a-t-il des valeurs aberrantes ?
2) Point moyen
Définition. Soit ( (x1 , y1 ), . . . , (xn , yn ) ) un série statistique double.

• On appelle point moyen de la série statistique le point du plan (x, y) où
n n
1X 1X
x= xi et y= yi .
n n
k=1 k=1
n
1X
• On définit la variance de la série statistique (x1 , . . . , xn ) par σx2 = (xi − x)2 .
n
k=1
n
1X
• On définit la variance de la série statistique (y1 , . . . , yn ) par σy2 = (yi − y)2 .
n
k=1
Remarques :
• On remarque que x est la moyenne des données x1 , . . . , xn et y est la moyenne des données y1 , . . . , yn .
n n
2
1X 2 2
1X 2
• On note x = xi et y = yi . On a la formule de Koenig-Huygens :
n n
k=1 k=1
n n
1X 2 1X 2
σx2 = xi − x2 = x2 − x2 et σy2 = yi − y 2 = y 2 − y 2 .
n n
k=1 k=1
• Si on note u = (1, . . . , 1) ∈ Rn , on a
1 1 1 1
x= hx, ui, y= hy, ui, σx2 = kx − xuk2 , σy2 = ky − yuk2 .
n n n n

• On a σx2 = 0 si et seulement si, pour tout i ∈ J1 ; nK, xi = x si et seulement tous les xi , 1 6 i 6 n sont
tous égaux. Il est raisonnable de supposer que ce n’est pas le cas.
Avec Python, on calcule x, y, σx2 , σy2 avec les commandes np.mean(X), np.mean(Y), np.var(X) et np.var(Y)
respectivement.
Exemple : Si on reprend l’exemple précédent, on obtient x = 5.438, y = 2.497, σx2 = 9.903 et σy2 = 2.093
approximativement.
3) Covariance et coefficient de corrélation linéaire
Définition. On définit la covariance de la série statistique double ( (x1 , y1 ), . . . , (xn , yn ) ) par

n
1X
Cov(x, y) = (xi − x)(yi − y).
n
k=1
Remarques :
n
1X
• On note xy = xi yi . On a la formule de Koenig-Huygens :
n
k=1
n
1X
Cov(x, y) = xi yi − x y = xy − x y.
n
k=1
1
• On a Cov(x, y) = hx − xu, y − yui.
n
• L’inégalité de Cauchy-Schwarz entraîne que
1 1 p q
|Cov(x, y)| = |hx − xu, y − yui| 6 kx − xuk ky − yuk = σx2 σy2
n n
Avec Python, on calcule Cov(x, y) avec la commande np.cov(x,y)[0,1] (la commande np.cov(x,y) renvoie
en fait une matrice symétrique d’ordre 2 dont les coefficients diagonaux sont les variances de x et y et les
coefficients non diagonaux sont la covariance). Cependant cette commande n’est pas au programme donc il faut
savoir la recalculer :
1 S=0
2 n=l e n ( x )
3 f o r i in range (n) :
4 S=S+x [ i ] ∗ y [ i ]
5 c o v=S/n−np . mean ( x ) ∗ np . mean ( y )
Définition. On définit le coefficient de corrélation linéaire de la série statistique double ( (x1 , y1 ), . . . , (xn , yn ) )
par
Cov(x, y)
ρ(x, y) = p q ,
σx2 σy2
lorsque σx2 6= 0 et σy2 6= 0.
Exemple : Si on reprend l’exemple précédent, on obtient Cov(x, y) = 3, 655 et ρ(x, y) = 0.803 approximativement.
Remarques :
• La dernière remarque entraîne que ρ(x, y) ∈ [−1 ; 1].
• La covariance (ou le coefficient de corrélation) est nul si et seulement si x − xu et y − yu sont orthogonaux.
• Le cas d’égalité de l’inégalité de Cauchy-Schwarz et la dernière remarque assure que |ρ(x, y)| = 1 si et
seulement si x − xu et y − y sont colinéaires si et seulement si il existe λ ∈ R tel que y − y = λ(x − x) (ce
qui se réécrit y = λ(x − x) + y) si et seulement si les points du nuage sont alignés. On en déduit :

Interprétations du coefficient de corrélation linéaire :
• Lorsque le coefficient de corrélation linéaire (ou la covariance) d’une série statistique est positive (resp.
négative), le nuage de points a une forme « montante » (resp. « descendante »), c’est-à-dire les caractères
X et Y varient dans le même sens (resp. le sens contraire).
• Lorsque |ρ(x, y)| est proche de 1, il se peut que la variable à expliquer Y dépende de manière « presque »
affine de X. On observera dans ce cas le nuage de points de la série statistique, et si celui-ci a bien l’allure
d’une droite, on cherchera l’équation de la droite de régression linéaire (cf. paragraphe suivant).
• Une covariance (ou un coefficient de corrélation linéaire) proche de 0 traduit l’absence de relation affine
entre les caractères X et Y .
Corrélation ne veut pas dire causalité (cf. exercice 3).
III Droite de régression linéaire

Supposons que X est la variable explicative et Y la variable à expliquer.
Chercher un modèle de régression consiste à savoir si Y est une fonction de X à un bruit près. Plus formellement,
il s’agit de déterminer une fonction f telle que Y = f (X) + ε où f est appelée fonction de régression et ε est une
variable aléatoire réelle appelée erreur d’ajustement (ou bruit, ou résidu).
Dans la suite de ce paragraphe, nous verrons le cas où f est une fonction affine : il existe (a, b) ∈ R2 tel que
f (X) = aX + b. On parle alors de régression linéaire. Il existe cependant bien d’autres choix pour la fonction f
(par exemple f (X) = eaX + b) et on essaye souvent de se ramener au cas linéaire (cf. exercices 1 et 2).
Lorsque le nuage de points associé à la série statistique a tendance à « s’étirer linéairement », il se peut que la
variable à expliquer Y dépende de manière « presque » affine de X. On cherche dans ce cas l’équation de la droite
s’approchant au mieux du nuage de points au sens des moindres carrés.
Définition. La droite de régression linéaire de Y (variable à expliquer) en X (variable explicative) de la série

statistique double ( (x1 , y1 ), . . . , (xn , yn ) ) est la droite d’équation y = ax + b telle que la quantité
n
X
F (a, b) = (yk − (axk + b))2
k=1
est minimale.
Remarques :
• Cette droite existe dès que les xi , 1 6 i 6 n, ne sont pas tous égaux (ce qui est une hypothèse
raisonnable). Par ailleurs elle est unique, comme on le verra dans la démonstration de la proposition suivante.
• Graphiquement, F (a, b) représente la somme des carrés des distances entre les points de la droite d’abscisse
xk et les points du nuage de même abscisse xk pour k ∈ J1 ; nK.
Proposition. Soit ( (x1 , y1 ), . . . , (xn , yn ) ) une série statistique double associée à X et Y . On suppose que les
xi , 1 6 i 6 n, ne sont pas tous égaux. On a alors σx2 > 0 et la droite de régression linéaire de Y en X a pour
équation y = b ax + bb avec
Cov(x, y) Cov(x, y)
a= 2
et bb = y − x,
σx2
b
σx
c’est-à-dire c’est la droite d’équation
Cov(x, y)
y= (x − x) + y.
σx2
Exemple : Si on reprend l’exemple précédent, on calcule que b a = 0, 369 (avec la commande

a=np.cov(X,Y)[0,1]/np.var(X)) et bb = 0, 490 (avec la commande np.mean(Y)-a*np.mean(X)).

Démonstration.
Voici un programme en Python qui représente la droite de régression sur l’intervalle [m, M ], où m et M sont des
réels tels que m < M implémentés en Python par m et M (on peut prendre pour m et M la plus petite et la plus
grand valeur respectivement de la série (x1 , . . . , xn )) :
3 a=np . c o v (X , Y) [ 0 , 1 ] / np . v a r (X)
4 b=np . mean (Y)−a ∗ np . mean (X)
5 p l t . p l o t ( [ m,M] , [ a ∗m+b , a ∗M+b ] )
6 p l t . show ( )

Exemple : Voici ce que l’on obtient avec l’exemple précédent, superposé au nuage de points :
Remarque : Si la variable à expliquer est X et si Y est la variable explicative (mais que l’on a tracé X en
abscisses et Y en ordonnée), on définit de même la droite de régression linéaire de X en Y de la série statistique
n
X 2
(ou du nuage associé) : il s’agit de la droite d’équation x = my + p telle que G(m, p) = xk − (myk + p)
k=1
Cov(x, y)
est minimal. De manière analogue, la droite de régression de X en Y a pour équation x = (y − y) + x.
σy2
Il s’agit donc de la droite d’équation :
σy2
y= (x − x) + y
Cov(x, y)
si la covariance ci-dessus est non nulle bien sûr.
Les points moyens, les variances, la covariance, la droite de régression ne sont que des indicateurs. Ils ne
caractérisent eu aucun cas les variables X et Y ni un éventuel lien de cause à effet. Les exemples suivants sont
assez parlant :

IV Exercices
Exercice 1 – D’après HEC ECE 2016. (HH) On s’intéresse à la fonction de production d’une entreprise qui
produit un certain bien à une époque donnée. On note respectivement X et Y les quantités de travail et de capital
requises pour produire une certaine quantité de ce bien, et l’on suppose que X > 0 et Y > 0.
On suppose que la production totale de l’entreprise est une variable aléatoire Q telle que Q = BX a Y 1−a eR , où
a ∈ ]0 ; 1[, B > 0 et R est une variable aléatoire suivant une loi normale centrée. Enfin, on pose :
b = ln(B), U = ln(X) − ln(Y ), et T = ln(Q) − ln(Y ).
On sélectionne n ∈ N∗ entreprises qui produisent le bien considéré à l’époque donnée. On mesure pour chaque
entreprise i ∈ J1 ; nK la quantité de travail xi et la quantité de capital yi utilisées ainsi que la quantité produite qi .
On suppose que, pour tout i ∈ J1 ; nK, xi > 0, yi > 0 et qi > 0.
Pour tout i ∈ J1 ; nK, xi , yi et qi sont des réalisations de variables aléatoires Xi , Yi , Qi ayant respectivement
les mêmes lois que X, Y , et Q. On a Qi = BXia Yi1−a exp(Ri ) et qi = Bxai yi1−a exp(ri ). Ici r1 , . . . , rn sont des
réalisations de R1 , R2 , ..., Rn qui sont des variables aléatoires supposées indépendantes et de même loi que R. On
pose, pour tout i ∈ J1 ; nK :
Ui = ln Xi − ln Yi , Ti = ln Qi − ln Yi et ti = ln qi − ln yi
Ainsi, pour chaque entreprise i ∈ J1 ; nK, ti est une réalisation de la variable aléatoire Ti .
On a relevé pour n = 16 entreprises qui produisent le bien considéré à l’époque donnée, les deux séries statistiques
(ui )16i6n et (ti )16i6n implémentées dans Python par les listes
u=[1.06,0.44,2.25,3.88,0.61,1.97,3.43,2.10,1.50,1.68,2.72,1.35,2.94,2.78,3.43,3.58]
t=[2.58,2.25,2.90,3.36,2.41,2.79,3.32,2.81,2.62,2.70,3.17,2.65,3.07,3.13,3.07,3.34]
1) Vérifier que T = aU + b + R et, pour tout i ∈ J1 ; nK, ti = aui + b + ri .
2) Représenter sur un même graphique :
• le nuage des points (u1 , t1 ), (u2 , t2 ), . . . , (un , tn ).
• la droite de régression de T en U .
• la droite de régression de U en T .
3) Interpréter le point d’intersection des deux droites de régression.
4) Estimer graphiquement les moyennes empiriques u et t.
Exercice 2 – Développement de bactéries. (HH) On étudie dans cet exercice le nombre de bactéries présentes
dans un bouillon de culture au fur et à mesure du temps.
On dispose de la matrice de données suivante :
donnees=np.array([[0,1,2,3,4,5,6],[32,47,65,92,132,190,275]])
Cette matrice contient deux lignes, la seconde indiquant le nombre de bactéries (par unité de volume) présentes dans
le bouillon de culture au cours de l’expérience : pour tout i ∈ J0 ; 6K, xi =donnees[0,i]= i et yi =donnees[1,i]
est le nombre de bactéries par unité de volume présentes dans le bouillon de culture après i heures.
1) Pour ce relevé statistique, quelle est la variable explicative X ? Quelle est la variable à expliquer Y ?
2) Représenter le nuage de points des données.
3) Avec Python calculer les moyennes x et y, les variances σx2 et σy2 des séries statistiques X et Y , ainsi la
covariance et le coefficient de corrélation linéaire r de la série statistique.
4) Superposer au nuage de points la droite de régression de y en x.

5) Le nuage de points de la série statistique peut laisser penser que Y est une fonction « exponentielle de X » :
il semble qu’il existe α et λ deux réels strictement positifs tels que Y ≈ λ.eαX . Remarquons que
Y ≈ λ.eαX ⇐⇒ ln(Y ) ≈ αX + ln λ.
Ainsi, il semble que la « nouvelle » variable à expliquer ln(Y ) est une fonction « presque » affine de X.
Nous allons alors étudier la série statistique bivariée de variable explicative X et de variable à expliquer
Z = ln(Y ), et nous allons déterminer la droite de régression linéaire de cette série.
a) Définir en Python un vecteur Z contenant (s0 , . . . , z6 ) = (ln(y0 ), . . . , ln(y6 )).
b) Déterminer l’équation de la droite de régression linéaire de Z en X, notée z = αx + β.
c) Représenter alors le nuage de points de la série statistique ( (x0 , z0 ), (x1 , z1 ), . . . , (x6 , z6 ) ) et lui
superpose la droite en question. Commenter.
d) Superposer à la courbe de la question 1, la courbe d’équation y = eβ eαx . Commenter.
Exercice 3 – Corrélation ne veut pas dire causalité. (H)

Une bonne corrélation entre deux séries de données ne signifie pas pour autant qu’il existe un lien de cause à effet
entre les deux. Voici deux exemples :
1) Ce tableau donne la consommation de margarine (en livre par personne) aux USA, et la taux de divorce
dans l’état du Maine (en divorce pour 1000 personnes).
Année 2000 2001 2002 2003 2004 2005 2006 2997 2008 2009
Taux de divorce 8,2 7 6,5 5,3 5,2 4 4,6 4,5 4,2 3,7
Consommation de margarine 5 4,7 4,6 4,4 4,3 4,1 4,2 4,2 4,2 4,1
Calculer le coefficient de corrélation. Commenter.
2) Ce tableau donne la consommation de mozzarella (en livre par personne) et le nombre de doctorats en génie
civil décernés aux USA.
Année 2000 2001 2002 2003 2004 2005 2006 2997 2008 2009
Consommation de mozzarella 9,3 9,7 9,7 9,7 9,9 10,2 10,5 11 10,6 10,6
Nombre de doctorats 480 501 540 552 547 622 655 701 712 708
Calculer le coefficient de corrélation. Commenter.
Exercice 4 – Autre démonstration de la droite de régression. (HH) Soient x1 , . . . , xn des réels qui ne sont
pas tous égaux. Soient y1 , . . . , yn des réels. On note
n n n n
1X 1X 1X 2 1X
x= xi , y= yi x2 = xi , xy = xi yi ,
n n n n
k=1 k=1 k=1 k=1
n n
1X 1X
σx2 = (xi − x)2 = x2 − x2 , et Cov(x, y) = (xi − x)(yi − y) = xy − x y.
n n
k=1 k=1
1) Montrer que σx2 > 0.

2) Montrer que la fonction
n
X
2
F : (a, b) ∈ R 7−→ (yi − axi − b)2
i=1

Cov(x, y) Cov(x, y)
est de classe C1 sur R2 et admet pour unique point critique (b
a, bb) = ,y − x .
σx2 σx2
3) Montrer que, pour tout (a, b) ∈ R2 ,
a, bb) = a2 σx2 + (ax + b)2 .

a, b + bb) − F (b
F (a + b
4) En déduire que F admet un unique minimum en (b

a, bb).

Feuille de TP no 3
Fonctions de plusieurs variables – Première

partie
I Représentations de fonctions de deux variables

1) Courbe, surface
Définition. Soit n ∈ N∗ . Soit f : Rn −→ R. On appelle graphe de f l’ensemble de Rn+1 défini par
Cf = {(x1 , x2 , . . . , xn+1 ) ∈ Rn+1 | xn+1 = f (x1 , . . . , xn )}
• Si n = 1, on retrouve la courbe d’une fonction de la variable réelle :
Cf = {(x, y) ∈ R2 | y = f (x)}
• Si n = 2, alors la courbe de f est une surface tracée dans l’espace :
Cf = {(x, y, z) ∈ R3 | z = f (x, y)}.
Remarque : Dans le cas où n = 2 (qui va nous intéresser dans ce chapitre), on peut voir les coordonnées x et y
d’un point (x, y) ∈ R2 comme la latitude et la longitude et z = f (x, y) comme l’altitude de ce point. Bien que ce
soit une surface en 3 dimensions, on arrive à la représenter dans le plan en jouant sur la perspective et en utilisant
des couleurs (les variations de couleurs représentent les variations d’altitude).
Exemples :
• Courbe de f : (x, y) ∈ R2 7−→ x2 + y 2 : • Courbe de f : (x, y) ∈ R2 7−→ sin(x) + cos(y) :
2) Lignes de niveaux
Définition. Soit n ∈ N∗ . Soit f : Rn −→ R. Soit λ ∈ R. On appelle ligne de niveau λ de f l’ensemble
{(x1 , . . . , xn ) ∈ R2 | f (x1 , . . . , xn ) = λ}.
Remarque :
• Si n = 2, représenter des lignes de niveau consiste à se placer dans le plan, se donner une liste de niveaux
puis, pour chacun des niveaux λ de la liste, représenter l’ensemble {(x, y) ∈ R2 | f (x, y) = λ} en indiquant
le niveau. Par exemple :

• Si n = 2 et si f est la fonction qui à la longitude et la latitude associe l’altitude, alors les lignes de niveau
représentent les points qui sont à la même altitude : si on se promène sur une ligne de niveau, on ne monte
pas et on ne descend pas : on reste au même niveau. Ce sont les lignes de niveau représentées sur les cartes
topographiques. Par exemple :
Exemples :
• Lignes de niveau de • Lignes de niveau de
f : (x, y) ∈ R2 7−→ x2 + y 2 : f : (x, y) ∈ R2 7−→ sin(x) + cos(y) :

Lecture de lignes de niveaux : Si au voisinage d’un point a, les lignes de niveaux ont tendance à se resserrer au
fur et à mesure que le niveau augmente, cela traduit qu’il y a un maximum local en a :
Si au voisinage d’un point a, les lignes de niveaux ont tendance à se resserrer au fur et à mesure que le niveau
diminue, cela traduit qu’il y a un minimum local en a :
3) Champ de gradient
Si f est une fonction de classe C 1 de R2 dans R, construire un champ de gradient de f revient à se donner
plusieurs points du plan et à tracer une flèche correspondant au vecteur gradient de chacun de ses points. Par
exemple :

Proposition. Soit f : Rn −→ R de classe C 1 sur Rn . Soit a ∈ Rn . Si le gradient ∇f (a) 6= 0, alors :
• ∇f (a) est orthogonal à la tangente à la ligne de niveau f (a) de f .
• ∇f (a) pointe vers les lignes de niveaux supérieurs (c’est-à-dire les lignes de niveau c pour tout c > f (a)).
Esquisse de démonstration.

Démonstration dans le cas particulier où f : (x, y) ∈ R2 7−→ 1 − x2 − y 2 .
A faire sur une feuille séparée.
Exemples :
• Champ de gradient de • Champ de gradient de
f : (x, y) ∈ R2 7−→ x2 + y 2 : f : (x, y) ∈ R2 7−→ sin(x) + cos(y) :
Lecture d’un champ de gradient : Dans un champ de gradient, on repère facilement les points critiques (en
lesquels le gradient est nul par définition).
• Si au voisinage d’un point critique a, tous les gradients du champ pointent en direction de a, cela traduit
qu’il y a un maximum local en a :
• Si au voisinage d’un point critique a tous les gradients du champ pointent dans la direction opposée à a,
cela traduit qu’il y a un minimum local en a :

• Si au voisinage d’un point critique a, les gradients ne pointent pas tous en direction du point ou dans la
direction opposée, alors cela traduit qu’il ne s’agit pas d’un extremum local :
On dit qu’il tel point est un point col ou un point selle, pour faire référence à une selle de cheval comme on
peut le voir sur la surface ci-dessus (dont le champ de gradient ci-dessus correspond) :
Analyser le champ de gradient permet alors de conjecturer de domaines du plan dont la restriction de f
à ces domaines présente en a un maximum local et d’autres domaines où c’est un minimum local. Dans
l’exemple ci-dessus, on conjecture que sur {(x, y) ∈ R2 | y = 0}, f admet un minimum local (le long de
cette droite, les gradients pointent dans la direction opposée de a = (0, 0)) et sur {(x, y) ∈ R2 | x = 0},
f admet un maximum local (le long de cette droite, les gradients pointent vers a = (0, 0)). Reste à le
démontrer proprement.
II Représentation à l’aide de Python

La maitrise des fonctions Python permettant la représentation graphique de fonctions de plusieurs variables n’est
pas exigible, conformément au programme.
La commande np.meshgrid est utilisée pour créer une grille rectangulaire à partir de deux tableaux unidimen-
sionnels donnés représentant l’indexation cartésienne de la grille. En lien avec cette fonction, la commande
• plt.contour sert à tracer des lignes de niveau.
• plt.quiver sert à tracer des gradients.
Pour une représentation de surfaces, on utilise la commande ax.plot_surface, en ayant au préalable importé :
1 from m p l _ t o o l k i t s . mplot3d i m p o r t Axes3D
2 ax = Axes3D ( p l t . f i g u r e ( ) )
Rentrons dans les détails : soit f une fonction définie sur un domaine D de R2 et à valeurs réelles. Soient a, b, c, d
des réels tels que a < b, c < d et [a ; b] × [c ; d] ⊂ D. On suppose que l’on implémente f, a, b, c, d en Python avec
les variables f,a,b,c,d respectivement.

• Pour tracer la surface représentative de f sur [a ; b] × [c ; d], on utilise les commandes suivantes :
1 #On f a i t l e s i m p o r t a t i o n s r e q u i s e s .
5 ax = Axes3D ( p l t . f i g u r e ( ) )
6
7 #On d i s c r é t i s e l e s a x e s ( i c i a v e c un p a s 0 . 0 1 ) .
8 X = np . a r a n g e ( a , b , 0 . 0 1 )
9 Y = np . a r a n g e ( c , d , 0 . 0 1 )#On p o u r r a i t a u s s i u t i l i s e r np . l i n s p a c e .
10
11 #On c r é e une g r i l l e r e c t a n g u l a i r e à p a r t i r de X e t Y .
12 X , Y=np . m e s h g r i d (X , Y)
13
14 #On c r é e l e t a b l e a u d e s i m a g e s de X , Y p a r f .
15 f=np . v e c t o r i z e ( f )#On v e c t o r i s e l a f o n c t i o n f s i n é c e s s a i r e .
16 Z=f (X , Y)
17
18 #On t r a c e l a s u r f a c e .
19 ax . p l o t _ s u r f a c e (X , Y , Z )
20 p l t . show ( )
Si on veut ajouter de la couleur à la surface, on peut remplacer la ligne 19 par :

1 from m a t p l o t l i b . cm i m p o r t coolwarm
2 ax . p l o t _ s u r f a c e (X , Y , Z , cmap=coolwarm )
• Pour tracer des lignes de niveaux, on commencer par lister les niveaux voulus (dans l’ordre croissant) dans
une liste L. Ensuite on utilise les commandes suivantes :
4
5 #On d i s c r é t i s e l e s a x e s ( i c i a v e c un p a s 0 . 0 1 ) .
6 X = np . a r a n g e ( a , b , 0 . 0 1 )
7 Y = np . a r a n g e ( c , d , 0 . 0 1 )#On p o u r r a i t a u s s i u t i l i s e r np . l i n s p a c e .
8
10 X , Y=np . m e s h g r i d (X , Y)
11
12 #On c r é e l e t a b l e a u d e s i m a g e s de X , Y p a r f .
13 f=np . v e c t o r i z e ( f )#On v e c t o r i s e l a f o n c t i o n f s i n é c e s s a i r e .
14 Z=f (X , Y)
15
16 #On t r a c e l e s l i g n e s de n i v e a u .
17 p l t . c o n t o u r (X , Y , Z , L )
18 p l t . show ( )
On peut aussi ajouter les indications des niveaux en remplaçant la ligne 17 par :
1 cp=p l t . c o n t o u r (X , Y , Z , L )
2 p l t . c l a b e l ( cp , i n l i n e =True , f o n t s i z e =10)
Si on remplace plt.contour(X,Y,Z,L) par plt.contour(X,Y,Z), les niveaux sont choisis par défaut.
• Pour tracer un champ de gradient, on utilise les commandes suivantes :
4
5 #On d i s c r é t i s e l e s a x e s .
6 #Le p a s ( i c i 0 . 1 ) ne d o i t p a s ê t r e t r o p p e t i t
7 #( s i n o n i l y a u r a t r o p de f l è c h e s ) .
8 X = np . a r a n g e ( a , b , 0 . 1 )
9 Y = np . a r a n g e ( c , d , 0 . 1 )#On p o u r r a i t a u s s i u t i l i s e r np . l i n s p a c e .

10
12 X , Y=np . m e s h g r i d (X , Y)
13
14 #On i m p l é mente l e g r a d i e n t de f .
15 def gradf (x , y ) :
16 r e t u r n . . . . . . , . . . . . . #g r a d i e n t de f .
17 g r a d f=np . v e c t o r i z e ( g r a d f )
18 dx , dy=g r a d f (X , Y)
19
20 #On t r a c e l e champ de g r a d i e n t .
21 p l t . q u i v e r (X , Y , dx , dy )
22 p l t . show ( )
2 2
Exemple : Prenons a = −2, b = 2 et f : (x, y) 7−→ xye−(x +y ) . Il s’agit d’une fonction de classe C 1 sur R2 et
on a, pour tout (x, y) ∈ R2 ,
2 2 2 2

∇f (x, y) = y(1 − 2x2 )e−(x +y ) , x(1 − 2y 2 )e−(x +y ) .
On implémente f et les deux dérivées partielles premières par :

1 def f (x , y ) :
2 r e t u r n x ∗ y ∗ np . exp ( −( x∗∗2+y ∗ ∗ 2 ) )
3
5 g=np . exp ( −( x∗∗2+y ∗ ∗ 2 ) )
6 r e t u r n y ∗(1 −2∗ x ∗ x ) ∗g , x ∗(1 −2∗ y ∗ y ) ∗ g
• Éxécutons les commandes :

2 ax=Axes3D ( p l t . f i g u r e ( ) )
3 X=np . a r a n g e ( − 2 , 2 , 0 . 0 1 ) , Y=X
4 X , Y=np . m e s h g r i d (X , Y)
5 Z=f (X , Y)
7 ax . p l o t _ s u r f a c e (X , Y , Z , cmap=coolwarm )
8 p l t . show ( )
On obtient alors la surface suivante :

1 X=np . a r a n g e ( − 2 , 2 , 0 . 0 1 ) ; Y=X
2 X , Y=np . m e s h g r i d (X , Y)
3 Z=f (X , Y)
4 cp=p l t . c o n t o u r (X , Y , Z )
5 p l t . c l a b e l ( cp , i n l i n e =True , f o n t s i z e =10)
6 p l t . show ( )
On obtient alors les lignes de niveau suivantes :
On remarque que, au voisinage des points de coordonnées approximatives (0.7, 0.7) et (−0.7, −0.7), les
lignes de niveaux se resserrent au fur et à mesure que le niveau augmente. Cela suggère qu’il y a un maximum
local en ces points. Au voisinage des points de coordonnées approximatives (−0.7, 0.7) et (0.7, −0.7), les
lignes de niveaux se resserrent au fur et à mesure que le niveau diminue. Cela suggère qu’il y a un minimum
local en ces points.
1 X=np . a r a n g e ( − 2 , 2 , 0 . 1 ) ; Y=X
2 X , Y=np . m e s h g r i d (X , Y)
3 dx , dy=g r a d f (X , Y)
4 p l t . q u i v e r (X , Y , dx , dy )
5 p l t . show ( )
On obtient alors le champ de gradient suivant :

On remarque qu’il semble y avoir 5 points critiques. Localement, toutes les flèches pointent vers les points
de coordonnées approximatives (0.7, 0.7) et (−0.7, −0.7). Cela suggère qu’il y a un maximum local en
ces points. Localement, toutes les flèches partent des points de coordonnées approximatives (−0.7, 0.7) et
(0.7, −0.7). Cela suggère qu’il y a un minimum local en ces points. En revanche, en le point de coordonnées
(0, 0), il y a des flèches qui pointent et des flèches qui partent localement. Cela suggère que c’est un point
selle.
III Exercices
2 +y 2 )
Exercice 1. (HH) Soit f : (x, y) ∈ R2 7−→ xye−(x . Il s’agit de la fonction de l’exemple ci-dessus.
1) Montrer que f est de classe C 1 sur R2 et déterminer ses points critiques.
2) Montrer que (0, 0) est un point selle.
3) a) Étudier les extrema de la fonction t ∈ R+ 7−→ te−t .
x2 + y 2
b) Justifier que, pour tout (x, y) ∈ R2 , xy 6 .
2
c) En déduire que f admet des extrema globaux en les quatre autre points critiques.
Exercice 2. (H) à (HHH)

1) Pour les fonctions suivantes, représenter la surface, des lignes de niveaux et un champ de gradient puis conjec-
turer la présence de points critiques et leur nature (point selle, point en lequel il y a un maximum/minimum
local/global) :
a) (x, y) 7−→ x3 + xy + y 3 ,
b) (x, y) 7−→ sin(x) + y 2 − 2y + 1,
c) (x, y) 7−→ xy − x2 y − xy 2 ,
d) (x, y) 7−→ x4 + y 4 − 2(x − y)2 ,
−3y
e) (x, y) 7−→ 2 ,
x + y2 + 1
f) (x, y) 7−→ ex (x + y 2 + ex ).
2) Démontrer ensuite ces conjectures.
Pour la question 1f, on montrera au préalable que ϕ : t 7−→ 1 + t + 2et s’annule en un unique point α et
que α ∈ [−2 ; −1].

Feuille de TP no 4
Convergences et approximations de variables

aléatoires
I Retour sur la loi faible des grands nombres

1) Approximation de probabilité ou d’espérance
Soient (Xn )n>1 une suite de variables aléatoires indépendantes admettant une espérance m et une variance.
La loi faible des grands nombres assure que
n
1X P
Xn = Xi −−−−−→ m,
n n→+∞
k=1
c’est-à-dire
∀ε > 0, P(|Xn − m| > ε) −−−−−→ 0.
n→+∞
Ainsi :
• Pour n assez grand (on peut même contrôler l’erreur grâce à l’inégalité de Bienaymé-Tchebychev ou le TCL,
cf. paragraphe III.1), Xn est une approximation de m = E(X1 ).
• On répète un grand nombre de fois une expérience indépendamment et on se demande le nombre de
fois qu’un certain phénomène est réalisé. Plus précisément, pour tout k ∈ N∗ , notons Ak l’événement
« l’événement qui nous intéresse est réalisé lors de la k-ième expérience ». On prend alors Xk = 1Ak pour
tout k ∈ N∗ et on a :
n
card({k ∈ N∗ | Ak est réalisé}) 1X P
= 1Ak −−−−−→ E(1A1 ) = P(A1 ).
n n n→+∞
k=1
Autrement dit, lorsqu’on réalise un grand nombre de fois une expérience indépendamment, la proportion
de fois qu’un événement est réalisé lors de ces expériences, est une approximation de la probabilité de cet
événement.
Nous avons vu de nombreux exemples d’application l’an passé et dans les TP no 0 et 1.
Supposons que l’on ait implémenté en Python l’espérance m dans la variable m et que la liste en Python X contienne
des réalisations x1 , . . . , xn des variables aléatoires X1 , . . . , Xn , avec n ∈ N∗ . La commande np.cumsum(X) renvoie
donc un vecteur contentant
x1 , x1 + x2 , x1 + x2 + x3 , . . . , x1 + x2 + · · · + xn
et donc np.cumsum(X)/range(1,len(X)+1) renvoie donc un vecteur contentant

x1 + x2 x1 + x2 + x3 x1 + x2 + · · · + xn
x1 , , ,..., .
2 3 n
Ainsi le script suivant permet d’illustrer graphiquement la loi faible des grands nombres :

3 n=l e n (X)
4 Xbar=np . cumsum (X) / r a n g e ( 1 , n+1)
5 p l t . p l o t ( r a n g e ( 1 , n+1) , Xbar )
6 p l t . p l o t ( [ 1 , n ] , [ m,m] )
7 p l t . show ( )
Ci contre, un exemple avec 1000 variables aléatoires

indépendantes de loi B(20, 1/4) donc avec
X=rd.binomial(20,1/4,1000) et m=5.
Remarque : Pourquoi la loi faible des grands nombres ? Et bien parce qu’il existe une loi forte des grands nombres.
On peut montrer (mais c’est bien plus difficile que pour la loi faible) que, si (Xn )n>1 est une suite de variable
aléatoire définies sur un espace probabilisé (Ω, A, P), qui sont indépendantes et de même loi admettant une
espérance m, alors
P ω ∈ Ω Xn (ω) −−−−−→ m = 1.
n→+∞
Autrement dit, presque sûrement, Xn −−−−−→ m. On parle de convergence presque sûre (attention ce terme est
n→+∞
hors-programme).
2) Histogramme et fonction de répartition empirique

Souvent cette année et l’an passé, nous avons superposé des histogrammes à des diagrammes à barres ou à des
courbes de densité pour conjecturer la loi d’une variable aléatoire. Il s’agit d’applications de la loi des grands
nombres. Démontrons-cela :
Soit (X1 , . . . , Xn ) des variables aléatoires indépendantes et de même loi qu’une variable aléatoire X (typiquement
on connaît des réalisations de X1 (ω), . . . , Xn (ω) qui peuvent donc être vues comme n réalisations indépendantes
de X).
• Cas où X est discrète. On construit alors un histogramme ou plutôt un diagramme à barre empirique. Pour
tout x ∈ X(Ω), on trace une barre dont la hauteur est la proportion de réalisations qui valent x. Il s’agit de
n
1X
1[Xi =x] .
n
k=1
Par la loi des grands nombres, cette quantité converge en probabilité vers E(1[X=x] ) = P(X = x) quand n
tend vers +∞. Cela explique bien pourquoi, lorsque n est grand, le diagramme empirique se superpose au
diagramme théorique.
• Cas où X est à densité. Notons F la fonction de répartition de X et f une densité de X. On sépare les
observations en classes. Supposons que l’une des classe corresponde aux valeurs entre a et b. La barre de
l’histogramme renormalisé correspondant à cette classe a pour hauteur
n
1 X
1[a<Xi 6b] .
n(b − a)
k=1
Par la loi des grands nombres, quand n tend vers +∞, cette quantité converge en probabilité vers
E(1[a<Xi 6b] ) P(a < X 6 b) F (b) − F (a)
= = .
b−a b−a b−a
F (b) − F (a)
Remarquons alors que, si F est dérivable en a et F 0 (a) = f (a), on a −−−→ F 0 (a) = f (a).
b−a b→a
Ainsi lorsque n est grand et b proche de a (c’est le cas lorsqu’il y a beaucoup de classes), cela explique
pourquoi la courbe de la densité épouse bien l’histogramme.
Dans l’exercice 8 du TP no 1, nous avons également défini la fonction de répartition empirique d’un échantillon et
démontré que, ponctuellement, elle converge en probabilité vers la fonction de répartition théorique.

3) Méthode de Monte-Carlo pour le calcul approché d’intégrales
La méthode de Monte-Carlo est une méthode permettant de calculer des valeurs numériques approchées en
utilisant des variables aléatoires. On a déjà vu des exemples dans le paragraphe 1 de la partie II (calcul approché de
probabilités d’événements ou d’espérances de variables aléatoires). Dans ce paragraphe, nous allons voir comment
la loi faible des grands nombres permet de justifier un procédé de calcul approché d’intégrales.
Z b
Soient a et b des réels tels que a < b. Soit f une fonction continue sur ]a ; b[ et telle que f (t) dt converge
a
absolument. Le théorème de transfert assure que, si U est une variable aléatoire de loi U(]a ; b[), alors
Z b
dx
E(f (U )) = f (x) .
a b−a
et donc Z b
f (x) dx = (b − a)E(f (U )).
a
1
Notons que l’existence de l’espérance de f (U ) est immédiate (car l’intégrale de x 7−→ |f (x)| 1 (x) sur
b − a ]a ;b[
]a ; b[ converge et que cette fonction est nulle en dehors de ]a ; b[). Il en est de même pour la variance de f (U ) si
Z b
on suppose de plus que (f (t))2 dt converge.
a
Si on se donne une suite (Un )n∈N∗ de variables aléatoires indépendantes de loi uniforme sur ]a ; b[, alors (f (Un ))n∈N∗
est une suite de variables aléatoires indépendantes (par théorème des coalitions) et de même loi. Elles admettent
une espérance et une variance donc la loi faible des grands nombres entraîne que
n
1X P
f (Ui ) −−−−−→ E(f (U )).
n n→+∞
i=1
Ainsi (puisque x 7−→ (b − a)x est continue sur R), on obtient :

n b
b−aX
Z
P
f (Ui ) −−−−−→ f (x) dx.
n n→+∞ a
i=1
n b
b−aX
Z
On en déduit que f (Ui ) est une approximation de f (x) dx.
n a
i=1
Néanmoins la loi faible des grands nombres ne permet pas de mesurer la rapidité de la convergence. On assortit
généralement le procédé ci-dessus d’une quantification des garanties d’approximation fournie par le Théorème
Central Limite (cf. paragraphe 3 du III). On peut aussi utiliser l’inégalité de Bienaymé-Tchebychev (mais elle est
beaucoup moins précise on trouvera une valeur de n garantissant une bonne approximation qui est bien exagérée).
Supposons que la variance de f (U ) est majorée, disons par un réel M que l’on connaît. On a alors
n Z b !
b−aX M
P f (Ui ) − f (t) dt > ε 6 (b − a)2 2 .
n a nε
i=1
En effet :

Ainsi :
√ n
(b − a) M M b−aX
• Àn∈ N∗et α ∈ ]0 ; 1[ fixés, si on prend ε = √ , alors (b − a)2 2 6 α et donc f (Ui )
αn nε n
√ i=1
Z b
(b − a) M
est une approximation de f (x) dx à √ près.
a αn
• Inversement, si on se donne ε > 0 et α ∈ ]0 ; 1[, on sait que, avec un niveau de confiance 1 de 1 − α, une
n Z b
b−aX
approximation f (Ui ) est une approximation de f (x) dx à ε près dès que n = .
n a
i=1
En effet :
Exercice 1. Calculer des valeurs approchées des intégrales suivantes à 10−4 près (avec une niveau de confiance
1 − α) avec un niveau de confiance de 95% et les comparer à les approximation de leurs valeurs exactes 2 fournies
par Python :
Z 1 Z 2 Z 1 Z 1p Z 1
dt dt dt 2
, , 2
, 1 − t dt, ln(t) dt.
0 1+t 0 1+t 0 1+t −1 0
Exercice
Z +∞ 2 – Le cas d’une intégrale sur R+ ou R. (HH) Soit f une fonction définie sur R+ et telle que
f (x) dx converge absolument.
0
1) a) Justifier que
Z +∞ Z 1
dt
f (x) dx = f (− ln(t)) .
0 0 t
b) A l’aide de la Zméthode de Monte-Carlo, déterminer un algorithme permettant de calculer une valeur
+∞
approchée de f (x) dx.
0
Z +∞ Z +∞
2) En remarquant que f (x) dx = f (x)ex × e−x dx, proposer une autre méthode permettant de
0 Z +∞0
calculer une valeur approchée de f (x) dx.
0
Z +∞ r
−x2 /2 π
3) Tester ces deux méthodes avec Python pour calculer e dx = . Comparer avec la vraie valeur.
0 2
Z +∞
4) Comment faire pour approcher f (x) dx avec Python lorsque celle-ci converge absolument ?
−∞
On pourra s’aider d’une bijection de ]0 ; 1[ dans R (comme par exemple t 7−→ ln(1/t − 1), t 7−→ ln(− ln(t))
ou t 7−→ tan(π(1/2 − t))), ou encore couper l’intégrale en deux, ou utiliser une loi Normale.
1. C’est-à-dire avec probabilité supérieure ou égale à 1 − α.
π π
2. Il faut savoir les calculer bien sûr. Elles font respectivement ln(2), ln(3), , , −1.
4 2

Exercice 3 – Estimation de la fonction de répartition. (HH)
1) Soit X une variable aléatoire réelle ne prenant que des valeurs positives. En utilisant la méthode de
Monte-Carlo, proposer une fonction qui prend en entrée x et qui calcule une valeur approchée de FX (x), la
fonction de répartition de X en x.
2) Utiliser cette fonction pour illustrer (en superposant la fonction de répartition estimée avec la fonction de
répartition théorique) le fait que :
• X1 + X2 ,→ B(n1 + n2 , p) lorsque X1 et X2 sont indépendantes de lois B(n1 , p) et B(n2 , p) respecti-
vement.
• X1 + X2 ,→ P(a1 + a2 ) lorsque X1 et X2 sont indépendantes de lois P(a1 ) et P(a2 ) respectivement.
• X1 + X2 ,→ N (m1 + m2 , σ12 + σ22 ) lorsque X1 et X2 sont indépendantes de lois N (m1 , σ12 ) et
N (m2 , σ22 ) respectivement.
• X1 + X2 + · · · + Xn ,→ γ(n) lorsque X1 , . . . , Xn sont indépendantes de loi E(1).
Pour la fonction de répartition en un réel x de la loi γ(n), on utilisera sp.gdtr(1,n,x) après
import scipy.special as sp.
Exercice 4 – Produit de deux variables aléatoires de loi uniforme. (HH) Soient X et Y deux variables
aléatoires indépendantes de même loi uniforme sur ]0 ; 1[. On note Z = XY .
1) Écrire une fonction Python qui prend en entrée t et qui calcule une valeur approchée de FZ (t) à l’aide de la
méthode de Monte-Carlo.
2) Avec Python, représenter graphiquement la courbe de FZ sur [−1/2 ; 3/2]. Lui superposer la courbe de la
fonction t 7−→ t(1 − ln(t))1]0 ;1[ (t) + 1[1 ;+∞[ (t). Que conjecturer ?
3) Montrer la conjecture.
On commencera par calculer la fonction de répartition de − ln(Z).
II Convergence en loi
Exercice 5 – D’après EDHEC 2017 et les oraux ESCP 2003. (HH) Soit (Xn )n>1 une suite de variables
aléatoires définies sur un même espace probabilisé (Ω, A, P) qui sont indépendantes et de même loi U([0 ; 1]).
Pour tout n ∈ N∗ , on note Mn = max{X1 , . . . , Xn }. Plus rigoureusement
∀ω ∈ Ω, Mn (ω) = max{X1 (ω), . . . , Xn (ω)}.
On admet que Mn est que variable aléatoire. Enfin, on pose Yn = n(1 − Mn ).

1) a) Soit n ∈ N∗ . Calculer FMn puis montrer que Mn est une variable aléatoire à densité.
b) Établir l’existence de E(Mn ) et E(Mn2 ). Les calculer.
c) Soit ε > 0. Donner un majorant (ne dépendant que de n et de ε) de P (Mn − 1)2 > ε2 .

d) Conclure que lim P(|Mn − 1| > ε) = 0. Que signifie ce résultat ?

n→+∞
2) a) Écrire une fonction en Python appelée SimulM qui prend en entrée n et qui renvoie une simulation
de Mn .
b) Pour n = 1000, construire l’histogramme renormalisé de 10000 réalisations de Yn avec 15 classes. Lui
superposer la densité d’une variable aléatoire de loi E(1). Que peut-on conjecturer ?
c) Pour tout n ∈ N∗ , calculer FYn .
d) Pour tout x ∈ R∗+ , calculer lim FYn (x).
n→+∞
e) Montrer la conjecture de la question 2b.

3) On considère les instruction suivantes en Python :
3
4 d e f SimulZ ( n ) :
5 U=n∗ r d . random ( n )
6 r e t u r n np . min (U)
7
8 m=5000; n =100; T=np . z e r o s (m)
9 f o r k i n r a n g e (m) :
10 T [ k ]= SimulZ ( n )
11 p r i n t ( np . sum (T<=1)/m)
a) Montrer que la fonction SimulZ, de paramètre n ∈ N∗ simule une variable aléatoire de même loi
que Yn .
b) En exécutant 10 fois le programme précédent, l’écran affiche les résultats suivants :
0.6418 0.6334 0.6452 0.629 0.6212 0.626 0.641 0.6282 0.63 0.6308
La valeur affichée à l’écran est une valeur approchée d’un nombre p. Préciser, à l’aide des questions
précédentes, la valeur exacte de p.
Exercice 6 – Convergence vers la loi de Gumbel. (HH)

1) Montrer que f : x 7−→ exp −(t + e−t ) est une densité de probabilité. On dit qu’une variable aléatoire qui

admet pour densité f suit une loi de Gumbel.

U
2) Soit U une variable aléatoire de loi U(]0 ; 1[). On admet que X = ln est une variable aléatoire.
1−U
Calculer sa fonction de répartition et montrer que c’est une variable à densité.
3) Soient (Xn )n>1 une suite de variables aléatoires définies sur un même espace (Ω, A, P) qui sont indépen-
dantes et de même loi que X. Pour tout n ∈ N∗ , on note Yn = max{X1 , . . . , Xn }. Plus rigoureusement
∀ω ∈ Ω, Yn (ω) = max{X1 (ω), . . . , Xn (ω)}.
On pose Zn = Yn − ln(n).
a) Écrire une fonction en Python qui prend en entrée n et qui simule Yn .
b) Pour n = 1000, tracer l’histogramme renormalisé de 10000 réalisations de Yn avec 20 classes. Lui
superposer le graphe de f . Que peut-on conjecturer ?
4) Montrer que la conjecture de la question précédente.
Exercice 7 – Simulation d’une loi de Poisson. (HHH)

1) À l’aide de l’approximation Binomiale/Poisson, écrire une fonction Python, appelée Simul_1, qui prend en
entrée a > 0 et qui simule une variable aléatoire de loi de Poisson de paramètre a à l’aide d’une variable
aléatoire de loi binomiale de premier paramètre 1000 en utilisant rd.binomial().
2) On a vu dans l’exercice 11 du TP no 1 que, si a > 0 et si (Ui )i>1 est une suite de variables aléatoires
indépendantes et de même loi uniforme sur ]0 ; 1[, alors
Y = min{n ∈ N | U1 U2 . . . Un+1 6 e−a }
suit une loi de Poisson de paramètre a. Écrire une fonction Python, appelée Simul_2, qui prend en entrée
a > 0 et qui simule une variable aléatoire loi de Poisson de paramètre a à l’aide de ce dernier résultat.
n
X ak
3) Soit a > 0. Soit U une variable aléatoire de loi uniforme sur ]0 ; 1[. Pour tout k ∈ N, notons fk = e−a .
k!
a) Calculer P(fk−1 < U 6 fk ) pour tout k ∈ N∗ . k=0
b) En déduire que Y = min{k ∈ N | U 6 fk } suit une loi de Poisson de paramètre a.

c) Compléter alors le programme suivant pour qu’il prenne en entrée a > 0 et simule une variable aléatoire
de loi de Poisson de paramètre a à l’aide de ce dernier résultat.
1 import . . . . . . . . . . . . . . . . . . . . . . .
2 import . . . . . . . . . . . . . . . . . . . . . . .
3 d e f Simul_3 ( a ) :
4 p=np . exp (−a )
5 f=p
6 k=0
7 U=........................
8 ..........................
9 k=k+1
10 p=....................
11 f=f+p
12 return . . . . . . . . . . . . . . . . . . .
4) Si on importe la librairie time, alors la commande time.time() renvoie un flottant contenant l’heure en
secondes (avec une certaine précision). Si on exécute cette commande avant et après un script, l’écart entre
les deux valeurs donne alors le temps d’exécution du script. Recopier et exécuter le script suivant :
1 import time
2 N=100000
3 a=4
4 s 1=t i m e . t i m e ( ) ; X1=[ Simul_1 ( a ) f o r k i n r a n g e (N) ] ; e1=t i m e . t i m e ( )
7 s 4=t i m e . t i m e ( ) ; X4=[ r d . p o i s s o n ( a ) f o r k i n r a n g e (N) ] ; e4=t i m e . t i m e ( )
8 p r i n t ( e1−s1 , e2−s2 , e3−s3 , e4−s 4 )
9 M=np . max ( [ np . max ( X1 ) , np . max ( X2 ) , np . max ( X3 ) , np . max ( X4 ) ] )
10 v a l e u r s =[ i −0.5 f o r i i n r a n g e (M+1) ]
11 p l t . h i s t ( [ X1 , X2 , X3 , X4 ] , b i n s=v a l e u r s , d e n s i t y=True )
12 p l t . show ( )
Commenter.
III Le Théorème Central Limite

1) Énoncé
Soient (Xn )n>1 une suite de variables aléatoires indépendantes admettant une espérance m et une variance
n
2 ∗ 1X
σ > 0. Pour tout n ∈ N , notons Xn = Xi . Le Théorème Central Limite assure que, si Z désigne une
n
k=1
variable aléatoire de loi N (0, 1), alors
∗ √ Xn − m L
Xn = n −−−−−→ Z,
σ n→+∞
c’est-à-dire, pour tout x ∈ R,

Z x
∗ 2 /2 dt
P(Xn 6 x) −−−−−→ Φ(x) = e−t √
n→+∞ −∞ 2π
ou encore, pour tous (a, b) ∈ R2 ,

Z b
∗ 2 /2 dt
P(a 6 Xn 6 b) −−−−−→ e−t √ .
n→+∞ a 2π

2) Représentation du TCL
a) Convergence des fonctions de répartition
Exercice 8. (HH)
1) Soit p ∈ ]0 ; 1[. Soit (Xn )n>1 une suite de variables aléatoires indépendantes de loi B(p). Notons m et σ 2
l’espérance et la variance d’une loi B(p).
a) Justifier que, pour tous n ∈ N∗ et x ∈ R,
√ Xn − m
p
P n 6 x = Fn,p x np(1 − p) + np ,
σ
où Fn,p désigne la fonction de répartition d’une variable aléatoire de loi B(n, p).
b) Écrire une fonction Python qui prend en entrée n, p et un réel t et qui renvoie Fn,p (t).
p
c) Avec Python, tracer la courbe représentative de x 7−→ Fn,p x np(1 − p) + np sur l’intervalle
[−4 ; 4] avec n = 1000 et p = 0, 3.
d) Lui superposer la courbe de Φ, la fonction de répartition d’une variable aléatoire de loi N (0, 1).
Commenter.
On rappelle que, si on réalise l’importation suivante : import scipy.special as sp, alors la com-
mande sp.ndtr est une fonction Python qui implémente Φ.
2) Soit a ∈ R∗+ . Soit (Xn )n>1 une suite de variables aléatoires indépendantes de loi P(a). Notons m et σ 2
l’espérance et la variance d’une loi P(a).
a) Justifier que, pour tous n ∈ N∗ et x ∈ R,
√ Xn − m √

P n 6 x = Fna x na + na ,
σ
où, pour tout b ∈ R∗+ , Fb désigne la fonction de répartition d’une variable aléatoire de loi P(b).
b) Écrire une fonction Python qui prend en entrée b et un réel t et qui renvoie Fb (t).
√
c) Avec Python, tracer la courbe représentative de x 7−→ Fna (x na + na) sur l’intervalle [−4 ; 4] avec
n = 100 et a = 3.
d) Lui superposer la courbe de Φ, la fonction de répartition d’une variable aléatoire de loi N (0, 1).
Commenter.
b) Illustration à l’aide d’histogramme empirique

Exercice 9. (HH)
1) Écrire une fonction en Python qui prend en argument n ∈ N∗ et le(s) paramètre(s) d’une certaine loi de
probabilité et qui :
n
√ Xn − m 1X
• Stocke N = 10000 réalisations de Y = n , avec Xn = Xi où X1 , . . . , Xn sont des
σ n
i=1
variables aléatoires indépendantes de la loi en question, dans un vecteur Y.
• Trace l’histogramme renormalisé des valeurs de Y avec 20 classes via la commande :
plt.hist(Y,bins=20,density=True)
• Lui superpose la courbe de la densité de la loi Normale.
2) Tester avec n = 100, n = 1000, n = 10000 et les lois usuelles du programme (uniforme, Bernoulli, binomiale,
géométrique, Poisson, exponentielle, gamma, Normale). Commenter.

IV Simulations d’une loi normale
1) Plusieurs méthodes de simulation
Voyons plusieurs méthodes permettant de simuler une variable aléatoire de loi N (0, 1).
a) Utilisation de rd.normal
Pour simuler une une variable aléatoire de loi N (0, 1), on peut utiliser la fonction rd.normal(0,1) du module
numpy.
b) Utilisation du TCL
Si (Xn )n∈N∗ est une suite de variables aléatoires indépendantes de même loi admettant une espérance m et une
variance σ 2 > 0, alors
√ n
!
∗ n 1X
Xn = Xi − m
σ n
k=1
converge en loi vers une variable aléatoire de loi N (0, 1) quand n tend vers +∞
∗
Pour simuler une une variable aléatoire de loi N (0, 1), on peut donc simuler Xn pour n assez grand et pour des
variables aléatoires que l’on sait facilement simuler.
Avec des lois uniformes sur [0 ; 1] : Pour n « assez grand » (mais pas tant que ça, comme on le verra, la convergence
étant très rapide), si X1 , . . . , Xn sont indépendantes de loi U([0 ; 1]) (on a m = 1/2 et σ 2 = 1/12), alors
n
!
∗ √ 1X 1
Xn = 12n Xi −
n 2
k=1
suit approximativement une loi N (0, 1). Le programme suivant prend n en entrée et renvoie cette quantité :
2 d e f NormaleTCL ( n ) :
3 S=np . sum ( r d . random ( n ) )
4 r e t u r n np . s q r t ( 1 2 ∗ n ) ∗ ( S/n −1/2)
Remarque : Si on prend n = 12 (on verra ultérieurement que c’est déjà pas mal), on obtient que
12
∗ X
X12 = Xi − 6
k=1
suit approximativement une loi N (0, 1).

Avec des lois de Bernoulli de paramètre p ∈ ]0 ; 1[ : Pour n « assez grand » (mais pas tant que ça, comme on
le verra, la convergence étant très rapide), si X1 , . . . , Xn sont indépendantes de loi B(p) (on a m = p et
σ 2 = p(1 − p)), alors
n
r !
∗ n 1X
Xn = Xi − p
p(1 − p) n
k=1
suit approximativement une loi N (0, 1). Le programme suivant prend n et p en entrée et renvoie cette quantité :
2 d e f NormaleTCL2 ( n , p ) :
3 S=r d . b i n o m i a l ( n , p )
4 r e t u r n np . s q r t ( n / ( p∗(1−p ) ) ) ∗ ( S/n−p )

c) Utilisation de la méthode d’inversion de la fonction de répartition
Dans le TP no 1, on a vu comment implémenter la fonction Φ, la fonction de répartition d’une variable aléatoire
de loi N (0, 1). On peut utiliser directement la commande sp.ndtr après import scipy.special as sp.
Exercice 10. (H)

1) Montrer que Φ est une bijection de R dans ]0 ; 1[.
2) Soit U ,→ U(]0 ; 1[). Montrer que Y = Φ−1 (U ) suit une loi N (0, 1).
3) a) A l’aide d’un algorithme de dichotomie, écrire une fonction qui prend en entrée t et qui calcule Φ−1 (t).
On cherchera l’unique antécédent de t entre −5 et 5.
b) En déduire une fonction Python, intitulé NormalInvRep, sans argument renvoie une simulation d’une
variable aléatoire de loi N (0, 1) avec cette méthode.
Remarques :
• On a déjà vu cette méthode dans le TP no 1. Il s’agit de la méthode d’inversion de la fonction de répartition
qui est plus générale.
• La fonction Φ−1 est déjà implémentée dans Python. Il suffit d’utiliser la commande sp.ndtri après
import scipy.special as sp. Mais celle-ci n’est pas au programme.
d) Utilisation de la méthode de Box-Muller

Exercice 11 – Méthode de Box-Muller. (HHH) On considère deux variables aléatoires U et V définies sur
un même espace probabilisé (Ω, A, P), indépendantes et de même loi uniforme sur ]0 ; 1].
h π πi
1) a) Montrer que sin réalise une bijection de − ; sur [−1 ; 1]. On note Arcsin sa bijection réciproque.
2 2
b) Montrer que Arcsin est dérivable sur ]−1 ; 1[ et que
1
∀x ∈ ]−1 ; 1[ , Arcsin0 (x) = √ .
1 − x2
c) Montrer que Arcsin est impaire.

p
2) On pose X = ln( −2 ln(U )). On admet que c’est une variable aléatoire sur (Ω, A, P).
a) Calculer la fonction de −2 ln(U )
e2x

b) Montrer que X est une variable aléatoire à densité donc une densité est g : x 7−→ exp 2x − .
2
3) On pose Y = sin(2πV ) et Z = ln(|Y |). On admet que Y et Z sont des variables aléatoires sur (Ω, A, P).
a) Montrer que, pour tout x ∈ ]0 ; 1], [Y > x] = [Arcsin(x) 6 2πV 6 π − Arcsin(x)].
b) Montrer que, pour tout x ∈ [−1 ; 0], [Y 6 x] = [π − Arcsin(x) 6 2πV 6 2π + Arcsin(x)].
c) En déduire la fonction de répartition de Y .
d) Montrer que Z admet pour densité la fonction
 x
 2√ e si x<0
h : x 7−→ π 1 − e2x
 0 si x>0
4) Justifier que la variable aléatoire S = X + Z admet une densité et donner en une densité sous forme d’une
intégrale.
p
5) On pose T = −2 ln(U ) sin(2πV ). On admet que c’est une variable aléatoire sur (Ω, A, P). Remarquons
que ln(|T |) = S.

a) Montrer qu’une densité de |T | sur R est
exp −e2t /2 2t
 Z +∞
 2 √ e dt si x>0
f : x 7−→ π ln(x) e2t − x2

0 si x60
1 2 2
b) Soit x > 0. A l’aide du changement de variable t = ln(x2 + u2 ), établir que f (x) = √ e−x /2 .
2 2π
6) Notons F et FT les fonctions de répartition respectives de |T | et T .
p
a) Montrer que −T = −2 ln(U ) sin(2π(1 − V )). En déduire que T et −T ont la même loi.
b) En déduire que, pour tout x ∈ R, P(T = x) = 0.
1 + F (x)
c) Montrer que, pour tout x ∈ R+ , FT (x) = .
2
1 − F (−x)
d) Montrer que, pour tout x ∈ R∗− , FT (x) = .
2
e) Conclure que T est bien une variable à densité.
f) En déduire que T suit une loi N (0, 1).
7) Proposer une méthode de simulation d’une variable aléatoire de loi N (0, 1).
2) Comparaison des méthodes
Exercice 12 – Comparaison des méthodes de simulation de variables aléatoires de loi N (0, 1). (HH)
En s’inspirant du script de la dernière question de l’exercice 3, créer des vecteurs contenant 100000 réalisations
de variables aléatoires indépendantes de loi N (0, 1) obtenus chacun avec une des méthodes de simulations vues
précédemment. Afficher un histogramme renormalisé et le temps d’exécution de chaque algorithme. Commenter.

Feuille de TP no 5
Fonctions de deux variables – Deuxième

partie
I Plan tangent
Soit Ω un ouvert de R2 . Soit a = (x0 , y0 ) ∈ Ω. Si f est une fonction de classe C 1 sur Ω à valeurs dans R, alors la
formule de Taylor à l’ordre 1 assure que
f (x) ≈ f (a) + h∇f (a), x − ai,
pour tout x au voisinage de a. Cela motive la définition suivante :
Définition. Soit Ω un ouvert de R2 . Soit (x0 , y0 ) ∈ Ω. Soit f : Ω 7−→ R de classe C 1 sur Ω. On appelle plan
tangent au graphe de f en (x0 , y0 ) le plan d’équation
z = f (x0 , y0 ) + ∂1 f (x0 , y0 )(x − x0 ) + ∂2 f (x0 , y0 )(y − x0 ).
Ainsi, pour représenter le plan tangent, on représente localement le graphe de la fonction (de deux variables)
g : (x, y) ∈ R2 7−→ f (x0 , y0 ) + ∂1 f (x0 , y0 )(x − x0 ) + ∂2 f (x0 , y0 )(y − x0 ).
2 2
Exemple : Testons avec la fonction f : (x, y) ∈ R2 7−→ xye−(x +y ) (cf. TP no 2). On commence par les
importations, l’implémentation de la fonction et du gradient et on représente la surface.
4 ax=Axes3D ( p l t . f i g u r e ( ) )
6
7 def f (x , y ) :
8 r e t u r n x ∗ y ∗ np . exp ( −( x∗∗2+y ∗ ∗ 2 ) )
9
11 g=np . exp ( −( x∗∗2+y ∗ ∗ 2 ) )
12 r e t u r n y ∗(1 −2∗ x ∗ x ) ∗g , x ∗(1 −2∗ y ∗ y ) ∗ g
13
14 X=np . a r a n g e ( − 2 , 2 , 0 . 0 1 )
15 Y=X
16 X , Y=np . m e s h g r i d (X , Y)
17 Z1=f (X , Y)
18 ax . p l o t _ s u r f a c e (X , Y , Z1 , cmap=coolwarm )
Ensuite, on peut définir la fonction qui implémente le plan :

1 d e f p l a n ( x0 , y0 , x , y ) :
2 a , b=g r a d f ( x0 , y0 )
3 r e t u r n f ( x0 , y0 )+a ∗ ( x−x0 )+b ∗ ( y−y0 )

Représentons le plan tangent en (1, 1) :
1 X=np . a r a n g e ( 0 , 2 , 0 . 1 )
2 Y=X
3 X , Y=np . m e s h g r i d (X , Y)
4 Z2=p l a n ( 1 , 1 , X , Y)
5 ax . p l o t _ s u r f a c e (X , Y , Z2 )
6 p l t . show ( )
√ √
Représentons le plan tangent en (−1/ 2, 1/ 2) :
1 a =1/2∗∗(1/2)
2 X=np . a r a n g e (−a−1,−a + 2 , 0 . 1 )
3 Y=np . a r a n g e ( a −2, a + 1 , 0 . 1 )
4 X , Y=np . m e s h g r i d (X , Y)
5 Z2=p l a n (−a , a , X , Y)
6 ax . p l o t _ s u r f a c e (X , Y , Z2 )
7 p l t . show ( )
Supposons de plus que f soit de classe C 2 sur Ω. La formule de Taylor à l’ordre 2 entraîne alors que

x − x0 1
f (x, y) = f (x0 , y0 ) + ∇f (x0 , y0 ), + q(x0 ,y0 ) (x − x0 , y − y0 ) + k(x − x0 , y − y0 )k2 ε(x − x0 , y − y0 ),
y − x0 2
| {z }
=g(x,y)
où q(x0 ,y0 ) est la forme quadratique associée à ∇2 f (x0 , y0 ), la Hessienne en (x0 , y0 ) et où ε est une fonction
définie au voisinage de (0, 0), continue en (0, 0) et nulle en (0, 0). Ainsi f (x, y) − g(x, y) est du signe de
q(x0 ,y0 ) (x − x0 , y − y0 ) au voisinage de (x0 , y0 ). Ainsi :
• Si ∇2 f (x0 , y0 ) ne possède que des valeurs propres strictement positives, f (x, y) − g(x, y) > 0 au voisinage
de (x0 , y0 ) et donc le plan tangent est en-dessous de la surface représentative de f au voisinage de (x0 , y0 ).
• Si ∇2 f (x0 , y0 ) ne possède que des valeurs propres strictement négatives, f (x, y) − g(x, y) 6 0 au voisinage
de (x0 , y0 ) et donc le plan tangent est au-dessus de la surface représentative de f au voisinage de (x0 , y0 ).
• Si ∇2 f (x0 , y0 ) possède des valeurs propres de signes contraires, la surface représentative de f traverse le
plan tangent au voisinage de (x0 , y0 ).
Si (x0 , y0 ) est un point critique, alors le plan tangent est horizontal. Dire que, au voisinage de (x0 , y0 ), le plan
tangent en (x0 , y0 ) est en-dessous (respectivement au-dessus) de la surface représentative de f signifie que f
admet un minimum (respectivement maximum) local en (x0 , y0 ). On retrouve donc le résultat du cours.
Le code suivant permet de calculer les valeurs propres de la matrice Hessienne de f en (x0 , y0 ) :
1 def Hessf (x , y ) :
2 d11 = . . . . . . . . . . . #d é r i v é e p a r t i e l l e d ’ o r d r e 2 d ’ i n d i c e ( 1 , 1 )
5 r e t u r n np . a r r a y ( [ [ d11 , d12 ] , [ d12 , d22 ] ] )
6
7 i m p o r t numpy . l i n a l g a s a l
8 a l . e i g ( H e s s f ( x0 , y0 ) ) [ 0 ]

2 +y 2 )
Exemple : Reprenons l’exemple de la fonction f : (x, y) ∈ R2 7−→ xye−(x . C’est une fonction de classe C 2
sur R2 et, pour tout (x, y) ∈ R2 ,
2 2 2 2)
!
2xy(2x2 − 3)e−(x +y ) (1 − 2x2 )(1 − 2y 2 )e−(x +y
∇2 f (x, y) = 2 2 2 2
(1 − 2x2 )(1 − 2y 2 )e−(x +y ) 2xy(2y 2 − 3)e−(x +y )
Cela donne le code suivant :

1 def Hessf (x , y ) :
2 g=np . exp ( −( x∗∗2+y ∗ ∗ 2 ) )
3 d11=2∗x ∗ y ∗ ( 2 ∗ x ∗x −3)∗ g
4 d22=2∗x ∗ y ∗ ( 2 ∗ y ∗y −3)∗ g
5 d12=(1−2∗x ∗ x ) ∗(1 −2∗ y ∗ y ) ∗ g
6 r e t u r n np . a r r a y ( [ [ d11 , d12 ] , [ d12 , d22 ] ] )
7
8 i m p o r t numpy . l i n a l g a s a l
9 a l . e i g ( H e s s f ( 1 / np . s q r t ( 2 ) , 1 / np . s q r t ( 2 ) ) ) [ 0 ]
10 a l . e i g ( H e s s f ( 1 / np . s q r t ( 2 ) , −1/ np . s q r t ( 2 ) ) ) [ 0 ]
11 a l . e i g ( H e s s f (−1/np . s q r t ( 2 ) , −1/ np . s q r t ( 2 ) ) ) [ 0 ]
12 a l . e i g ( H e s s f (−1/np . s q r t ( 2 ) , 1 / np . s q r t ( 2 ) ) ) [ 0 ]
13 al . eig ( Hessf (0 ,0) ) [ 0 ]
14 al . eig ( Hessf (1 ,1) ) [ 0 ]
On trouve : [-0.736,-0.736], [0.736,0.736], [-0.736,-0.736], [0.736, 0.736], √ [1.,-1.]

√ et
[-0.135,-0.406]. √ Cela nous
√ permet de conjecturer que f √ admet un√maximum local en (1/ 2, 1/ 2), √ un mini-
√
mum local en (1/ 2, −1/ 2), un maximum local en (−1/ 2, −1/ 2), un minimum local en (−1/ 2, 1/ 2),
un point selle en (0, 0). De plus, le plan tangent en (1, 1) est au-dessus de la surface représentative.
Exercice 1. (HH) Reprendre l’exercice 2 du TP no 2 et conjecturer la nature locale des points critiques des
différentes fonctions à l’aide du signe des valeurs propres de la Hessienne obtenu avec Python. Puis le démontrer.
II Optimisation sous contrainte linéaire

Soit Ω un ouvert de R2 . Soit a = (x0 , y0 ) ∈ Ω. Soit f est une fonction de classe C 1 sur Ω à valeurs dans R. On
étudie f sous la contrainte linéaire C = {(x, y) ∈ R2 | g(x, y) = c}. Puisqu’il s’agit d’une contrainte linéaire, il
existe deux réels a et b tels que g : (x, y) 7−→ ax + by. On remarque que C est une droite affine d
On suppose que, sous la contrainte C , f admet un extremum local en un point (x0 , y0 ). Ce point appartient donc
à la ligne de niveau f (x0 , y0 ) de f . Notons-la L0 .
• On rappelle qu’une ligne de niveau est formée des points de même altitude. Ainsi, d’un côté de la ligne L0
se trouvent des points d’altitude strictement plus élevée que f (x0 , y0 ) et de l’autre des points d’altitude
strictement moins élevée que f (x0 , y0 ).
• Le point (x0 , y0 ) appartient à la contrainte C , qui se trouve être une droite affine. Ainsi (x0 , y0 ) est un
point d’intersection de L0 et de C .
• Si la droite affine C traverse la ligne de niveau L0 , alors il existe, au voisinage de (x0 , y0 ) des points de C
en lesquels f prend des valeurs supérieurs à f (x0 , y0 ) et d’autres points en lesquels f prend des valeurs
inférieures à f (x0 , y0 ), ce qui contredit que f admet un extremum local en (x0 , y0 ) sous la contrainte C .
Ainsi C est orthogonale à la tangente à L0 en (x0 , y0 ).
• On peut retrouver ce dernier point avec les résultats vus en cours : ∇f (x0 , y0 ) est orthogonale au noyau
de g. De plus on a vu dans le TP no 2 que ∇f (x0 , y0 ) est orthogonal à la tangente à L0 en (x0 , y0 ). Ainsi la
tangente à L0 en (x0 , y0 ) est parallèle au noyau de g, qui est lui même parallèle à la contrainte C . Comme
elles ont (x0 , y0 ) pour point d’intersection, elles sont confondues.
Exemple : Soit f : (x, y) 7−→ x2 + 4x − 4y 2 − 3 et la contrainte C = {(x, y) ∈ R2 | x + y = 1}. Traçons des

lignes de niveaux et la droite d’équation y = −x + 1 :

On conjecture que C (en rouge) est tangente à la ligne de niveau 5 et passe par le point (2, −1). Cela suggère
que (2, −1) est un point critique de f sous la contrainte C .
Exercice 2. (HH) Soient f : (x, y) 7−→ x2 + 4x − 4y 2 − 3 et C = {(x, y) ∈ R2 | x + y = 1}.

1) Reproduire la figure de l’exemple ci-dessus à l’aide de Python.
2) Démontrer que f admet bien (2, −1) pour point critique de f sous la contrainte C .
3) Montrer que f admet un maximum global en (−2, 1) sous la contrainte C .
Exercice 3. (HH) Soient f : (x, y) 7−→ 2x3 − 3x2 y − 6x + y 3 et C = {(x, y) ∈ R2 | 2x + y = 1}.

1) Représenter les lignes de niveaux de f et la droite C . Conjecturer la présence d’un point critique pour f
sous la contrainte C .
On pourra restreindre le tracé au rectangle [−6 ; 4] × [−5 ; 3] et on fera en sorte que le niveau -3 soit
représenté.
2) Démontrer que f admet bien un unique point critique de f sous la contrainte C
3) Montrer que f admet un unique minimum global sous la contrainte C .
Exercice 4. (HH) Soient f : (x, y) 7−→ x3 + 2x2 y − 4y 3 et C = {(x, y) ∈ R2 | x − y = 1}.

1) Représenter les lignes de niveaux de f et la droite C . Conjecturer la présence de deux points critiques pour
f sous la contrainte C .
On pourra restreindre le tracé au carré [−8 ; 8]2 et on fera en sorte que les niveaux 4/27 et 76 soient
représentés.
2) Démontrer que f admet bien deux points critiques de f sous la contrainte C
3) Montrer que, sous la contrainte C , f admet un minimum local et un maximum local mais qu’il ne s’agit
pas de d’extrema globaux.

Feuille de TP no 6
Estimation ponctuelle et par intervalle de

confiance
Exercice 1. (H) Écrire une fonction en Python qui prend en entrée n et α et qui simule N = 10000 fois des
variables aléatoires X1 , . . . , Xn indépendantes et de même loi uniforme sur ]0 ; 1[ et qui renvoie la proportion de
1
fois, parmi ces N fois, où m = appartient à l’intervalle de confiance asymptotique
2

Sn Sn
Xn − t1−α/2 √ ; Xn + t1−α/2 √ .
n n
La tester pour différentes valeurs de n et α. Commenter.

Pour la réciproque de Φ, on utilisera sp.ndtri après import scipy.special as sp.
Exercice 2. (HH) Soit (Xn )n>1 une suite de variables aléatoires admettant 2 un moment d’ordre 4. On note m
leur espérance et σ 2 leur variance. Pour tout n ∈ N∗ , on pose
n n
1X 1X
Xn = Xi et Sn2 = (Xi − Xn )2 .
n n
i=1 i=1
La quantité Sn2 est appelée variance empirique de X1 , . . . , Xn .

1) Pour tout n ∈ N∗ , notons
n
1X 2
Tn2 = Xi et t2 = E(X12 ).
n
i=1
P P
a) Justifier que Tn2 −−−−−→ t2 et (Xn )2 −−−−−→ m2 .
n→+∞ n→+∞
b) Vérifier que, pour tout n ∈ N∗ ,
∀n ∈ N∗ , Sn2 − σ 2 = Tn2 − t2 − (Xn )2 − m2 .

c) Soient n ∈ N∗ et ε > 0. En déduire que

2 h εi h εi
Sn − σ 2 > ε ⊂ Tn2 − t2 > ∪ (Xn )2 − m2 > .
2 2
P
2) En déduire que Sn2 −−−−−→ σ 2 .
n→+∞
En vertu du résultat de l’exercice précédent, du Théorème Central Limite et d’un théorème (qui a disparu
du nouveau programme mais qui était pourtant fort utile) appelée lemme de Slutsky, on obtient le résultat
(hors-programme donc) suivant :
√ Xn − m L
n −−−−−→ Z,
Sn n→+∞
avec Z une variable aléatoire de loi N (0, 1). Nous allons utiliser cette convergence dans l’exercice suivant.
2. En fait l’existence d’une variance suffit puisque la loi faible des grands nombres reste vrai si les variables aléatoires en jeu
admettent seulement une espérance (mais, dans le programme, il faut un moment d’ordre 2 pour pouvoir le démontrer).

Exercice 3 – Intervalle de confiance pour l’espérance d’une loi Normale de variance connue. (HH)
Soient m ∈ R, σ > 0 et α ∈ ]0 ; 1[. Soit (Xi )i>1 une suite de variable aléatoires de loi N (m, σ 2 ) (on suppose que
n
∗ 1X
σ est connu). Pour tout n ∈ N , notons Xn = Xi .
n
k=1
1) Justifier que Xn est un estimateur sans biais et convergent de m.

α uα σ uα σ
2) On note uα désigne l’unique antécédent de 1 − par Φ. Justifier que Xn − √ ; Xn + √ est un
2 n n
intervalle de confiance (non asymptotique) de niveau 1 − α pour m.
3) Pour α = 0.05 et pour différentes valeurs de m, σ et n, simuler N = 10000 fois Xn et compter la proportion
de fois où m tombe dans l’intervalle de confiance (on parle de niveau réel) et comparer cette proportion
avec 1 − α.
Exercice 4 – Intervalle de confiance asymptotique pour la paramètre d’une loi de Bernoulli. (HH)
Soient p ∈ ]0 ; 1[ et α ∈ ]0 ; 1[. Soit (Xi )i>1 une suite de variable aléatoires de loi B(p). Pour tout n ∈ N∗ ,
n
1X
notons Xn = Xi .
n
k=1
1) Justifier que Xn est un estimateur sans biais et convergent de p.
1
2) Montrer que p(1 − p) 6 .
4
1 1
3) Montrer que Xn − √ ; Xn + √ est un intervalle de confiance (non asymptotique) de niveau
2 nα 2 nα
1 − α pour p.

α uα uα
4) On note uα désigne l’unique antécédent de 1 − par Φ. Justifier que Xn − √ ; Xn + √ est un
2 2 n 2 n
intervalle de confiance asymptotique de niveau 1 − α pour p.
v
u n
∗
u1 X √ Xn − p L
5) Pour tout n ∈ N , notons Sn = t (Xi − Xn ))2 . On admet que n −−−−−→ N avec
n Sn n→+∞
k=1

uα Sn uα Sn
N ,→ N (0, 1). Montrer alors que Xn − √ ; Xn + √ est un intervalle de confiance asympto-
n n
tique de niveau 1 − α pour p.
6) Pour α = 0.05 et pour différentes valeurs de p et de n, simuler N = 10000 fois X1 , . . . , Xn et compter :
• l’amplitude des deux premiers intervalles de confiance et l’amplitude moyenne (on parle d’incertitude)
du troisième.
• la proportion de fois où p tombe dans ces intervalles de confiance (on parle de niveau réel) et comparer
cette proportion avec 1 − α.
Quel intervalle de confiance est le meilleur ?
Problème – Adapté de ECRICOME 2021 et des oraux de l’ESCP 2005. (HHH) Toutes les variables
aléatoires considérées dans cet exercice sont définies sur le même espace probabilisé (Ω, A, P). Soit θ ∈ R∗+ . On
considère X une variable aléatoire admettant pour densité
( 2x
si x ∈ [0 ; θ]
fθ : x 7−→ θ2
0 sinon.
1) a) Justifier que fθ est bien une densité de probabilité.

b) Expliciter la fonction de répartition Fθ de X.
On considère une suite de variables aléatoires (Xn )n>1 indépendantes et de même loi que X.

2) Étude d’un premier estimateur de θ. Pour tout n ∈ N∗ , on note Mn = max{X1 ; X2 ; . . . ; Xn }.
√
a) Montrer que, si U ,→ U([0 ; 1]), alors θ U a la même loi que X.
b) Écrire une fonction en Python, appelée Simul_M, qui prend en entrée n et θ et qui renvoie une
simulation de Mn .
c) Modifier la fonction précédente pour qu’elle renvoie une liste contenant une réalisation de (M1 , . . . , Mn ).
On l’appellera Simul_MM.
On rappelle que, en Python, si L désigne une liste ou un vecteur et si i désigne un entier non nul,
alors L[:i] renvoie uniquement les i premières coordonnées de L.
d) Écrire un script en Python permet d’obtenir le graphique ci-dessus consistant en cinq réalisations
mutuellement indépendantes de (M1 , . . . , M100 ) dans le cas où θ = 1.
A partir de ce graphique, que peut-on conjecturer sur l’estimateur Mn ?

e) Montrer que, pour tout n ∈ N∗ , Mn est une variable aléatoire à densité. Donner en une densité.
f) Calculer les deux premiers moments de Mn .
g) Montrer que Mn est un estimateur biaisé de θ. Est-il asymptotiquement sans biais ?
h) Soit ε > 0 et n ∈ N∗ . Expliciter P(|Mn − θ| > ε). L’estimateur Mn est-il convergent ?
i) Calculer E((Mn − θ)2 ) (quantité appelée risque quadratique 1 de Mn ). Quel résultat retrouve-t-on ?
n
1X
3) Étude d’un second estimateur de θ. Pour tout n ∈ N∗ , notons Xn = Xi .
n
i=1
a) Donner l’espérance et la variance de Xn .
b) Déduire de la variable aléatoire Xn un estimateur sans biais Zn de θ.
c) Écrire une fonction en Python, appelée Simul_Z, qui prend en entrée n et θ et qui renvoie une
réalisation de Zn .
d) Modifier la fonction précédente pour qu’elle renvoie une liste contenant une réalisation de (Z1 , . . . , Zn ).
On l’appellera Simul_ZZ.
e) Écrire un script en Python permet d’obtenir le graphique ci-dessus consistant en cinq réalisations
mutuellement indépendantes de (Z1 , . . . , Z100 ) dans le cas où θ = 1.
1. Le risque quadratique d’un estimateur mesure l’écart moyen entre l’estimateur est le paramètre qu’il estime. Plus il est petit, plus
l’estimateur est précis

A partir de ce graphique, que peut-on conjecturer sur l’estimateur Mn ?
f) Calculer E((Zn −θ)2 ) (quantité appelée risque quadratique1 de Zn ). L’estimateur Zn est-il convergent ?
4) Comparaison des deux estimateurs.
a) Comparer les risques quadratiques de Mn et Zn . Quelle méthode choisiriez-vous pour estimer la valeur
du paramètre θ ?
b) On rappelle que, en Python, la commande plt.hist(L,bins=50,density=True trace un histo-
gramme renormalisé avec 50 classes à partir des données de la liste L.
Écrire un script Python qui permet d’obtenir les graphiques ci-dessus consistant en un histogramme de
5000 réalisation de M100 et un histogramme de 5000 réalisation de Z100 dans le cas où θ = 1.
En quoi ces graphiques confortent-ils votre choix d’estimateur ?

5) Un premier intervalle de confiance asymptotique pour θ.

a) Montrer que la suite de variables aléatoires 2n(θ − Mn ) n>1 convergence en loi vers une variable
aléatoire dont on identifiera la loi et son (ses) paramètre(s).
b) Soit α ∈ ]0 ; 1[. Déduire de la question précédente un intervalle de confiance asymptotique de niveau
de confiance 1 − α pour le paramètre θ, construit à partir de Mn .
6) Un second intervalle de confiance asymptotique pour θ.
√
a) Montrer que la suite de variables aléatoires n(Zn − θ) n>1 convergence en loi vers une variable
aléatoire dont on identifiera la loi et son (ses) paramètre(s).
b) Soit α ∈ ]0 ; 1[. Déduire de la question précédente un intervalle de confiance asymptotique de niveau
de confiance 1 − α pour le paramètre θ, construit à partir de Zn .
7) Comparaison des deux intervalles de confiance asymptotiques.

a) Lequel de ces deux intervalles de confiance asymptotique vous semble le meilleur ?
b) En Python, si A désigne une matrice réelle, alors la commande np.max(A,0) renvoie un vecteur ligne
contenant le maximum de chaque colonne de A. La commande np.mean(A,0) renvoie quand à elle
un vecteur ligne contenant la moyenne de chaque colonne de A.
Recopier et compléter le script Python suivant :
1 n=100
2 N=10000
3 t h e t a =2
4 a l p h a =0.05
5 X = . . . . . . . . . . . . . . . . . . . . . . . #Une m a t r i c e de t a i l e nxN de r é a l i s a t i o n s de X
6 M = . . . . . . . . . . . . . . . . . . . . . . . #N r é a l i s a t i o n s de M_n
7 Z = . . . . . . . . . . . . . . . . . . . . . . . #N r é a l i s a t i o n s de Z_n
8
9 #Dé f i n i t i o n d e s b o r n e s d e s i n t e r v a l l e s de c o n f i a n c e :
10 aM = . . . . . . . . . . . . . . . . . . . . . . . . . . ; bM = . . . . . . . . . . . . . . . . . . . . . . . . . .
11 import s c i p y . s p e c i a l as sp
12 u=s p . n d t r i (1− a l p h a / 2 )#on a P h i ( u )=1−a l p h a /2
13 aZ = . . . . . . . . . . . . . . . . . . . . . . . . . . ; bZ = . . . . . . . . . . . . . . . . . . . . . . . . . .
14
15 #" I n c e r t i t u d e " : L a r g e u r moyenne d e s deux i n t e r v a l l e s de c o n f i a n c e s :
16 LM=np . mean (bM−aM)
17 LZ=np . mean ( bZ−aZ )
18
19 #" N i v e a u r é e l " : P r o p o r t i o n d ’ i n t e r v a l l e s de c o n f i a n c e s c o n t e n a n t t h e t a :
20 pM=(np . sum ( t h e t a <=bM)−np . sum ( t h e t a <aM) ) /N
21 pZ=(np . sum ( t h e t a <=bZ )−np . sum ( t h e t a <aZ ) ) /N
22
23 p r i n t ( " E s t i m a t i o n p o n c t u e l l e de t h e t a p a r l ’ e s t i m a t e u r M_n : "+s t r (M[ 0 ] ) )
24 p r i n t ( " I n t e r v a l l e s de c o n f i a n c e o b t e n u s a v e c l ’ e s t i m a t e u r M_n : " )
25 p r i n t ( ’ L a r g e u r moyenne : ’+s t r (LM)+ ’ e t n i v e a u r é e l : ’+s t r (pM∗ 1 0 0 ) )
26 p r i n t ( " E s t i m a t i o n p o n c t u e l l e de t h e t a p a r l ’ e s t i m a t e u r Z_n : "+s t r ( Z [ 0 ] ) )
27 p r i n t ( " I n t e r v a l l e s de c o n f i a n c e o b t e n u s a v e c l ’ e s t i m a t e u r Z_n : " )
28 p r i n t ( ’ L a r g e u r moyenne : ’+s t r ( LZ )+ ’ e t n i v e a u r é e l : ’+s t r ( pZ ∗ 1 0 0 ) )
Expliquer ce que font les commandes des lignes 20 et 21 du script.

c) Exécuter ensuite ce script. Commenter.
8) Un intervalle de confiance pour θ. On suppose dans cette question que n est un entier impair. Il existe
donc k ∈ N tel que n = 2k + 1. On admet l’existence de 2k + 1 fonctions ϕ1 , ϕ2 , . . . , ϕ2k+1 continues sur
R2k+1 à valeurs réelles telles que Y1 , Y2 , . . . , Y2k+1 définies par
∀i ∈ J1 ; 2k + 1K, Yi = ϕi (X1 , X2 , . . . , X2k+1 )
sont des variables aléatoires à densité de telle sorte que, pour tout ω ∈ Ω, Y1 (ω), Y2 (ω), . . . , Y2k+1 (ω) soit
un réarrangement par ordre croissante de X1 (ω), X2 (ω), . . . , X2k+1 (ω) :
∀ω ∈ Ω, Y1 (ω) 6 Y2 (ω) 6 · · · 6 Y2k+1 (ω).

√
En particulier Yk+1 est la médiane empirique de l’échantillon (X1 , . . . , X2k+1 ). On pose Tn = 2 Yk+1 .
On se donne α ∈ ]0 ; 1[. On définit la variable aléatoire Dn
X n
θ
Dn = card i ∈ J1 ; nK Xi < √ = 1Xi <θ/√2
2 i=1
a) Justifier que Dn suit une loi binomiale dont on précisera les paramètres.

θ
b) Justifier que, pour tout i ∈ J1 ; nK, Yi > √ = [Dn < i].
2
1
c) Montrer que, pour tout ` ∈ J0 ; nK, P(Dn > n − `) = P(Dn 6 `). En déduire que P(Dn > k + 1) = .
2
α
d) Montrer que l’ensemble En,α = i ∈ N P(Dn > i) 6 admet un minimum. On le note jα .
2

e) Montrer que jα > k + 1. En déduire que Yn−jα +1 6 Yjα presque sûrement.

θ
f) Déduire des questions précédentes que P Yn−jα +1 < √ 6 Yjα > 1 − α.
2
g) En déduire un intervalle de confiance pour θ au niveau de confiance 1 − α.
Vérifier que l’estimateur Tn prend presque sûrement ses valeurs dans cet intervalle.
h) Justifier que la fonction Python suivante prend en entrée α et n et renvoie le minimum de En,α .
1 d e f minE ( n , a l p h a ) :
2 i=n+1
3 p=1/2∗∗n
4 s=p
5 w h i l e s<=a l p h a / 2 :
6 i=i −1
7 p=p∗ i / ( n−i +1)
8 s=s+p
9 return i
i) En Python, si A désigne une matrice réelle, alors la commande np.sort(A,0) renvoie une copie de A
triée colonne par colonne, par ordre croissant (chaque colonne est triée indépendamment).
Compléter le script Python ci-dessous afin que son exécution retourne un vecteur MedEmp contenant p
réalisation de la médiane empirique Yk+1 .
1 k=50
2 n=2∗k+1
3 N=10000
4 t h e t a =2
5 a l p h a =0.05
6 X = . . . . . . . . . . . . . . . . . . . . . . . #Une m a t r i c e de t a i l e nxN de r é a l i s a t i o n s de X
7 Y=np . s o r t (X , 0 )#T r i c o l o n n e p a r c o l o n n e
8 j=minE ( n , a l p h a )#C a l c u l de j _ a l p h a
9
10 #Dé f i n i t i o n d e s b o r n e s d e s i n t e r v a l l e s de c o n f i a n c e :
11 aT = . . . . . . . . . . . . . . . . . . . . . . . . . . ; bT = . . . . . . . . . . . . . . . . . . . . . . . . . .
12
13 #" I n c e r t i t u d e " : L a r g e u r moyenne d e s deux i n t e r v a l l e s de c o n f i a n c e s :
14 LT=np . mean ( bT−aT )
15
16 #" N i v e a u r é e l " : P r o p o r t i o n d ’ i n t e r v a l l e s de c o n f i a n c e s c o n t e n a n t t h e t a :
17 pT=(np . sum ( t h e t a <=bT )−np . sum ( t h e t a <aT ) ) /N
18
19 p r i n t ( " E s t i m a t i o n p o n c t u e l l e de t h e t a p a r l ’ e s t i m a t e u r T_n : "
+s t r ( . . . . . . . . . . . ) )
20 p r i n t ( " I n t e r v a l l e s de c o n f i a n c e o b t e n u s a v e c l ’ e s t i m a t e u r T_n : " )
21 p r i n t ( ’ L a r g e u r moyenne : ’+s t r (LT)+ ’ e t n i v e a u r é e l : ’+s t r ( pT ∗ 1 0 0 ) )
Commenter et comparer avec les estimateurs asymptotiques. Si on prend une petite valeur de k
(après tout c’est un intervalle de confiance non asymptotique), qu’obtient-on ? Est-ce plus ou moins
intéressant ?

Poly TP

Transféré par

Droits d'auteur :

Formats disponibles

Poly TP

Transféré par

Informations du document

Description originale:

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Poly TP

Transféré par

Droits d'auteur :

Formats disponibles

TP d’Informatique

0 Révisions de première année . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5

1 Variables aléatoires à densité avec Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15

3 Fonctions de plusieurs variables – Première partie . . . . . . . . . . . . . . . . . . . . . . . . 29

4 Convergences et approximations de variables aléatoires . . . . . . . . . . . . . . . . . . . . . 40

5 Fonctions de deux variables – Deuxième partie . . . . . . . . . . . . . . . . . . . . . . . . . . 51

6 Estimation ponctuelle et par intervalle de confiance . . . . . . . . . . . . . . . . . . . . . . . 55

Lycée Carnot – H2B 3 Matthias Gorny

Lycée Carnot – H2B 4 Matthias Gorny

Révisions de première année

I Commandes et structures de bases

Exercice 4 – Recherche du max et du min. (HH)

II Suites, sommes, produits

Cette fonction ne devra pas utiliser de fonction factorielle.

Lycée Carnot – H2B 5 Matthias Gorny

Exercice 9 – Nombres de Bell. On pose B0 = 1 et

Lycée Carnot – H2B 6 Matthias Gorny

Lycée Carnot – H2B 7 Matthias Gorny

Lycée Carnot – H2B 8 Matthias Gorny

(x − α)2 (f 0 (x) − f 0 (α))

(b − a)(f (b) − f (a)) (b − a)2 (f 0 (b) − f 0 (a)) (b − a)5

On utilisera l’exercice précédent et on vérifiera ensuite avec la commande al.solve.

Lycée Carnot – H2B 9 Matthias Gorny

Lycée Carnot – H2B 10 Matthias Gorny

b) Déterminer la loi de N . Préciser son espérance et sa variance.

Lycée Carnot – H2B 11 Matthias Gorny

5) Un étudiant nous propose comme loi de X5 le résultat suivant :

Lycée Carnot – H2B 12 Matthias Gorny

on obtient le graphique suivant :

Lycée Carnot – H2B 13 Matthias Gorny

0 200 400 600 800 1,000

Interpréter le graphique puis justifier vos observations.

Lycée Carnot – H2B 14 Matthias Gorny

Variables aléatoires à densité avec Python

I Représentation graphique des lois à densité usuelles

Exercice 2 – Représentation de lois exponentielles. (H)

Exercice 3 – Représentation de lois normales. (H)

Exercice 4 – Représentation de lois gamma. (HH)

Lycée Carnot – H2B 15 Matthias Gorny

Exercice 5 – « Vérification » des simulations. (HH)

Exercice 6 – Somme de loi exponentielles. (HH)

Lycée Carnot – H2B 16 Matthias Gorny

2) Utilisation de la méthode d’inversion

Lycée Carnot – H2B 17 Matthias Gorny

Que remarque-t-on ? Comment l’expliquer ?

3) Retour sur la simulation de lois discrètes

Y = min{n ∈ N | U1 U2 . . . Un+1 6 e−λ }.

1) Pour tout i ∈ N∗ , on pose Fi = − ln(Ui ). Quelle est la loi de Fi ?

Lycée Carnot – H2B 18 Matthias Gorny

∀ω ∈ Ω, Nt (ω) = sup {n ∈ N | Sn (ω) 6 t}.

1) Pour tout t ∈ R∗+ , montrer que P (Nt = 0) = e−λt .

c) En déduire que P(Nt = −1) = 0.

Lycée Carnot – H2B 19 Matthias Gorny

Par laquelle des instructions suivantes faut-il compléter la ligne manquante ?

1 F=np . cumsum (P)

Lycée Carnot – H2B 20 Matthias Gorny

La commande Python est la suivante :

Exemple : Si les données sont implémentées dans