$course$/QCM de maths/Première spécialité/Expérimentations et simulation Simulation d'une variable aléatoire avec Python, échantillons :
moyenne d'un échantillon et espérance de la variable, effet de
la taille de l'échantillon, ordre de grandeur des écarts en
$\dfrac{2\sigma}{\sqrt{n}}$, lecture et écriture de fonctions
Python (moyenne, fréquence, répétition d'expériences).

]]> Expérimentations et simulation — Q01 : Simuler un dé en Python Quelle instruction Python simule le lancer d'un dé équilibré
à six faces (après from random import randint) ?

]]> randint(a, b) : entier uniforme sur $\{a, \ldots, b\}$,
bornes incluses. Un dé : randint(1, 6). (Autre outil :
random(), réel uniforme dans $[0\,;\,1[$.)

]]> 1.0 0.0 0 true true abc randint(1, 6)

]]> Bonne réponse : randint(a, b) renvoie un entier au
hasard entre a et b inclus : ici un entier de $1$
à $6$, chacun avec la même probabilité.

]]> randint(0, 6)

]]> Erreur : cette instruction peut renvoyer $0$, qui n'est
pas une face du dé (sept valeurs au lieu de six).

]]> randint(1, 5)

]]> Erreur : la borne supérieure de randint est
incluse : randint(1, 5) ne produirait jamais de
$6$.

]]> 6 * randint(0, 1)

]]> Erreur : cette expression ne renvoie que $0$ ou $6$ :
rien à voir avec un dé.

]]> Expérimentations et simulation — Q02 : Simuler une épreuve de Bernoulli Après from random import random, quelle expression Python
vaut True avec la probabilité $0{,}3$ (simulation d'un
succès de probabilité $0{,}3$) ?

]]> Simulation d'un succès de probabilité $p$ :
random() < p. C'est la brique de base de toutes les
simulations de variables aléatoires.

]]> 1.0 0.0 0 true true abc random() < 0.3

]]> Bonne réponse : random() est uniforme sur $[0\,;\,1[$ :
la probabilité qu'il tombe sous $0{,}3$ vaut exactement
$0{,}3$.

]]> random() > 0.3

]]> Erreur de sens : cette condition a pour probabilité
$1 - 0{,}3 = 0{,}7$ : elle simule l'échec.

]]> random() == 0.3

]]> Erreur : l'égalité exacte avec un réel tiré au hasard a
une probabilité (quasi) nulle : ce test ne réussit
pratiquement jamais.

]]> randint(0, 3)

]]> Erreur : cette instruction renvoie un entier entre $0$ et
$3$, pas un booléen de probabilité $0{,}3$.

]]> Expérimentations et simulation — Q03 : Moyenne d'échantillon et espérance On simule un échantillon de taille $n$ d'une variable
aléatoire $X$ et on calcule la moyenne $m$ des valeurs
obtenues. Quelle affirmation est correcte ?

]]> Distinction clé du programme : moyenne d'échantillon
(aléatoire, observée) contre espérance (fixe, théorique). La
simulation fait percevoir la convergence de l'une vers
l'autre.

]]> 1.0 0.0 0 true true abc $m$ varie d'un échantillon à l'autre, alors que $E(X)$
est un nombre fixe du modèle

]]> Bonne réponse : la moyenne observée est aléatoire
(chaque simulation en donne une différente) ; l'espérance
est une constante théorique dont $m$ s'approche.

]]> $m = E(X)$ exactement, dès que $n \geq 30$

]]> Erreur : aucune taille finie ne garantit l'égalité
exacte : $m$ fluctue autour de $E(X)$, de moins en moins
quand $n$ grandit.

]]> $E(X)$ change à chaque simulation

]]> Erreur : l'espérance est calculée sur la loi (les
probabilités du modèle), pas sur les données simulées :
elle ne bouge pas.

]]> $m$ et $E(X)$ n'ont aucun lien

]]> Erreur : tout le chapitre repose sur leur lien : $m$
estime $E(X)$, d'autant mieux que l'échantillon est
grand.

]]> Expérimentations et simulation — Q04 : Une fonction moyenne en Python Quelle fonction Python renvoie correctement la moyenne d'une
liste non vide L de nombres ?

]]> Fonction attendue au programme : sum(L) / len(L). La lire,
l'écrire et la modifier (moyenne d'une partie, fréquence…)
sont des capacités attendues.

]]> 1.0 0.0 0 true true abc def moyenne(L): return sum(L) / len(L)]]> Bonne réponse : sum(L) additionne les éléments et
len(L) en donne le nombre : somme divisée par
l'effectif.

]]> def moyenne(L): return sum(L) / n]]> Erreur : la variable n n'est définie nulle part dans la
fonction : erreur d'exécution. L'effectif s'obtient par
len(L).

]]> def moyenne(L): return len(L) / sum(L)]]> Fraction renversée : ceci calcule l'inverse de la
moyenne. La somme va au numérateur.

]]> def moyenne(L): return sum(L) - len(L)]]> Erreur : une moyenne se calcule par division, pas par
soustraction.

]]> Expérimentations et simulation — Q05 : Effet de la taille de l'échantillon On compare des moyennes d'échantillons de taille $n = 100$
puis $n = 10\,000$ d'une même variable aléatoire. Qu'observe-t-on
typiquement ?

]]> Constat expérimental central : la distance entre moyenne
d'échantillon et espérance a tendance à diminuer quand $n$
augmente, à l'échelle $\frac{\sigma}{\sqrt{n}}$.

]]> 1.0 0.0 0 true true abc Les moyennes des grands échantillons sont plus resserrées
autour de l'espérance

]]> Bonne réponse : plus l'échantillon est grand, plus la
moyenne observée est stable et proche de $E(X)$ : les
fluctuations se diluent.

]]> Les moyennes fluctuent autant, quelle que soit la taille

]]> Erreur : la simulation montre le contraire : l'écart
typique décroît (en $\frac{1}{\sqrt{n}}$).

]]> Les grands échantillons donnent des moyennes plus grandes

]]> Erreur : la taille réduit la dispersion des moyennes,
elle ne déplace pas leur centre (toujours $E(X)$).

]]> Au-delà de $n = 1000$, la moyenne devient exactement
l'espérance

]]> Erreur : aucun seuil ne supprime l'aléa ; il s'atténue
progressivement, sans jamais disparaître.

]]> Expérimentations et simulation — Q06 : L'échelle $\dfrac{2\sigma}{\sqrt{n}}$ Pour diviser par $10$ l'ordre de grandeur
$\dfrac{2\sigma}{\sqrt{n}}$ des écarts entre moyenne
d'échantillon et espérance, par combien faut-il multiplier la
taille $n$ de l'échantillon ?

]]> La précision d'une moyenne d'échantillon évolue en
$\frac{1}{\sqrt{n}}$ : gagner un facteur $10$ de précision
coûte un facteur $100$ de données. Racine carrée : le coût de
la précision statistique.

]]> 1.0 0.0 0 true true abc Par $100$

]]> Bonne réponse : l'écart varie en $\dfrac{1}{\sqrt{n}}$ :
diviser par $10$ exige $\sqrt{n}$ multiplié par $10$,
donc $n$ par $100$.

]]> Par $10$

]]> Erreur : $n \times 10$ ne divise l'écart que par
$\sqrt{10} \approx 3{,}2$, à cause de la racine carrée.

]]> Par $\sqrt{10}$

]]> Erreur : cela ne diviserait l'écart que par
$10^{1/4} \approx 1{,}8$. La racine impose de
quadrupler l'effort pour chaque facteur $2$… et
$\times 100$ pour un facteur $10$.

]]> Par $1000$

]]> Trop : $\sqrt{1000} \approx 31{,}6$ diviserait l'écart
par plus de $30$. Le bon facteur est $10^2 = 100$.

]]> Expérimentations et simulation — Q07 : Répéter une expérience Que fait l'instruction Python for _ in range(1000): placée
au-dessus d'un bloc de code ?

]]> for _ in range(N): répète $N$ fois : combinée à un
compteur de succès ou à une liste de résultats, elle simule
$N$ expériences pour estimer fréquences et moyennes.

]]> 1.0 0.0 0 true true abc Elle exécute le bloc $1000$ fois

]]> Bonne réponse : range(1000) fournit $1000$ tours de
boucle ; le nom _ signale qu'on n'utilise pas le
compteur. C'est le squelette de toute simulation répétée.

]]> Elle exécute le bloc jusqu'à obtenir $1000$

]]> Erreur : aucune condition d'arrêt sur une valeur : le
nombre de répétitions est fixé à $1000$ (ce serait le
rôle d'un while).

]]> Elle crée une liste de $1000$ zéros

]]> Erreur : for répète du code ; la création de liste
utiliserait par exemple [0] * 1000.

]]> Elle exécute le bloc une fois avec $n = 1000$

]]> Erreur : la boucle exécute le bloc mille fois, une
par tour.

]]> Expérimentations et simulation — Q08 : Estimer une probabilité par simulation Pourquoi simuler $10\,000$ fois une expérience pour estimer
la probabilité d'un événement ?

]]> Estimation par simulation : fréquence sur $N$ répétitions
$\approx$ probabilité, avec une précision qui croît avec $N$.
Exemple du programme : estimer $\pi$ ou une aire par
Monte-Carlo.

]]> 1.0 0.0 0 true true abc Parce que la fréquence observée sur un grand nombre de
répétitions approche la probabilité cherchée

]]> Bonne réponse : c'est la loi des grands nombres (version
vulgarisée) : la fréquence estime la probabilité, utile
quand le calcul exact est hors de portée (méthode de
Monte-Carlo).

]]> Parce que la fréquence observée est exactement égale à la
probabilité

]]> Erreur : la fréquence reste une approximation
fluctuante ; elle se resserre autour de la probabilité
sans la donner exactement.

]]> Parce qu'une simulation remplace toute démonstration

]]> Erreur : la simulation conjecture et illustre ; elle
ne démontre pas. Les deux registres se complètent.

]]> Parce que l'ordinateur produit du vrai hasard parfait

]]> Erreur : les générateurs sont pseudo-aléatoires ;
l'argument valable est statistique (grand nombre de
répétitions), pas la perfection du hasard machine.

]]> Expérimentations et simulation — Q09 : La proportion des cas dans $\left[\mu - \frac{2\sigma}{\sqrt{n}}\,;\,\mu + \frac{2\sigma}{\sqrt{n}}\right]$ On simule $N$ échantillons de taille $n$ d'une variable
d'espérance $\mu$ et d'écart-type $\sigma$, et on calcule
chaque moyenne $m$. Quelle proportion des cas vérifie
typiquement $|m - \mu| \leq \dfrac{2\sigma}{\sqrt{n}}$ ?

]]> Constat de simulation (capacité attendue) : environ $95\ \%$
des moyennes d'échantillons tombent à moins de
$\frac{2\sigma}{\sqrt{n}}$ de $\mu$. La terminale en fera un
théorème (concentration, Bienaymé-Tchebychev).

]]> 1.0 0.0 0 true true abc Environ $95\ \%$

]]> Bonne réponse : c'est le constat expérimental attendu au
programme : l'écart dépasse rarement deux fois
$\dfrac{\sigma}{\sqrt{n}}$ (ordre de grandeur, précisé en
terminale).

]]> Environ $50\ \%$

]]> Erreur : la moitié des cas correspondrait à un intervalle
bien plus étroit (environ $0{,}7\sigma/\sqrt{n}$ de
rayon). À $2\sigma/\sqrt{n}$ : autour de $95\ \%$.

]]> Exactement $100\ \%$

]]> Erreur : quelques échantillons « malchanceux » sortent de
l'intervalle (environ $5\ \%$) : l'aléa ne se laisse pas
enfermer totalement.

]]> Environ $5\ \%$

]]> Inversé : $5\ \%$ est la proportion des cas qui
sortent de l'intervalle.

]]> Expérimentations et simulation — Q10 : Lire une simulation complète Que renvoie cette fonction ?

