Loi binomiale

1. Dessiner l'arbre, un niveau par épreuve, avec \(p\) sur chaque branche de succès et \(1 - p\) sur chaque branche d'échec (les mêmes nombres à chaque niveau, puisque les épreuves sont identiques et indépendantes).
2. Repérer les chemins qui composent l'événement : par exemple « exactement deux succès » retient les chemins qui contiennent exactement deux lettres \(S\).
3. Multiplier le long de chaque chemin, puis additionner les chemins retenus : tous les chemins qui ont le même nombre de succès ont la même probabilité, il suffit donc de les compter.

• Bords : \(\dbinom{n}{0} = \dbinom{n}{n} = 1\).
• Symétrie : pour \(0 \leq k \leq n\), \(\dbinom{n}{k} = \dbinom{n}{n-k}\).
• Relation de Pascal : pour \(n \geq 2\) et \(1 \leq k \leq n - 1\), $$\binom{n}{k} = \binom{n-1}{k-1} + \binom{n-1}{k}.$$
• Somme des coefficients : $$\binom{n}{0} + \binom{n}{1} + \dots + \binom{n}{n} = 2^n,$$ car l'arbre à \(n\) niveaux a \(2^n\) chemins, chacun compté une fois, dans le terme \(\dbinom{n}{k}\) de son nombre \(k\) de succès.

def pascal_row(n):
    row = [1]                      # row 0
    for i in range(n):
        previous = row
        row = [1]                  # first coefficient of the new row
        for k in range(len(previous) - 1):
            row.append(previous[k] + previous[k + 1])   # Pascal's relation
        row.append(1)              # last coefficient
    return row

print(pascal_row(5))               # [1, 5, 10, 10, 5, 1]

1. Simuler un échantillon de taille \(n\) : répéter le test \(n\) fois, les tirages étant indépendants, et compter les succès ; le nombre obtenu est un entier \(k\) compris entre \(0\) et \(n\).
2. Répéter l'échantillon \(N\) fois et relever, pour chaque valeur \(k\), combien d'échantillons ont donné exactement \(k\) succès.
3. Diviser par \(N\) : les quotients sont les fréquences observées des valeurs \(0, 1, \dots, n\) ; leur somme vaut \(1\).
4. Représenter les fréquences observées à côté du diagramme en bâtons des probabilités \(P(X = k)\), où \(X\) suit la loi \(\mathcal{B}(n\,;\,p)\).

from random import random
from math import comb

def successes(n, p):
    k = 0
    for i in range(n):
        if random() < p:
            k = k + 1
    return k

def observed_frequencies(n, p, N):
    counts = [0] * (n + 1)
    for j in range(N):
        k = successes(n, p)
        counts[k] = counts[k] + 1
    return [c / N for c in counts]

def probabilities(n, p):
    # comb(n, k) is the number of paths with k successes
    return [comb(n, k) * p**k * (1 - p)**(n - k) for k in range(n + 1)]

print(observed_frequencies(4, 0.3, 1000))
print([round(q, 4) for q in probabilities(4, 0.3)])