Loi des grands nombres.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 successifs à la roulette. Nous allons alors faire la moyenne des gains (ou pertes) et voir combien nous allons gagner si l'on fait ça plusieurs fois."
   ]
  },
  {
   "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": [
      "1\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": [
      "-5.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": [
    "### La joie des listes\n",
    "\n",
    "Et maintenant, dernière chose à faire dans notre simulation: à partir de la liste de nos tirages, nous devons faire la **moyenne** des résultats, pour savoir ce que l'on gagne en moyenne. Nous devons donc faire la moyenne d'une liste.\n",
    "\n",
    "Pour faire la moyenne d'un ensemble de valeur, on doit diviser la **somme** de chaque valeur par **le nombre de valeurs** que l'on a. Alors, déjà, comment connaitre le nombre de valeurs que l'on a dans notre liste ? C'est très simple: la fonction qui nous permet de faire ça, très pratique, est `len` ! Voici un exemple:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n"
     ]
    }
   ],
   "source": [
    "# Vous pouvez modifier le code et le ré-exécuter en faisant Maj+Entrée.\n",
    "\n",
    "ma_liste = [1, 3, 5, 1, 7]\n",
    "print(len(ma_liste)) # Affiche la taille de la liste"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Maintenant, deuxième question: comment nous allons calculer la **somme** des nombres de la liste ? La question est au final assez simple: créons une variable `somme` et ajoutons dedans chaque valeur de la liste. Un peu comme ça:\n",
    "\n",
    "```\n",
    "somme = 0\n",
    "Pour chaque valeur dans la liste:\n",
    "     Ajouter la valeur à `somme`\n",
    "```\n",
    "\n",
    "Traduisons maintenant ça en Python. La première ligne est évidente, la troisième est `somme = somme + valeur`, mais comment faire pour la deuxième ? Vous allez être encore une fois très satisfait, car il suffit d'écrire `for valeur in liste` !\n",
    "\n",
    "En effet, la boucle `for` ne sert pas qu'à faire `for i in range(n)`, mais aussi à faire `for element in ensemble` ! Dans ce cas, la variable `element` va changer à chaque itération, et avoir successivement toutes les valeurs contenus dans `ensemble` ! On l'utilisais alors avec `range`, qui est en réalité un objet imaginé spécialement et qui contient les valeurs sur un certain intervalle, comme entre $0$ et $n-1$ par exemple.\n",
    "\n",
    "Voici un exemple pour mieux comprendre:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "5\n",
      "un texte\n",
      "-0.54\n",
      "un autre\n"
     ]
    }
   ],
   "source": [
    "# Vous pouvez modifier le code et le ré-exécuter en faisant Maj+Entrée.\n",
    "\n",
    "ma_liste = [1, 5, \"un texte\", -0.54, \"un autre\"]\n",
    "for élément in ma_liste:\n",
    "    print(élément)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Quelle bonne surprise, non ?\n",
    "\n",
    "Cette notation va nous être *très utile* ici, car on peut écrire un programme pour avoir la somme des valeurs d'une liste:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "17\n"
     ]
    }
   ],
   "source": [
    "# Vous pouvez modifier le code et le ré-exécuter en faisant Maj+Entrée.\n",
    "\n",
    "ma_liste = [1, 3, 5, 1, 7]\n",
    "somme = 0\n",
    "for élément in ma_liste:\n",
    "    somme = somme + élément\n",
    "print(somme)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nous pouvons donc écrire une fonction `moyenne` qui prend une liste `liste` et calcule la moyenne de ses éléments.\n",
    "\n",
    "Mais avant de la regarder, je vous conseille d'essayer de l'écrire vous-même. Oui, oui ! C'est un entraînement classique et intéressant pour bien comprendre la notion de liste, et voir l'intérêt qu'elles ont. Il faut certes réfléchir un peu, mais quand vous trouvez (reprenez tout ce qu'on a vu pour ça), vous serez satisfaits, et vous verrez que c'est bien plus pratique que si l'on devait créer une variable par nombre et en faire la moyenne directement.\n",
    "\n",
    "Bon, voici une correction à cette exercice improvisé:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def moyenne(liste):\n",
    "    \"\"\"Calcule la moyenne de la liste.\"\"\"\n",
    "    nb_éléments = len(liste)\n",
    "    somme = 0\n",
    "    for élément in liste:\n",
    "        somme = somme + élément\n",
    "    return somme / nb_éléments"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Et voilà, nous avons tout ce qu'il nous faut: nous pouvons simuler autant de tirage à la roulette que l'on veut, mettre tous les résultats dans une liste et calculer le gain moyen !\n",
    "\n",
    "Mais avant de voir les résultats, j'ai juste envie de terminer cette découverte des listes: il existe *une autre manière*, encore plus simple, de créer la fonction `moyenne`. Eh oui, je ne vous l'avais pas dit tout de suite pour que l'on fasse le détour par la boucle `for`, mais il existe en faite une fonction déjà toute faite pour calculer la somme des valeurs d'une liste: la fonction `sum(liste)`... Maintenant que vous savez ça, vous pouvez raccourcir l'écriture de la fonction sur deux lignes:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Paf ! Deux lignes !\n",
    "def moyenne(liste):\n",
    "    \"\"\"Calcule la moyenne de la liste\"\"\"\n",
    "    return sum(liste) / len(liste)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Le résultat !\n",
    "\n",
    "Aaah, nos victimes 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": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test (10 essais): -6.0\n",
      "Test (1000 essais): -3.62\n",
      "Test (100000 essais): -3.482\n",
      "Test (10000000 essais): -3.508958\n"
     ]
    }
   ],
   "source": [
    "# Vous pouvez modifier le code et le ré-exécuter en faisant Maj+Entrée.\n",
    "\n",
    "échantillon_1 = liste_expérience(10)\n",
    "moyenne_1 = moyenne(échantillon_1)\n",
    "print(\"Test (10 essais):\", moyenne_1)\n",
    "\n",
    "échantillon_2 = liste_expérience(1000)\n",
    "moyenne_2 = moyenne(échantillon_2)\n",
    "print(\"Test (1000 essais):\", moyenne_2)\n",
    "\n",
    "échantillon_3 = liste_expérience(100000)\n",
    "moyenne_3 = moyenne(échantillon_3)\n",
    "print(\"Test (100000 essais):\", moyenne_3)\n",
    "\n",
    "échantillon_4 = liste_expérience(10000000)\n",
    "moyenne_4 = moyenne(échantillon_4)\n",
    "print(\"Test (10000000 essais):\", moyenne_4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nous voyons alors que notre gain moyen est en fait... Une perte moyenne: nous avons perdu $-3,514862$ € à chaque tirage en moyenne ! Pour 10000000 tirages, je vous laisse calculer, ça fait... $-35148620$ € 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: il est au début assez différent de $-3,51$€, puis s'en rapproche de plus en plus... Mais comment nous aurions pu prévoir, sans aucune simulation, que cela se rapprocherait de cette valeur ?\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",
    "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",
    "Par exemple, la pression d'un gaz, le courant électrique dans un fil, les températures... changent en réalité chaque centième de millisecondes, voir encore plus, mais lorsque l'on fait une mesure sur une seconde entière, on aura une valeur moyenne qui change au final jamais en une seconde. Sinon, imaginez votre thermomètre faire des allers-retours incessants et très rapides !\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 10000000 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
}