from random import randint
def f(n):
    c = 0
    for _ in range(n):
        if randint(1, 6) == 6:
            c = c + 1
    return c / n
]]> Schéma type d'une simulation : initialiser un compteur,
boucler $n$ fois, incrémenter sous condition, renvoyer
c / n (fréquence). À savoir lire, modifier et écrire.

]]> 1.0 0.0 0 true true abc La fréquence de « 6 » observée sur $n$ lancers de dé
simulés

]]> Bonne réponse : le compteur c compte les 6 obtenus, et
c / n en donne la fréquence : elle approche
$\dfrac{1}{6} \approx 0{,}167$ pour $n$ grand.

]]> Le nombre de « 6 » obtenus

]]> Presque : ce serait return c. La division finale
c / n transforme le compte en fréquence.

]]> La probabilité exacte $\dfrac{1}{6}$

]]> Erreur : la fonction renvoie une fréquence simulée,
fluctuante ($0{,}171$, $0{,}163$…), proche de
$\frac{1}{6}$ sans lui être égale.

]]> Toujours $0$, car c est initialisé à $0$

]]> Erreur : c démarre à $0$ puis s'incrémente à chaque
6 : l'initialisation n'est pas une valeur définitive.

]]> Expérimentations et simulation — Q11 : Modifier la simulation Dans la fonction précédente, par quoi remplacer la condition
randint(1, 6) == 6 pour estimer la fréquence d'un résultat
pair ?

]]> Adapter une simulation = changer la condition de succès
sans toucher au générateur : parité par % 2 == 0, seuil par
>= 5, appartenance par in (2, 4, 6).

]]> 1.0 0.0 0 true true abc randint(1, 6) % 2 == 0

]]> Bonne réponse : le reste modulo $2$ nul caractérise les
pairs ($2$, $4$, $6$) : la fréquence approchera
$\dfrac{3}{6} = 0{,}5$.

]]> randint(1, 6) == 2, 4, 6

]]> Erreur de syntaxe : cette écriture ne teste pas
l'appartenance (il faudrait in (2, 4, 6) ou le test de
parité % 2 == 0).

]]> randint(1, 6) % 2 == 1

]]> Sens inversé : reste $1$ modulo $2$ caractérise les
impairs.

]]> randint(2, 6)

]]> Erreur : changer les bornes fausse le dé lui-même (plus
que $5$ faces) au lieu de tester la parité du résultat.

]]> Expérimentations et simulation — Q12 : Conclure prudemment d'une simulation On simule $100$ lancers d'une pièce supposée équilibrée et
on observe une fréquence de pile de $0{,}56$. Peut-on
conclure que la pièce est truquée ?

]]> Esprit critique attendu : comparer l'écart observé
($0{,}06$) à la fluctuation typique
$\frac{2\sigma}{\sqrt{n}}$ ($0{,}1$ pour $n = 100$) : rien
d'anormal. Grossir l'échantillon resserre l'intervalle et
rend le verdict possible.

]]> 1.0 0.0 0 true true abc Non : pour $n = 100$, un écart de $0{,}06$ est dans la
fluctuation normale d'échantillonnage

]]> Bonne réponse : l'ordre de grandeur des fluctuations est
$\dfrac{2\sigma}{\sqrt{n}} = \dfrac{2 \times 0{,}5}{10} =
0{,}1$ : observer $0{,}56$ n'a rien d'anormal pour une
pièce équilibrée.

]]> Oui : $0{,}56 \neq 0{,}5$, donc la pièce est déséquilibrée

]]> Erreur : la fréquence observée fluctue toujours
autour de la probabilité ; l'égalité exacte serait au
contraire surprenante. Il faut comparer l'écart à son
ordre de grandeur naturel.

]]> Oui, si la simulation a été faite en Python

]]> Erreur : l'outil n'y change rien ; la question est
statistique (taille de l'écart contre taille de la
fluctuation attendue).

]]> Non : une simulation ne donne jamais aucune information

]]> Trop fort : la simulation informe (avec $n = 100\,000$,
une fréquence de $0{,}56$ serait accablante) ; ici
l'échantillon est simplement trop petit pour conclure.

]]>