Voici un extrait du programme de BTS (excellente lecture les jours de pluie !) :

Ambitieux ! En fait, un processus est une variable aléatoire dépendant du temps, qui est donc plus abstrait qu’une « simple » variable aléatoire. Mais il se trouve qu’un processus de Poisson peut être vu sous deux angles différents :

• projeté sur l’axe des temps (entre deux gouttes de pluie ci-dessous), il mène à des variables aléatoires exponentielles ;
• projeté sur l’axe des fréquences (nombre de gouttes de pluie par seconde ci-dessous) il mène à des variables aléatoires de Poisson.

C’est assez similaire à ces exercices où on demande la forme d’un solide qui ressemble à un disque vu d’au-dessus et à un carré vu de côté (si, si ça existe, et c’est même au programme du collège)...

Pour voir un exemple de processus de Poisson (traité avec la loi exponentielle en Terminale et avec la loi de Poisson en BTS), voir cet article de volcanologie. Mais en attendant d’aller voir s’il y a une éruption volcanique, on ne peut qu’écouter la pluie qui tombe :

Pensées poissonniennes d'un jour de pluie

Remarque sur les fonctions graphiques de ce fichier: Le premier paramètre est un entier allant de 1 à 4; c'est le numéro du graphique sur lequel on dessine l'histogramme ou le diagramme en bâtons. Le second paramètre est un réel positif, c'est la valeur maximale de x sur l'axe des abscisses. Enfin le troisième paramètre est un tableau de nombres.

I/ Simulation de variables aléatoires exponentielles

Il va bientôt pleuvoir: Quelques gouttes tombent petit à petit, au hasard. On fait l'hypothèse qu'elles sont indépendantes entre elles, et que la probabilité que deux d'entre elles tombent exactement en même temps, est nulle. Alors, en notant λ le nombre moyen de gouttes de pluie par seconde, l'intervalle de temps entre deux gouttes est modélisé par une variable aléatoire exponentielle X de paramètre λ. Théoriquement parlant, cela signifie que la chute d'une goutte de pluie ne fait pas vieillir le nuage dont les gouttes tombent.

Alors, la fonction de répartition de X est 1-e-λx ce qui veut dire que

