Math ECG 2.

2023-2024

Mathématiques Appliquées - F. Gaunard

http://frederic.gaunard.com
ENC Bessières, Paris 17e.

Chapitre 1. Simulation de variables aléatoires finies

et discrètes. Diagrammes à bâtons.

1 Avant-propos
Ce premier chapitre a plusieurs motivations. Déjà, il permet quelques révisions sur les variables aléa-
toires finies et discrètes et notamment sur les lois usuelles, qu’on va rencontrer tout le temps.
Ensuite, il donne le ton dès le premier chapitre; c’est un cours de mathématiques appliquées; en probabil-
ités, la simulation sous Python est une composante incontournable du programme et sera très présente
tout au long de l’année.

+ On va donc considérer que, dans tous les programmes et exercices venir, auront déjà été importées
sous leurs alias habituels les bibliothèques et libraires nécessaires à chaque situation:
import numpy as np
import numpy . random as rd
import matplotlib . pyplot as plt

2 Simulation d’une variable aléatoire avec rd.random( )

Commençons par quelques rappels.

Résultat du cours de première année

Soit (Ω, P(Ω)) un espace probabilisable. On appelle variable aléatoire réelle (ou v.a.r) sur (Ω, P(Ω))
toute application
X:Ω→R
L’ensemble X(Ω) s’appelle l’univers image de X. C’est l’ensemble des valeurs prises par X.

Une variable aléatoire est caractérisée par sa loi.

À retenir!
+ En pratique, dans le cas d’un univers Ω discret (fini ou infini), la loi d’une variable aléatoire sera
la donnée de tous les couples
(x, P (X = x)), x ∈ X(Ω).
+ La loi sera la principale information dont on disposera sur une variable aléatoire, l’univers Ω étant
le plus souvent implicite et non précisé.
2 Simulation de VAD
Avant de simuler une variable aléatoire, il est important d’avoir compris comment simuler un évènement
de probabilité p.

À retenir!
La commande rd.random( ) renvoie un nombre réel aléatoire entre 0 et 1 suivant la loi uniforme
(continue) U([0; 1])a. Plus précisément, si p ∈ [0; 1], la probabilité que le nombre renvoyé soit
inférieure ou égale à p (ou dans un intervalle de longueur p) vaut exactement p.

On identifie et décide de représenter donc un évènement de probabilité p par le fait que le nombre
aléatoire ainsi renvoyé soit inférieur ou égal à p (ou dans un intervalle de longueur p).
aCette loi usuelle sera introduite et étudiée dans la chapitre sur les variables aléatoires à densité

Exercice 1. Le score d’un joueur lors d’un lancer de fléchette est modélisé par une variable aléatoire
X telle que X(Ω) = {0, 2, 5, 10} et
1 1 1 1
P (X = 0) = , P (X = 2) = , P (X = 5) = , et P (X = 10) = .
5 2 5 10
(1) Calculer l’espérance et la variance de X.
(2) Découper l’intervalle [0; 1] en quatre intervalles où pourrait tomber un nombre aléatoire généré
avec rd.random() dans le but de simuler X. Écrire alors une fonction simul_X() qui renvoie
une simulation de la variable X.
(3) On ajoute les commandes suivantes. Les exécuter et commenter l’affichage.
def sample_X ( n ) :
S=[]
f o r k in range ( n ) :
S . append ( simul_X ( ) )
return S

p r i n t ( np . mean ( sample_X ( 1 0 0 0 ) ) )

À retenir!
Un n−échantillon d’une variable aléatoire X est un n−uplet dont chaque composante est une variable
aléatoire Xi de même loi que X et qui sont toutes mutuellement indépendantes.

La moyenne empirique des réalisations d’un n−échantillon (que l’on obtient grâce à la commande
np.mean( ) ) fournit alors une estimation (valeur approchée) de l’espérance de X (quand celle-ci
existe). Cette observation prendra tout son sens avec le chapitre Estimation de fin d’année.

