{"cells":[{"metadata":{"trusted":false},"cell_type":"markdown","source":"<h1 style=\"color:#D89B00; text-align:center; font-size:2.8em; font-weight:700; margin:30px 0;\">\nIV - Simulation de variables aléatoires discrètes\n</h1>"},{"metadata":{"trusted":false},"cell_type":"markdown","source":"Simuler une expérience aléatoire, c'est demander à l'ordinateur de la « rejouer » un grand nombre de fois. Cela permet :\n\n<ul>\n<li>de <strong style=\"color:#D89B00;\">conjecturer</strong> une loi, une probabilité, une espérance avant de les calculer ;</li>\n<li>de <strong style=\"color:#D89B00;\">vérifier</strong> un calcul théorique ;</li>\n<li>de <strong style=\"color:#D89B00;\">comprendre</strong> une expérience en deux temps (conditionnement) en la programmant.</li>\n</ul>\n\n<h1 style=\"color:#D89B00;\">Liste des commandes Python exigibles aux concours</h1>\n\n<ul>\n<li>Importations : <code>import numpy as np</code>, <code>import numpy.random as rd</code>, <code>import matplotlib.pyplot as plt</code>.</li>\n<li>Simulation de lois usuelles : <code>rd.random</code>, <code>rd.randint</code>, <code>rd.binomial</code>, <code>rd.geometric</code>, <code>rd.poisson</code>.</li>\n<li>Simulation d'un échantillon : argument supplémentaire donnant la taille.</li>\n<li>Histogramme : <code>plt.hist</code>.</li>\n<li>Estimation par moyenne empirique : <code>np.mean</code>, <code>np.var</code>, <code>np.sum</code>, <code>np.cumsum</code>.</li>\n<li>Simulation d'expériences construites à l'aide de boucles <code>for</code>, <code>while</code>, de tests <code>if</code> et de listes.</li>\n</ul>\n\nCommençons par importer les bibliothèques utiles (à exécuter en premier)."},{"metadata":{"trusted":true},"cell_type":"code","source":"import numpy as np\nimport numpy.random as rd\nimport matplotlib.pyplot as plt","execution_count":null,"outputs":[]},{"metadata":{"trusted":false},"cell_type":"markdown","source":"<h1 style=\"color:#D89B00;\">I. Le générateur aléatoire de base</h1>\n\nTout part d'une unique commande : <code>rd.random()</code> renvoie un réel choisi « au hasard » dans $[0,1[$, de façon uniforme : pour tout $0\\leq a\\leq b\\leq 1$, la probabilité que le nombre obtenu soit dans $[a,b[$ vaut $b-a$."},{"metadata":{"trusted":true},"cell_type":"code","source":"rd.random()","execution_count":null,"outputs":[]},{"metadata":{"trusted":false},"cell_type":"markdown","source":"<div style=\"border-left: 4px solid #D89B00; padding: 8px 12px; margin: 12px 0;\">\n<strong style=\"color:#D89B00;\">Attention :</strong>\n\nChaque exécution donne un résultat différent : relancez la cellule précédente plusieurs fois !\n</div>"},{"metadata":{"trusted":false},"cell_type":"markdown","source":"<h2 style=\"color:#D89B00;\">I.1 Simuler un événement de probabilité $p$</h2>\n\nSi $U$ est un nombre renvoyé par <code>rd.random()</code>, alors\n$$\\mathbf{P}(U<p)=p.$$\nLe test <code>rd.random() < p</code> est donc réalisé avec la probabilité $p$ : il permet de simuler un événement de probabilité $p$."},{"metadata":{"trusted":false},"cell_type":"markdown","source":"<div style=\"border-left: 4px solid #D89B00; padding: 8px 12px; margin: 12px 0;\">\n<strong style=\"color:#D89B00;\">Exemple — Loi de Bernoulli</strong>\n\nPour simuler une variable aléatoire $X$ de loi $\\mathcal{B}(p)$ on écrit :\n</div>"},{"metadata":{"trusted":true},"cell_type":"code","source":"def bernoulli(p):\n    if rd.random() < p:\n        return 1\n    else:\n        return 0\n\nbernoulli(0.3)","execution_count":null,"outputs":[]},{"metadata":{"trusted":false},"cell_type":"markdown","source":"La fonction renvoie $1$ (succès) avec la probabilité $p$ et $0$ (échec) avec la probabilité $1-p$."},{"metadata":{"trusted":false},"cell_type":"markdown","source":"<h2 style=\"color:#D89B00;\">I.2 Loi uniforme sur $[\\mkern-2.7mu[ 1,n]\\mkern-2.7mu]$</h2>\n\nLa commande <code>rd.randint(a,b)</code> renvoie un entier choisi de façon équiprobable parmi $a,a+1,\\ldots,b-1$.\n\n<div style=\"border-left: 4px solid #D89B00; padding: 8px 12px; margin: 12px 0;\">\n<strong style=\"color:#D89B00;\">Attention :</strong>\n\nLa borne <code>b</code> est <strong>exclue</strong> !\n</div>"},{"metadata":{"trusted":false},"cell_type":"markdown","source":"<div style=\"border-left: 4px solid #D89B00; padding: 8px 12px; margin: 12px 0;\">\n<strong style=\"color:#D89B00;\">Exemple — Un dé équilibré</strong>\n\nPour simuler le lancer d'un dé à six faces, c'est-à-dire une variable de loi $\\mathcal{U}([\\mkern-2.7mu[ 1,6]\\mkern-2.7mu])$ :\n</div>"},{"metadata":{"trusted":true},"cell_type":"code","source":"rd.randint(1, 7)","execution_count":null,"outputs":[]},{"metadata":{"trusted":false},"cell_type":"markdown","source":"Plus généralement, <code>rd.randint(1, n+1)</code> simule une variable de loi $\\mathcal{U}([\\mkern-2.7mu[ 1,n]\\mkern-2.7mu])$.\n\n<div style=\"border-left: 4px solid #D89B00; padding: 8px 12px; margin: 12px 0;\">\n<strong style=\"color:#D89B00;\">Remarque :</strong>\n\nOn peut aussi n'utiliser que <code>rd.random</code> : l'entier <code>int(n*rd.random())+1</code> suit la loi $\\mathcal{U}([\\mkern-2.7mu[ 1,n]\\mkern-2.7mu])$.\n</div>"},{"metadata":{"trusted":false},"cell_type":"markdown","source":"<div style=\"border-left: 4px solid #D89B00; padding: 8px 12px; margin: 12px 0;\">\n<strong style=\"color:#D89B00;\">Exercice — Faire connaissance</strong>\n\n<ol>\n<li>Exécuter plusieurs fois chacune des lignes suivantes et indiquer à la suite des <code>#</code> ce que l'on obtient.</li>\n<li>Quelles valeurs peut prendre <code>rd.randint(0, 2)</code> ?</li>\n</ol>\n</div>"},{"metadata":{"trusted":true},"cell_type":"code","source":"rd.random()                           #","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"rd.random() < 0.5                     #","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"rd.randint(1, 7)                      #","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"rd.randint(0, 2)                      #","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"[rd.randint(1, 4) for k in range(10)] #","execution_count":null,"outputs":[]},{"metadata":{"trusted":false},"cell_type":"markdown","source":"<h1 style=\"color:#D89B00;\">II. Simulation des lois usuelles</h1><h2 style=\"color:#D89B00;\">II.1 À partir de <code>rd.random</code></h2>\n\nLes lois usuelles se décrivent par des expériences : on peut les simuler en rejouant ces expériences.\n\n<ul>\n<li><strong style=\"color:#D89B00;\">Loi binomiale $\\mathcal{B}(n,p)$</strong> : nombre de succès lors de $n$ épreuves de Bernoulli indépendantes de paramètre $p$.</li>\n<li><strong style=\"color:#D89B00;\">Loi géométrique $\\mathcal{G}(p)$</strong> : rang du premier succès dans une suite infinie d'épreuves de Bernoulli indépendantes de paramètre $p$.</li>\n</ul>"},{"metadata":{"trusted":false},"cell_type":"markdown","source":"<div style=\"border-left: 4px solid #D89B00; padding: 8px 12px; margin: 12px 0;\">\n<strong style=\"color:#D89B00;\">Exercice — Reconstruire les lois usuelles</strong>\n\n<ol>\n<li>Compléter la fonction <code>binomiale(n, p)</code> qui simule la loi $\\mathcal{B}(n,p)$ à l'aide de <code>rd.random</code> et d'une boucle <code>for</code>.</li>\n<li>Compléter la fonction <code>geometrique(p)</code> qui simule la loi $\\mathcal{G}(p)$ à l'aide de <code>rd.random</code> et d'une boucle <code>while</code>.</li>\n</ol>\n<div style=\"border-left: 4px solid #D89B00; padding: 8px 12px; margin: 12px 0;\">\n<strong style=\"color:#D89B00;\">Idée :</strong>\n\nLa boucle <code>while</code> de la question 2 s'arrête presque sûrement : un succès finit toujours par arriver.\n</div>\n</div>"},{"metadata":{"trusted":true},"cell_type":"code","source":"def binomiale(n, p):\n    S = ...\n    for k in range(...):\n        if ...:\n            S = ...\n    return S\n\nbinomiale(17, 0.6)   # Ligne de test : relancer plusieurs fois","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"def geometrique(p):\n    rang = ...\n    while ...:           # tant qu'on obtient un échec\n        rang = ...\n    return rang\n\ngeometrique(0.2)     # Ligne de test : relancer plusieurs fois","execution_count":null,"outputs":[]},{"metadata":{"trusted":false},"cell_type":"markdown","source":"Pour la loi de Poisson, il n'existe pas de description simple par une expérience : on utilisera directement la commande dédiée."},{"metadata":{"trusted":false},"cell_type":"markdown","source":"<h2 style=\"color:#D89B00;\">II.2 Les commandes de <code>numpy.random</code></h2>\n\nLa bibliothèque <code>numpy.random</code>, importée par <code>import numpy.random as rd</code>, contient directement des commandes de simulation.\n\n<table>\n<tr><td><code>rd.randint(1,n+1)</code></td><td>simule la loi $\\mathcal{U}([\\mkern-2.7mu[ 1,n]\\mkern-2.7mu])$</td></tr>\n<tr><td><code>rd.binomial(n,p)</code></td><td>simule la loi $\\mathcal{B}(n,p)$</td></tr>\n<tr><td><code>rd.geometric(p)</code></td><td>simule la loi $\\mathcal{G}(p)$</td></tr>\n<tr><td><code>rd.poisson(lam)</code></td><td>simule la loi $\\mathcal{P}(\\lambda)$, avec <code>lam</code> $=\\lambda$</td></tr>\n</table>\n\n<div style=\"border-left: 4px solid #D89B00; padding: 8px 12px; margin: 12px 0;\">\n<strong style=\"color:#D89B00;\">À retenir :</strong>\n\nPour la loi de Bernoulli $\\mathcal{B}(p)$ on utilise <code>rd.binomial(1,p)</code>.\n</div>"},{"metadata":{"trusted":true},"cell_type":"code","source":"rd.binomial(10, 0.3)   # une réalisation de la loi B(10 ; 0,3)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"rd.geometric(0.4)      # une réalisation de la loi G(0,4)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"rd.poisson(2)          # une réalisation de la loi P(2)","execution_count":null,"outputs":[]},{"metadata":{"trusted":false},"cell_type":"markdown","source":"<h2 style=\"color:#D89B00;\">II.3 Simuler un échantillon</h2>\n\nCes commandes acceptent un argument supplémentaire <code>N</code> qui donne le <strong style=\"color:#D89B00;\">nombre de réalisations indépendantes</strong> souhaité. Le résultat est un tableau (<code>array</code>) de <code>N</code> valeurs."},{"metadata":{"trusted":false},"cell_type":"markdown","source":"<div style=\"border-left: 4px solid #D89B00; padding: 8px 12px; margin: 12px 0;\">\n<strong style=\"color:#D89B00;\">Exemple — Échantillons</strong>\n\n<ul>\n<li>10 réalisations indépendantes de $\\mathcal{G}(0,4)$ ;</li>\n<li>7 réalisations indépendantes de $\\mathcal{B}(20\\,;\\,0,3)$.</li>\n</ul>\n</div>"},{"metadata":{"trusted":true},"cell_type":"code","source":"rd.geometric(0.4, 10)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"rd.binomial(20, 0.3, 7)","execution_count":null,"outputs":[]},{"metadata":{"trusted":false},"cell_type":"markdown","source":"Les valeurs obtenues sont les réalisations de variables aléatoires $X_1,\\ldots,X_N$ indépendantes, toutes de même loi.\n\n<div style=\"border-left: 4px solid #D89B00; padding: 8px 12px; margin: 12px 0;\">\n<strong style=\"color:#D89B00;\">Remarque :</strong>\n\nÉcrire <code>rd.geometric(0.4, 10)</code> est plus court <strong>et beaucoup plus rapide</strong> que <code>[geometrique(0.4) for k in range(10)]</code>.\n</div>"},{"metadata":{"trusted":false},"cell_type":"markdown","source":"<div style=\"border-left: 4px solid #D89B00; padding: 8px 12px; margin: 12px 0;\">\n<strong style=\"color:#D89B00;\">Exercice — Quelle commande ?</strong>\n\nDonner la commande Python permettant de simuler :\n<ol>\n<li>$1000$ réalisations indépendantes d'une loi binomiale $\\mathcal{B}(20\\,;\\,0,4)$ ;</li>\n<li>$500$ réalisations indépendantes d'une loi de Poisson de paramètre $3$ ;</li>\n<li>$200$ lancers indépendants d'un dé à $6$ faces ;</li>\n<li>$50$ réalisations indépendantes d'une loi géométrique de paramètre $\\frac16$.</li>\n</ol>\n</div>"},{"metadata":{"trusted":true},"cell_type":"code","source":"X1 = ...\nX2 = ...\nX3 = ...\nX4 = ...\n\nprint(len(X1), len(X2), len(X3), len(X4))   # Ligne de test : doit afficher 1000 500 200 50","execution_count":null,"outputs":[]},{"metadata":{"trusted":false},"cell_type":"markdown","source":"<h1 style=\"color:#D89B00;\">III. Représenter et exploiter un échantillon</h1><h2 style=\"color:#D89B00;\">III.1 Histogramme</h2>\n\nPour représenter les données d'un échantillon <code>X</code>, on utilise la bibliothèque <code>matplotlib.pyplot</code> :\n\n<pre><code>plt.hist(X, bins=B, density=True, edgecolor='k')\nplt.show()</code></pre>\n\n<ul>\n<li><code>bins=B</code> où <code>B</code> est la liste des bornes des classes ;</li>\n<li><code>density=True</code> fournit l'histogramme des <strong>fréquences</strong> (sans cette option, on obtient l'histogramme des effectifs) ;</li>\n<li><code>edgecolor='k'</code> dessine le contour des barres en noir.</li>\n</ul>\n\n<div style=\"border-left: 4px solid #D89B00; padding: 8px 12px; margin: 12px 0;\">\n<strong style=\"color:#D89B00;\">À retenir :</strong>\n\nPour une variable à valeurs entières, on choisit des classes centrées sur les entiers : <code>B = [k-0.5 for k in range(a, b+2)]</code> pour des valeurs entre <code>a</code> et <code>b</code>.\n</div>"},{"metadata":{"trusted":false},"cell_type":"markdown","source":"<div style=\"border-left: 4px solid #D89B00; padding: 8px 12px; margin: 12px 0;\">\n<strong style=\"color:#D89B00;\">Exemple — Histogramme d'une loi binomiale</strong>\n\nOn simule $10\\,000$ réalisations de la loi $\\mathcal{B}(10\\,;\\,0,3)$.\n</div>"},{"metadata":{"trusted":true},"cell_type":"code","source":"n, p, N = 10, 0.3, 10000\nX = rd.binomial(n, p, N)\n\nB = [k-0.5 for k in range(n+2)]      # classes centrées sur 0, 1, ..., n\n\nplt.figure()                          # Nouvelle figure\nplt.hist(X, bins=B, density=True, edgecolor='k')\nplt.show()","execution_count":null,"outputs":[]},{"metadata":{"trusted":false},"cell_type":"markdown","source":"La barre située en $k$ a pour hauteur la fréquence d'apparition de la valeur $k$ dans l'échantillon, valeur proche de $\\mathbf{P}([X=k])$."},{"metadata":{"trusted":false},"cell_type":"markdown","source":"<h2 style=\"color:#D89B00;\">III.2 Comparaison avec la loi théorique</h2>\n\nPour valider la simulation, on superpose à l'histogramme les valeurs théoriques $\\mathbf{P}([X=k])$."},{"metadata":{"trusted":false},"cell_type":"markdown","source":"<div style=\"border-left: 4px solid #D89B00; padding: 8px 12px; margin: 12px 0;\">\n<strong style=\"color:#D89B00;\">Exemple — Comparaison pour la loi géométrique</strong>\n\nSi $X\\hookrightarrow\\mathcal{G}(p)$, alors $\\mathbf{P}([X=k])=p(1-p)^{k-1}$ pour tout $k\\in\\mathbb{N}^*$.\n</div>"},{"metadata":{"trusted":true},"cell_type":"code","source":"p, N = 0.4, 10000\nX = rd.geometric(p, N)\nm = max(X)                         # plus grande valeur observée\n\nplt.figure()\nB = [k-0.5 for k in range(1, m+2)]\nplt.hist(X, bins=B, density=True, edgecolor='k')\n\nx = list(range(1, m+1))\ny = [p*(1-p)**(k-1) for k in x]\nplt.plot(x, y, 'ro')               # probabilités théoriques en rouge\nplt.show()","execution_count":null,"outputs":[]},{"metadata":{"trusted":false},"cell_type":"markdown","source":"<div style=\"border-left: 4px solid #D89B00; padding: 8px 12px; margin: 12px 0;\">\n<strong style=\"color:#D89B00;\">Idée :</strong>\n\nPlus $N$ est grand, meilleure est l'adéquation : c'est la <em>loi des grands nombres</em> pour les fréquences.\n</div>"},{"metadata":{"trusted":false},"cell_type":"markdown","source":"<div style=\"border-left: 4px solid #D89B00; padding: 8px 12px; margin: 12px 0;\">\n<strong style=\"color:#D89B00;\">Exercice — Loi de Poisson</strong>\n\nOn simule $N=10000$ réalisations de la loi $\\mathcal{P}(2)$.\n<ol>\n<li>Représenter l'histogramme des fréquences de l'échantillon obtenu.</li>\n<li>Superposer les valeurs théoriques $\\mathrm{e}^{-2}\\dfrac{2^k}{k!}$ pour $k$ entre $0$ et la plus grande valeur observée.</li>\n</ol>\n<div style=\"border-left: 4px solid #D89B00; padding: 8px 12px; margin: 12px 0;\">\n<strong style=\"color:#D89B00;\">Conseil :</strong>\n\nLa commande <code>factorial</code> s'importe par <code>from math import factorial</code>.\n</div>\n</div>"},{"metadata":{"trusted":true},"cell_type":"code","source":"from math import factorial\n\nlam, N = 2, 10000\nX = ...\nm = max(X)\n\nplt.figure()\nB = [... for k in range(...)]\nplt.hist(..., bins=..., density=True, edgecolor='k')\n\nx = list(range(m+1))\ny = [... for k in x]\nplt.plot(x, y, 'ro')\nplt.show()   # Ligne de test : les points rouges doivent être au sommet des barres","execution_count":null,"outputs":[]},{"metadata":{"trusted":false},"cell_type":"markdown","source":"<h2 style=\"color:#D89B00;\">III.3 Estimer une probabilité, une espérance, une variance</h2>\n\nSoit $(X_i)_{i\\in\\mathbb{N}^*}$ une suite de variables aléatoires indépendantes de même loi que $X$. Les fréquences et les moyennes observées sur un grand échantillon sont proches de leurs valeurs théoriques.\n\n<ul>\n<li><strong style=\"color:#D89B00;\">Probabilité</strong> : la fréquence d'apparition d'un événement est proche de sa probabilité. Avec un échantillon <code>X</code>, la commande <code>np.mean(X >= 5)</code> donne la fréquence de l'événement $[X\\geq 5]$.</li>\n<li><strong style=\"color:#D89B00;\">Espérance</strong> : la moyenne <code>np.mean(X)</code> est proche de $\\mathbf{E}(X)$.</li>\n<li><strong style=\"color:#D89B00;\">Variance</strong> : <code>np.var(X)</code> est proche de $\\mathbf{V}(X)$.</li>\n</ul>\n\n<div style=\"border-left: 4px solid #D89B00; padding: 8px 12px; margin: 12px 0;\">\n<strong style=\"color:#D89B00;\">Idée :</strong>\n\nLes comparaisons <code>X >= 5</code> fournissent un tableau de booléens ; <code>np.mean</code> le traite comme un tableau de $0$ et de $1$ et en renvoie la moyenne, c'est-à-dire la proportion de <code>True</code>.\n</div>"},{"metadata":{"trusted":false},"cell_type":"markdown","source":"<div style=\"border-left: 4px solid #D89B00; padding: 8px 12px; margin: 12px 0;\">\n<strong style=\"color:#D89B00;\">Exemple — Loi géométrique</strong>\n\nPour $X\\hookrightarrow\\mathcal{G}\\left(\\frac14\\right)$, on sait que $\\mathbf{E}(X)=4$, $\\mathbf{V}(X)=12$ et $\\mathbf{P}([X\\geq 5])=\\left(\\frac34\\right)^4\\simeq 0,316$.\n</div>"},{"metadata":{"trusted":true},"cell_type":"code","source":"X = rd.geometric(1/4, 100000)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"np.mean(X)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"np.var(X)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"np.mean(X >= 5)","execution_count":null,"outputs":[]},{"metadata":{"trusted":false},"cell_type":"markdown","source":"<div style=\"border-left: 4px solid #D89B00; padding: 8px 12px; margin: 12px 0;\">\n<strong style=\"color:#D89B00;\">Attention :</strong>\n\nUne simulation ne démontre rien : elle ne fournit que des <strong>valeurs approchées</strong>, différentes d'une exécution à l'autre. Pour un résultat exact, un calcul reste indispensable.\n</div>"},{"metadata":{"trusted":false},"cell_type":"markdown","source":"<div style=\"border-left: 4px solid #D89B00; padding: 8px 12px; margin: 12px 0;\">\n<strong style=\"color:#D89B00;\">Exemple — Visualiser la loi des grands nombres</strong>\n\nOn trace l'évolution de la moyenne empirique $\\dfrac{X_1+\\cdots+X_n}{n}$ en fonction de $n$ pour des variables de loi $\\mathcal{G}\\left(\\frac14\\right)$.\n</div>"},{"metadata":{"trusted":true},"cell_type":"code","source":"N = 5000\nX = rd.geometric(1/4, N)\nM = np.cumsum(X) / np.arange(1, N+1)    # M[n-1] = moyenne des n premières valeurs\n\nplt.figure()\nplt.plot(M)\nplt.axhline(4, color='r')                # l'espérance théorique\nplt.show()","execution_count":null,"outputs":[]},{"metadata":{"trusted":false},"cell_type":"markdown","source":"<div style=\"border-left: 4px solid #D89B00; padding: 8px 12px; margin: 12px 0;\">\n<strong style=\"color:#D89B00;\">Remarque :</strong>\n\n<code>np.cumsum(X)</code> renvoie le tableau des sommes partielles $X_1$, $X_1+X_2$, $X_1+X_2+X_3$, …\n</div>\n\nLa courbe se stabilise autour de $\\mathbf{E}(X)=4$."},{"metadata":{"trusted":false},"cell_type":"markdown","source":"<h1 style=\"color:#D89B00;\">IV. Simuler une expérience aléatoire</h1>\n\nPour simuler une variable aléatoire définie par une expérience, on <strong style=\"color:#D89B00;\">rejoue l'expérience</strong> avec les commandes de simulation, puis on lit la valeur de la variable.\n<h2 style=\"color:#D89B00;\">IV.1 Expériences avec arrêt</h2>"},{"metadata":{"trusted":false},"cell_type":"markdown","source":"<div style=\"border-left: 4px solid #D89B00; padding: 8px 12px; margin: 12px 0;\">\n<strong style=\"color:#D89B00;\">Exemple — Géométrique tronquée</strong>\n\nOn lance une pièce donnant PILE avec la probabilité $0,3$ jusqu'à obtenir le premier PILE, mais on s'arrête dans tous les cas après $10$ lancers. On note $X$ le nombre de lancers effectués.\n\nPlusieurs programmes sont possibles :\n</div>"},{"metadata":{"trusted":true},"cell_type":"code","source":"def simul_X():\n    n = 1\n    while n < 10:\n        if rd.random() < 0.7:     # FACE : on continue\n            n = n + 1\n        else:                      # PILE : on s'arrête\n            return n\n    return n\n\ndef simul_Xbis():\n    n = 1\n    while n < 10 and rd.random() < 0.7:\n        n = n + 1\n    return n\n\ndef simul_Xter():\n    for n in range(1, 11):\n        if rd.random() < 0.3:\n            return n\n    return 10\n\nprint(simul_X(), simul_Xbis(), simul_Xter())","execution_count":null,"outputs":[]},{"metadata":{"trusted":false},"cell_type":"markdown","source":"<div style=\"border-left: 4px solid #D89B00; padding: 8px 12px; margin: 12px 0;\">\n<strong style=\"color:#D89B00;\">Idée :</strong>\n\nUne instruction <code>return</code> arrête immédiatement la fonction, y compris au milieu d'une boucle.\n</div>\n\nUne autre approche : $X=\\min(T,10)$ où $T\\hookrightarrow\\mathcal{G}(0,3)$ :"},{"metadata":{"trusted":true},"cell_type":"code","source":"def simul_Xquater():\n    return min(rd.geometric(0.3), 10)\n\nsimul_Xquater()","execution_count":null,"outputs":[]},{"metadata":{"trusted":false},"cell_type":"markdown","source":"<div style=\"border-left: 4px solid #D89B00; padding: 8px 12px; margin: 12px 0;\">\n<strong style=\"color:#D89B00;\">Exercice — Géométrique tronquée — suite</strong>\n\nAvec l'expérience précédente :\n<ol>\n<li>Représenter l'histogramme des fréquences de $10\\,000$ réalisations indépendantes de $X$.</li>\n<li>Donner une valeur approchée de $\\mathbf{P}([X=10])$, puis calculer sa valeur exacte.</li>\n</ol>\n</div>"},{"metadata":{"trusted":true},"cell_type":"code","source":"L = [... for k in range(10000)]\nB = [k-0.5 for k in range(1, 12)]\n\nplt.figure()\nplt.hist(..., bins=B, density=True, edgecolor='k')\nplt.show()\n\nprint(...)   # Ligne de test : valeur approchée de P(X=10)","execution_count":null,"outputs":[]},{"metadata":{"trusted":false},"cell_type":"markdown","source":"<div style=\"border-left: 4px solid #D89B00; padding: 8px 12px; margin: 12px 0;\">\n<strong style=\"color:#D89B00;\">Exercice — Le premier six</strong>\n\nOn lance un dé équilibré jusqu'à obtenir un $6$. On note $X$ le nombre de lancers nécessaires.\n<ol>\n<li>Écrire une fonction <code>simul_X()</code> simulant $X$ <strong>sans</strong> utiliser <code>rd.geometric</code>.</li>\n<li>Quelle est la loi de $X$ ? Donner son espérance.</li>\n<li>Estimer $\\mathbf{E}(X)$ et $\\mathbf{P}([X>6])$ à l'aide de $10\\,000$ simulations. Comparer à $\\left(\\frac56\\right)^6$.</li>\n</ol>\n</div>"},{"metadata":{"trusted":true},"cell_type":"code","source":"def simul_X():\n    n = ...\n    while ...:\n        n = ...\n    return n\n\nsimul_X()   # Ligne de test : relancer plusieurs fois","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"X = np.array([simul_X() for k in range(10000)])\n\nprint(...)           # estimation de E(X)\nprint(...)           # estimation de P(X>6)\nprint((5/6)**6)      # valeur théorique","execution_count":null,"outputs":[]},{"metadata":{"trusted":false},"cell_type":"markdown","source":"<h2 style=\"color:#D89B00;\">IV.2 Expériences avec des listes : les urnes</h2>\n\nOn modélise le contenu d'une urne par une liste."},{"metadata":{"trusted":false},"cell_type":"markdown","source":"<div style=\"border-left: 4px solid #D89B00; padding: 8px 12px; margin: 12px 0;\">\n<strong style=\"color:#D89B00;\">Exemple — Tirages dans une urne</strong>\n\nUne urne contient $3$ boules blanches et $2$ boules noires.\n<ul>\n<li><strong style=\"color:#D89B00;\">Tirage avec remise</strong> : on choisit un indice au hasard, sans modifier la liste.</li>\n<li><strong style=\"color:#D89B00;\">Tirage sans remise</strong> : on retire la boule tirée de la liste.</li>\n</ul>\n</div>"},{"metadata":{"trusted":true},"cell_type":"code","source":"urne = ['B', 'B', 'B', 'N', 'N']\n\ndef tirage_avec_remise(urne):\n    i = rd.randint(0, len(urne))\n    return urne[i]\n\ndef tirage_sans_remise(urne):\n    i = rd.randint(0, len(urne))\n    boule = urne[i]\n    del urne[i]\n    return boule\n\nu = urne[:]                    # copie de l'urne\nprint(tirage_avec_remise(urne), tirage_sans_remise(u), u)","execution_count":null,"outputs":[]},{"metadata":{"trusted":false},"cell_type":"markdown","source":"<div style=\"border-left: 4px solid #D89B00; padding: 8px 12px; margin: 12px 0;\">\n<strong style=\"color:#D89B00;\">Attention :</strong>\n\nOn travaille sur une <strong>copie</strong> de la liste pour ne pas modifier l'urne initiale : <code>u = urne[:]</code>.\n</div>"},{"metadata":{"trusted":false},"cell_type":"markdown","source":"<div style=\"border-left: 4px solid #D89B00; padding: 8px 12px; margin: 12px 0;\">\n<strong style=\"color:#D89B00;\">Exercice — Deux boules sans remise</strong>\n\nUne urne contient $3$ boules blanches et $2$ boules noires. On tire successivement et sans remise deux boules. On note $Y$ le nombre de boules blanches obtenues.\n<ol>\n<li>Écrire une fonction <code>simul_Y()</code> simulant $Y$.</li>\n<li>Estimer $\\mathbf{P}([Y=2])$ avec $10\\,000$ simulations.</li>\n<li>Calculer la valeur exacte de $\\mathbf{P}([Y=2])$.</li>\n</ol>\n</div>"},{"metadata":{"trusted":true},"cell_type":"code","source":"def simul_Y():\n    urne = ['B', 'B', 'B', 'N', 'N']\n    Y = ...\n    for k in range(2):\n        i = ...\n        if ...:\n            Y = ...\n        del ...\n    return Y\n\nsimul_Y()   # Ligne de test : relancer plusieurs fois","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"L = np.array([simul_Y() for k in range(10000)])\nprint(...)   # estimation de P(Y=2)","execution_count":null,"outputs":[]},{"metadata":{"trusted":false},"cell_type":"markdown","source":"<div style=\"border-left: 4px solid #D89B00; padding: 8px 12px; margin: 12px 0;\">\n<strong style=\"color:#D89B00;\">Exercice — Maximum de deux dés</strong>\n\nOn lance deux dés équilibrés et on note $T$ le plus grand des deux résultats.\n<ol>\n<li>Écrire une fonction <code>simul_T()</code> simulant $T$.</li>\n<li>Estimer $\\mathbf{P}([T=6])$ et la comparer à $\\frac{11}{36}$.</li>\n</ol>\n</div>"},{"metadata":{"trusted":true},"cell_type":"code","source":"def simul_T():\n    return ...\n\nsimul_T()   # Ligne de test : relancer plusieurs fois","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"L = np.array([simul_T() for k in range(10000)])\nprint(...)      # estimation de P(T=6)\nprint(11/36)    # valeur théorique","execution_count":null,"outputs":[]},{"metadata":{"trusted":false},"cell_type":"markdown","source":"<h1 style=\"color:#D89B00;\">V. Simuler un couple de variables : conditionnement</h1>\n\nBeaucoup d'expériences se déroulent en deux temps : la valeur de $X$ est d'abord obtenue, puis la loi de $Y$ dépend de cette valeur. On simule alors $X$, puis $Y$ <strong style=\"color:#D89B00;\">sachant</strong> la valeur obtenue pour $X$.\n\n<div style=\"border-left: 4px solid #D89B00; padding: 8px 12px; margin: 12px 0;\">\n<strong style=\"color:#D89B00;\">Idée :</strong>\n\nLa loi conditionnelle de $Y$ sachant $[X=k]$ est lue sur l'énoncé : c'est ce qu'on donne à la commande de simulation de $Y$.\n</div>"},{"metadata":{"trusted":false},"cell_type":"markdown","source":"<div style=\"border-left: 4px solid #D89B00; padding: 8px 12px; margin: 12px 0;\">\n<strong style=\"color:#D89B00;\">Exemple — Uniforme puis binomiale</strong>\n\nOn dispose de $n$ urnes numérotées de $1$ à $n$ ; l'urne $k$ contient $k$ boules blanches et $n-k$ boules noires. On choisit une urne de façon équiprobable, puis on effectue $n$ tirages avec remise dans l'urne choisie. On note $X$ le numéro de l'urne et $Y$ le nombre de boules blanches obtenues.\n\nOn a $X\\hookrightarrow\\mathcal{U}([\\mkern-2.7mu[ 1,n]\\mkern-2.7mu])$ et, pour tout $k\\in[\\mkern-2.7mu[ 1,n]\\mkern-2.7mu]$, la loi de $Y$ sachant $[X=k]$ est la loi $\\mathcal{B}\\left(n,\\frac kn\\right)$.\n</div>"},{"metadata":{"trusted":true},"cell_type":"code","source":"def simul_XY(n):\n    X = rd.randint(1, n+1)\n    Y = rd.binomial(n, X/n)\n    return (X, Y)\n\nsimul_XY(100)","execution_count":null,"outputs":[]},{"metadata":{"trusted":false},"cell_type":"markdown","source":"<div style=\"border-left: 4px solid #D89B00; padding: 8px 12px; margin: 12px 0;\">\n<strong style=\"color:#D89B00;\">Exemple — Géométrique puis binomiale</strong>\n\nOn lance une pièce équilibrée jusqu'à obtenir le premier PILE. Si $k$ lancers ont été nécessaires, on relance alors $k$ fois la pièce. On note $X$ le nombre de lancers de la première série et $Y$ le nombre de PILE obtenus lors de la seconde série.\n\nOn a $X\\hookrightarrow\\mathcal{G}\\left(\\frac12\\right)$ et, pour tout $k\\in\\mathbb{N}^*$, la loi de $Y$ sachant $[X=k]$ est la loi $\\mathcal{B}\\left(k,\\frac12\\right)$.\n</div>"},{"metadata":{"trusted":true},"cell_type":"code","source":"def simul_XY():\n    X = rd.geometric(1/2)\n    Y = rd.binomial(X, 1/2)\n    return (X, Y)\n\nsimul_XY()","execution_count":null,"outputs":[]},{"metadata":{"trusted":false},"cell_type":"markdown","source":"<div style=\"border-left: 4px solid #D89B00; padding: 8px 12px; margin: 12px 0;\">\n<strong style=\"color:#D89B00;\">Remarque :</strong>\n\nOn peut aussi demander d'écrire ces programmes <strong>sans</strong> les commandes <code>rd.binomial</code> et <code>rd.geometric</code>. On utilise alors les fonctions <code>binomiale</code> et <code>geometrique</code> construites à partir de <code>rd.random</code> dans la partie II.\n\nLes commandes <code>rd.binomial</code> et <code>rd.randint</code> acceptent aussi des tableaux en argument : <code>X = rd.geometric(1/2, N)</code> suivi de <code>Y = rd.binomial(X, 1/2)</code> simule d'un coup $N$ réalisations indépendantes du couple $(X,Y)$.\n</div>"},{"metadata":{"trusted":false},"cell_type":"markdown","source":"<div style=\"border-left: 4px solid #D89B00; padding: 8px 12px; margin: 12px 0;\">\n<strong style=\"color:#D89B00;\">Exercice — Estimer à partir d'un couple</strong>\n\nOn reprend l'expérience « géométrique puis binomiale » ci-dessus.\n<ol>\n<li>Simuler $10\\,000$ réalisations du couple $(X,Y)$ et estimer $\\mathbf{E}(Y)$ et $\\mathbf{P}([Y=0])$.</li>\n<li>Justifier (sur papier) les valeurs $\\mathbf{E}(Y)=1$ et $\\mathbf{P}([Y=0])=\\frac13$.</li>\n</ol>\n</div>"},{"metadata":{"trusted":true},"cell_type":"code","source":"N = 10000\nX = ...\nY = ...\n\nprint(...)   # estimation de E(Y)\nprint(...)   # estimation de P(Y=0)","execution_count":null,"outputs":[]},{"metadata":{"trusted":false},"cell_type":"markdown","source":"<div style=\"border-left: 4px solid #D89B00; padding: 8px 12px; margin: 12px 0;\">\n<strong style=\"color:#D89B00;\">Exercice — Uniforme puis binomiale</strong>\n\nDans l'expérience « uniforme puis binomiale » avec $n=10$ :\n<ol>\n<li>Estimer $\\mathbf{E}(Y)$ à l'aide de $10\\,000$ simulations.</li>\n<li>Calculer (sur papier) $\\mathbf{E}(Y)$ en utilisant l'espérance conditionnelle $\\mathbf{E}_{[X=k]}(Y)$.</li>\n</ol>\n</div>"},{"metadata":{"trusted":true},"cell_type":"code","source":"n, N = 10, 10000\nX = ...\nY = ...\n\nprint(...)   # Ligne de test : estimation de E(Y)","execution_count":null,"outputs":[]},{"metadata":{"trusted":false},"cell_type":"markdown","source":"<h1 style=\"color:#D89B00;\">VI. Simuler une loi quelconque à support fini</h1>\n\nQue faire pour une loi qui n'est pas une loi usuelle ?\n\nSi $X(\\Omega)=\\{x_1,\\ldots,x_r\\}$ avec $\\mathbf{P}([X=x_i])=p_i$, on découpe l'intervalle $[0,1[$ en $r$ intervalles consécutifs de longueurs $p_1,\\ldots,p_r$ :\n$$[0,\\,p_1[\\ ,\\quad [p_1,\\,p_1+p_2[\\ ,\\quad \\ldots,\\quad [p_1+\\cdots+p_{r-1},\\,1[.$$\nOn tire $U$ avec <code>rd.random()</code> et on renvoie $x_i$ si $U$ tombe dans le $i$-ème intervalle : cela se produit avec la probabilité $p_i$."},{"metadata":{"trusted":false},"cell_type":"markdown","source":"<div style=\"border-left: 4px solid #D89B00; padding: 8px 12px; margin: 12px 0;\">\n<strong style=\"color:#D89B00;\">Exemple — Une loi donnée par un tableau</strong>\n\nSimulons $X$ telle que $X(\\Omega)=\\{-1,0,2\\}$ avec $$\\mathbf{P}([X=-1])=0,2,\\quad \\mathbf{P}([X=0])=0,5\\quad\\text{et}\\quad\\mathbf{P}([X=2])=0,3.$$\n</div>"},{"metadata":{"trusted":true},"cell_type":"code","source":"def simul(valeurs, probas):\n    U = rd.random()\n    S = 0                          # somme cumulée des probabilités\n    for k in range(len(valeurs)):\n        S = S + probas[k]\n        if U < S:\n            return valeurs[k]\n    return valeurs[-1]\n\nsimul([-1, 0, 2], [0.2, 0.5, 0.3])","execution_count":null,"outputs":[]},{"metadata":{"trusted":false},"cell_type":"markdown","source":"<div style=\"border-left: 4px solid #D89B00; padding: 8px 12px; margin: 12px 0;\">\n<strong style=\"color:#D89B00;\">Exercice — Vérification</strong>\n\n<ol>\n<li>Simuler $10\\,000$ réalisations de la loi de l'exemple précédent.</li>\n<li>Estimer l'espérance de cette loi et la comparer à sa valeur théorique.</li>\n</ol>\n</div>"},{"metadata":{"trusted":true},"cell_type":"code","source":"L = [... for k in range(10000)]\n\nprint(...)   # Ligne de test : estimation de l'espérance\nprint(...)   # valeur théorique","execution_count":null,"outputs":[]},{"metadata":{"trusted":false},"cell_type":"markdown","source":"<div style=\"border-left: 4px solid #D89B00; padding: 8px 12px; margin: 12px 0;\">\n<strong style=\"color:#D89B00;\">Exercice — Une loi à votre façon</strong>\n\nSoit $X$ la variable aléatoire à valeurs dans $\\{1,2,3,4\\}$ telle que $\\mathbf{P}([X=1])=0,1$, $\\mathbf{P}([X=2])=0,2$, $\\mathbf{P}([X=3])=0,3$ et $\\mathbf{P}([X=4])=0,4$.\n<ol>\n<li>À l'aide de la fonction <code>simul</code>, simuler $10\\,000$ réalisations de $X$.</li>\n<li>Représenter l'histogramme des fréquences et superposer les probabilités théoriques.</li>\n</ol>\n</div>"},{"metadata":{"trusted":true},"cell_type":"code","source":"L = ...\n\nplt.figure()\nplt.hist(..., bins=..., density=True, edgecolor='k')\nplt.plot(..., ..., 'ro')\nplt.show()   # Ligne de test : les points rouges doivent être au sommet des barres","execution_count":null,"outputs":[]},{"metadata":{"trusted":false},"cell_type":"markdown","source":"<h1 style=\"color:#D89B00;\">VII. Exercices</h1>"},{"metadata":{"trusted":false},"cell_type":"markdown","source":"<div style=\"border-left: 4px solid #D89B00; padding: 8px 12px; margin: 12px 0;\">\n<strong style=\"color:#D89B00;\">Exercice — Loi binomiale à la main</strong>\n\n<ol>\n<li>Écrire une fonction <code>binomiale(n, p)</code> simulant la loi $\\mathcal{B}(n,p)$ à l'aide de <code>rd.random</code> seulement.</li>\n<li>Représenter l'histogramme des fréquences de $5000$ réalisations de <code>binomiale(8, 0.5)</code>.</li>\n<li>Estimer l'espérance et la variance, et les comparer à $np$ et $np(1-p)$.</li>\n</ol>\n</div>"},{"metadata":{"trusted":true},"cell_type":"code","source":"def binomiale(n, p):\n    ...\n\nbinomiale(8, 0.5)   # Ligne de test","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"X = [binomiale(8, 0.5) for k in range(5000)]\n\nplt.figure()\nplt.hist(..., bins=..., density=True, edgecolor='k')\nplt.show()\n\nprint(..., ...)   # moyenne et variance empiriques (théoriques : 4 et 2)","execution_count":null,"outputs":[]},{"metadata":{"trusted":false},"cell_type":"markdown","source":"<div style=\"border-left: 4px solid #D89B00; padding: 8px 12px; margin: 12px 0;\">\n<strong style=\"color:#D89B00;\">Exercice — Temps d'attente du premier succès</strong>\n\nUne machine fabrique des pièces, chacune étant défectueuse avec la probabilité $0,05$, indépendamment des autres. On note $X$ le rang de la première pièce défectueuse.\n<ol>\n<li>Quelle est la loi de $X$ ?</li>\n<li>Écrire une fonction <code>simul_X()</code> simulant $X$ avec une boucle <code>while</code>.</li>\n<li>Estimer la probabilité que les $20$ premières pièces soient correctes. Comparer à la valeur exacte.</li>\n</ol>\n</div>"},{"metadata":{"trusted":true},"cell_type":"code","source":"def simul_X():\n    ...\n\nsimul_X()   # Ligne de test : relancer plusieurs fois","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"X = np.array([simul_X() for k in range(10000)])\n\nprint(...)       # estimation de la probabilité\nprint(0.95**20)  # valeur exacte","execution_count":null,"outputs":[]},{"metadata":{"trusted":false},"cell_type":"markdown","source":"<div style=\"border-left: 4px solid #D89B00; padding: 8px 12px; margin: 12px 0;\">\n<strong style=\"color:#D89B00;\">Exercice — Somme de deux lois de Poisson</strong>\n\nOn simule $N=10000$ réalisations indépendantes de deux variables $X$ et $Y$ de lois respectives $\\mathcal{P}(1)$ et $\\mathcal{P}(2)$, indépendantes.\n<ol>\n<li>Écrire un programme créant le tableau <code>S</code> des valeurs de $X+Y$.</li>\n<li>Représenter l'histogramme des fréquences de <code>S</code> et le comparer à la loi $\\mathcal{P}(3)$.</li>\n<li>Quelle propriété du cours cette simulation illustre-t-elle ?</li>\n</ol>\n</div>"},{"metadata":{"trusted":true},"cell_type":"code","source":"from math import factorial\n\nN = 10000\nS = ...\n\nm = max(S)\nplt.figure()\nplt.hist(..., bins=..., density=True, edgecolor='k')\n\nx = list(range(m+1))\ny = [... for k in x]\nplt.plot(x, y, 'ro')\nplt.show()   # Ligne de test : les points rouges doivent être au sommet des barres","execution_count":null,"outputs":[]},{"metadata":{"trusted":false},"cell_type":"markdown","source":"Réponse à la question 3 :"}],"metadata":{"kernelspec":{"name":"python3","display_name":"Python 3","language":"python"}},"nbformat":4,"nbformat_minor":2}