• P(X<a)=1-e^-λ×a (définition de la fonction de répartition)
• P(X≥a)=e^-λ×a (passage à l'évènement contraire)
• P(-λ× X ≤ -λ× a)=e^-λ×a (multiplication des deux membres par un nombre négatif)
• P(e^-λ×X≤ e^-λ×a)=e^-λ×a (la fonction exponentielle est croissante)

En posant U=e^-λ×X et x=e^-λ×a, la dernière des probabilités ci-dessus s'écrit P(U≤x)=x, ce qui signifie que la fonction de répartition de U est égale à x; sa dérivée est la loi de U; on trouve x'=1, donc la loi de U est la constante égale à 1: U suit une loi uniforme sur ]0;1[.

On peut remonter les calculs, et donc si U est uniforme sur ]0;1[, -ln(U)/λ suit une loi exponentielle de paramètre λ. Or on sait simuler une variable aléatoire uniforme sur ]0;1[ (en JavaScript c'est Math.random()), et l'algorithme suivant permet donc de simuler une variable aléatoire exponentielle:

λ = 5 effectifs = new Array() N = 40 for classe in [0...N] effectifs[classe] = 0 for n in [1..10000] X = -Math.log(Math.random())/λ effectifs[Math.floor N*X]++ histogramme 1, 2, effectifs

Lancer cet algorithme

Le caractère exponentiel de la distribution apparaît nettement sur l'histogramme. On peut essayer d'autres valeurs de λ et de N (mais ne pas oublier de changer le second paramètre de la fonction histogramme en bas du script).

II/ Fréquence des chutes de gouttes de pluie

Des météorologistes ont disposé un drôle d'appareil, qui fait penser à un compteur Geiger: À chaque fois qu'une goutte de pluie tombe sur une plaque métallique, un microphone enregistre un "plic" qui incrémente un compteur. À chaque seconde, la valeur du compteur est envoyée à un appareil de collecte de données et le compteur est remis à zéro. Ainsi, seconde après seconde, le nombre de gouttes d'eau qui sont tombées (c'est-à-dire la fréquence des gouttes d'eau) est envoyé à la station météo. Il s'agit d'une variable aléatoire Y, que l'on peut simuler par un algorithme de comptage :

λ = 5 effectifs = new Array() for classe in [0...20] effectifs[classe] = 0 for n in [1..10000] [Y,compteur] = [0,0] until Y > 1 Y += -Math.log(Math.random())/λ compteur++ effectifs[compteur-1]++ diagrammeBatons 2, 1, effectifs

Lancer cet algorithme

III/ Loi de Poisson

La variable aléatoire Y du paragraphe précédent suit une loi de Poisson de paramètre λ. Cette loi a été découverte par Siméon Denis Poisson au milieu du XIXe siècle, comme cas limite d'une loi binomiale lorsque n est grand et p est suffisamment petit pour que λ=n×p ne soit pas trop grand. Poisson a alors montré que la loi suivie par Y est P(Y=k)=e^-λ×λ^k/k!. On peut le vérifier en comparant le diagramme en bâtons des fréquences ci-dessus, avec celui des probabilités théoriques ci-dessous:

λ = 5 probas = (6*Poisson(λ,k) for k in [0..20]) efface document.getElementById('can3') diagrammeBatonsTheorique 3, 1, probas

Lancer cet algorithme

On peut superposer les deux diagrammes en bâtons pour comparaison, en ajoutant simplement diagrammeBatonsTheorique 2, 1, probas (ainsi que la création de tableau probas) au script précédent.

La pluie s'est intensifiée, ce qui s'est manifesté par une augmentation du paramètre λ. En remplaçant 5 par une valeur plus grande (quelques dizaines de gouttes de pluie par seconde; essayer par exemple λ=20 et les probabilités jusqu'à 100, avec un second paramètre égal à 4 pour la fonction diagrammeBatonsTheorique) pour λ, on constate que le diagramme en bâtons prend une forme de courbe en cloche. Ce qui veut dire que le bruit d'une averse est modélisé par un bruit blanc gaussien (variables aléatoires normales statistiquement indépendantes). Mais ceci est une autre histoire...

IV/ Algorithme de Knuth pour simuler une variable aléatoire de Poisson

Pleuvait-il lorsque Donald Knuth a eu cette idée pour simuler rapidement une variable aléatoire de Poisson ? Voici un méta-algorithme:

• L'algorithme ci-dessus revient à additionner des variables exponentielles de paramètre λ jusqu'à ce que leur somme dépasse 1.
• Il revient donc à additionner des expressions du type -ln(x)/λ (où x est uniforme sur ]0;1[) jusqu'à ce que leur somme dépasse 1
• On aura donc le même effet si on additionne des expressions du type ln(x) jusqu'à ce que leur somme passe en-dessous de -λ
• ... ou en multipliant leurs exponentielles x jusqu'à ce que leur produit passe en-dessous de e^-λ

C'est l'algorithme de Knuth pour simuler une variable aléatoire de Poisson de paramètre λ :

λ = 20 effectifs = new Array() for classe in [0...100] effectifs[classe] = 0 for n in [1..10000] [Z,compteur] = [1,0] until Z < Math.exp(-λ) Z *= Math.random() compteur++ effectifs[compteur-1]++ diagrammeBatons 4, 2, effectifs

Lancer cet algorithme

Cet algorithme est très rapide sur une machine qui effectue rapidement les multiplications de réels. Et encore plus rapide lorsque λ est petit.

Récit d’une séquence pédagogique menée en classe de BTS

Découvrir tout ça a été possible sur alcoffeethmique en trois séances :

1. Découverte de la loi uniforme sur [0 ;1] avec découverte des outils ;
2. Découverte de la loi exponentielle de paramètres λ=1 et 10, par simulation ;
3. Découverte de la loi de Poisson de mêmes paramètres.

La première séance a été concentrée sur la notion d’insertion dans Libre Office Writer :

• insertion d’un hyperlien (vers alcoffeethmique pour rappeler l’outil qui a servi) ;
• insertion d’un cadre autour d’une partie du texte (scripts CoffeeScript et le cas échéant, la sortie des données)
• insertion d’une image (l’histogramme en svg, après passage par un éditeur de texte permettant par exemple de modifier les couleurs)

Voici quelques rapports de TP remarquables mais significatifs :

La seconde séance a été consacrée à remplacer alea() qui simule une variable aléatoire uniforme sur [0 ;1], par l’opposé de son logarithme, qui suit une loi exponentielle de paramètre 1. Puis à explorer d’autres valeurs du paramètre comme 10 :

La troisième séance a consisté à simuler des sommes de variables aléatoires exponentielles en comptant le nombre de termes jusqu’à ce que la somme dépasse 1. On note qu’il a fallu dessiner des diagrammes en bâtons puisque la loi de Poisson est discrète. Une difficulté statistique est apparue, avec le script proposé qui était

stats = new Sac()
for n in [1..1000]
    gouttes = 0
    instant = -0.1*ln(alea())
    until instant > 1
        gouttes += 1
        instant -= 0.1*ln(alea())
    stats.ajoute gouttes
diagrammeBatonsTrie stats.effectifs, 200

En effet, un objet de type sac ne possède pas de méthodes statistiques comme la moyenne ou l’écart-type. En fait il aurait mieux valu ne créer le sac qu’au dernier moment :

liste = []
for n in [1..1000]
    gouttes = 0
    instant = -0.1*ln(alea())
    until instant > 1
        gouttes += 1
        instant -= 0.1*ln(alea())
    liste.push gouttes
stats = new Sac liste
diagrammeBatonsTrie stats.effectifs, 200

Les deux scripts produisent ce genre de graphique :

La différence entre les deux versions est que la première consiste à créer au début un sac vide, puis à y ajouter, au fur et à mesure, les valeurs prises par la variable aléatoire de Poisson, alors que la seconde consiste à ajouter les valeurs dans une liste, et après cela seulement, créer un sac dans lequel on place d’un seul coup toute la liste. Cette nouvelle version permet de faire des calculs statistiques sur la liste :

liste = []
for n in [1..1000]
    gouttes = 0
    instant = -0.1*ln(alea())
    until instant > 1
        gouttes += 1
        instant -= 0.1*ln(alea())
    liste.push gouttes
affiche laMoyenneDe liste
affiche laVarianceDe liste

Si le temps l’avait permis, il aurait été possible alors de conjecturer l’égalité entre l’espérance, la variance et le paramètre.

A propos de temps, ça ne s’invente pas, le jour du TP sur les gouttes de pluie, il y avait de fortes pluies qui ont empêché plusieurs étudiants d’être présents ce jour-là. Les autres ont apporté ces contributions remarquables :