Simulations probabilistes

Simuler le hasard avec Python

Quand on jette une pièce ou un dé, on ne peut pas prévoir le résultat — mais on sait qu'à la longue, environ une fois sur deux on obtient pile, et environ une fois sur six on obtient un 1. Ce passage du « cas par cas imprévisible » à des fréquences stables est au cœur des probabilités. Et avec Python, on peut le voir se produire en direct, en simulant des milliers d'expériences en moins d'une seconde.

À la fin de cette fiche, tu sauras tirer un nombre au hasard, simuler un lancer de pièce ou de dé, calculer la fréquence d'un événement sur un grand nombre d'essais, observer la loi des grands nombres sur un graphique, estimer $\pi$ par la méthode de Monte-Carlo, et faire faire une marche aléatoire à un personnage.

Tirer un nombre au hasard

Le module random de la bibliothèque standard fournit tout ce qu'il faut pour générer du hasard. Trois fonctions suffisent pour 90 % des situations :

• random.random() renvoie un flottant tiré au hasard dans $[0, 1[$.
• random.randint(a, b) renvoie un entier tiré au hasard dans $[a, b]$ (bornes incluses).
• random.choice(liste) choisit un élément au hasard dans une liste.

Relance plusieurs fois la cellule : les valeurs changent à chaque exécution. C'est exactement ce qu'on attend du hasard.

import random
print(random.randint(1, 100))

import random
print(random.choice(['pierre', 'feuille', 'ciseaux']))

import random

de1 = random.randint(1, 6)
de2 = random.randint(1, 6)
print('Dé 1 :', de1)
print('Dé 2 :', de2)
print('Somme :', de1 + de2)

Compter les succès sur un grand nombre d'essais

L'intérêt d'une simulation, c'est de répéter une expérience beaucoup de fois et de compter les cas favorables. La structure typique :

• une variable de comptage initialisée à $0$
• une boucle for qui répète l'expérience $N$ fois
• à chaque tour, on incrémente le compteur si l'événement est réalisé
• à la fin, la fréquence est `compteur / N`

Relance la cellule plusieurs fois : la fréquence reste très proche de $0{,}5$. C'est la loi des grands nombres : sur un grand nombre d'essais, la fréquence d'un événement s'approche de sa probabilité.

import random

N = 10000
six = 0
for _ in range(N):
    if random.randint(1, 6) == 6:
        six += 1

print('Fréquence du 6 :', six / N)

import random

N = 10000
pairs = 0
for _ in range(N):
    if random.randint(1, 6) % 2 == 0:
        pairs += 1

print('Fréquence des pairs :', pairs / N)

import random

N = 100000
succes = 0
for _ in range(N):
    if random.randint(1, 6) + random.randint(1, 6) == 7:
        succes += 1

print('Fréquence de la somme 7 :', succes / N)
print('Théorique :', 1 / 6)

Voir la loi des grands nombres se former

La fréquence devient stable quand $N$ grandit. Pour le voir, on enregistre la fréquence après chaque lancer et on la trace en fonction du nombre d'essais. La courbe doit converger visuellement vers $0{,}5$ pour une pièce équilibrée.

Au début, la courbe oscille fortement : avec 10 lancers, obtenir 7 piles est crédible et donne une fréquence de $0{,}7$. Mais dès que $N$ dépasse quelques milliers, la courbe se rapproche inexorablement de $0{,}5$ — c'est la loi des grands nombres en action.

import random
import matplotlib.pyplot as plt

N = 5000
six = 0
frequences = []
for k in range(1, N + 1):
    if random.randint(1, 6) == 6:
        six += 1
    frequences.append(six / k)

plt.plot(frequences)
plt.axhline(1 / 6, color='red', linestyle='--', label='1/6')
plt.legend()
plt.grid(True)
plt.show()

import random
import matplotlib.pyplot as plt

N = 3000
for run in range(3):
    piles = 0
    freq = []
    for k in range(1, N + 1):
        if random.choice(['pile', 'face']) == 'pile':
            piles += 1
        freq.append(piles / k)
    plt.plot(freq, label=f'simulation {run + 1}')

plt.axhline(0.5, color='black', linestyle='--')
plt.legend()
plt.grid(True)
plt.show()

Histogramme : voir la distribution

Plutôt que de compter un seul événement, on peut s'intéresser à toute la distribution : combien de 1, de 2, de 3, etc. Pour cela, on stocke tous les résultats dans une liste et on demande à matplotlib de tracer un histogramme.

Les six barres sont à peu près de même hauteur ($\approx 1667$) : le dé est équilibré. Mais sur la somme de deux dés, la distribution n'est plus uniforme — on a beaucoup plus de 7 que de 2 ou de 12. C'est l'occasion de visualiser la forme triangulaire caractéristique :

import random
import matplotlib.pyplot as plt

N = 20000
valeurs = [random.random() for _ in range(N)]

plt.hist(valeurs, bins=20, edgecolor='black')
plt.title('Distribution uniforme')
plt.show()

import random
import matplotlib.pyplot as plt

N = 50000
sommes = [random.randint(1, 6) + random.randint(1, 6) + random.randint(1, 6) for _ in range(N)]

plt.hist(sommes, bins=range(3, 20), edgecolor='black', align='left')
plt.title('Somme de 3 dés')
plt.show()

Estimer $\pi$ par la méthode de Monte-Carlo

On peut estimer $\pi$ en lançant des fléchettes au hasard sur un carré contenant un quart de disque, puis en comptant la proportion qui tombe dans le quart de disque. C'est la méthode de Monte-Carlo, une des techniques numériques les plus utilisées en physique, finance et IA.

Le principe. Soit le carré $[0, 1] \times [0, 1]$ d'aire 1 et le quart de disque de centre $O$ et de rayon 1, contenu dans le carré, d'aire $\dfrac{\pi}{4}$. Si l'on tire un point $(x, y)$ au hasard dans le carré, la probabilité qu'il tombe dans le quart de disque vaut $\dfrac{\pi}{4}$. Donc, sur $N$ tirages, la fréquence des points dans le disque approche $\dfrac{\pi}{4}$, et $4 \times \text{fréquence}$ approche $\pi$.

Avec 100 000 tirages, on obtient typiquement $\pi \approx 3{,}14$ — exact à deux décimales. Pour visualiser, on peut colorer les points selon qu'ils tombent dans le disque ou pas :

Marche aléatoire

Imagine un personnage placé en $0$ sur une droite. À chaque pas, on tire pile ou face : pile $\to$ il avance d'un pas, face $\to$ il recule d'un pas. Où sera-t-il après 1000 pas ? La réponse est… on ne sait pas, mais on peut le simuler.

Relance la cellule plusieurs fois : la position finale fluctue énormément. En moyenne sur beaucoup de marches, elle vaut $0$, mais l'écart-type vaut $\sqrt{N}$ — on s'éloigne de l'origine, lentement mais sûrement, en $\sqrt{N}$.

import random
import matplotlib.pyplot as plt

N = 2000
x, y = 0, 0
xs, ys = [0], [0]
for _ in range(N):
    direction = random.choice(['N', 'S', 'E', 'O'])
    if direction == 'N':
        y += 1
    elif direction == 'S':
        y -= 1
    elif direction == 'E':
        x += 1
    else:
        x -= 1
    xs.append(x)
    ys.append(y)

plt.plot(xs, ys)
plt.gca().set_aspect('equal')
plt.title('Marche aléatoire 2D')
plt.grid(True)
plt.show()

import numpy as np

N = 1_000_000
des = np.random.randint(1, 7, size=(4, N))
sommes = des.sum(axis=0)
proba = np.mean(sommes > 18)
print('P(somme > 18) ≈', proba)