4 missions · 1 h 10 · Python dans le navigateur, rien à installer
Taille du code
Exercice notéTP noté du chapitre 1 · par groupes
Combien mettre en Bourse ?
Un client place 100 000 € pendant dix ans : combien en Bourse ?
Vous simulez ses 10 000 avenirs en Python.
Vous signez un conseil et le défendez, avec sa marge.
Ouvert en classe le jeudi 19 novembre à 19 h 05. À rendre le vendredi 20 novembre 2026 avant 23 h 59, par e‑mail à l’enseignant (adresse donnée en séance).
Mesurer une chance en comptant les parties gagnées
L'énigme
Python démarre dans la page…
1L'énigme
1654. Le chevalier de Méré, un joueur, propose deux paris. Pari A : on lance un dé 4 fois ; on gagne la partie si au moins un six sort. Pari B : on lance deux dés 24 fois ; on gagne si au moins un double six sort (deux six d’un coup). Pour Méré, c’est pareil : 4 lancers pour 6 faces, c’est comme 24 lancers pour les 36 résultats de deux dés. Pourtant, on raconte qu’il perdait au pari B. Il interroge le mathématicien Blaise Pascal. Les deux paris gagnent-ils aussi souvent ?
2Votre pari
À votre avis, quel pari gagne le plus souvent ?
Le pari A gagne 51,77 % des parties, le pari B 49,14 %. L’écart est mince : moins de trois points.
C’est l’inverse : le pari A gagne 51,77 % des parties, le pari B 49,14 %. Le pari B perd même plus souvent qu’il ne gagne.
C’est le raisonnement de Méré, et il est faux : le pari A gagne 51,77 % des parties, le pari B 49,14 %. Les deux paris donnent en moyenne autant de succès par partie (deux tiers de six au pari A, deux tiers de double six au pari B), mais pas la même chance d’en avoir au moins un.
Choisissez, puis verrouillez : on ne revient pas sur un pari.
3L'expérience
Verrouillez d'abord votre pari.
4La formule du cours
Elle s’ouvre quand votre pari est verrouillé : elle ne doit rien vous souffler.
Case 1 de la fiche
p^=Nk
p chapeau égale k sur N : le nombre k de parties gagnées, divisé par le nombre N de parties jouées. Le chapeau veut dire « mesuré » : p, sans chapeau, est la vraie chance, celle du compte exact.
Pourquoi cette formule.Une probabilité est une proportion : la part des parties gagnées s’approche de la vraie chance à mesure que l’on joue.
À la fin de cette mission, vous savez :
mesurer une probabilité en simulant, c’est-à-dire en faisant jouer l’ordinateur au hasard : N parties, k gagnées, la part k/N
calculer cette part en une ligne de Python : la moyenne d’un tableau de True et de False (vrai, faux)
expliquer pourquoi deux chances proches demandent beaucoup de parties pour être départagées
5À vous de coder
La cellule ci-dessous, le cadre de code, joue déjà 1 000 parties de chaque pari, avec des dés tirés au hasard. Elle range le résultat dans deux tableaux : des suites de cases, une case par partie. Dans gagne_A, une case vaut True (vrai) si la partie du pari A est gagnée, False (faux) sinon ; gagne_B fait de même pour le pari B. À vous d’écrire les deux lignes marquées « À vous », puis d’exécuter la cellule.
À la ligne p_A = None, remplacez None, qui veut dire « rien encore », par la part des parties gagnées au pari A : le nombre de parties gagnées divisé par le nombre de parties jouées (la formule k/N du cours). C’est un nombre entre 0 et 1, que le signe = range sous le nom p_A.
Faites de même à la ligne p_B = None, avec gagne_B.
Exécutez la cellule : la scène joue vos parties et affiche vos deux parts.
Python en clair
np.array([True, False, True])
un tableau, écrit ici à la main : des valeurs rangées à la suite, une par case (np désigne NumPy, la boîte à outils de calcul chargée au début du TP). gagne_A est un tableau de 1 000 cases, une par partie : True (vrai) si la partie est gagnée, False (faux) sinon.
True, False
vrai, faux. Dans un calcul, Python compte True pour 1 et False pour 0.ExempleTrue + True + False→donne2
x.sum()
la somme des valeurs du tableau x (sum veut dire « somme » en anglais). Ici, x désigne n’importe quel tableau : le point applique l’opération à x, et les parenthèses, vides, lancent le calcul. Sur des True et des False, la somme est le nombre de True.Exemplenp.array([True, False, True]).sum()→donne2
x.mean()
la moyenne des valeurs du tableau x, c’est-à-dire leur somme divisée par leur nombre (mean veut dire « moyenne »). Sur des True et des False, c’est la part de True : un nombre entre 0 et 1. Python écrit les nombres décimaux avec un point au lieu de la virgule.Exemplenp.array([True, False, True]).mean()→donne0.6666666666666666
# Ces lignes jouent les parties : elles sont prêtes, rien à y changer.# rng tire les nombres au hasard ; la graine 1654 donne les mêmes dés à tout le monde.rng = np.random.default_rng(1654)N = 1_000 # parties jouées à chaque pari (1_000 se lit 1000)des_A = rng.integers(1, 7, size=(N, 4)) # pari A : N parties de 4 lancers, faces 1 à 6 (7 exclu)gagne_A = (des_A == 6).any(axis=1) # pour chaque partie : True si l'un des 4 dés vaut 6des_B = rng.integers(1, 7, size=(N, 24, 2)) # pari B : N parties de 24 lancers de deux désgagne_B = (des_B == 6).all(axis=2).any(axis=1) # True si l'un des 24 lancers donne deux six# Vos deux lignes : la part des parties gagnées à chaque pari.p_A = None # À vous : la part des parties gagnées au pari A, entre 0 et 1p_B = None # À vous : la part des parties gagnées au pari B, entre 0 et 1# La scène joue vos parties et affiche vos deux parts ; print les écrit sous la cellule.montrer("des", des_A=des_A[:60], gagne_A=gagne_A, estimation_A=p_A, des_B=des_B[:20], gagne_B=gagne_B, estimation_B=p_B)print("pari A :", p_A, " pari B :", p_B)
Maj + Entrée
Sur vos 1 000 parties de chaque pari, le pari A gagne 53,1 % des parties, le pari B 50,7 % : le pari A mène, de peu. Ce sont des mesures : avec d’autres dés, tirés avec une autre graine, vous trouveriez des parts un peu différentes. La révélation donne le compte exact.
1L'idée
La part des parties gagnées, c’est la moyenne des True et des False, quand on compte True pour 1 et False pour 0.
2La ligne à trous
p_A = gagne_A.____() et p_B = ______.mean()
3La solution
p_A = gagne_A.mean() et p_B = gagne_B.mean(). Sur un tableau de True et de False, la moyenne compte True pour 1 et False pour 0 : c’est la part des parties gagnées.
# Ces lignes jouent les parties : elles sont prêtes, rien à y changer.# rng tire les nombres au hasard ; la graine 1654 donne les mêmes dés à tout le monde.rng = np.random.default_rng(1654)N = 1_000 # parties jouées à chaque pari (1_000 se lit 1000)des_A = rng.integers(1, 7, size=(N, 4)) # pari A : N parties de 4 lancers, faces 1 à 6 (7 exclu)gagne_A = (des_A == 6).any(axis=1) # pour chaque partie : True si l'un des 4 dés vaut 6des_B = rng.integers(1, 7, size=(N, 24, 2)) # pari B : N parties de 24 lancers de deux désgagne_B = (des_B == 6).all(axis=2).any(axis=1) # True si l'un des 24 lancers donne deux six# Vos deux lignes : la part des parties gagnées à chaque pari.p_A = gagne_A.mean() # À vous : la part des parties gagnées au pari A, entre 0 et 1p_B = gagne_B.mean() # À vous : la part des parties gagnées au pari B, entre 0 et 1# La scène joue vos parties et affiche vos deux parts ; print les écrit sous la cellule.montrer("des", des_A=des_A[:60], gagne_A=gagne_A, estimation_A=p_A, des_B=des_B[:20], gagne_B=gagne_B, estimation_B=p_B)print("pari A :", p_A, " pari B :", p_B)
6La révélation
Verrouillez d'abord votre pari.
Le compte exact : 51,77 % pour le pari A, 49,14 % pour le pari B.
Ce que vous avez découvert : le pari A gagne un peu plus souvent que le pari B, contrairement à ce que pensait Méré. Le juge, ici, est le compte exact, car on sait compter tous les cas par un calcul. Avec 4 lancers d’un dé, il y a 6 × 6 × 6 × 6 = 1 296 suites de faces possibles, toutes aussi probables. Celles qui n’ont aucun six se comptent d’un coup : 5 faces permises à chaque lancer, soit 5 × 5 × 5 × 5 = 625. Les 671 autres gagnent : 671 sur 1 296, soit 51,77 %. Le même calcul donne 49,14 % pour le pari B. L’écart, 2,63 points, est mince : si l’on rejouait souvent vos 1 000 parties de chaque pari, avec d’autres dés, le pari B ferait au moins aussi bien que le pari A une fois sur huit environ (12,4 %). Pascal raconte l’affaire au mathématicien Pierre de Fermat le 29 juillet 1654 : « comme de 671 à 625 », écrit-il, c’est-à-dire 671 suites gagnantes contre 625 perdantes. Leur correspondance est souvent tenue pour la naissance du calcul des probabilités.
7Comprendrepourquoi ceci, et pas cela
3 questions « pourquoi », avec leur réponse. Elles s’ouvrent quand votre pari est verrouillé : elles ne doivent rien vous souffler.
1Pourquoi une moyenne, et pas une somme ?
Une probabilité, c’est une proportion. Sur vos 1 000 parties du pari A, 531 sont gagnées : 531 sur 1 000, soit 53,1 %. Notez 1 une partie gagnée et 0 une partie perdue : cette part est exactement la moyenne des 1 et des 0. La somme, 531, grandit avec le nombre de parties : jouez-en deux fois plus, elle double à peu près. La moyenne, non : elle reste près de la vraie chance, 51,77 %, et s’en approche à mesure que l’on joue. C’est donc elle qui mesure la chance.
En Python
Sur le tableau des True et des False, .sum() donne le nombre de parties gagnées (531) et .mean() leur part, que Python écrit 0.531 : le point y remplace la virgule.
En finance
Le prix d’une option, un contrat dont le gain dépend du prix futur d’une action, se calcule lui aussi par une moyenne sur les avenirs simulés, et non par une somme (mission 3). Un assureur mesure de même la fréquence des sinistres, les dommages qu’il rembourse : le nombre de sinistres divisé par le nombre de contrats.
2Pourquoi la règle de Méré, 4 sur 6 comme 24 sur 36, est-elle fausse ?
Sa règle mesure en fait le nombre moyen de succès par partie. Pari A : 4 lancers × 1 chance sur 6, soit deux tiers de six par partie ; pari B : 24 lancers × 1 chance sur 36, soit deux tiers de double six. Sur ce point, Méré a raison : les deux moyennes sont égales. Mais une partie est gagnée dès le premier succès : deux six dans la même partie ne la font pas gagner deux fois. Il faut donc regarder la chance de n’avoir aucun succès. Les lancers sont indépendants (le résultat de l’un ne dépend pas des autres), donc leurs chances se multiplient : (5/6)^4 = 48,23 % de perdre au pari A, (35/36)^24 = 50,86 % au pari B. On gagne le reste du temps : 51,77 % et 49,14 %.
En Python
La chance exacte de gagner au pari A s’écrit 1 - (5/6)**4, où ** est la puissance. La cellule du rebondissement l’écrit 1 - 5**4 / 6**4, ce qui revient au même.
En finance
En crédit, un prêt fait défaut quand l’emprunteur ne rembourse pas. Quatre prêts qui font défaut chacun une fois sur 6, ou vingt-quatre prêts qui font défaut chacun une fois sur 36, donnent en moyenne autant de défauts, mais pas la même chance d’en subir au moins un : 51,77 % contre 49,14 %, si les défauts sont indépendants.
3Pourquoi simuler, plutôt que compter toutes les possibilités ?
Pour le pari A, on peut tout compter : 4 lancers d’un dé donnent 1 296 suites possibles, et 671 contiennent au moins un six. Pour le pari B, 24 lancers de deux dés donnent 36^24 suites, un nombre à 38 chiffres : aucun ordinateur ne peut les passer en revue une à une. Pascal trouve quand même la réponse exacte, par une astuce de calcul : la chance de n’avoir aucun double six, (35/36)^24. La plupart des problèmes réels n’ont pas d’astuce de ce genre. La simulation n’en demande aucune : on joue, puis on compte. Vos 1 000 parties donnent 53,1 % au pari A, à 1,3 point du compte exact, et cette précision ne dépend pas du nombre de suites possibles.
En Python
La simulation tient en deux lignes de la cellule : rng.integers(1, 7, size=(N, 4)) lance les 4 dés de chacune des N parties, et (des_A == 6).any(axis=1) regarde, partie par partie, si l’un des dés vaut 6. Aucune liste de cas n’est écrite.
En finance
Le gain de nombreux produits financiers dépend de tout le chemin du marché, jour après jour : les avenirs possibles sont innombrables, et souvent aucune formule ne les résume. Banques et assureurs simulent alors des milliers d’avenirs : vous le ferez pour une option (mission 3) et pour un assureur (mission 4).
8Et si… ?pour qui a fini : une variante, qui prépare la suite
Et si Méré avait voulu voir l’écart en jouant, sans rien calculer ? À la table, un joueur ne voit que ses propres parties. Imaginez des « saisons » : une saison, ce sont cent parties de chaque pari. Ce qui change : la cellule joue 10 000 saisons ; pour chacune, k_A donne le nombre de parties gagnées au pari A, sur cent, et k_B au pari B. La question : dans quelle part des saisons le mauvais pari, B, gagne-t-il plus de parties que le bon ? L’intérêt : savoir si un joueur pouvait sentir, à la table, un écart de 2,63 points.
À la ligne devant_A = None, remplacez None par un tableau qui vaut True pour chaque saison où le pari A gagne plus de parties que le pari B.
À la ligne devant_B = None, faites de même pour les saisons où le pari B gagne plus de parties que le pari A. Une égalité ne compte pour aucun des deux.
Exécutez la cellule : la scène compte les saisons où chaque pari mène.
Python en clair
a > b
compare deux tableaux de même taille, case par case : True là où la valeur de a est strictement plus grande que celle de b, False ailleurs. Une égalité donne donc False. Pour inclure les égalités parmi les succès de A, écrivez a >= b. Pour compter les égalités seules, écrivez a == b.Exemplenp.array([52, 47, 50]) > np.array([49, 51, 50])→donne[ True False False]
# Ces lignes jouent les saisons : elles sont prêtes, rien à y changer.rng = np.random.default_rng(1655)saisons = 10_000 # dix mille saisons de 100 parties de chaque parik_A = rng.binomial(100, 1 - 5**4 / 6**4, saisons) # parties gagnées au pari A, saison par saisonk_B = rng.binomial(100, 1 - 35**24 / 36**24, saisons) # parties gagnées au pari B, saison par saison# binomial : les parties gagnées sur 100, chacune avec la chance exacte du pari (** : la puissance).devant_A = None # À vous : True pour chaque saison où le pari A gagne plus de parties que le pari Bdevant_B = None # À vous : True pour chaque saison où le pari B gagne plus de parties que le pari A# La scène compte les saisons où chaque pari mène.montrer("des", gagne_A=devant_A, gagne_B=devant_B, params={"etiquettes": ["Saisons où A mène", "Saisons où B mène"], "jauge": [0.0, 1.0]})
Maj + Entrée
Le pari B mène dans 33,3 % des saisons, le pari A dans 61,4 % ; les autres saisons sont des égalités. Le calcul exact donne 32,9 % pour le pari B. Une saison sur trois environ, le hasard fait donc mener le mauvais pari : cent parties ne suffisent pas pour sentir un écart de 2,63 points. Combien en faut-il ? La mission 2 mesure ce que coûte la précision.
1L'idée
Comparez les deux tableaux saison par saison : le signe > le fait pour toutes les saisons d’un coup, et donne un True ou un False par saison.
2La ligne à trous
devant_A = k_A > ___ et devant_B = ___ > k_A
3La solution
devant_A = k_A > k_B et devant_B = k_B > k_A. Le signe > compare les deux tableaux case par case ; une égalité donne False, elle ne compte donc pour aucun des deux paris.
# Ces lignes jouent les saisons : elles sont prêtes, rien à y changer.rng = np.random.default_rng(1655)saisons = 10_000 # dix mille saisons de 100 parties de chaque parik_A = rng.binomial(100, 1 - 5**4 / 6**4, saisons) # parties gagnées au pari A, saison par saisonk_B = rng.binomial(100, 1 - 35**24 / 36**24, saisons) # parties gagnées au pari B, saison par saison# binomial : les parties gagnées sur 100, chacune avec la chance exacte du pari (** : la puissance).devant_A = k_A > k_B # À vous : True pour chaque saison où le pari A gagne plus de parties que le pari Bdevant_B = k_B > k_A # À vous : True pour chaque saison où le pari B gagne plus de parties que le pari A# La scène compte les saisons où chaque pari mène.montrer("des", gagne_A=devant_A, gagne_B=devant_B, params={"etiquettes": ["Saisons où A mène", "Saisons où B mène"], "jauge": [0.0, 1.0]})
9À retenir, et je signe
Une probabilité se mesure en comptant la part des parties gagnées ; un petit écart entre deux chances demande beaucoup de parties pour se voir.
Une phrase modèle
Le pari A est le meilleur : 53,1 % de parties gagnées contre 50,7 % pour le pari B sur mes 1 000 parties, et 51,77 % contre 49,14 % au compte exact.
Mission 2 sur 4
Niveau 2 15 min
π, et le prix d’une décimale
Savoir ce que coûte la précision
L'énigme
Python démarre dans la page…
1L'énigme
Dans le film, 3 200 fléchettes tombent au hasard dans un carré, et l’on compte celles qui tombent dans un quart de disque. On en tire π ≈ 3,13 : une seule décimale juste. Une estimation s’annonce avec sa marge, un « plus ou moins » qui dit de combien elle peut se tromper : environ 95 fois sur 100, l’estimation tombe à moins d’une marge de la vraie valeur. Viser une décimale de précision supplémentaire, c’est demander une marge dix fois plus petite. La question : combien de fois plus de fléchettes faut-il pour cela ?
2Votre pari
À votre avis, avec quatre fois plus de fléchettes, la marge est divisée par combien ?
Ce serait le cas si la marge baissait comme un sur N, le nombre de fléchettes. Elle baisse comme un sur sa racine, √N : quatre fois plus de fléchettes la divisent par √4 = 2.
La marge baisse comme un sur la racine du nombre de fléchettes : quatre fois plus de fléchettes la divisent par √4 = 2. Pour la diviser par 10, il en faut donc cent fois plus.
Ce serait le cas si la marge baissait comme un sur N², le carré du nombre de fléchettes. Elle baisse comme un sur sa racine, √N : quatre fois plus de fléchettes la divisent par √4 = 2.
Choisissez, puis verrouillez : on ne revient pas sur un pari.
3L'expérience
Verrouillez d'abord votre pari.
4Les formules du cours
Elles s’ouvrent quand votre pari est verrouillé : elles ne doivent rien vous souffler.
Case 3 de la fiche
erreur typique=Nσ
L’erreur typique d’une moyenne de N tirages (ici, N fléchettes) : l’écart habituel entre cette moyenne et la vraie valeur. Elle vaut σ divisé par la racine de N, où σ, l’écart-type d’un seul tirage, mesure de combien un tirage s’écarte d’habitude de la moyenne.
Pourquoi cette formule.Les écarts de tirages indépendants ne vont pas tous dans le même sens : l’écart de leur somme ne grandit que comme √N, si bien que celui de la moyenne, la somme divisée par N, baisse comme 1/√N.
Case 4 de la fiche
estimation±1,96Nσ^
L’estimation, plus ou moins 1,96 fois σ̂ divisé par la racine de N. Ce « plus ou moins » est la marge à 95 % ; il dessine une fourchette autour de l’estimation, l’intervalle de confiance de la fiche. σ̂, « sigma chapeau », est l’écart-type mesuré sur les tirages.
Pourquoi cette formule.Quand N est grand, les estimations se répartissent en cloche autour de la vraie valeur, et environ 95 % d’entre elles tombent à moins de 1,96 erreur typique ; σ, inconnu, y est remplacé par sa mesure σ̂.
À la fin de cette mission, vous savez :
estimer π en comptant les fléchettes tombées au hasard dans un quart de disque
compléter et appeler une fonction, estimer, qui donne la moyenne de tirages et sa marge à 95 %
dire ce que coûte une décimale de plus : cent fois plus de tirages
5À vous de coder
Étape 1 sur 2
Les 3 200 fléchettes du film sont déjà lancées dans le carré, d’aire 1 ; pour chacune, dedans vaut True si elle tombe dans le quart de disque, d’aire π/4, et False sinon. Le nom pi_hat se lit « pi chapeau » (hat veut dire chapeau en anglais) : comme dans le cours, le chapeau signale une valeur mesurée.
À la ligne pi_hat = None, remplacez None, qui veut dire « rien encore », par une estimation de π tirée de dedans.
Exécutez la cellule : la scène compte vos fléchettes et affiche votre estimation.
Python en clair
x.mean()
déjà vu en mission 1 : la moyenne des valeurs de x. Sur un tableau de True et de False, True compte 1 et False compte 0 : la moyenne est la part des True.Exemplenp.array([True, True, False, True]).mean()→donne0.75
a * b
a fois b : en Python, le signe « fois » s’écrit *, comme dans Excel.Exemple3 * 0.25→donne0.75
rng = np.random.default_rng(21) # le hasard, fixé par la graine 21 : les fléchettes du filmN = 3_200 # le nombre de fléchettes (le _ sépare les milliers : 3 200)x, y = rng.random((N, 2)).T # N points au hasard dans le carré : x et y, leurs coordonnéesdedans = x**2 + y**2 <= 1 # True si x² + y² ≤ 1 : dans le quart de disque (aire π/4)pi_hat = None # À vous : l'estimation de π, tirée de dedans# la scène dessine vos fléchettes et affiche votre estimationmontrer("flechettes", x=x, y=y, dedans=dedans, estimation=pi_hat)print("π estimé :", pi_hat)
Maj + Entrée
Vous retrouvez le chiffre du film : 2 505 fléchettes dedans sur 3 200, soit π ≈ 3,13125. Une seule décimale est juste.
1L'idée
Chaque fléchette tombe dans le quart de disque avec une probabilité égale à son aire, π/4. La part des fléchettes dedans estime donc π/4 : il reste à en tirer π.
2La ligne à trous
pi_hat = _ * dedans.mean()
3La solution
pi_hat = 4 * dedans.mean() : la moyenne de dedans est la part des fléchettes dedans, qui estime π/4 ; quatre fois cette part estime donc π.
rng = np.random.default_rng(21) # le hasard, fixé par la graine 21 : les fléchettes du filmN = 3_200 # le nombre de fléchettes (le _ sépare les milliers : 3 200)x, y = rng.random((N, 2)).T # N points au hasard dans le carré : x et y, leurs coordonnéesdedans = x**2 + y**2 <= 1 # True si x² + y² ≤ 1 : dans le quart de disque (aire π/4)pi_hat = 4 * dedans.mean() # À vous : l'estimation de π, tirée de dedans# la scène dessine vos fléchettes et affiche votre estimationmontrer("flechettes", x=x, y=y, dedans=dedans, estimation=pi_hat)print("π estimé :", pi_hat)
Étape 2 sur 2
La fonction estimer est déjà commencée : elle reçoit des tirages, appelés x, compte leur nombre N et calcule leur moyenne.
À la ligne marge = np.nan, remplacez np.nan, « pas un nombre », par la marge à 95 % de la formule du cours, 1,96 σ̂/√N : 1,96 fois l’écart-type des tirages, divisé par la racine de N.
Exécutez la cellule : elle applique votre fonction à vos 3 200 fléchettes, comptées 4 si elles tombent dedans et 0 sinon, puis trace l’erreur mesurée (l’écart-type de 200 estimations de π) pour 5 nombres de fléchettes.
Sur le site, lisez le graphique. Dans le carnet de secours, lisez la pente affichée : l’enseignant peut projeter la courbe du corrigé. Les axes du graphique sont logarithmiques : de 100 à 1 000 ou de 1 000 à 10 000, la distance est la même. Une erreur qui baisse comme une puissance de N y dessine donc une droite, dont la pente est cette puissance.
Python en clair
def estimer(x): … return …
une fonction : un calcul qui porte un nom. def la crée ; x désigne les tirages qu’on lui donnera ; return dit ce qu’elle rend. Les lignes décalées de quatre espaces forment son corps : gardez ce décalage dans votre ligne. On s’en sert en l’appelant par son nom, les tirages entre parenthèses, comme len(x), qui compte les valeurs de x : estimer(4 * dedans) fait le calcul sur vos fléchettes.
x.std()
l’écart-type des valeurs de x : de combien une valeur s’écarte d’habitude de leur moyenne (dans Excel, ECARTYPE.PEARSON). Dans l’exemple, comme pour une fléchette, chaque valeur vaut 4 ou 0.Exemplenp.array([4, 4, 0, 4]).std()→donne1.7320508075688772
np.sqrt(N)
la racine carrée de N (dans Excel, RACINE) ; np désigne NumPy, la boîte à outils de calcul.Exemplenp.sqrt(400)→donne20.0
1.96 * a / b
comme en mission 1, un nombre décimal s’écrit avec un point : 1.96, et non 1,96. Le calcul se lit de gauche à droite : 1,96 fois a, puis le tout divisé par b.Exemple1.96 * 10 / 4→donne4.9
def estimer(x): # une fonction : x, les tirages qu'on lui donne """La moyenne des tirages x, et sa marge à 95 %. Cette fonction vous servira jusqu'à la séance 7.""" x = np.asarray(x, dtype=float) # en tableau de nombres (True vaut 1, False 0) N = len(x) # le nombre de tirages moyenne = x.mean() # leur moyenne : l'estimation marge = np.nan # À vous : 1,96 fois l'écart-type des tirages, divisé par la racine de N return float(moyenne), float(marge) # la fonction rend deux nombrespi_hat, marge = estimer(4 * dedans) # vos 3 200 fléchettes : 4 si dedans, 0 sinonprint("π ≈", pi_hat, "±", marge)# Ensuite, rien à écrire : l'erreur mesurée. Pour chaque nombre de fléchettes n, la cellule refait# l'expérience 200 fois ; l'erreur est l'écart-type de ces 200 estimations de π.rng = np.random.default_rng(1812) # un nouveau hasard, pour des expériences neuvestailles = [100, 400, 1_600, 6_400, 25_600] # cinq nombres de fléchettes, chacun 4 fois le précédenterreurs, marges = [], [] # deux listes vides, remplies par la bouclefor n in tailles: # pour chaque nombre de fléchettes n : estimations = [] for essai in range(200): # 200 expériences de n fléchettes u, v = rng.random((n, 2)).T # n fléchettes au hasard estimations.append(4 * np.mean(u**2 + v**2 <= 1)) # l'estimation de π de cette expérience erreurs.append(float(np.std(estimations))) # l'erreur mesurée : l'écart-type des 200 estimations # votre marge, sur la dernière expérience ; [1] : le second nombre rendu (Python compte depuis 0) marges.append(estimer(4 * (u**2 + v**2 <= 1))[1])# la pente de la droite des erreurs, sur les axes logarithmiquespente = float(np.polyfit(np.log(tailles), np.log(erreurs), 1)[0])montrer("erreur", N=tailles, erreur=erreurs, marge=marges, pente=pente)print("pente des erreurs mesurées :", pente)
Maj + Entrée
Vos 3 200 fléchettes donnent π ≈ 3,131 ± 0,057. Sur le graphique, chaque fois que les fléchettes sont multipliées par 4, l’erreur mesurée est divisée par 2 environ. La pente de la droite des erreurs vaut −0,50 : l’erreur baisse comme N puissance −1/2, c’est-à-dire comme un sur √N.
1L'idée
Dans la fonction, les tirages s’appellent x et leur nombre N. Il reste à traduire la phrase de la consigne avec ces deux noms et les mots de « Python en clair ».
2La ligne à trous
marge = 1.96 * x.____() / np.____(N)
3La solution
marge = 1.96 * x.std() / np.sqrt(N) : l’écart-type des tirages, divisé par la racine de N, donne l’erreur typique de la moyenne ; 1,96 en fait une marge à 95 %.
def estimer(x): # une fonction : x, les tirages qu'on lui donne """La moyenne des tirages x, et sa marge à 95 %. Cette fonction vous servira jusqu'à la séance 7.""" x = np.asarray(x, dtype=float) # en tableau de nombres (True vaut 1, False 0) N = len(x) # le nombre de tirages moyenne = x.mean() # leur moyenne : l'estimation marge = 1.96 * x.std() / np.sqrt(N) # À vous : 1,96 fois l'écart-type des tirages, divisé par la racine de N return float(moyenne), float(marge) # la fonction rend deux nombrespi_hat, marge = estimer(4 * dedans) # vos 3 200 fléchettes : 4 si dedans, 0 sinonprint("π ≈", pi_hat, "±", marge)# Ensuite, rien à écrire : l'erreur mesurée. Pour chaque nombre de fléchettes n, la cellule refait# l'expérience 200 fois ; l'erreur est l'écart-type de ces 200 estimations de π.rng = np.random.default_rng(1812) # un nouveau hasard, pour des expériences neuvestailles = [100, 400, 1_600, 6_400, 25_600] # cinq nombres de fléchettes, chacun 4 fois le précédenterreurs, marges = [], [] # deux listes vides, remplies par la bouclefor n in tailles: # pour chaque nombre de fléchettes n : estimations = [] for essai in range(200): # 200 expériences de n fléchettes u, v = rng.random((n, 2)).T # n fléchettes au hasard estimations.append(4 * np.mean(u**2 + v**2 <= 1)) # l'estimation de π de cette expérience erreurs.append(float(np.std(estimations))) # l'erreur mesurée : l'écart-type des 200 estimations # votre marge, sur la dernière expérience ; [1] : le second nombre rendu (Python compte depuis 0) marges.append(estimer(4 * (u**2 + v**2 <= 1))[1])# la pente de la droite des erreurs, sur les axes logarithmiquespente = float(np.polyfit(np.log(tailles), np.log(erreurs), 1)[0])montrer("erreur", N=tailles, erreur=erreurs, marge=marges, pente=pente)print("pente des erreurs mesurées :", pente)
6La révélation
Verrouillez d'abord votre pari.
π = 3,14159…
Vous venez de le mesurer : quatre fois plus de fléchettes divisent l’erreur mesurée par 2 environ, et non par 4. L’erreur baisse comme un sur la racine de N, d’où une pente proche de −1/2 sur le graphique. Pour la diviser par 10, il faut donc cent fois plus de fléchettes : c’est le prix d’une décimale. Le juge confirme : π est bien dans la marge de vos 3 200 fléchettes, et la marge exacte, 1,96 σ/√N avec σ = 1,6422 (l’écart-type exact d’une fléchette), a une pente de −1/2 exactement.
7Comprendrepourquoi ceci, et pas cela
4 questions « pourquoi », avec leur réponse. Elles s’ouvrent quand votre pari est verrouillé : elles ne doivent rien vous souffler.
1Pourquoi l’erreur baisse comme 1/√N, et pas comme 1/N ?
Une fléchette seule se trompe beaucoup : elle vaut 4 ou 0, quand π vaut 3,14 ; son écart-type, σ = 1,6422, mesure cet écart typique. Additionnez N fléchettes : leurs écarts ne vont pas tous dans le même sens. Pour des tirages indépendants, ce sont les variances (les carrés des écarts-types) qui s’additionnent : la somme a une variance N σ², donc un écart-type σ√N, et non N σ. La moyenne divise cette somme par N : son erreur typique vaut σ√N/N, c’est-à-dire σ/√N. Le cours le disait : le hasard ne compense pas, il se dilue. Vos mesures le confirment : l’erreur vaut 0,161 avec 100 fléchettes et 0,080 avec 400, divisée par 2 seulement pour quatre fois plus de fléchettes.
En Python
C’est le np.sqrt(N) de votre ligne : on divise par la racine de N, pas par N. La cellule le contrôle : np.polyfit mesure la pente de vos erreurs sur les axes logarithmiques, −0,50, soit N puissance −1/2.
En finance
Sur un desk (l’équipe d’une salle de marché qui traite un produit), un prix d’option deux fois plus précis demande quatre fois plus de simulations, donc quatre fois plus de temps de calcul. C’est pourquoi les banques cherchent plutôt à réduire σ, à budget de calcul égal : c’est l’objet de la séance 2.
2Pourquoi multiplier par 1,96, et pas par 1 ou par 2 ?
Refaites l’expérience un grand nombre de fois : les estimations de π se répartissent en cloche autour de la vraie valeur, et la largeur de cette cloche est l’erreur typique σ/√N. Quand N est grand, cette cloche est celle de la loi normale : c’est le théorème central limite du cours. Pour la loi normale, 68 % des valeurs tombent à moins d’un écart-type du centre, et 95 % à moins de 1,96 écart-type ; il reste 2,5 % de chaque côté. L’estimation ± 1,96 erreur typique contient donc la vraie valeur environ 95 fois sur 100. Avec 1, ce ne serait qu’environ deux fois sur trois ; avec 2, environ 95,4 % : presque pareil, mais 1,96 est le nombre qui donne 95 %. C’est une approximation, bonne quand N est grand, et non une garantie. Vos 3 200 fléchettes donnent π ≈ 3,131 ± 0,057 : π y est bien.
En Python
C’est le 1.96 de votre ligne. Changer ce seul nombre change le niveau annoncé : 1.645 pour environ 90 %, 2.58 pour environ 99 %.
En finance
En banque comme en assurance, un chiffre simulé se présente ainsi : l’estimation, plus ou moins sa marge à 95 %. Sans cette marge, une équipe de contrôle des risques ne peut pas juger si un prix simulé est assez précis.
3Pourquoi l’écart-type des tirages, et pas leur variance ?
Une marge s’ajoute à l’estimation et s’en retranche : elle doit être dans la même unité qu’elle. L’écart-type l’est : c’est l’écart typique d’un tirage à la moyenne des tirages. La variance est son carré : pour des gains en euros, elle serait en euros au carré. Sur vos 3 200 fléchettes, l’écart-type vaut 1,649 et la variance 2,720. On mesure l’écart-type sur les tirages eux-mêmes, car le vrai σ est inconnu en pratique : c’est le σ̂ de la formule, le chapeau voulant dire « mesuré ». Ici, il est tout près du vrai, 1,6422 ; divisé par √N, il donne l’erreur typique de l’estimation, sans refaire la simulation.
En Python
C’est x.std() : l’écart-type du tableau x que reçoit la fonction. x.var() donnerait la variance ; la vérification le signale.
En finance
L’écart-type annuel des rendements d’une action (des rendements logarithmiques, pour être exact) s’appelle sa volatilité : 20 % pour l’action de la mission 3. On l’annonce en écart-type plutôt qu’en variance, pour la même raison : elle s’exprime alors dans l’unité des rendements, en pourcentage.
4Pourquoi une fonction, et pas la formule recopiée à chaque fois ?
La marge revient partout : dans cette mission, puis pour le prix d’une option (mission 3), pour la ruine d’un assureur (mission 4), et jusqu’à la séance 7. Recopier la formule, c’est risquer une faute à chaque copie : N à la place de √N, 2 à la place de 1,96. Une fonction s’écrit une fois, se vérifie une fois, puis s’appelle par son nom, sur n’importe quels tirages. Dans cette cellule, elle sert déjà 6 fois : sur vos 3 200 fléchettes, puis sur la dernière expérience de chacun des 5 nombres de fléchettes du graphique. Si la formule devait changer, on la corrigerait à un seul endroit.
En Python
def estimer(x): crée la fonction, et return dit ce qu’elle rend : deux nombres, la moyenne puis la marge. La ligne pi_hat, marge = estimer(4 * dedans) l’appelle, puis range ces deux nombres dans pi_hat et marge.
En finance
Banques et assureurs travaillent ainsi : des bibliothèques de fonctions écrites et testées une fois, que toutes les équipes appellent, par exemple pour le prix de chaque produit ou pour le capital exigé par Solvabilité II, la réglementation européenne des assureurs.
8Et si… ?pour qui a fini : une variante, qui prépare la suite
Et si vous vouliez une marge de ± 0,0001 à 95 %, au lieu de vos ± 0,057 ? Combien de fléchettes faudrait-il lancer ? À la ligne N_besoin = None, remplacez None par le nombre de fléchettes N pour lequel la marge 1,96 σ/√N vaut 0,0001. Ici, σ est l’écart-type exact d’une fléchette, déjà calculé dans sigma. La cellule prolonge alors la droite de votre marge jusqu’à ce nombre. L’intérêt : connaître le prix d’une précision avant de lancer la moindre simulation.
Python en clair
(a / b)**2
le carré de a / b : en Python, la puissance s’écrit ** (le ^ d’Excel veut dire autre chose en Python). Les parenthèses mettent au carré tout le quotient ; sans elles, seul b le serait.Exemple(6 / 3)**2→donne4.0
1e-4
l’écriture scientifique : 1e-4 veut dire 1 × 10⁻⁴, soit 0,0001 ; de même, 1e10 vaut dix milliards.Exemple1e-4 == 0.0001→donneTrue
# sigma : l'écart-type exact d'une fléchette, 4 √(p(1 − p)) avec p = π/4 (np.pi : π selon NumPy)sigma = 4 * np.sqrt(np.pi / 4 * (1 - np.pi / 4))N_besoin = None # À vous : le nombre de fléchettes pour une marge de ± 0,0001# la marge de vos 3 200 fléchettes, et celle que vous visez : la droite qui les reliemontrer("erreur", N=[len(dedans), N_besoin], marge=[marge, 0.0001], params={"x": [1_000, 1e10], "y": [1e-5, 1.0], "etiquettes": ["Votre marge, prolongée"]})print("fléchettes nécessaires :", N_besoin)
Maj + Entrée
Il faut 1,04 milliard de fléchettes, environ dix fois les 100 millions du film. Chaque décimale de plus coûte cent fois plus de fléchettes.
1L'idée
La marge vaut 1,96 σ/√N, où σ est l’écart-type d’une fléchette (déjà dans sigma) et N le nombre de fléchettes. Écrivez que cette marge vaut 0,0001, puis isolez N.
2La ligne à trous
N_besoin = (1.96 * sigma / ______)**2
3La solution
N_besoin = (1.96 * sigma / 0.0001)**2 : si 1,96 σ/√N = 0,0001, alors √N = 1,96 σ/0,0001, et N en est le carré.
# sigma : l'écart-type exact d'une fléchette, 4 √(p(1 − p)) avec p = π/4 (np.pi : π selon NumPy)sigma = 4 * np.sqrt(np.pi / 4 * (1 - np.pi / 4))N_besoin = (1.96 * sigma / 0.0001)**2 # À vous : le nombre de fléchettes pour une marge de ± 0,0001# la marge de vos 3 200 fléchettes, et celle que vous visez : la droite qui les reliemontrer("erreur", N=[len(dedans), N_besoin], marge=[marge, 0.0001], params={"x": [1_000, 1e10], "y": [1e-5, 1.0], "etiquettes": ["Votre marge, prolongée"]})print("fléchettes nécessaires :", N_besoin)
9À retenir, et je signe
La marge baisse comme un sur la racine du nombre de tirages : la diviser par 10 coûte cent fois plus de tirages.
Une phrase modèle
Avec 3 200 fléchettes, π ≈ 3,131 ± 0,057 ; une marge dix fois plus petite demanderait cent fois plus de fléchettes, 320 000.
Mission 3 sur 4
Niveau 3 20 min
Le prix d’une option, et celle qui n’a pas de formule
Estimer un prix par une moyenne
L'énigme
Python démarre dans la page…
1L'énigme
1973. Fischer Black et Myron Scholes publient la formule du prix d’une option d’achat. Ce contrat donne le droit, sans obligation, d’acheter une action à une date fixée, l’échéance (dans un an), et à un prix fixé, le prix d’exercice K = 100 €. L’action vaut 100 € aujourd’hui. À l’échéance, si elle vaut plus que K, le contrat rapporte la différence : c’est son gain. Sinon, rien. Changez certains détails du contrat, et la formule disparaît : il faut simuler les avenirs de l’action, puis faire une moyenne. Mais la moyenne de quoi ?
2Votre pari
À votre avis, lequel de ces trois calculs donne le prix du contrat aujourd’hui ?
C’est le prix : 10,45 €, la valeur exacte de Black-Scholes. On calcule le gain de chaque avenir, on en fait la moyenne, puis on la ramène à aujourd’hui.
Le gain du prix moyen ne vaut que 4,88 €, moins de la moitié du prix. En moyennant d’abord les prix, les baisses effacent les hausses ; or le contrat ignore les baisses. Le gain du prix moyen n’est pas la moyenne des gains.
C’est trop cher : 10,99 €. Ce gain n’arrive que dans un an, et un euro reçu dans un an vaut moins qu’un euro aujourd’hui, qui peut rapporter des intérêts d’ici là. Ramené à aujourd’hui, le gain moyen vaut 10,45 €.
Choisissez, puis verrouillez : on ne revient pas sur un pari.
3L'expérience
Verrouillez d'abord votre pari.
4La formule du cours
Elle s’ouvre quand votre pari est verrouillé : elle ne doit rien vous souffler.
Case 2 de la fiche
E[f(X)]≈N1i=1∑Nf(Xi)
E[f(X)] se lit « espérance de f de X » : la moyenne de f(X) sur tous les avenirs possibles. Elle est à peu près égale à la moyenne simulée : on additionne les N valeurs f(Xᵢ), puis on divise par N. Ici, chaque Xᵢ est un avenir simulé de l’action, et f(X) le nombre qu’on lit dans un avenir. Lequel ? C’est toute la question de cette mission.
Pourquoi cette formule.Un prix est une espérance, c’est-à-dire la moyenne d’un nombre sur tous les avenirs possibles ; or une moyenne se simule.
À la fin de cette mission, vous savez :
traduire un contrat financier en une ligne de Python
estimer le prix d’un contrat par simulation, avec sa marge à 95 %
chiffrer un contrat qui n’a pas de formule, en changeant une seule ligne
5À vous de coder
Votre boîte à outilsdéjà chargée : ce que les missions d'avant ont construit
# Votre boîte à outils : la fonction estimer de la mission 2.def estimer(x): """La moyenne des tirages x, et sa marge à 95 %. Cette fonction vous servira jusqu'à la séance 7.""" x = np.asarray(x, dtype=float) N = len(x) moyenne = x.mean() marge = 1.96 * x.std() / np.sqrt(N) return float(moyenne), float(marge)
Les N = 10 000 avenirs de l’action sont déjà simulés, mois par mois, avec le modèle de Black-Scholes : prix de départ S0 = 100 €, taux sans risque r = 5 % par an (le taux d’un placement sûr), volatilité vol = 20 % (l’ampleur typique des variations de l’action sur un an), échéance T = 1 an ; z contient les tirages au hasard, un par avenir et par mois. Le tableau S a une ligne par avenir et une colonne par fin de mois, 12 colonnes en tout : sa dernière colonne donne le prix final de chaque avenir.
À la ligne gains = None, remplacez None par le gain de chaque avenir : son prix final moins K = 100 € s’il est positif, 0 sinon.
À la ligne prix, marge = None, None, remplacez None, None par la moyenne des gains ramenée à aujourd’hui, et sa marge à 95 %. Ramener à aujourd’hui, c’est multiplier par e^(−rT), ce que vaut aujourd’hui un euro reçu dans T années ; la fonction estimer de la mission 2 donne la moyenne et la marge d’un seul coup.
Exécutez la cellule : la scène allume les avenirs gagnants et affiche votre prix.
Python en clair
S[:, -1]
la dernière colonne du tableau S : le prix de chaque avenir au dernier mois, donc à l’échéance. Entre crochets, on écrit d’abord les lignes, puis les colonnes : : veut dire « toutes les lignes », et -1 « la dernière colonne ». Un calcul entre ce tableau et un nombre se fait case par case, avenir par avenir, comme une formule Excel recopiée sur toute une colonne.ExempleS = np.array([[1, 2, 3, 4], [5, 6, 7, 8]]); S[:, -1]→donne[4 8]
np.maximum(a, 0)
case par case, le plus grand des deux : la valeur de a, ou 0 (dans Excel, MAX(A1;0) recopié sur la colonne). Un nombre négatif devient 0 ; un nombre positif ne change pas. Attention : np.max, sans « imum », donne un seul nombre, le plus grand du tableau.Exemplenp.maximum(np.array([-7, 0, 8]), 0)→donne[0 0 8]
np.exp(x)
l’exponentielle, e^(x) (dans Excel, EXP). Par exemple, e^(−0,05 × 1) ≈ 0,9512 : ce que vaut aujourd’hui un euro reçu dans un an, au taux sans risque de 5 %.Exemplenp.exp(-0.05 * 1)→donne0.951229424500714
prix, marge = estimer(x)
déjà vu en mission 2 : estimer reçoit un tableau x et renvoie deux nombres, la moyenne de x et sa marge à 95 %. Les deux noms à gauche du signe = les reçoivent, dans cet ordre.
rng = np.random.default_rng(1987)N, S0, K, r, vol, T = 10_000, 100, 100, 0.05, 0.20, 1.0z = rng.standard_normal((N, 12)) # N avenirs, 12 moisS = S0 * np.exp(np.cumsum((r - vol**2 / 2) * T / 12 + vol * np.sqrt(T / 12) * z, axis=1)) # le prix à la fin de chaque moisgains = None # À vous : le gain de chaque avenir à l'échéance (S[:, -1] est le prix dans un an)prix, marge = None, None # À vous : la moyenne des gains ramenée à aujourd'hui, et sa marge (estimer)montrer("trajectoires", chemins=np.hstack([np.full((200, 1), S0), S[:200]]), gains=gains, estimation=prix, marge=marge)print("prix aujourd'hui :", prix, "±", marge)
Maj + Entrée
Les avenirs qui finissent au-dessus de 100 € s’allument ; leurs gains tombent dans l’histogramme. Votre prix : 10,28 € ± 0,28 €.
1L'idée
Le gain d’un avenir est le plus grand de deux nombres : son prix final moins K, ou 0. Ensuite, chaque gain se ramène à aujourd’hui en le multipliant par e^(−rT), et estimer en fait la moyenne.
gains = np.maximum(S[:, -1] - K, 0) et prix, marge = estimer(np.exp(-r * T) * gains) : d’abord le gain de chaque avenir, ensuite la moyenne de ces gains, ramenés à aujourd’hui.
rng = np.random.default_rng(1987)N, S0, K, r, vol, T = 10_000, 100, 100, 0.05, 0.20, 1.0z = rng.standard_normal((N, 12)) # N avenirs, 12 moisS = S0 * np.exp(np.cumsum((r - vol**2 / 2) * T / 12 + vol * np.sqrt(T / 12) * z, axis=1)) # le prix à la fin de chaque moisgains = np.maximum(S[:, -1] - K, 0) # À vous : le gain de chaque avenir à l'échéance (S[:, -1] est le prix dans un an)prix, marge = estimer(np.exp(-r * T) * gains) # À vous : la moyenne des gains ramenée à aujourd'hui, et sa marge (estimer)montrer("trajectoires", chemins=np.hstack([np.full((200, 1), S0), S[:200]]), gains=gains, estimation=prix, marge=marge)print("prix aujourd'hui :", prix, "±", marge)
6La révélation
Verrouillez d'abord votre pari.
La formule de Black-Scholes : 10,4506 €.
Un prix est une moyenne : la moyenne des gains, ramenée à aujourd’hui. Dans la formule du cours, f(X) est donc le gain de l’avenir X, ramené à aujourd’hui. Le juge, la formule de Black-Scholes, tombe dans votre marge. Le gain du prix moyen, lui, ne vaut que 4,88 € : en moyennant d’abord les prix, les baisses effacent les hausses, alors que le contrat garde les hausses et ignore les baisses. Dans le modèle de cette option d’achat, si seule la volatilité augmente, le prix de l’option augmente. Et un contrat qui n’a pas de formule ? C’est le rebondissement, juste après.
7Comprendrepourquoi ceci, et pas cela
4 questions « pourquoi », avec leur réponse. Elles s’ouvrent quand votre pari est verrouillé : elles ne doivent rien vous souffler.
1Pourquoi la moyenne des gains, et pas le gain du prix moyen ?
Prenez deux de vos avenirs. Dans le premier, l’action finit à 117,30 € : le gain vaut 17,30 €. Dans le dixième, elle finit à 75,28 € : le gain vaut 0, car le droit d’acheter à 100 € ne sert à rien. La moyenne des deux gains vaut 8,65 € ; leur prix moyen, 96,29 €, reste sous 100 €, et son gain vaut 0. En moyennant d’abord les prix, la baisse efface la hausse ; le contrat, lui, garde la hausse et ignore la baisse. Sur vos 10 000 avenirs, même effet : ramenés à aujourd’hui, la moyenne des gains vaut 10,28 €, le gain du prix moyen 4,63 € seulement ; les valeurs exactes sont 10,45 € et 4,88 €.
En Python
L’ordre se lit dans vos deux lignes : np.maximum(…, 0) donne d’abord un gain par avenir, puis estimer en fait la moyenne. Pour revoir ces deux avenirs, tapez S[0, -1] et S[9, -1] : Python numérote les lignes à partir de 0.
En finance
Pour valoriser cette option, on simule l’action avec le taux sans risque du modèle, r, le taux d’un placement sûr. On ramène à aujourd’hui le gain de chaque avenir, puis on fait la moyenne. Dès qu’un contrat a un plancher ou un plafond, le résultat de l’avenir moyen n’est en général pas le résultat moyen : c’est pourquoi banques et assureurs simulent tous les avenirs, et pas seulement un scénario moyen.
2Pourquoi np.maximum(…, 0), et pas simplement le prix final moins K ?
Une option d’achat est un droit, pas une obligation. Si l’action finit sous K = 100 €, personne n’achète à 100 € ce qui vaut moins : on laisse le droit expirer, et le gain vaut 0, jamais un nombre négatif. Dans vos 10 000 avenirs, 4 424 finissent sous 100 € : leur gain est 0. Sans ce plancher, ces avenirs compteraient comme des pertes, et le prix tomberait de 10,28 € à 4,63 €. Ce n’est pas un hasard. Sans le plancher, retirer K puis faire la moyenne, ou faire la moyenne puis retirer K, revient au même : 4,63 € est exactement le gain du prix moyen de vos avenirs, ramené à aujourd’hui (le calcul exact donne 4,88 €). Toute la différence vient du plancher à 0.
En Python
np.maximum(…, 0) compare chaque case du tableau à 0 et garde la plus grande des deux valeurs. Sans np., max(…, 0) refuse un tableau entier, et np.max(…, 0) rendrait un seul nombre, le plus grand gain.
En finance
Ce plancher à 0 est la forme de tout droit qu’on exerce seulement s’il rapporte. En assurance, un contrat de réassurance « stop-loss » (en excédent de pertes) paie ce que les sinistres de l’année dépassent un seuil fixé à l’avance, sinon rien : la même forme.
3Pourquoi ramener le gain à aujourd’hui, en le multipliant par e^(−rT) ?
Le gain est payé dans un an ; le prix, lui, se paie aujourd’hui. Un euro placé aujourd’hui au taux sans risque r = 5 % devient e^(rT) ≈ 1,0513 € dans un an. À l’inverse, un euro reçu dans un an ne vaut aujourd’hui que e^(−rT) ≈ 0,9512 €. La moyenne exacte des gains vaut 10,99 € dans un an ; aujourd’hui, elle vaut 10,99 € × 0,9512 ≈ 10,45 €. Oublier ce facteur, c’est payer 0,54 € de trop.
En Python
Ce facteur s’écrit np.exp(-r * T) : un seul nombre, qui multiplie chaque case du tableau gains. Ramener chaque gain puis faire la moyenne, ou l’inverse, donne le même prix.
En finance
C’est l’actualisation, le geste de base de la finance : un flux futur se ramène à aujourd’hui avant d’être comparé ou additionné. Un assureur fait de même avec ce qu’il devra payer : sous Solvabilité II, il l’actualise avec la courbe des taux sans risque publiée par l’autorité européenne des assurances (EIOPA).
4Pourquoi simuler, si la formule de Black-Scholes donne déjà le prix ?
Pour l’option d’achat, la formule sert de juge : 10,45 € tombe dans votre marge, 10,28 € ± 0,28 €. La méthode a donc passé l’épreuve sur un cas où l’on connaît la réponse. Mais la formule ne vaut que pour ce contrat-là : faites-le payer sur la moyenne des 12 prix de fin de mois, et l’on ne connaît plus de formule qui donne le prix d’un seul calcul. La simulation, elle, ne change que d’une ligne : c’est le rebondissement. Une formule répond à une question ; la simulation répond à toutes celles qu’on sait simuler.
En Python
D’un contrat à l’autre, seule la ligne gains change. Les avenirs simulés, l’actualisation et estimer restent les mêmes.
En finance
Beaucoup de contrats n’ont pas de formule et se chiffrent par simulation : options sur une moyenne ou sur plusieurs actions, contrats d’assurance vie avec garanties. Une entreprise qui achète du pétrole chaque mois, par exemple, peut se protéger avec une option asiatique : elle porte sur un prix moyen, comme ses achats.
8Et si… ?pour qui a fini : une variante, qui prépare la suite
Et si le contrat payait sur la moyenne des prix de l’année, et non sur le prix final ? C’est une option asiatique : à l’échéance, elle paie ce que la moyenne des 12 prix de fin de mois dépasse K = 100 €, sinon rien. On ne lui connaît pas de formule fermée, c’est-à-dire de formule qui donne le prix d’un seul calcul, comme celle de Black-Scholes. La simulation, elle, la chiffre comme l’option d’achat. Prédisez d’abord : vaut-elle plus ou moins que l’option d’achat ? Puis changez une seule ligne, celle des gains, et lisez son prix et sa marge. L’intérêt : chiffrer, avec sa marge, ce contrat sur la moyenne des prix, pour lequel on n’a pas de formule simple comme celle de Black-Scholes.
Python en clair
S.mean(axis=1)
la moyenne de chaque ligne de S : pour chaque avenir, la moyenne de ses 12 prix de fin de mois (dans Excel, MOYENNE sur chaque ligne). Sans axis, .mean() (mission 1) ferait la moyenne de tout le tableau, un seul nombre ; avec axis=0, la moyenne de chaque colonne, c’est-à-dire de chaque mois.ExempleS = np.array([[1, 2, 3, 4], [5, 6, 7, 8]]); S.mean(axis=1)→donne[2.5 6.5]
gains = np.maximum(S[:, -1] - K, 0) # À vous : changez cette ligne ; l'asiatique paie ce que la moyenne des 12 prix mensuels dépasse Kprix, marge = estimer(np.exp(-r * T) * gains)montrer("trajectoires", chemins=np.hstack([np.full((200, 1), S0), S[:200]]), gains=gains, estimation=prix, marge=marge, params={"releves": [k / 12 for k in range(1, 13)], "etiquettes": ["Option asiatique"]})print("asiatique :", prix, "±", marge)
Maj + Entrée
Avec cette graine, vous devez lire 6,09 € ± 0,17 € : l’asiatique vaut moins que l’option d’achat. Ici, la moyenne des 12 prix est moins dispersée que le prix final : dans vos avenirs, son écart-type vaut 12,79 €, contre 21,06 €. Son niveau moyen est aussi plus bas : 102,61 €, contre 104,87 €. Environ 95 fois sur 100, la fourchette prix ± marge, construite ainsi, contient le vrai prix. Une simulation indépendante, sur quatre millions d’avenirs avec la méthode de la séance 2, donne un autre repère : 6,1560 € ± 0,0002 €, bien dans votre fourchette. Cette méthode, appliquée à vos 10 000 avenirs, rendra la marge environ 36 fois plus petite.
1L'idée
Le tableau S a une ligne par avenir et une colonne par mois. La moyenne d’un avenir se prend le long de sa ligne, sur ses 12 prix.
2La ligne à trous
gains = np.maximum(S.mean(axis=_) - K, 0)
3La solution
gains = np.maximum(S.mean(axis=1) - K, 0) : axis=1 fait la moyenne le long de chaque ligne, donc des 12 prix d’un avenir.
gains = np.maximum(S.mean(axis=1) - K, 0) # À vous : changez cette ligne ; l'asiatique paie ce que la moyenne des 12 prix mensuels dépasse Kprix, marge = estimer(np.exp(-r * T) * gains)montrer("trajectoires", chemins=np.hstack([np.full((200, 1), S0), S[:200]]), gains=gains, estimation=prix, marge=marge, params={"releves": [k / 12 for k in range(1, 13)], "etiquettes": ["Option asiatique"]})print("asiatique :", prix, "±", marge)
9À retenir, et je signe
Un prix est la moyenne des gains, ramenée à aujourd’hui : d’abord le gain de chaque avenir, ensuite la moyenne.
Une phrase modèle
Avec 10 000 avenirs, l’option d’achat vaut 10,28 € ± 0,28 €, une fourchette qui contient Black-Scholes, 10,45 € ; avec la variante, l’asiatique vaut 6,09 € ± 0,17 €.
Mission 4 sur 4
Niveau 4 20 min
La ruine une fois sur deux cents
Lire une marge, et choisir le nombre d’avenirs
L'énigme
Python démarre dans la page…
1L'énigme
Un assureur garde une réserve : l’argent qui paie les sinistres, les dommages de ses clients. Au départ, elle couvre 31 sinistres de coût moyen. Les primes, payées par les clients, rapportent en moyenne 20 % de plus que ne coûtent les sinistres. Si la réserve passe un jour sous zéro, l’assureur est ruiné. Sa règle : une ruine au plus une fois sur 200 (0,5 %). Un stagiaire simule 100 avenirs possibles de l’assureur, tirés au hasard : aucune ruine. Il écrit « risque nul ». Signeriez-vous son rapport ?
2Votre pari
À votre avis, si la chance de ruine est proche d’une sur 200, que montrent le plus souvent 100 avenirs simulés ?
Oui. Avec la vraie chance de ruine de cet assureur, 100 avenirs ne montrent aucune ruine dans 62 % des cas, une seule dans 30 %, deux ou plus dans 8 %. Le « zéro » du stagiaire est donc le résultat le plus fréquent, même si le risque n’est pas nul.
Une seule ruine n’arrive que dans 30 % des cas. Le plus fréquent est aucune ruine : 62 % des cas. Une ruine sur 200 est rare : sur 100 avenirs, on en attend moins d’une en moyenne.
Deux ruines ou plus : 8 % des cas seulement. Le plus fréquent est aucune ruine : 62 % des cas. Une ruine sur 200 est rare : sur 100 avenirs, on en attend moins d’une en moyenne.
Choisissez, puis verrouillez : on ne revient pas sur un pari.
3L'expérience
Verrouillez d'abord votre pari.
4Les formules du cours
Elles s’ouvrent quand votre pari est verrouillé : elles ne doivent rien vous souffler.
Case 1 de la fiche
p^=Nk
La chance de ruine estimée, p chapeau, est le nombre k d’avenirs ruinés divisé par le nombre N d’avenirs simulés.
Pourquoi cette formule.Une chance de ruine est une proportion : en notant 1 un avenir ruiné et 0 un avenir sauf, k/N est la moyenne de ces 1 et de ces 0, celle que calcule estimer.
Case 4 de la fiche
p^±1,96Nσ^⟹N=(ε1,96σ^)2
La marge à 95 % vaut 1,96 fois sigma chapeau, l’écart-type mesuré d’un avenir, divisé par la racine de N. Pour une marge visée ε (ici 0,001), on en tire le nombre d’avenirs : N = (1,96 σ̂ / ε)².
Pourquoi cette formule.La marge baisse comme un sur √N : pour isoler N, on élève au carré, et c’est pourquoi diviser la marge par 10 coûte cent fois plus d’avenirs.
À la fin de cette mission, vous savez :
estimer une chance de ruine par la part des avenirs ruinés, et l’annoncer avec sa marge à 95 %
calculer, avant de simuler, le nombre d’avenirs qui donne la marge voulue : N = (1,96 σ / marge visée)²
expliquer pourquoi « zéro ruine sur cent » ne prouve pas qu’un risque est nul
5À vous de coder
Votre boîte à outilsdéjà chargée : ce que les missions d'avant ont construit
# Votre boîte à outils : la fonction estimer de la mission 2.def estimer(x): """La moyenne des tirages x, et sa marge à 95 %. Cette fonction vous servira jusqu'à la séance 7.""" x = np.asarray(x, dtype=float) N = len(x) moyenne = x.mean() marge = 1.96 * x.std() / np.sqrt(N) return float(moyenne), float(marge)
Étape 1 sur 2
Les 100 avenirs de l’expérience sont déjà simulés par la fonction simuler_assureur, en haut de la cellule : elle suit la réserve sinistre après sinistre, jusqu’au 1 000e. Elle renvoie ruines, un tableau qui vaut True pour chaque avenir ruiné, False pour les autres.
À la ligne p, marge = None, None, remplacez None, None par la chance de ruine estimée, c’est-à-dire la part des avenirs ruinés, et sa marge à 95 % : la fonction estimer de la mission 2 donne les deux d’un seul coup.
Exécutez la cellule : la scène montre quelques chemins de réserve. Votre estimation, elle, compte les ruines sur tous les avenirs simulés.
Python en clair
estimer(x)
déjà vu en missions 2 et 3 : la moyenne des valeurs de x, puis sa marge à 95 %.
x.mean()
déjà vu en mission 1 : sur des True et des False, True compte 1 et False compte 0. La moyenne donne donc la part des True.Exemplenp.array([False, True, False, False]).mean()→donne0.25
def simuler_assureur(N, rng, traces=40): """N avenirs de l'assureur du film, sinistre après sinistre, jusqu'au 1 000e. Réserve de départ 31 ; entre deux sinistres, il encaisse 1,2 par unité de temps ; un sinistre par unité de temps en moyenne, de taille moyenne 1. S'arrêter au 1 000e sinistre change la chance de ruine de moins de 0,002 point. Renvoie : ruines (True si la réserve passe un jour sous zéro) ; pour la scène, la réserve des premiers avenirs après chaque sinistre, et le numéro du sinistre qui les ruine.""" reserve = np.full(N, 31.0) # la réserve de départ de chaque avenir : 31 sinistres moyens ruines = np.zeros(N, dtype=bool) # N fois False : aucun avenir n'est encore ruiné trace = [reserve[:traces].copy()] # pour la scène seulement : la réserve des premiers avenirs for _ in range(1000): # 1 000 sinistres, l'un après l'autre # rng.exponential(1.0, N) : N nombres tirés au hasard, de moyenne 1. Le premier tirage est l'attente # avant le sinistre (les primes rentrent à 1,2 par unité de temps), le second est le montant du sinistre. reserve += 1.2 * rng.exponential(1.0, N) - rng.exponential(1.0, N) # primes encaissées, puis un sinistre ruines |= reserve < 0 # True dès que la réserve passe sous zéro, et pour de bon trace.append(reserve[:traces].copy()) reserves = np.array(trace).T # pour la scène seulement : une ligne par avenir tracé sous_zero = reserves < 0 instants = np.where(sous_zero.any(axis=1), sous_zero.argmax(axis=1), np.nan) # le sinistre qui ruine (nan : aucun) return ruines, reserves, instantsrng = np.random.default_rng(200)ruines, reserves, instants = simuler_assureur(100, rng) # les 100 avenirs de l'expériencep, marge = None, None # À vous : la part des avenirs ruinés, et sa marge à 95 % (avec la fonction estimer)montrer("surplus", chemins=reserves, temps=np.arange(reserves.shape[1]), ruine=ruines, instants_ruine=instants, estimation=p, marge=marge)print("ruines :", ruines.sum(), "sur", len(ruines), " estimation :", p, "±", marge)
Maj + Entrée
Zéro ruine sur 100 : votre estimation dit 0 % ± 0. Aucune réserve n’est passée sous zéro, donc les 100 valeurs de ruines valent toutes False, c’est-à-dire 0 : leur écart-type est nul, et la marge aussi. Cette marge nulle ne prouve rien : elle vaut zéro seulement parce qu’aucune ruine n’est tombée.
1L'idée
La chance de ruine estimée est la part des avenirs ruinés : la moyenne des True et des False de ruines. La fonction estimer donne cette moyenne et sa marge, comme pour π en mission 2.
2La ligne à trous
p, marge = _______(ruines)
3La solution
p, marge = estimer(ruines) : la moyenne des True et des False est la part des avenirs ruinés, et estimer y joint sa marge à 95 %.
def simuler_assureur(N, rng, traces=40): """N avenirs de l'assureur du film, sinistre après sinistre, jusqu'au 1 000e. Réserve de départ 31 ; entre deux sinistres, il encaisse 1,2 par unité de temps ; un sinistre par unité de temps en moyenne, de taille moyenne 1. S'arrêter au 1 000e sinistre change la chance de ruine de moins de 0,002 point. Renvoie : ruines (True si la réserve passe un jour sous zéro) ; pour la scène, la réserve des premiers avenirs après chaque sinistre, et le numéro du sinistre qui les ruine.""" reserve = np.full(N, 31.0) # la réserve de départ de chaque avenir : 31 sinistres moyens ruines = np.zeros(N, dtype=bool) # N fois False : aucun avenir n'est encore ruiné trace = [reserve[:traces].copy()] # pour la scène seulement : la réserve des premiers avenirs for _ in range(1000): # 1 000 sinistres, l'un après l'autre # rng.exponential(1.0, N) : N nombres tirés au hasard, de moyenne 1. Le premier tirage est l'attente # avant le sinistre (les primes rentrent à 1,2 par unité de temps), le second est le montant du sinistre. reserve += 1.2 * rng.exponential(1.0, N) - rng.exponential(1.0, N) # primes encaissées, puis un sinistre ruines |= reserve < 0 # True dès que la réserve passe sous zéro, et pour de bon trace.append(reserve[:traces].copy()) reserves = np.array(trace).T # pour la scène seulement : une ligne par avenir tracé sous_zero = reserves < 0 instants = np.where(sous_zero.any(axis=1), sous_zero.argmax(axis=1), np.nan) # le sinistre qui ruine (nan : aucun) return ruines, reserves, instantsrng = np.random.default_rng(200)ruines, reserves, instants = simuler_assureur(100, rng) # les 100 avenirs de l'expériencep, marge = estimer(ruines) # À vous : la part des avenirs ruinés, et sa marge à 95 % (avec la fonction estimer)montrer("surplus", chemins=reserves, temps=np.arange(reserves.shape[1]), ruine=ruines, instants_ruine=instants, estimation=p, marge=marge)print("ruines :", ruines.sum(), "sur", len(ruines), " estimation :", p, "±", marge)
Étape 2 sur 2
Combien d’avenirs faut-il pour que la marge à 95 % de la chance de ruine vaille ± 0,1 point de pourcentage, soit ± 0,001 en proportion ? Ce nombre N est le budget du calcul : chaque avenir coûte du temps de machine. On le calcule avant de simuler, en retournant la formule de la marge, 1,96 σ / √N. Il faut d’abord σ, l’écart-type d’un avenir (1 s’il est ruiné, 0 sinon). Sur les 100 avenirs sans ruine de l’étape 1, l’écart-type observé vaut 0 : pour estimer σ, on prend un essai plus grand, une simulation pilote de 10 000 avenirs déjà simulée dans pilote (True pour un avenir ruiné).
À la ligne sigma = None, remplacez None par l’écart-type des valeurs de pilote.
À la ligne N = None, remplacez None par le nombre d’avenirs pour lequel 1,96 σ / √N vaut 0,001, la marge visée.
Exécutez la cellule : elle simule ces N avenirs ; la scène en dessine quelques chemins, votre estimation compte les ruines sur tous.
Python en clair
x.std()
déjà vu en mission 2 : l’écart-type des valeurs de x. Sur des True et des False, comptés 1 et 0, il vaut √(p(1 − p)), où p est la part des True.Exemplenp.array([True, False, False, False]).std()→donne0.4330127018922193
(a / b)**2
le carré de a / b : en Python, la puissance s’écrit ** (vu au rebondissement de la mission 2). Les parenthèses mettent au carré tout le quotient ; sans elles, seul b le serait.Exemple(6 / 2)**2→donne9.0
0.001
un millième, écrit avec un point comme tout nombre décimal en Python. Attention aux unités : un dixième de point de pourcentage, 0,1 %, vaut 0,001 en proportion.Exemple0.1 / 100→donne0.001
pilote, _, _ = simuler_assureur(10_000, np.random.default_rng(2001), traces=0) # le pilote : 10 000 avenirs# pilote vaut True pour chaque avenir ruiné, False sinon ; les deux _ reçoivent ce qu'on ne garde pas (les tracés)sigma = None # À vous : σ, l'écart-type d'un avenir (1 s'il est ruiné, 0 sinon), mesuré sur le piloteN = None # À vous : le nombre d'avenirs pour une marge de ± 0,001 (0,1 point de pourcentage)n = 0 if N is None else int(np.ceil(N)) # un nombre entier d'avenirs, arrondi au-dessusif n > 50_000: # garde-fou : un N faux ne doit pas bloquer l'ordinateur print("N =", n, ": vérifiez le calcul avant une si longue simulation.") n = 0ruines, reserves, instants = simuler_assureur(n, np.random.default_rng(2002)) # les n avenirs, simulés maintenantp, marge = estimer(ruines) if n > 0 else (None, None) # l'estimation et sa marge, comme à l'étape 1montrer("surplus", chemins=reserves, temps=np.arange(reserves.shape[1]), ruine=ruines, instants_ruine=instants, estimation=p, marge=marge)print(n, "avenirs :", ruines.sum(), "ruines ; estimation :", p, "±", marge)
Maj + Entrée
Avec le σ du pilote, il faut 21 773 avenirs. Ils donnent 117 ruines, soit 0,537 % ± 0,097 % : la marge visée, ± 0,1 point, est tenue. Dans la mosaïque, une case par avenir : les rares cases rouges sont les avenirs ruinés.
1L'idée
D’abord σ : l’écart-type des True et des False du pilote, comptés 1 et 0. Ensuite, écrivez que la marge 1,96 σ / √N vaut 0,001, et isolez N.
2La ligne à trous
sigma = pilote.___() puis N = (1.96 * sigma / _____)**2
3La solution
sigma = pilote.std(), environ 0,0753, puis N = (1.96 * sigma / 0.001)**2, environ 21 773 avenirs. Si 1,96 σ / √N = 0,001, alors √N = 1,96 σ / 0,001, et N en est le carré. On prend le σ du pilote, car l’écart-type observé sur les 100 avenirs sans ruine vaut 0.
pilote, _, _ = simuler_assureur(10_000, np.random.default_rng(2001), traces=0) # le pilote : 10 000 avenirs# pilote vaut True pour chaque avenir ruiné, False sinon ; les deux _ reçoivent ce qu'on ne garde pas (les tracés)sigma = pilote.std() # À vous : σ, l'écart-type d'un avenir (1 s'il est ruiné, 0 sinon), mesuré sur le piloteN = (1.96 * sigma / 0.001)**2 # À vous : le nombre d'avenirs pour une marge de ± 0,001 (0,1 point de pourcentage)n = 0 if N is None else int(np.ceil(N)) # un nombre entier d'avenirs, arrondi au-dessusif n > 50_000: # garde-fou : un N faux ne doit pas bloquer l'ordinateur print("N =", n, ": vérifiez le calcul avant une si longue simulation.") n = 0ruines, reserves, instants = simuler_assureur(n, np.random.default_rng(2002)) # les n avenirs, simulés maintenantp, marge = estimer(ruines) if n > 0 else (None, None) # l'estimation et sa marge, comme à l'étape 1montrer("surplus", chemins=reserves, temps=np.arange(reserves.shape[1]), ruine=ruines, instants_ruine=instants, estimation=p, marge=marge)print(n, "avenirs :", ruines.sum(), "ruines ; estimation :", p, "±", marge)
6La révélation
Verrouillez d'abord votre pari.
La chance exacte d’être ruiné un jour est de 0,4753 % (formule admise ici, expliquée en séance 3). Notre simulation s’arrête au 1 000e sinistre : l’écart dû à cet arrêt est inférieur à 0,002 point.
Votre fourchette, 0,537 % ± 0,097 %, contient la valeur exacte : c’est ce qui arrive environ 95 fois sur 100. Le rapport « zéro ruine sur cent » ne prouvait rien : avec la vraie chance de ruine, zéro ruine sur cent avenirs arrive 62 % du temps. Pour un événement rare, la précision se paie en avenirs : il en a fallu 21 773 pour ± 0,1 point, et une marge dix fois plus fine en demanderait cent fois plus, environ 2,2 millions. Attention : votre fourchette contient aussi le seuil de 0,5 %. Elle ne dit donc pas si l’assureur tient sa règle, même si la valeur exacte est juste en dessous. Pour trancher à moindre coût, la séance 3 apprend à viser les avenirs qui ruinent. Avec cette mission, la méthode du TP est complète : estimer par une moyenne, donner sa marge, et choisir le nombre de tirages avant de simuler.
7Comprendrepourquoi ceci, et pas cela
3 questions « pourquoi », avec leur réponse. Elles s’ouvrent quand votre pari est verrouillé : elles ne doivent rien vous souffler.
1Pourquoi « zéro ruine sur cent » ne veut-il pas dire « risque nul » ?
Une ruine sur 200, c’est rare : sur 100 avenirs, on en attend moins d’une en moyenne. Avec la vraie chance de ruine de cet assureur, 100 avenirs ne montrent aucune ruine dans 62 % des cas : c’est le résultat le plus fréquent. Le zéro du stagiaire vient donc du petit nombre d’avenirs, pas d’un risque nul. La marge aussi vaut zéro : 100 valeurs toutes égales à 0 ont un écart-type nul, et 1,96 × 0 / √N = 0. La marge à 95 % est une approximation, bonne quand on a vu assez de ruines ; sans aucune ruine, elle ne dit plus rien. Le rebondissement chiffre jusqu’où le risque peut monter sans contredire ce zéro.
En Python
Sur les 100 avenirs, la fonction estimer rend 0 pour la chance et 0 pour la marge, sans le moindre avertissement : la moyenne et l’écart-type d’une suite de zéros sont nuls. C’est à vous de lire ce zéro.
En finance
Solvabilité II, la règle européenne des assureurs, retient un niveau de confiance de 99,5 % pour les pertes de fonds propres de base à un an. Ici, on compte les réserves qui passent un jour sous zéro.
2Pourquoi calculer le nombre d’avenirs avant de simuler, et pas essayer jusqu’à ce que la marge convienne ?
Le nombre d’avenirs N, c’est le budget du calcul : chaque avenir coûte du temps de machine. Or la marge, 1,96 σ / √N, se prévoit sans rien simuler, dès qu’on connaît σ. Le pilote de 10 000 avenirs donne 0,57 % ± 0,15 % : trop large pour ± 0,1 point. À tâtons, on perdrait du temps : doubler N ne divise la marge que par √2, environ 1,4. On écrit plutôt 1,96 σ / √N = 0,001, et l’on isole N : le calcul dit d’avance combien d’avenirs simuler pour viser la marge voulue. Fixer N d’avance évite aussi un piège : s’arrêter au moment où le résultat arrange rend la fourchette trompeuse, car elle contient alors la vraie valeur moins souvent qu’annoncé.
En Python
La ligne N = … de l’étape 2 vient avant simuler_assureur(n, …). On simule d’abord le pilote pour prévoir N. Ensuite seulement, on tire les nouveaux avenirs et on mesure la marge obtenue. La cellule refuse même plus de 50 000 avenirs, pour qu’un N faux ne bloque pas l’ordinateur.
En finance
Un calcul de capital simule des milliers de scénarios économiques, et chacun coûte du temps de machine. On fixe d’abord la précision exigée, puis le nombre de scénarios : c’est ainsi qu’on prévoit le coût d’un calcul, à la banque comme chez l’assureur.
3Pourquoi mesurer σ sur une simulation pilote, et pas sur les cent avenirs de l’étape 1 ?
Sur les 100 avenirs de l’étape 1, aucune ruine : les 100 valeurs valent 0, leur écart-type aussi, et la formule donnerait N = 0. Il faut un premier essai plus grand, la simulation pilote : 10 000 avenirs, dont 57 ruinés, assez pour mesurer σ. Pour un avenir qui vaut 1 s’il est ruiné et 0 sinon, σ = √(p(1 − p)) : σ dépend de la chance de ruine p, que l’on cherche justement, d’où la mesure. Et pourquoi pas σ = 0,5, la borne valable pour toute proportion (σ ne la dépasse jamais) ? Elle est 6,6 fois plus grande que le σ du pilote, et N grandit comme le carré de σ : il serait 44 fois trop grand, 960 400 avenirs.
En Python
L’écart-type se lit avec .std(), comme dans la fonction estimer : sur les True et les False du pilote, comptés 1 et 0, il donne σ. Sur les 100 avenirs de l’étape 1, il donnerait 0, et la vérification vous le dirait.
En finance
C’est la pratique des grands calculs : un petit essai d’abord, pour mesurer la dispersion, puis le calcul complet, à la bonne taille. Un écart-type mal mesuré se paie : trop grand, des heures de calcul pour rien ; trop petit, une marge plus large que promis.
8Et si… ?pour qui a fini : une variante, qui prépare la suite
Et si l’on n’avait que les 100 avenirs du stagiaire ? Son « zéro ruine » ne prouve pas que le risque est nul, mais il rend invraisemblable un risque élevé, qui aurait montré des ruines. Jusqu’où le risque peut-il monter sans contredire ce zéro ? Cherchez la plus grande chance de ruine q pour laquelle « zéro ruine sur cent » arrive encore au moins une fois sur vingt (5 %). À la ligne borne = None, remplacez None par cette chance q : la scène trace alors la fourchette de 0 à borne. Comparez-la au seuil de 0,5 % : ce rapport peut-il se signer ?
Python en clair
a**(1/n)
la racine n-ième de a : le nombre qui, élevé à la puissance n, redonne a (dans l’exemple, 2 × 2 × 2 = 8). Ainsi a**(1/2) est la racine carrée de a.Exemple8**(1/3)→donne2.0
(1 - q)**100
la chance que 100 avenirs indépendants échappent tous à la ruine, si chacun y échappe avec la chance 1 − q. Au seuil de 0,5 %, elle vaut encore 61 %.Exemple(1 - 0.005)**100→donne0.6057704364907279
# Si la vraie chance de ruine vaut q, un avenir y échappe avec la chance 1 - q, et cent avenirs indépendants# y échappent tous avec la chance (1 - q)**100 : c'est la chance de voir zéro ruine sur cent.borne = None # À vous : la chance de ruine q pour laquelle (1 - q)**100 vaut 0,05# le rapport du stagiaire : zéro ruine sur cent, et ce que ce zéro permet d'affirmer (de 0 à borne)montrer("surplus", ruine=np.zeros(100, dtype=bool), estimation=0.0, marge=borne)print("« zéro sur cent » reste plausible jusqu'à une chance de ruine de", borne)
Maj + Entrée
« Zéro sur cent » laisse possible une chance de ruine de 2,95 %, environ 6 fois le seuil de 0,5 %. Ce rapport ne se signe pas. C’est la « règle de trois » des statisticiens : zéro événement sur N essais laisse possible une chance d’environ 3/N. Le stagiaire pouvait seulement écrire : « la chance de ruine est au plus d’environ 3 %, à 95 % ».
1L'idée
Un avenir échappe à la ruine avec la chance 1 − q. Cent avenirs indépendants y échappent tous avec la chance (1 − q)¹⁰⁰. Écrivez qu’elle vaut 0,05, soit une fois sur vingt, puis isolez q : prenez la racine centième des deux côtés.
2La ligne à trous
borne = 1 - 0.05**(1/___)
3La solution
borne = 1 - 0.05**(1/100), environ 2,95 %. Si (1 − q)¹⁰⁰ = 0,05, alors 1 − q est la racine centième de 0,05, et q vaut 1 moins cette racine. Au-delà de cette borne, voir zéro ruine sur cent arriverait moins d’une fois sur vingt.
# Si la vraie chance de ruine vaut q, un avenir y échappe avec la chance 1 - q, et cent avenirs indépendants# y échappent tous avec la chance (1 - q)**100 : c'est la chance de voir zéro ruine sur cent.borne = 1 - 0.05**(1/100) # À vous : la chance de ruine q pour laquelle (1 - q)**100 vaut 0,05# le rapport du stagiaire : zéro ruine sur cent, et ce que ce zéro permet d'affirmer (de 0 à borne)montrer("surplus", ruine=np.zeros(100, dtype=bool), estimation=0.0, marge=borne)print("« zéro sur cent » reste plausible jusqu'à une chance de ruine de", borne)
9À retenir, et je signe
Un résultat simulé se signe avec sa marge ; pour un événement rare, la marge se paie en avenirs, et leur nombre se calcule avant de simuler : N = (1,96 σ / marge visée)².
Une phrase modèle
Avec 21 773 avenirs, j’estime la chance de ruine à 0,537 % ± 0,097 %, une fourchette qui contient la valeur exacte, 0,475 % ; je refuse « zéro sur cent », qui n’exclut pas une chance de ruine de 2,95 %.
TP 1Après la mission 4
Mon bilan
Vos paris, votre code, les phrases que vous avez signées, et le Python du TP.
Le bilan se remplit au fil des missions : paris verrouillés, cellules justes, phrases signées. Il reste dans ce navigateur.
Le Python du TP 1
Les 19 mots de Python que les missions ont apportés, dans l’ordre où ils sont venus : de quoi relire vos lignes.
1Mission 1 · Le pari du chevalier de Méré
np.array([True, False, True])
un tableau, écrit ici à la main : des valeurs rangées à la suite, une par case (np désigne NumPy, la boîte à outils de calcul chargée au début du TP). gagne_A est un tableau de 1 000 cases, une par partie : True (vrai) si la partie est gagnée, False (faux) sinon.
True, False
vrai, faux. Dans un calcul, Python compte True pour 1 et False pour 0.
x.sum()
la somme des valeurs du tableau x (sum veut dire « somme » en anglais). Ici, x désigne n’importe quel tableau : le point applique l’opération à x, et les parenthèses, vides, lancent le calcul. Sur des True et des False, la somme est le nombre de True.
x.mean()
la moyenne des valeurs du tableau x, c’est-à-dire leur somme divisée par leur nombre (mean veut dire « moyenne »). Sur des True et des False, c’est la part de True : un nombre entre 0 et 1. Python écrit les nombres décimaux avec un point au lieu de la virgule.
a > b
compare deux tableaux de même taille, case par case : True là où la valeur de a est strictement plus grande que celle de b, False ailleurs. Une égalité donne donc False. Pour inclure les égalités parmi les succès de A, écrivez a >= b. Pour compter les égalités seules, écrivez a == b.
2Mission 2 · π, et le prix d’une décimale
a * b
a fois b : en Python, le signe « fois » s’écrit *, comme dans Excel.
def estimer(x): … return …
une fonction : un calcul qui porte un nom. def la crée ; x désigne les tirages qu’on lui donnera ; return dit ce qu’elle rend. Les lignes décalées de quatre espaces forment son corps : gardez ce décalage dans votre ligne. On s’en sert en l’appelant par son nom, les tirages entre parenthèses, comme len(x), qui compte les valeurs de x : estimer(4 * dedans) fait le calcul sur vos fléchettes.
x.std()
l’écart-type des valeurs de x : de combien une valeur s’écarte d’habitude de leur moyenne (dans Excel, ECARTYPE.PEARSON). Dans l’exemple, comme pour une fléchette, chaque valeur vaut 4 ou 0.
np.sqrt(N)
la racine carrée de N (dans Excel, RACINE) ; np désigne NumPy, la boîte à outils de calcul.
1.96 * a / b
comme en mission 1, un nombre décimal s’écrit avec un point : 1.96, et non 1,96. Le calcul se lit de gauche à droite : 1,96 fois a, puis le tout divisé par b.
(a / b)**2
le carré de a / b : en Python, la puissance s’écrit ** (le ^ d’Excel veut dire autre chose en Python). Les parenthèses mettent au carré tout le quotient ; sans elles, seul b le serait.
1e-4
l’écriture scientifique : 1e-4 veut dire 1 × 10⁻⁴, soit 0,0001 ; de même, 1e10 vaut dix milliards.
3Mission 3 · Le prix d’une option, et celle qui n’a pas de formule
S[:, -1]
la dernière colonne du tableau S : le prix de chaque avenir au dernier mois, donc à l’échéance. Entre crochets, on écrit d’abord les lignes, puis les colonnes : : veut dire « toutes les lignes », et -1 « la dernière colonne ». Un calcul entre ce tableau et un nombre se fait case par case, avenir par avenir, comme une formule Excel recopiée sur toute une colonne.
np.maximum(a, 0)
case par case, le plus grand des deux : la valeur de a, ou 0 (dans Excel, MAX(A1;0) recopié sur la colonne). Un nombre négatif devient 0 ; un nombre positif ne change pas. Attention : np.max, sans « imum », donne un seul nombre, le plus grand du tableau.
np.exp(x)
l’exponentielle, e^(x) (dans Excel, EXP). Par exemple, e^(−0,05 × 1) ≈ 0,9512 : ce que vaut aujourd’hui un euro reçu dans un an, au taux sans risque de 5 %.
S.mean(axis=1)
la moyenne de chaque ligne de S : pour chaque avenir, la moyenne de ses 12 prix de fin de mois (dans Excel, MOYENNE sur chaque ligne). Sans axis, .mean() (mission 1) ferait la moyenne de tout le tableau, un seul nombre ; avec axis=0, la moyenne de chaque colonne, c’est-à-dire de chaque mois.
4Mission 4 · La ruine une fois sur deux cents
0.001
un millième, écrit avec un point comme tout nombre décimal en Python. Attention aux unités : un dixième de point de pourcentage, 0,1 %, vaut 0,001 en proportion.
a**(1/n)
la racine n-ième de a : le nombre qui, élevé à la puissance n, redonne a (dans l’exemple, 2 × 2 × 2 = 8). Ainsi a**(1/2) est la racine carrée de a.
(1 - q)**100
la chance que 100 avenirs indépendants échappent tous à la ruine, si chacun y échappe avec la chance 1 − q. Au seuil de 0,5 %, elle vaut encore 61 %.
Le fichier, avec votre code, sert à travailler hors du site (dans Jupyter, ou dans Google Colab) ; en classe, il n’est pas nécessaire : tout se fait sur cette page.
Cellule librePour essayer une idée, ou le code donné en séance : rien n'est vérifié ni noté
# Collez ou écrivez votre code ici, puis « Exécuter »