ECC 1A 2017-2018

Probabilités
TD 1

Objectifs.

— Calculer et manipuler les espérances

Exercice 1. Calculer l’espérance et la variance de X lorsque

1. X ∼ B(n, p),
2. X ∼ N (m, σ 2 ),
3. X ∼ P(λ),
4. X ∼ G(p),
5. X ∼ E(λ).
Puis, calculer P(X = k) pour k ∈ N, lorsque X ∼ B(n, 0.5). Quelle est la valeur de X la plus probable ?

Correction. On utilise ici à chaque fois le théorème de transfert.

1. Le calcul donne EX = np et Var(X) = np(1 − p).
y2
2. L’espérance se calcule avec le changement de variable y = x−m et la symétrie de y 7→ σ√y2π e 2σ2 .
Et la variance s’obtient à l’aide d’une intégration par partie, et le calcul de l’intégrale de Gauss.
On obtient EX = m et Var(X) = σ 2 .
λn−1 n
3. L’espérance s’obtient en remarquant que EX = λe−λ n≥1 (n−1)! = λe−λ n≥0 λn! = λ. Puis,
P P

de la même façon, on obtient EX(X − 1) = λ2 qui donne Var(X) = λ.

 
4. On remarque que EX = (1 − p) n≥0 np(1 − p)n−1 = p(1 − p) − ∂p ∂ P n = 1−p . De
P
n≥1 (1 − p) p
1−p
la même façon, en calculant EX(X − 1), on obtient Var(X) = p2
.
1 1
5. Une intégration par partie (ou deux) permet d’obtenir EX = λ et Var(X) = λ2
.
À nouveau le théorème de transfert permet d’obtenir pour 0 ≤ k ≤ n
 
n −n
P(X = k) = PX ({k}) = 2 ,
k

et 0 si k > n. Le maximum est obtenu pour k = bn/2c ou k = dn/2e.

Exercice 2. On jette 37 pièces, suivant une loi B(0.5)⊗37 (chaque pièce fait pile avec probabilité 0.5).
Puis on définit la variable aléatoire X qui compte le nombre de pile obtenus.
1. Quelle est la valeur la plus probable de X ?
2. Quelle est la valeur moyenne de X ?

Correction. En appliquant
le théorème de transfert, on montre que X suit une loi binomiale (en
montrant que PX ({k}) = nk 2−n pour 0 ≤ k ≤ n). Il suffit alors d’appliquer le résultat de l’exercice 1.
1. 18 et 19
2. 18.5

Exercice 3. Soit X ∼ E(λ).

 1. Vérifier que pour tout t, s ∈ R+ ,

P(X > t + s|X > s) = P(X > t). (1)

2. (**) Montrer la réciproque :

Si une variable aléatoire X à valeurs dans R+ vérifie (1), alors il existe λ > 0 tel que X ∼ E(λ).

Correction.
1. D’une part,

P(X > t + s ∩ X > s) P(X > t + s)

P(X > t + s|X > s) = = = e−λ(t+s) eλs = e−λt ,
P(X > s) P(X > s)

et d’autre part,
P(X > t) = e−λ(t)

2. On note G(t) = P(X > t). L’égalité (1) indique alors que pour tout t, s ∈ R+ ,

G(t + s) = G(t)G(s).

Pour tout p, q ∈ N∗ on a alors par récurrence,

 q
1
G(1) = G
q
et    p
p 1
G =G = G(1)p/q .
q q
En posant G(1) = e−λ , on obtient alors

G(s) = e−λs , ∀s ∈ Q+ .

Comme G est décroissante, on a pour tout t ∈ R, et s− , s+ ∈ Q tels que s− ≤ t ≤ s+ ,

− +
e−λs ≥ G(t) ≥ e−λs

On obtient alors le résultat en faisant tendre s− et s+ vers t.

Exercice 4. Soient (Xn )n≥1 ∼ E(λ)⊗∞ et t ∈ R+ .

1. (*) Montrer que pour tout k ∈ N, la loi de ki=1 Xi a pour densité par rapport à la mesure de
P
Lebesgue
λk xk−1 −λx
x 7→ 1x>0 e .
(k − 1)!
2. (**) Montrer que la variable aléatoire Nt définie par
n
( )
X
Nt = sup n ∈ N; Xi ≤ t
i=1

suit une loi de Poisson de paramètre λt (avec la convention que sup{∅} = 0).

Correction.
1. En procédant par récurrence, on montre avec le changement de variable (x1 + x2 , x1 ) = (u, v)
l’initialisation de la récurrence. Puis, un changement de variable similaire permet d’aboutir au
résultat.
 2. On remarque que pour tout k ∈ N∗ ,
k
!
t
λk xk−1 −λx
X Z
P(Nt ≥ k) = P Xi ≤ t = e dx,
0 (k − 1)!
i=1

d’après la première partie de l’exercice. Donc,

Z t k k−1 Z t k+1 k
λ x −λx λ x −λx
P(Nt = k) = e dx − e dx
0 (k − 1)! 0 k!
Z t k k−1
λ x
= e−λx (k − λx) dx
0 k!
k
Par ailleurs, en notant Fk : t 7→ e−λt (λt)
k! ,

∂Fk λk xk−1 −λx

= e (k − λx) .
∂t k!
Comme pour tout k ∈ N∗ , Fk (0) = 0 = P(N0 = k), et P(Nt = k) et Fk ont même dérivée par
rapport à t, on en déduit que P(Nt = k) = Fk (t) pour tout k ∈ N∗ .
Donc Nt suit bien une loi de Poisson de paramètres λt. (Le cas k = 0 est une conséquence du
fait que Nt est à valeurs dans N.)

Exercice 5. Un serveur qui reçoit des requêtes en continu, traite la n-ème avec un temps Xn ∼ E(1)
en secondes.
1. Combien de requêtes sont traitées, en moyenne, en 1 minute ?
2. Quelle est la probabilité que le serveur traite plus de 100 requêtes en 1 minute ?

Correction. Il suffit d’appliquer le résultat précédent.

1. Le nombre de requêtes traitées suit une loi de Poisson de paramètre λ = 60. Donc 60 requêtes
sont traitées en moyenne par minute.
2. On cherche P(X > 100) lorsque X ∼ P(60). Autrement dit, la probabilité que le serveur traitre
plus de 100 requêtes en une minute est de
∞
X 60i
e−60 < 10−5 .
i!
i=100