Lois discrètes

• \(0 \leq P(X=x_i) \leq 1\) pour tout \(i=1,\dots,n\),
• \(\displaystyle\sum_{i=1}^n P(X=x_i) =P(X=x_1)+P(X=x_2)+\dots+P(X=x_n)= 1 \).

• \(E(aX) = aE(X)\) (multiplier la variable par \(a\) multiplie son espérance par \(a\)).
• \(E(X+b) = E(X) + b\) (ajouter \(b\) à la variable ajoute \(b\) à son espérance).

• L'espérance est \(E(X) = \frac{n+1}{2}\).
• La variance est \(V(X) = \frac{n^2-1}{12}\).

1. Repérer le chemin qui réalise à la fois \(E\) et \(F\).
2. Multiplier les probabilités le long de ce chemin.

1. Repérer tous les chemins qui mènent à \(F\).
2. Calculer le produit des probabilités le long de chaque chemin, puis additionner ces produits.

1. Dessiner l'arbre, un niveau par épreuve, et écrire la probabilité de chaque branche ; les probabilités des branches issues d'un même nœud ont pour somme \(1\).
2. Probabilité d'un chemin : multiplier les probabilités le long du chemin, de la racine à la feuille.
3. Probabilité d'un événement : additionner les probabilités des chemins qui le réalisent (deux chemins différents sont des issues disjointes).
4. « Au moins un » : passer par le contraire « aucun », qui a bien moins de chemins (un seul quand chaque épreuve est réduite à « l'issue se produit ou non »).

• L'espérance est \(E(X) = p\),
• La variance est \(V(X) = p(1 - p)\),
• L’écart-type est \(\sigma(X) = \sqrt{p(1 - p)}\).

• 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.

• \(E(X) = n p\) (espérance),
• \(V(X) = n p (1 - p)\) (variance),
• \(\sigma(X) = \sqrt{n p (1 - p)}\) (écart-type).

• Sur TI : Utiliser binomFdp(n, p, k) pour \(P(X = k)\) et binomfrép(n, p, k) pour \(P(X \leq k)\).
• Sur Casio : Utiliser BinomialPD(k, n, p) et BinomialCD(k, n, p).
• Sur NumWorks : Application Probabilités, choisir Binomiale.

• \(P(X < k) = P(X \leq k-1)\)
• \(P(X \geq k) = 1 - P(X \leq k-1)\)
• \(P(X > k) = 1 - P(X \leq k)\)
• \(P(a \leq X \leq b) = P(X \leq b) - P(X \leq a-1)\)

from math import comb

def binomial_pmf(n, p, k):
    """P(X = k) for X ~ B(n, p)"""
    return comb(n, k) * p**k * (1 - p)**(n - k)

def binomial_cdf(n, p, k):
    """P(X <= k)"""
    return sum(binomial_pmf(n, p, j) for j in range(k + 1))

def capacity(n, p, alpha):
    """smallest k such that P(X > k) <= alpha"""
    k = 0
    while 1 - binomial_cdf(n, p, k) > alpha:
        k = k + 1
    return k

print(binomial_pmf(10, 0.3, 4))      # 0.2001...
print(binomial_cdf(10, 0.3, 4))      # 0.8497...
print(capacity(105, 0.95, 0.05))     # 103

1. On cherche le plus petit entier \(a\) tel que \(P(X \leq a) > \frac{\alpha}{2}\).
2. On cherche le plus petit entier \(b\) tel que \(P(X \leq b) \geq 1 - \frac{\alpha}{2}\).

• calculer l'intervalle \(I_n = \left[\, p - \dfrac{1}{\sqrt{n}}\,;\; p + \dfrac{1}{\sqrt{n}} \,\right]\) ;
• si \(f\) se situe à l'intérieur de \(I_n\), l'observation est compatible avec le modèle (elle fait partie des \(95\,\pourcent\) habituels) ;
• si \(f\) se situe à l'extérieur de \(I_n\), l'observation est un résultat surprenant : une telle valeur est rare sous le modèle, ce qui jette un doute sur la proportion supposée \(p\).

from random import random, randint

def bernoulli(p):
    """1 with probability p, 0 otherwise"""
    if random() < p:
        return 1
    return 0

def uniform(n):
    """a random integer of {1, ..., n}"""
    return randint(1, n)

def binomial(n, p):
    """number of successes in n independent trials"""
    return sum(bernoulli(p) for i in range(n))

def geometric(p):
    """rank of the first success"""
    k = 1
    while random() >= p:      # failure: try again
        k = k + 1
    return k

N = 10000
print(sum(binomial(10, 0.3) == 4 for i in range(N)) / N)   # about 0.200
print(sum(geometric(0.3) == 2 for i in range(N)) / N)      # about 0.210