Loi des grands nombres v 2.0.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Espérance et loi des grands nombres\n",
    "\n",
    "**Note: Les blocs de code de cette fiche sont *interactifs*: vous pouvez double-cliquer dessus, moidifier leur contenu et/ou exécuter à nouveau le code à l'intérieur en appuyant sur Maj + Entrée.**\n",
    "\n",
    "Nous avons vu, dans notre cours, ce qu'est une **variable aléatoire**: une fonction qui à chaque issue d'une expérience aléatoire associe un nombre. Nous avons aussi vu comment calculer une valeur en particulier, que l'on appelle **l'espérance**.\n",
    "\n",
    "Nous allons voir ici, par l'exemple de la roulette, que l'espérance d'une variable aléatoire est une valeur très intéressante lorsque l'on veut étudier la variable, grâce à un théorème mathématique *très* important: la **loi de grands nombres**.\n",
    "\n",
    "## Un problème: la roulette française\n",
    "\n",
    "Pour cela, nous allons \"jouer\" à la roulette français (spoil: n'y jouez jamais réellement en casino). Hop, nous allons toute la classe au casino pour une sortie pédagogique, après avoir pris 18 ans chacun, et on se dirige vers la table de jeu.\n",
    "\n",
    "Un des paris que nous allons pouvoir faire, selon [ce document](https://docs.google.com/document/d/1N-QZC5zoDVxyepuI65WX1MuOofjYPJuceNRREsQyJgg/edit), c'est de parier sur la douzaine: on va parier, par exemple, que le numéro tiré sera entre 1 et 12. On va parier, disons, $10$ euros à chaque fois sur ça. Lorsque l'on gagnera, nous allons obtenir $2 \\times 10 = 20$ €, ce qui fait, en prenant en compte que l'on a dépensé $10$ €, un gain net de $20 - 10 = 10$ €.\n",
    "\n",
    "Alors, à votre avis, si l'on parie un très grand nombre de fois sur la douzaine, combien d'argent allons-nous gagner ou perdre en moyenne ? Pour le savoir, nous allons faire le test, tout simplement ! Mais puisque nous n'avons pas un porte-monnaie extensible et le temps nécessaire, et pour cause de confinement, nous n'allons pas tester tout ceci avec Python !\n",
    "\n",
    "J'en vois au fond qui sont tombés dans les pommes... Le choc émotionnel, surement... Bon, pendant que j'emmène les autres à l'infirmerie, je vous rassure tout de suite: on va faire ça pas-à-pas, et avec un harnais comme à l'accrobranche, ne vous inquiétez pas ! Ca sera aussi le moment de vous faire découvrir une notion de première spé maths: les listes. Pareil, nous allons voir ça en temps et en heure.\n",
    "\n",
    "## Simulation en Python\n",
    "\n",
    "Donc, voici notre objectif: nous allons simuler, avec Python, des tirages à la roulette. Nous allons alors, à chaque tirage, calculer le gain (ou la perte) que nous avons en moyenne pour le moment, et voir comment cette moyenne évolue."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Le module `random`\n",
    "\n",
    "Une première chose qui nous vient à l'esprit tout de suite, c'est: comment va-t-on faire pour simuler un tirage aléatoire à la roulette française ? A chaque lancers de la roulette, un nombre entre $0$ et $36$ va sortir, au hasard. Comment demander à Python de faire ça ?\n",
    "\n",
    "Pour le faire, nous allons utiliser un module spécialisé dans les **nombres pseudo-aléatoires** (pourquoi \"pseudo\" ? Parce que la Vie n'est pas parfaite, et que c'est impossible pour un ordinateur de générer des nombres parfaitement aléatoire...). Ce module s'appelle... `random` (c'est vrai, c'est pas ouf), et nous allons l'utiliser dans notre programme, en écrivant cette ligne:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Le module `random` permet pas mal de choses marrantes (voici [sa documentation](https://docs.python.org/fr/3/library/random.html), mais nous allons ici utiliser une des fonctions, la fonction `randint` qui prend deux nombres `a` et `b`, prend au hasard un nombre en `a` et `b` compris et le renvoie:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "print(random.randint(1,3))\n",
    "print(random.randint(1,3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nous pouvons, avec cette fonction, simuler un tirage à la roulette: pour cela, nous allons créer une fonction `expérience` qui, lorsqu'on l'appelle, va tirer un nombre entre $0$ et $36$ (comme à la roulette). Si ce nombre est en $1$ et $12$, on aura gagné au final $10$€. Sinon, on aura perdu $10$€. La fonction va alors nous renvoyer le gain à la fin du tirage.\n",
    "\n",
    "Voici la bête:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def expérience():\n",
    "    \"\"\"Simule un tirage à la roulette et renvoie le gain.\"\"\"\n",
    "    nombre = random.randint(0, 36)\n",
    "    if 1 <= nombre <= 12 :\n",
    "        return 10\n",
    "    else:\n",
    "        return -10"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si on la teste, on voit qu'elle fonctionne parfaitement:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "-10\n",
      "-10\n"
     ]
    }
   ],
   "source": [
    "# Vous pouvez modifier le code et le ré-exécuter en faisant Maj+Entrée.\n",
    "\n",
    "print(expérience())\n",
    "print(expérience())\n",
    "print(expérience())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### La notion de liste\n",
    "\n",
    "Maintenant, nous voudrions utiliser cette fonction pour faire un *grand* nombre de tirage et les stocker. Comment faire ? Nous pourrions créer plusieurs variables, dans lesquels il y aurait les résultats, comme ceci:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.0\n"
     ]
    }
   ],
   "source": [
    "var0 = expérience()\n",
    "var1 = expérience()\n",
    "var2 = expérience()\n",
    "var3 = expérience()\n",
    "#...\n",
    "\n",
    "print((var0 + var1 + var2 + var3) / 4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Mais vous voyez bien le problème: c'est très répétitif... Et là, on voudrait pas faire juste 4 tirages, mais 1000, voir *100000* !\n",
    "\n",
    "Nous allons donc ici utiliser les **listes**. Une **liste** est un type de données (comme un entier, une chaine de caractère ou un nombre à virgule), mais qui contient dedans un certain nombre de *\"boîtes\"*. Chaque *\"boîte\"* se voit attribuer un numéro, son **index** (la 1ere a le numéro 0, la 2eme le numéro 1, etc.). Ainsi, pour accéder à la boîte, il faudra donner son numéro, et on pourra alors avoir accès à son contenu, ou alors changer son contenu. L'intérêt est alors qu'on n'a besoin de ne créer *qu'une* liste, puis la modifier, au lieu d'avoir *plein* de variables et de devoir toutes les gérer indépendamment.\n",
    "\n",
    "Voici un exemple de liste, pour illustrer:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 5, 'un texte', -0.54, 'un autre']\n",
      "1\n",
      "5\n",
      "[1, 5, \"J'en prendrais\", -0.54, 'un autre']\n"
     ]
    }
   ],
   "source": [
    "# Vous pouvez modifier le code et le ré-exécuter en faisant Maj+Entrée.\n",
    "\n",
    "# Création de la liste\n",
    "ma_liste = [1, 5, \"un texte\", -0.54, \"un autre\"]\n",
    "\n",
    "# Affichage de toute la liste\n",
    "print(ma_liste)\n",
    "\n",
    "# Affiche le premier nombre\n",
    "print(ma_liste[0])\n",
    "\n",
    "# Affiche le deuxième\n",
    "print(ma_liste[1])\n",
    "\n",
    "# Modifie la troisème valeur\n",
    "ma_liste[2] = \"J'en prendrais\"\n",
    "\n",
    "# Affiche la liste ainsi modifiée\n",
    "print(ma_liste)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Faites bien attention à ceci: une liste de longueur $n$ contient des boîtes numérotées de $0$ à $n-1$. *C'est une erreur fréquente* lorsqu'on découvre les listes, mais vous inquiétez pas, on s'y fait.\n",
    "\n",
    "Les listes vont nous être très utiles ici: il nous suffit de créer une liste, de la taille qu'on veut, puis de la remplir avec pleins de résultats de nos tirages. Voici la fonction `liste_expérience` qui crée une liste de `taille` éléments et la remplit comme dit:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def liste_expérience(taille):\n",
    "    \"\"\"Crée une liste contenant `taille` résultats à la roulette française.\"\"\"\n",
    "    résultat = [0] * taille # Crée une liste de `taille` éléments, rempli avec des 0\n",
    "    for i in range(taille): # Pour i allant de 0 à taille-1\n",
    "        résultat[i] = expérience() # Remplit la i-éme boîte avec le résultat d'un tirage\n",
    "    return résultat # Renvoie la liste entière"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Et là, vous voyez un des intérêts de `for i in range(n)`: en effet, dans ces boucles, la valeur `i` va changer à chaque répétition et aller de `0` à `n-1`. Pratique pour remplir une liste !\n",
    "\n",
    "Et là, nous avons une certaine *satisfaction* quand on teste notre fonction:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[-10, -10, -10, 10, 10, -10, -10, -10, -10, 10, 10, -10, -10, -10, -10]\n",
      "[10, 10, -10, -10, -10, -10, -10, -10, -10, 10, -10, -10, -10, -10, -10, 10, -10, -10, -10, -10]\n"
     ]
    }
   ],
   "source": [
    "# Vous pouvez modifier le code et le ré-exécuter en faisant Maj+Entrée.\n",
    "\n",
    "print(liste_expérience(15))\n",
    "print(liste_expérience(20))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Calcul de la moyenne au cours du temps\n",
    "\n",
    "Bien, nous arrivons maintenant à avoir autant de tirages que l'on veut, ordonnés dans une liste. Passons maintenant à la deuxième étape de notre programme: nous devons calculer à chaque nouveau tirage le gain moyen pour le moment.\n",
    "\n",
    "Pour calculer cette moyenne, nous devons calculer, à chaque instant, la somme des gains et pertes (le total), puis le diviser par le nombre de tirages que nous avons fait.\n",
    "\n",
    "Une manière de calculer la moyenne à chaque instant est alors d'avoir une variable `gain_total` qui sera la somme des gains et pertes, que l'on divise par le nombre de tirages effectués. Pour chaque tirage, on ajoutera alors à `gain_total` le gain obtenu, on augmentera le nombre de tirages de 1, on calculera la moyenne et on l'ajoutera à une liste qui contiendra les moyennes successives, `liste_moyennes`.\n",
    "\n",
    "On pourrait alors avoir cet algorithme:\n",
    "\n",
    "```\n",
    "gain_total = 0\n",
    "nombre_tirages = 0\n",
    "liste_moyennes = []\n",
    "Pour chaque élément de liste_tirages:\n",
    "    Ajouter l'élément à gain_total\n",
    "    Augmenter nombre_tirages de 1\n",
    "    Ajouter à liste_moyennes la valeur (gain_total / nombre_tirages)\n",
    "```\n",
    "\n",
    "Prenez un peu de temps pour bien lire et comprendre ce que l'on vient d'écrire, car on va devoir maintenant traduire ceci en Python !\n",
    "\n",
    "Les trois premières lignes du programme sont évidentes à traduire. Les trois dernières, on peut les traduire avec un peu de réflexion (on verra ça un peu après). Mais comment faire pour la quatrième ? Vous allez être un peu supris, mais c'est très simple: `for élément in liste_tirage` !\n",
    "\n",
    "Et c'est maintenant qu'il faut lever le voile sur la boucle `for`. Depuis la seconde, nous l'avons utilisé sous cette forme, `for i in range(n)`. Cela répétait alors les instructions décalées vers la droite, et à chaque répétition, la variable `i` changeait, allant de $0$ à $n-1$. Mais en fait, on peut très bien remplacer `range` par une liste: la variable `i` va alors changer de valeur à chaque répétition, mais cette fois, elle va prendre, une par une, dans l'ordre, les valeurs contenues dans la liste !\n",
    "\n",
    "Pour mieux comprendre ça, voici un petit exemple:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "La valeur de élément est 1\n",
      "La valeur de élément est 6\n",
      "La valeur de élément est blabla\n",
      "La valeur de élément est 2.5\n"
     ]
    }
   ],
   "source": [
    "# Vous pouvez modifier le code et le ré-exécuter en faisant Maj+Entrée.\n",
    "\n",
    "liste_exemple = [1, 6, \"blabla\", 2.5]\n",
    "for élément in liste_exemple:\n",
    "    print(\"La valeur de élément est\", élément)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vous voyez ici que `élément` vaut, tour à tour, `1`, `6`, `\"blabla\"` et `2.5`.\n",
    "\n",
    "Mais alors, qu'est-ce que `range` ? C'est en fait un type spécial qui contient des valeurs dans un certain intervalle ! Il a été fait exprès par les créateurs de Python afin de l'utiliser pour des répétitions, et pour que les boucles `for i in range(n)` fonctionne un peu comme dans les autres langages (pour pas paumer les experts de C/C++ par exemple, et parce qu'il n'y a aucune raison de se révolter).\n",
    "\n",
    "Cette manière d'écrire est très pratique avec les listes: ainsi, lorsqu'on a une liste, on peut étudier ses valeurs une à une, dans l'ordre. C'est par exemple très pratique pour nous, car on a une liste de gains et pertes, dans l'ordre où elles sont tirées, et on va alors faire évoluer la moyenne.\n",
    "\n",
    "Avec ceci, on peut créer une fonction, `moyennes_successives`, qui prend une liste `liste_données`, calcule au fur et à mesure les moyennes, les ajoute dans une liste `liste_moyenne` et renvoie `liste_moyenne`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def moyennes_successives(liste_données):\n",
    "    gain_total = 0\n",
    "    nombre_tirages = 0\n",
    "    liste_moyennes = []\n",
    "    for gain in liste_données:\n",
    "        gain_total = gain_total + gain\n",
    "        nombre_tirages = nombre_tirages + 1\n",
    "        liste_moyennes.append(gain_total / nombre_tirages)\n",
    "    return liste_moyennes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vous remarquez alors la ligne `liste_moyennes.append(gain_total / nombre_tirage)`. Cette ligne permet d'ajouter à la fin `liste_moyennes` une \"boîte\", contenant `gain_total / nombre_tirages`. Il existe aussi une manière d'enlever la dernière boîte d'une liste, en écrivant `liste.pop()`.\n",
    "\n",
    "On peut alors tester cette fonction avec quelques listes (pas forcément des tirages de roulette):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1.0, 1.0, 1.0, 1.0]\n",
      "[1.0, 0.5, 0.6666666666666666]\n",
      "[]\n"
     ]
    }
   ],
   "source": [
    "# Vous pouvez modifier le code et le ré-exécuter en faisant Maj+Entrée.\n",
    "\n",
    "print(moyennes_successives([1, 1, 1, 1]))\n",
    "print(moyennes_successives([1, 0, 1]))\n",
    "print(moyennes_successives([]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Et ça fonctionne !\n",
    "\n",
    "Maintenant, c'est bon, nous avons tous ce qu'il faut pour simuler des tirages à la roulette et voir comment évolue notre gain moyen à la roulette."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Le résultat !\n",
    "\n",
    "Aaah, les allergiques de Python sont revenues ! Vous avez pas eu trop mal, pendant cette partie ? De toutes façons, c'est bientôt terminé, ne vous en faites pas !\n",
    "\n",
    "(Bon, plus sérieusement, la situation est encore assez critique pour l'intégration de Python dans les cours, trois ans après la réforme, et c'est très dommage, on peut vraiment avoir un support pédagogique (comme ici pour la loi des grands nombres) très intuitif et pratique... Enfin bon... Sachez que vous n'êtes pas seul si vous ne comprenez pas très bien la programmation Python.)\n",
    "\n",
    "Donc, vous l'attendiez tous, nous allons voir quel est le gain moyen en pariant sur la douzaine ! Je vais ici faire des tests avec de plus en plus d'essais:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10.0\n",
      "-4.4\n",
      "-3.406\n",
      "-3.453\n"
     ]
    }
   ],
   "source": [
    "# Vous pouvez modifier le code et le ré-exécuter en faisant Maj+Entrée.\n",
    "\n",
    "échantillon = liste_expérience(20000)\n",
    "moyennes = moyennes_successives(échantillon)\n",
    "\n",
    "print(moyennes[0])\n",
    "print(moyennes[99])\n",
    "print(moyennes[9999])\n",
    "print(moyennes[-1]) # Affiche la dernière valeur (-2 donne l'avant-dernier, etc.)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nous voyons alors que notre gain moyen est en fait... Une perte moyenne: nous avons perdu $-3,51$ € à chaque tirage en moyenne ! Pour 10000000 tirages, je vous laisse calculer, ça fait... $-351000000$ € au total ! Heureusement que l'on est pas allé au casino pour faire ça !\n",
    "\n",
    "Mais regardez comment évolue la moyenne au fur et à mesure que l'on augmente le nombre d'essais ! Pour cela, je reprends la liste `moyennes`, mais je vais afficher les moyennes sous forme de graphique (pas besoin de connaitre comment faire, même si faire vos propres petits graphiques peu être marrant):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "nbEssais = list(range(1, len(moyennes) + 1))\n",
    "\n",
    "plt.plot(nbEssais, moyennes)\n",
    "\n",
    "plt.xlabel(\"Nombre de tirages effectués\")\n",
    "plt.ylabel(\"Gain moyen\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Commentons ce graphique: tout d'abord, au premier tirage, la moyenne peut être soit de $-10$, soit de $10$ (logique). La moyenne va alors beaucoup changer jusqu'aux environs de 2500 essais (on voit dans cette zone de grands pics et de grand creux). Puis, la moyenne semble devenir de moins en moins changeante (puisqu'un nouveau tirage, parmi quelques milliers d'autres, va plus beaucoup influencer la moyenne), et la courbe semble se stabiliser aux alentours de $-3.5$... Comme le montre les valeurs que l'on avait calculé juste avant !\n",
    "\n",
    "La moyenne semble donc converger vers un nombre, ici $-3,5$, au fur et à mesure que l'on augmente le nombre de tirages. mais comment aurions-nous pu le savoir à l'avance, sans avoir besoin de simuler plusieurs milliers de tirages à la roulette ?\n",
    "\n",
    "C'est là qu'il faut invoquer un des Pokémons légendaires des probabilités: j'ai nommé... la loi des grands nombres !\n",
    "\n",
    "## La loi des grands nombres\n",
    "\n",
    "Cette loi est très importante en statistique: en effet, elle nous montre un moyen de savoir vers quel résultat moyen on va tendre en réaliser un grand nombre de fois (d'où son nom) une expérience aléatoire.\n",
    "\n",
    "En effet, cette loi nous dit ceci:\n",
    "\n",
    "> Lorsque le nombre $n$ d'observations à l'issue d'une expérience aléatoire tend vers l'infini, la moyenne de ces observations s'approche de l'espérance de l'expérience.\n",
    "\n",
    "Autrement dit, lorsque que $n$ tend vers l'infini, la moyenne de $n$ observations d'une variable $G$ tend vers $E(G) = \\sum_{i=0}^{n} P(G=x_i)x_i$, avec $x_0$, $x_1$, $x_2$... les différentes valeurs possibles de $G$.\n",
    "\n",
    "C'est très intéressant, car cela nous permet, comme expliqué dans [cette vidéo](https://www.youtube.com/watch?v=HRnYFpdR8WM), de voir, dans un aléatoire par définition imprévisible, une forme de régularité et de certitude sur le long terme. Pour peu que le nombre de fois qu'on fait le test est suffisament grand, on peut imaginer que l'on aura en moyenne la même valeur.\n",
    "\n",
    "C'est un phénomène que l'on retrouve au quotidien, dans la vie de tous les jours. Par exemple, la pression au baromètre, le courant électrique dans une lampe, les températures... changent en réalité à chaque centième de millisecondes, voir encore plus, mais lorsque l'on fait une observation sur un dizième de seconde par exemple, on aura une valeur moyenne qui change au final presque jamais, d'un dizième à l'autre. Sinon, imaginez votre thermomètre faire des allers-retours incessants, ou votre ampoule griller car elle s'allume et s'éteind sans cesse, et ça tout le temps !\n",
    "\n",
    "Mais revenons à notre roulette: selon cette loi, notre gain moyen à la roulette tend bien vers un nombre précis (ça parait bête, mais on aurait pu juste avoir ces résultats par pur hasard), et ce nombre est l'espérance de la variable aléatoire du gain à la roulette.\n",
    "\n",
    "Ainsi, il nous suffit de calculer l'espérance pour voir vers quoi tend ce gain moyen ! On dresse un petit tableau de la variable, et on fait le calcul:\n",
    "\n",
    "| $G$ | $-10$ | $10$ |\n",
    "| --- | --- | --- |\n",
    "|$P(G=...) =$ | $\\frac{12}{37}$ | $\\frac{25}{37}$ |\n",
    "\n",
    "Calcul de l'espérance:\n",
    "\n",
    "$$\n",
    "E(G) = P(G = 10) \\times 10 + P(G = -10) \\times (-10) \\\\\n",
    "E(G) = \\frac{12}{37} \\times 10 + \\frac{25}{37} \\times (-10) \\\\\n",
    "E(G) = \\frac{-130}{37} \\\\\n",
    "E(G) \\approx -3,5135\n",
    "$$\n",
    "\n",
    "Ainsi, selon la loi des grands nombres, le gain moyen va tendre, en jouent un grand nombre de fois, vers $-3,5135$ € environ. Donc, on a la triste nouvelle que l'on perdra notre argent à beaucoup y jouer...\n",
    "\n",
    "Remarquez bien qu'avec 20000 tirages, nous avons obtenu un résultat assez proche de cette espérance ! La loi des grands nombres est bien confirmé ici: plus l'on fait de tirage à la roulette, plus la moyenne est proche de l'espérance."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}