Chapitre 7 – Variables aléatoires discrètes et loi binomiale

On lance un dé équilibré ; \(X\) = nombre de points.

Dé : \(E(X) = 1\cdot\frac16 + 2\cdot\frac16 + \dots + 6\cdot\frac16 = \dfrac{1+2+3+4+5+6}{6} = \dfrac{21}{6} = 3{,}5\).

Jeu : on gagne \(5\) € avec probabilité \(0{,}2\), on perd \(2\) € avec probabilité \(0{,}8\). Gain moyen :

Le joueur perd en moyenne \(0{,}60\) € par partie : jeu défavorable.

Un QCM comporte \(10\) questions ; à chacune, \(4\) réponses possibles dont une seule correcte. Un élève répond au hasard. Soit \(X\) le nombre de bonnes réponses.

• Reconnaissance : \(10\) questions identiques et indépendantes, deux issues (bonne / mauvaise), \(p = \frac14 = 0{,}25\). Donc \(X \sim B(10\,;\,0{,}25)\).
• Aucune bonne réponse : \(P(X=0) = 0{,}75^{10} \approx 0{,}0563\).
• Exactement \(3\) bonnes réponses : \(P(X=3) = \binom{10}{3}(0{,}25)^{3}(0{,}75)^{7} = 120\times0{,}015625\times0{,}1335 \approx 0{,}250\).
• Nombre moyen de bonnes réponses : \(E(X) = 10\times0{,}25 = 2{,}5\).

La plupart des calculatrices lycée disposent d'une fonction de loi binomiale :

• binomFdp\((n,p,k)\) (ou binompdf) donne \(P(X=k)\) ;
• binomFrép\((n,p,k)\) (ou binomcdf) donne la probabilité cumulée \(P(X\le k)\).

Le coefficient binomial \(\binom nk\) s'obtient avec la touche nCr (ou combinaison).

=LOI.BINOMIALE.N(k;n;p;FAUX) donne \(P(X=k)\) ; avec VRAI, la probabilité cumulée \(P(X\le k)\). =COMBIN(n;k) donne \(\binom nk\).

from math import comb   # comb(n, k) = coefficient binomial

def proba_binomiale(n, p, k):
    return comb(n, k) * p**k * (1 - p)**(n - k)

n, p = 10, 0.25
proba = [proba_binomiale(n, p, k) for k in range(n + 1)]
esperance = sum(k * proba[k] for k in range(n + 1))
print(round(esperance, 4), "≈", n * p)   # 2.5 ≈ 2.5

On construit chaque ligne à partir de la précédente grâce à la relation de Pascal \(\binom nk = \binom{n-1}{k-1} + \binom{n-1}{k}\) : chaque terme est la somme des deux termes situés au-dessus. On n'utilise que des listes.

def triangle_pascal(n):
    """Renvoie la liste des lignes 0 à n du triangle de Pascal."""
    triangle = [[1]]                 # ligne 0
    for i in range(1, n + 1):
        precedente = triangle[-1]    # dernière ligne construite
        ligne = [1]                  # premier terme : toujours 1
        for k in range(1, i):
            # relation de Pascal : somme des deux termes au-dessus
            ligne.append(precedente[k - 1] + precedente[k])
        ligne.append(1)              # dernier terme : toujours 1
        triangle.append(ligne)
    return triangle

for ligne in triangle_pascal(5):
    print(ligne)
# [1]
# [1, 1]
# [1, 2, 1]
# [1, 3, 3, 1]
# [1, 4, 6, 4, 1]
# [1, 5, 10, 10, 5, 1]

Avec la fonction proba_binomiale ci-dessus, on trace le diagramme en bâtons de la loi de probabilité :

import matplotlib.pyplot as plt

n, p = 10, 0.25
valeurs = list(range(n + 1))                          # k = 0, 1, ..., n
probas = [proba_binomiale(n, p, k) for k in valeurs]

plt.bar(valeurs, probas, width=0.4)
plt.xlabel("k")
plt.ylabel("P(X = k)")
plt.title("Loi binomiale B(10 ; 0,25)")
plt.show()

Lien avec la classe de première : en simulant \(N\) échantillons de taille \(n\) d'une loi de Bernoulli de paramètre \(p\) (avec random.random() < p, comme en première), l'histogramme des fréquences observées du nombre de succès se rapproche de ce diagramme en bâtons lorsque \(N\) est grand : la loi binomiale est le modèle théorique dont la simulation donne une image approchée.

On représente l'espérance de lois binomiales \(B(n,p)\) d'abord à \(p\) fixé et \(n\) variable, puis à \(n\) fixé et \(p\) variable :

def esperance_binomiale(n, p):
    """Espérance calculée par la somme des k * P(X = k)."""
    probas = [proba_binomiale(n, p, k) for k in range(n + 1)]
    return sum(k * probas[k] for k in range(n + 1))

# 1) p fixé à 0,25 ; n varie de 1 à 30
liste_n = list(range(1, 31))
esperances = [esperance_binomiale(n, 0.25) for n in liste_n]
plt.plot(liste_n, esperances, "o")   # points alignés, pente 0,25
plt.xlabel("n") ; plt.ylabel("E(X)")
plt.show()

# 2) n fixé à 20 ; p varie de 0 à 1
liste_p = [k / 100 for k in range(101)]
esperances = [esperance_binomiale(20, p) for p in liste_p]
plt.plot(liste_p, esperances)        # droite, pente 20
plt.xlabel("p") ; plt.ylabel("E(X)")
plt.show()

Dans les deux cas, les points obtenus sont alignés sur une droite passant par l'origine : à \(p\) fixé, \(E(X)\) est proportionnelle à \(n\) (pente \(p\)) ; à \(n\) fixé, elle est proportionnelle à \(p\) (pente \(n\)). C'est bien ce que dit la formule admise \(E(X) = np\).