Exercice 2. On désigne par n un entier naturel supérieur ou égal à 2. On lance n fois une pièce équili-
brée (c’est-à-dire donnant Pile avec la probabilité 1/2, les lancers étant supposés indépendants.
On note Z la variable aléatoire qui vaut 0 si l’on n’obtient aucun Pile pendant ces n lancers et qui, dans
le cas contraire, prend pour valeur le rang du premier pile.

(1) Recopier et compléter la fonction suivante permettant de simuler la variable aléatoire Z.

def simul_Z ( n ) :
f o r i in range ( 1 , n + 1 ) :
i f ........ :
return ...
return ...
Chapitre 1. 3
(2) Réécrire cette fonction en utilisant une boucle while.
(3) Déterminer P (X = k) pour k ∈ J0; nK. (On pourra différencier deux cas selon que 1 ≤ k ≤ n et
k = 0.)

3 (Simulation de) Lois usuelles finies et discrètes

3.1 Loi uniforme U(Jm; nK)
Résultat du cours de première année
On dit que X suit une loi uniforme sur Jm; nK), ce qu’on note X ,→ U(Jm; nK) si X(Ω) =
Jm; nK et
1
∀k ∈ Jm; nK, P (X = k) =
n−m+1
De plus,
n+m (n − m + 1)2 − 1
E(X) = , V (X) = .
2 12
+ On peut reconnaître une loi uniforme lors d’un tirage dont les issues sont équiprob-
ables (lancer d’un dé non truqué, tirage de boules indiscernables ...).

+ La commande rd.randint(m, n+1) renvoie une simulation d’une variable X ,→

U(Jm; nK).

Exercice 3. On dispose de n urnes, numérotées de 1 à n. Pour chaque k ∈ J1, nK, l’urne k est composée
de boules numérotées de 1 à k. On choisit une urne au hasard puis on tire une boule dans cette urne et
on note Xn la variable aléatoire qui prend la valeur du numéro de la boule piochée.
Écrire une fonction simul_X(n) qui simule Xn .

3.2 Loi de Bernoulli B(p)

Résultat du cours de première année
On dit que X suit une loi de Bernoulli de paramètre p, ce qu’on note X ,→ B(p) si
X(Ω) = {0; 1} et
P (X = 1) = p, P (X = 0) = 1 − p.
De plus,
E(X) = p, V (X) = p(1 − p).
+ La loi de Bernoulli correspond à une situation à deux alternatives, l’une qu’on appelle
succès (et lors de laquelle la variable prend la valeur 1) et l’autre qu’on appelle échec.

Exercice 4. Écrire, à l’aide de la commande np.rand( ) une fonction Bernoulli(p) permettant de

simuler une variable X ,→ B(p).
4 Simulation de VAD
3.3 Loi binomiale B(n, p)
Résultat du cours de première année
On dit que X suit une loi binomiale de paramètres n et p, ce qu’on note X ,→ B(n, p) si
X(Ω) = J0, nK et
 
n k
∀k ∈ J0, nK, P (X = k) = p (1 − p)n−k
k
De plus,
E(X) = np, V (X) = np(1 − p).
+ Si n = 1, la loi binomiale B(1, p) n’est rien d’autre que la loi de Bernoulli B(p).

+ On reconnait une loi binomiale de paramètre n et p lorsque l’on compte le nombre

de succès (dont la probabilité de chaque est p) lors de n répétitions indépendantes
d’épreuves de Bernoulli.

+ La commande rd.binomial(n,p) renvoie une simulation d’une variable X ,→

B(n, p).

+ On peut alors très rapidement simuler une variable de Bernoulli de paramètre p avec la commande
rd.binomial(1,p).

Exercice 5. Écrire, à l’aide de la commande np.rand( ) et d’une boucle for, une fonction Binomiale(n,p)
permettant de simuler une variable X ,→ B(n, p).

3.4 Loi géométrique G(p)

Résultat du cours de première année
On dit que X suit une loi géométrique de paramètre p, ce qu’on note X ,→ G(p) si
X(Ω) = N∗ et
∀k ∈ N∗ , P (X = k) = (1 − p)k−1 p
De plus, X admet espérance et variance et
1 1−p
E(X) = , V (X) = .
p p2
+ Une loi géométrique correspond au temps d’attente du premier succès (de probabilité
p) lors de répétitions (infinies) indépendantes d’une même épreuve de Bernoulli.
+ La commande rd.geometric(p) renvoie une simulation d’une variable X ,→ G(p).

