Lois à densité et loi uniforme

Une loi à densité décrit une variable aléatoire continue, qui peut prendre toutes les valeurs d'un intervalle : une durée, un volume, un délai. La probabilité qu'elle tombe entre a et b est l'aire sous la courbe de sa fonction de densité, entre a et b. La loi uniforme sur [a ; b] est la plus simple : sa densité est constante, et la probabilité d'un intervalle est proportionnelle à sa longueur. Ce chapitre pose ces notions, puis calcule probabilités, espérance et écart type d'une loi uniforme, avec un délai aléatoire de mise à jour comme fil conducteur.

Variable continue : pourquoi P(X = a) vaut 0

Une durée de vie, un temps de réponse, un délai d'attente peuvent prendre n'importe quelle valeur d'un intervalle : 12 minutes, 12,5 minutes, 12,537 minutes… On parle de variable aléatoire continue. On ne peut plus faire la liste des valeurs avec leurs probabilités comme au chapitre 4 : il y en a une infinité, et la probabilité d'obtenir exactement 12,537 000… minutes est nulle.

On raisonne donc sur des intervalles : la probabilité que le délai soit compris entre 10 et 20 minutes, inférieur à 5 minutes, supérieur à 25 minutes. Et comme P(X = a) = 0 pour toute valeur a, les bornes ne comptent pas :

P(a ≤ X ≤ b) = P(a < X < b) = P(a ≤ X < b) = P(a < X ≤ b)

Densité de probabilité : une probabilité est une aire

Une loi continue est décrite par une fonction de densité f, positive, dont la courbe délimite avec l'axe horizontal une aire totale égale à 1. La probabilité que X tombe dans un intervalle est l'aire sous la courbe au-dessus de cet intervalle :

                   b
P(a ≤ X ≤ b)  =   ∫  f(x) dx
                   a

L'intégrale est l'outil qui calcule une aire sous une courbe ; le cours Fonctions et intégrales la présente. Le programme du BTS exclut toute théorie générale des lois à densité : il suffit de savoir qu'une probabilité est une aire, de la lire sur un graphique et de la calculer pour les lois du programme. Pour la loi uniforme, l'aire est celle d'un rectangle, sans intégrale ; pour la loi exponentielle, une formule la donne ; pour la loi normale, la calculatrice s'en charge.

La fonction de répartition F donne la probabilité cumulée F(x) = P(X ≤ x), l'aire à gauche de x. On en déduit toutes les autres probabilités :

• P(a ≤ X ≤ b) = F(b) − F(a) ;
• P(X > a) = 1 − F(a).

F part de 0, croît, et finit à 1 : c'est l'équivalent continu de P(X ≤ k) pour une loi discrète.

La loi uniforme sur [a ; b]

Une variable X suit la loi uniforme sur [a ; b], notée U([a ; b]), quand elle prend ses valeurs dans [a ; b] et que tous les sous-intervalles de même longueur ont la même probabilité. Sa densité est constante sur [a ; b] :

f(x) = 1 / (b − a)   si a ≤ x ≤ b,      f(x) = 0 sinon

Le graphe de f est un rectangle de base b − a et de hauteur 1 / (b − a) : son aire vaut bien 1. La probabilité d'un intervalle [c ; d] inclus dans [a ; b] est l'aire d'un rectangle plus petit :

                   d − c        longueur de [c ; d]
P(c ≤ X ≤ d)  =  —————————  =  ————————————————————
                   b − a        longueur de [a ; b]

C'est l'équivalent continu de « cas favorables sur cas possibles » : on compare des longueurs au lieu de compter des issues. La fonction de répartition vaut F(x) = (x − a) / (b − a) pour x entre a et b.

Exemple : le délai aléatoire avant une mise à jour

Si les 300 postes d'une entreprise téléchargent leurs mises à jour à 3 h 00 précises, le serveur et le lien Internet saturent. Les outils d'administration étalent donc les départs au hasard. Sous Linux, l'option RandomizedDelaySec d'un minuteur systemd retarde chaque déclenchement d'une durée tirée au hasard, de façon uniforme, entre 0 et la valeur indiquée (minuteurs systemd).

Un administrateur règle ce délai à 30 minutes. Le délai D, en minutes, suit la loi uniforme sur [0 ; 30] : sa densité vaut 1/30 entre 0 et 30.

• P(D ≤ 5) = (5 − 0) / 30 = 1/6 ≈ 0,1667 : un poste sur six démarre sa mise à jour dans les 5 premières minutes.
• P(10 ≤ D ≤ 20) = (20 − 10) / 30 = 1/3 ≈ 0,3333.
• P(D > 25) = (30 − 25) / 30 = 1/6.
• P(D = 15) = 0 : un délai d'exactement 15 minutes, au millionième de seconde près, n'a aucune chance.

Avec 300 postes, l'administrateur peut attendre en moyenne 300 × 1/6 = 50 départs pendant les 5 premières minutes, au lieu de 300 à la même seconde.

Espérance, variance et écart type

Le programme présente l'espérance et la variance d'une loi continue comme le prolongement du cas discret : la somme Σ xᵢ × pᵢ devient une intégrale, E(X) = ∫ x f(x) dx. Pour la loi uniforme, le calcul donne :

           a + b                (b − a)²                b − a
E(X)  =  —————————      V(X) = ——————————      σ(X) = ———————
             2                     12                     √12

L'espérance est le milieu de l'intervalle, ce qui se comprend : aucune valeur n'est privilégiée. Pour le délai de mise à jour :

• E(D) = (0 + 30) / 2 = 15 minutes : sur un grand nombre de nuits et de postes, le délai moyen est d'un quart d'heure ;
• V(D) = 30² / 12 = 75 et σ(D) = 30 / √12 ≈ 8,66 minutes.

Simuler une loi uniforme

Toutes les simulations du cours partent de la même brique : un nombre aléatoire uniforme entre 0 et 1, fourni par random.random() en Python, NbrAléat sur TI (menu math, onglet PROB), Ran# sur Casio, ALEA() dans un tableur. Pour obtenir une valeur uniforme sur [a ; b], on l'étire et on la décale : a + (b − a) × U, où U suit U([0 ; 1]).

import random

def delai_uniforme(a, b):
    return a + (b - a) * random.random()   # même chose que random.uniform(a, b)

n = 100_000
delais = [delai_uniforme(0, 30) for _ in range(n)]
print(sum(delais) / n)                          # environ 15, l'espérance
print(sum(1 for d in delais if d <= 5) / n)     # environ 0.167, soit 1/6

Le programme demande justement de « concevoir et exploiter une simulation dans le cadre d'une loi uniforme ». Le chapitre 11 s'en sert pour simuler la loi exponentielle et la loi normale à partir de cette seule brique.

Exercices

import random

def simule_frequence(a, b, c, d, n):
    compte = 0
    for _ in range(n):
        x = a + (b - a) * random.random()
        if c <= x <= d:
            compte += 1
    return compte / n

print(simule_frequence(0, 30, 10, 20, 100_000))   # environ 0.333