Exercice 6. Écrire, à l’aide de la commande rd.rand( ) et d’une boucle while une fonction Geometrique(p)
permettant de simuler une variable X ,→ G(p).
Chapitre 1. 5
3.5 Loi de Poisson P(λ)
Résultat du cours de première année
On dit que X suit une loi de Poisson de paramètre λ > 0, ce qu’on note X ,→ P(λ) si
X(Ω) = N et
λk
∀k ∈ N, P (X = k) = e−λ
k!
De plus, X admet espérance et variance et
E(X) = λ, V (X) = λ2 .
+ La commande rd.poisson(m) renvoie une simulation d’une variable X ,→ P (m).

Exercice 7. Chaque jour, le nombre de personnes subissant un test de dépistage dans une certaine
pharmacie est modélisé par une variable X suivant une loi de Poisson de paramètre m = 5. Chaque test
a une certaine probabilité p = 1/10 d’être positif et les tests sont indépendants les uns des autres. On
note N le nombre de tests positifs un jour donné.
(1) Écrire une fonction permettant simuler la variable N .
(2) Créer un échantillon de taille 1000 de cette variable aléatoire et le comparer, avec un histogramme,
à un échantillon de même taille d’une loi de Poisson de paramètre mp = 0, 5. Conjecturer.
(3) (*) En commençant par expliciter PX=n (N = k) (en faisant attention sur le couplage des indices
n et k), démontrer le résultat précédemment conjecturé.

4 Diagrammes à bâtons
Rappel de commande en Python
La commande bar(x, y) du package matplotlib.pyplot permet de représenter un diagramme
à bâtons.
Plus précisément, en notant les arguments x = [x1 , ..., xn ] et y = [y1 , ..., yn ] (listes de mêmes
longueurs) elle permet de positionner un bâton de hauteur yi en face de la valeur xi .

Affichage Python

p=1/2
K = [ k f o r k in range ( 1 , 1 0 ) ]
p_th = [ p * ( 1 -p ) ** (k - 1 ) f o r k in K ]
plt . bar (K , p_th )
plt . show ( )

Exercice 8. Représenter le diagramme à bâtons dont les hauteurs des bâtons sont les valeurs théoriques
de la loi uniforme U(J1; N K).
Remarque
+ On ne fera pas de confusion avec la commande hist(U) (du même package) qui
représente l’histogramme des valeurs d’une liste U.
6 Simulation de VAD
Si les histogrammes sont très utiles pour représenter graphiquement la répartition empirique d’une loi
simulée avec un échantillon (de grande taille) lorsque la variable simulée est à densité (car les données
sont continues), les diagrammes à bâtons sont plus adaptés lorsque la loi est finie.

Il est souvent très efficace d’utiliser de tels diagrammes pour conjecturer sur la loi suivie (par exemple
si tous les bâtons ont à peu près la même hauteur, il est raisonnable de penser que la loi est uniforme
- sur l’ensemble des valeurs prises, ou bien en mettant en parallèle des bâtons d’une autre loi - usuelle
simulée ou hauteur théorique).
Les diagrammes à bâtons sont aussi pratiques pour visualiser (ou conjecturer graphiquement d’) une
convergence en loi 1. Par exemple, les commandes ci-dessous permettent d’afficher les bâtons dont les
hauteurs sont les valeurs théoriques de la loi géométrique de paramètre p = 1/2 (pour les 10 premiers
entiers).

À retenir!
L’idée est alors de créer un n−échantillon (avec n grand) et de créer un diagramme à bâtons dont la
liste x en abscisses est celles des valeurs obtenues par simulation et la liste y en ordonnées celle des
fréquences de chaque valeur dans l’échantillon.

4.1 Premier exemple

Une urne contient des boules numérotées de 1 à n, indiscernables au toucher. On effectue alors n tirages
sans remise dans l’urne et on note, pour tout k ∈ J1, nK, Xk la variable aléatoire qui prend la valeur de
la boule obtenue au k−ième tirage.

(1) Écrire une fonction Python d’en-tête def simul_X(k,n): qui renvoie une simulation de Xk .
(2) On ajoute les commandes suivantes. Expliquer ce qu’elles font. On insistera que la commande
de la ligne 6.

n=6
k=4
echantillon = [ simul_X (k , n ) f o r j in range ( 1 0 0 0 ) ]
freq = [ 0 ] * 6
f o r j in range ( 1 0 0 0 ) :
freq [ echantillon [ j ] -1 ] += 1 # ligne 6
freq = [ freq [ j ] / 1 0 0 0 f o r j in range ( n ) ]
plt . bar ( [ j f o r j in range ( 1 , n + 1 ) ] , freq )
plt . show ( )

(3) Leur exécution permet l’affichage suivant. Émettre une conjecture.

1Voir le Chapitre Convergence(s) et approximations.

Chapitre 1. 7

Affichage Python

4.2 Deuxième exemple

On lance indéfiniment une pièce donnant Pile avec la probabilité p et Face avec la probabilité q = 1 − p.
On suppose que p ∈]0, 1[ et on admet que les lancers sont mutuellement indépendants.

Pour tout entier naturel k, supérieur ou égal à 2, on dit que le k ième lancer est un changement s’il amène
un résultat différent de celui du (k − 1)ième lancer.

On note Pk (resp. Fk ) l’événement : "on obtient Pile (resp. Face) au k ième lancer".
Pour tout entier naturel n supérieur ou égal à 2, on note Xn la variable aléatoire égale au nombre de
changements survenus durant les n premiers lancers.

(1) Écrire une fonction d’en-tête def simul_X(n,p): qui renvoie une simulation de Xn .

(2) Quelles commandes peut-on ajouter pour représenter le diagramme à bâtons des fréquences des
valeurs prises par un 1000−échantillon de Xn ?

(3) Représenter le diagramme à bâtons susmentionné dans le cas p = 1/2 et n = 3 puis n = 4

puis n = 5. Représenter en parallèle des batôns correspondant aux hauteurs théoriques de la loi
B(n − 1, 1/2). Émettre une conjecture.
8 Simulation de VAD

Sélection d’exercices - Travaux dirigés

Exercice 9. On considère la variable aléatoire X telle que X(Ω) = {−1, 0, 1} et
P (X = −1) = P (X = 1) = 1/4, P (X = 0) = 1/2.
Écrire une fonction Python permettant de simuler X
Exercice 10. Une urne contient 1 boule bleue, 2 boules blanches et 3 boules rouges. On pioche
successivement et avec remise 3 boules dans cette urne. Si on obtient les 3 couleurs, on marque 2 points,
si on obtient une seule couleur 1 point et 0 point sinon. On note X la variable aléatoire qui prend la
valeur du nombre de points marqués sur une partie.
(1) Déterminer la loi de X. Écrire une fonction Python qui simule X.
(2) Calculer E(X) puis V (X).
Exercice 11. Une urne contient initialement deux boules rouges et une boule bleue indiscernables au
toucher. On appelle "tirage" la séquence suivant:

On pioche, au hasard, une boule de l’urne, puis :

• Si la boule piochée est bleue, on la remet dans l’urne.
• Si la boule piochée est rouge, on ne la remet pas dans l’urne mais on remet une boule bleue dans
l’urne à sa place.

Pour tout entier naturel n non nul, on note Yn la variable aléatoire discrète égale au nombre de boules
rouges présentes dans l’urne à l’issue du n−ième tirage.

(1) Compléter la fonction ci-dessous afin qu’elle simule la variable Yn .

def simul_Y ( n ) :
r = 2 # nombre de boules rouges dans l ’ urne
f o r k in range ( n ) :
i f ... :
if ... :
...
return ....
(2) On cherche à estimer lim P (Yn = 0). On introduit la variable Tn définie par
n→+∞

1, si [Yn = 0]
Tn =
0, sinon
(a) Quelle est la loi de la variable Tn ?
(b) Écrire une fonction qui simule Tn .
(c) On admet que la moyenne empirique d’un échantillon de 1000 réalisations de Tn renvoie une
estimation de P (Yn = 0). Écrire une suite d’instruction permettant de visualiser graphique-
ment l’évolution de (l’estimation de) P (Yn = 0) en fonction de n. Que peut-on conjecturer
quant à la limite ci-dessus?
(d) Justifier que (Yn = 0) ⊂ (Yn+1 = 0). En déduire que la conjecture précédente se reformule
comme !
+∞
[
P (Yn = 0) = 1.
n=2
Interpréter.

(3) On note Z la variable aléatoire égale au numéro du "tirage" amenant la dernière boule rouge.
(a) Donner Z(Ω).
(b) Écrire une fonction qui simule la variable Z.
Chapitre 1. 9
Exercice 12. Soit N un entier supérieur ou égal à 3. On considère une urne qui contient (N − 1) boules
blanches et une seule boule noire.
On effectue des tirages sans remise jusqu’à l’obtention de la boule noire et on note X la variable
aléatoire qui prend pour valeur le nombre de tirages nécessaires.
(1) Écrire une fonction simul_X(N) qui renvoie une simulation de la variable X.
(2) Recopier et exécuter les instructions ci-contre. Comparer avec le diagramme théorique de
l’Exercice 8. Commenter, conjecturer, démontrer.
import matplotlib . pyplot as plt

N = 5 # on fera varier les valeurs de N

freq_val_X = np . zeros ( N )
f o r k in range ( 1 0 0 0 0 ) :
i = simul_X ( N )
freq_val_X [i - 1 ] += 1
freq_val_X = freq_val_X / 1 0 0 0 0
plt . bar ( range ( 1 , N + 1 ) , freq_val_X )
plt . show ( )

Exercice 13. On donne le code suivant. Le recopier et exécuter fig_mystere pour plusieurs valeurs
de n. Expliquer, commenter.
import numpy as np
import matplotlib . pyplot as plt

def mystere (n , k ) :
return np . prod ( [ range (n - k + 1 , n + 1 ) ] ) / np . prod ( range ( 1 , k + 1 ) )

def fig_mystere ( n ) :
Y = [ mystere (n , k ) f o r k in range ( 0 , n + 1 ) ]
X = [ k f o r k in range ( n + 1 ) ]
plt . bar (X , Y )
plt . show ( )

Exercice 14. On effectue une succession infinie de lancers indépendants d’une pièce équilibrée, donnant
pile avec la probabilité p = 1/2 et face avec la probabilité q = 1 − p = 1/2.
On s’intéresse aux successions de lancers amenant un même côté.

On dit que la première série est de longueur k (avec k ∈ N∗ ) si les k premiers lancers ont amené le même
côté de la pièce et le (k + 1)-ième l’autre côté.
De même, la deuxième série commence au lancer suivant la fin de la première série et se termine (si elle
se termine) au lancer précédant un changement de côté. On définit de même les séries suivantes.
Pour tout i de N∗ , on note Pi (resp. Fi ) l’événement : " le i-ième lancer amène pile (resp. face) ".
Pour tout n de N∗ , on note Nn la variable aléatoire égale au nombre de séries obtenus lors des n premiers
lancers.

(1) Soit n ∈ N∗ .
(a) Justifier que Nn (Ω) = J1; nK.
(b) Calculer les probabilités P (Nn = 1) et P (Nn = n).

(2) (a) Déterminer les lois des variables aléatoires N1 et N2 et calculer leurs espérances.
(b) Déterminer la loi de N3 puis vérifier que E(N3 ) = 2.
10 Simulation de VAD
(3) Simulation informatique sous Python.

(a) Écrire une fonction def lancer(p): qui simule un lancer d’une pièce en renvoyant 1 si on
obtient pile (avec probabilité p ∈]0; 1[) et 0 si on obtient face (avec probabilité q = 1 − p).
(b) Compléter la fonction suivante qui, étant donnés un entier n de N∗ , simule n lancers de la
pièce et renvoie la valeur de Nn obtenue. On rappelle que dans cet exercice p vaut 1/2.
def simul_N ( n ) :
# Simulation des n lancers stockés dans la liste L
L = [ ]
f o r k in range ( .......... )
L . append ( ....... )
end
# Calcul de la valeur de Nn stockée dans la variable N
N = .........
f o r i in range ( ........ , .......... )
if ................ :
N = .........
return N
(4) (*) On pose, pour tout n de N∗ et pour tout s de [0; 1]
n
X
Gn (s) = P (Nn = k)sk .
k=1

La fonction Gn s’appelle fonction génératrice de la variable Nn .

(a) Calculer, pour tout n de N∗ , Gn (0) et Gn (1).

(b) Montrer que G0n (1) = E(Nn ).
(c) Soit n ∈ N∗ . En utilisant un système complet d’évènements associé à la variable Nn , montrer
que :
1 1
∀k ∈ J1; n + 1K, P (Nn+1 = k) = P (Nn = k) + P (Nn = k − 1).
2 2
∗
(d) En déduire : ∀n ∈ N , ∀s ∈ [0; 1],
 
1+s
Gn+1 (s) = Gn (s).
2
(e) En déduire, pour tout n de N∗ et pour tout s de [0; 1],
 n−1
1+s
Gn (s) = s · .
2
(f) En déduire, à l’aide de la question 4b, que le nombre moyen de séries lors des n premiers
lancers est (n + 1)/2.
Exercice 15. On effectue une succession infinie de lancers indépendants d’une pièce donnant Pile avec
probabilité p. On note q = 1 − p.
On dit que la première série est de longueur n ≥ 1 si les n premiers lancers ont amené le même côté de
la pièce et le (n + 1)-ième l’autre côté. De même la deuxième série commence au lancer suivant la fin
de la première série et se termine au lancer précédant un changement de côté.

Par exemple si les lancers donnent les résultats F F P P P P P P F F F P P . . . alors la première série est de
longueur 2 et la deuxième est de longueur 6.
Soient X1 et X2 les variables aléatoires égales aux longueurs de la première et deuxième série.
Chapitre 1. 11
(1) Recopier et compléter la fonction suivante, prenant en argument la probabilité p d’obtenir Pile
et permettant de simuler la variable aléatoire X1 .
def simul_X 1 ( p ) :
X=1
t_old = rd . binomial ( 1 ,p )
t_new = rd . binomial ( 1 ,p )
while .... :
X = ...
t_old = ...
t_new = ...
return X
(2) On ajoute le code suivant qui affiche la figure reproduite ci-après. Interpréter.
p=0.5
N=1000
x 1 = [ simul_X 1 ( p ) f o r k in range ( N ) ]
x 2 = [ rd . geometric ( p ) f o r k in range ( N ) ]
plt . hist ( [ x 1 , x 2 ] , color = [ ’ orange ’ , ’ pink ’] , density = True ,
label = [ ’ X_ 1 ’ , ’G ( 0 . 5 ) ’] )
plt . title ( ’ comparaison de distributions ’)
plt . legend ( )
plt . show ( )

Affichage Python

(3) Déterminer la loi de X1 . Retrouver le résultat conjecturé à la question précédente. Montrer

qu’elle admet une espérance que l’on explicitera.

(4) Écrire une fonction d’entête simul_X2(p) permettant de simuler la variable X2 .

(5) Déterminer, pour (k, j) ∈ N∗ × N∗ , P (X1 = k ∩ X2 = j). En déduire, à l’aide de la formule des
probabilités totales, la loi de X2 .
12 Simulation de VAD
1 1
Exercice 16. On considère la suite (uk ) définie, pour k ≥ 2 par uk = − .
k−1 k
(1) Vérifier la suite (uk ) peut être considérée comme une distribution de probabilité. On note alors
Y une variable aléatoire telle que Y (Ω) = J2, +∞J et P (Y = k) = uk .

Soit n ∈ N∗ . On dispose d’une urne contenant n boules, indiscernables au toucher, numérotées de 1 à n

et on effectue des tirages successifs, avec remise, dans cette urne.
On introduit la variable aléatoire Xn qui prend la valeur du rang du tirage pour lequel, pour la première
fois, la boule piochée a un numéro supérieur ou égal à celle piochée lors du tout premier tirage.
Pour tout k ∈ N∗ , on note Tk la variable aléatoire qui correspond au numéro de la boule piochée au
k−ième tirage.

(2) (a) Recopier et compléter la fonction suivante de sorte qu’elle renvoie une simulation de Xn .
import numpy as np
import numpy . random as rd

def simul_X ( n ) :
t = .........
k = ........
while .......... :
k=k+1
return k
(3) Compléter les commandes suivantes qui permettent d’obtenir une liste de fréquences des valeurs
obtenues pour un 1000−échantillon de Xn .
def frequence ( n ) :
S = [ simul_X ( n ) f o r k in range ( 1 0 0 0 ) ]
m = max ( S )
f = np . zeros ( m )
f o r k in range ( 1 0 0 0 ) :
f [ ...... ] += 1
return f / 1 0 0 0
(4) On ajoute les commandes suivantes dont l’exécution permet l’affichage ci-après. Interpréter.
def u ( k ) :
return 1 / (k - 1 ) -1 / k

import matplotlib . pyplot as plt

n = 5 # puis n = 1 0 , puis n = 2 5 puis n = 1 0 0

obs = frequence ( n )
N = min ( len ( obs ) , 1 4 )
x = [ k f o r k in range ( 2 , N + 2 ) ]
U = [ u ( k ) f o r k in x ]
h = [ obs [ k ] f o r k in range ( N ) ]
plt . plot (x , U , ’ kx ’)
plt . bar (x , h , width = 0 . 1 )
plt . show ( )
Chapitre 1. 13

Affichage Python Affichage Python

n=5 n = 10

Affichage Python Affichage Python

n = 25 n = 100

(4) (a) Soient k ≥ 2 et 1 ≤ i ≤ k. Écrire l’évènement [Xn = k] ∩ [T1 = i] à l’aide d’évènements

dépendant uniquement des variables aléatoires Tj .
(b) En déduire que, pour tout k ≥ 2,
n  k−2  k−1 !
1X i−1 i−1
P (Xn = k) = − .
n i=1 n n
(5) (*) Montrer que (Xn ) converge en loi vers Y . (Cette question est pour l’instant réservée aux
khubes.)
14 Simulation de VAD
Exercice 17.  
6 3 0
1
On considère la matrice M définie par M = 0 3 4 et les trois vecteurs de M3,1 (R) suivants
6 0 0 2
     
1 −1 3
V1 = 0 ,
 V2 =  1 , V3 = −4
 
0 0 1
(1) La matrice M est-elle inversible ?
(2) Calculer M V1 , M V2 et M V3 en fonction de V1 , V2 et V3 .

Une urne contient une boule rouge et deux boules blanches. On effectue dans cette urne une succession
de tirages d’une boule selon le protocole suivant :
• si la boule tirée est rouge, elle est remise dans l’urne.
• si la boule tirée est blanche, elle n’est pas remise dans l’urne.

Pour tout entier i supérieur ou égal à 1, on note Bi (respectivement Ri ) l’événement "on obtient une
boule blanche (respectivement une boule rouge) lors du ième tirage".

Pour tout entier n supérieur ou égal à 1, on note Xn le nombre de boules blanches contenues dans l’urne
à l’issue du nème tirage et on pose X0 = 2.
 
P [Xn = 0]
On introduit la matrice colonne Un = P [Xn = 1].
P [Xn = 2]
(3) (a) Déterminer pour tout entier naturel n, l’ensemble des valeurs prises par la variable Xn ( on
distinguera les trois cas : n = 0, n = 1 et n ≥ 2).
(b) Recopier et compléter en justifiant le diagramme de transition ci-contre de la suite (Xn )
(pour n ≥ 2). On précisera notamment à quelles probabilités conditionnelles correspondent
les valeurs sur les flèches du diagramme.
...

...
2/3

... 1 2 ...

(c) En utilisant la formule des probabilités totales avec un système complet d’évènements con-
struit avec la variable Xn , montrer que pour tout entier n supérieur ou égal à 2, on a l’égalité
suivante :
1 2
P (Xn+1 = 1) = P (Xn = 1) + P (Xn = 2).
2 3
Montrer de même qu’on a
Un+1 = M Un .
Chapitre 1. 15
Vérifier que l’égalité précédente reste valable pour n = 0 et n = 1.
(d) En déduire par récurrence, pour tout entier naturel n, la relation suivante :
 n  n
1 1
Un = V1 + 4 V2 + V3 .
2 3
(e) Donner la loi de la variable Xn .
(4) Calculer E (Xn ) , espérance de Xn , ainsi que sa limite lorsque n tend vers +∞.

(5) Recopier et compléter la fonction suivante permettant de représenter graphiquement la trajectoire

de la v.a. Xn .
def traj_X ( n ) :
X = np . zeros ( n + 1 )
X [ 0 ] =...........
f o r i in range ( 1 , n + 1 ) :
i f X [i - 1 ] == 0 :
X [ i ] =.....
e l i f ...... :
X [ i ] = ...
else :
........
N = [ k f o r k in range ( n + 1 ) ]
plt . grid ( )
plt . plot (N , X , ’ ko ’)
plt . show ( )