Not That Abstract
Français English

TP 1 — L'estimation par simulation

4 missions · 1 h 10 · Python dans le navigateur, rien à installer

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).

Télécharger le kit (.zip)Lire la consigne (PDF)Ouvrir l’expérienceÀ ouvrir après avoir signé votre conseil, question 5.2.

Mission 1 sur 4 Niveau 1 15 min

Le pari du chevalier de Méré

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 ?

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^=kN\hat p = \dfrac{k}{N}

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.

  1. À 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.
  2. Faites de même à la ligne p_B = None, avec gagne_B.
  3. 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 + Falsedonne2
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 6
des_B = rng.integers(1, 7, size=(N, 24, 2))      # pari B : N parties de 24 lancers de deux dés
gagne_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 1
p_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
1 L'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.

2 La ligne à trous

p_A = gagne_A.____() et p_B = ______.mean()

3 La 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 6
des_B = rng.integers(1, 7, size=(N, 24, 2))      # pari B : N parties de 24 lancers de deux dés
gagne_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 1
p_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.

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.

Pourquoi 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.

Pourquoi 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.

Pourquoi 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.

  1. À 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.
  2. À 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.
  3. 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 pari
k_A = rng.binomial(100, 1 - 5**4 / 6**4, saisons)       # parties gagnées au pari A, saison par saison
k_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 B
devant_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
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 pari
k_A = rng.binomial(100, 1 - 5**4 / 6**4, saisons)       # parties gagnées au pari A, saison par saison
k_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 B
devant_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.

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 ?

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\text{erreur typique} = \dfrac{\sigma}{\sqrt{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,96 σ^N\text{estimation} \pm 1{,}96\,\dfrac{\hat\sigma}{\sqrt{N}}

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.

  1. À la ligne pi_hat = None, remplacez None, qui veut dire « rien encore », par une estimation de π tirée de dedans.
  2. 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.25donne0.75
rng = np.random.default_rng(21)    # le hasard, fixé par la graine 21 : les fléchettes du film
N = 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ées
dedans = 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 estimation
montrer("flechettes", x=x, y=y, dedans=dedans, estimation=pi_hat)
print("π estimé :", pi_hat)
Maj + Entrée
1 L'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 π.

2 La ligne à trous

pi_hat = _ * dedans.mean()

3 La 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 film
N = 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ées
dedans = 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 estimation
montrer("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.

  1. À 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.
  2. 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.
  3. 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 / 4donne4.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 nombres


pi_hat, marge = estimer(4 * dedans)    # vos 3 200 fléchettes : 4 si dedans, 0 sinon
print("π ≈", 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 neuves
tailles = [100, 400, 1_600, 6_400, 25_600]  # cinq nombres de fléchettes, chacun 4 fois le précédent
erreurs, marges = [], []                    # deux listes vides, remplies par la boucle
for 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 logarithmiques
pente = 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
1 L'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 ».

2 La ligne à trous

marge = 1.96 * x.____() / np.____(N)

3 La 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 nombres


pi_hat, marge = estimer(4 * dedans)    # vos 3 200 fléchettes : 4 si dedans, 0 sinon
print("π ≈", 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 neuves
tailles = [100, 400, 1_600, 6_400, 25_600]  # cinq nombres de fléchettes, chacun 4 fois le précédent
erreurs, marges = [], []                    # deux listes vides, remplies par la boucle
for 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 logarithmiques
pente = 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.

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.

Pourquoi 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.

Pourquoi 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.

Pourquoi 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.

Pourquoi 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)**2donne4.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.0001donneTrue
# 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 relie
montrer("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
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 relie
montrer("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.

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 ?

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)]  ≈  1N∑i=1Nf(Xi)E\,[f(X)] \;\approx\; \frac{1}{N}\sum_{i=1}^{N} f(X_i)

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.

  1. À la ligne gains = None, remplacez None par le gain de chaque avenir : son prix final moins K = 100 € s’il est positif, 0 sinon.
  2. À 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.
  3. 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.0
z = rng.standard_normal((N, 12))                       # N avenirs, 12 mois
S = 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 mois

gains = 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
1 L'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.

2 La ligne à trous

gains = np.maximum(S[:, -1] - K, _) puis prix, marge = estimer(np.exp(-r * T) * _____)

3 La solution

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.0
z = rng.standard_normal((N, 12))                       # N avenirs, 12 mois
S = 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 mois

gains = 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.

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.

Pourquoi 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.

Pourquoi 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.

Pourquoi 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).

Pourquoi 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 K
prix, 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
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 K
prix, 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.

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 ?

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^=kN\hat p = \dfrac{k}{N}

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,96 σ^N⟹N=(1,96 σ^ε)2\begin{gathered}\hat p \pm 1{,}96\,\dfrac{\hat\sigma}{\sqrt{N}} \\ \Longrightarrow\quad N = \left(\dfrac{1{,}96\,\hat\sigma}{\varepsilon}\right)^{2}\end{gathered}

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.

  1. À 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.
  2. 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, instants


rng = np.random.default_rng(200)
ruines, reserves, instants = simuler_assureur(100, rng)   # les 100 avenirs de l'expérience

p, 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
1 L'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.

2 La ligne à trous

p, marge = _______(ruines)

3 La 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, instants


rng = np.random.default_rng(200)
ruines, reserves, instants = simuler_assureur(100, rng)   # les 100 avenirs de l'expérience

p, 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é).

  1. À la ligne sigma = None, remplacez None par l’écart-type des valeurs de pilote.
  2. À la ligne N = None, remplacez None par le nombre d’avenirs pour lequel 1,96 σ / √N vaut 0,001, la marge visée.
  3. 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)**2donne9.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 / 100donne0.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 pilote
N = 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-dessus
if 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 = 0
ruines, reserves, instants = simuler_assureur(n, np.random.default_rng(2002))   # les n avenirs, simulés maintenant
p, marge = estimer(ruines) if n > 0 else (None, None)   # l'estimation et sa marge, comme à l'étape 1
montrer("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
1 L'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.

2 La ligne à trous

sigma = pilote.___() puis N = (1.96 * sigma / _____)**2

3 La 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 pilote
N = (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-dessus
if 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 = 0
ruines, reserves, instants = simuler_assureur(n, np.random.default_rng(2002))   # les n avenirs, simulés maintenant
p, marge = estimer(ruines) if n > 0 else (None, None)   # l'estimation et sa marge, comme à l'étape 1
montrer("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.

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.

Pourquoi « 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.

Pourquoi 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.

Pourquoi 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)**100donne0.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
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)².

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.

Mission 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.

Mission 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.

Mission 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.

Mission 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 »
Maj + Entrée
Échap

    Tapez pour chercher dans le polycopié, les transcriptions et les TP.

    ↑ ↓ choisirEntrée ouvrir

    Raccourcis clavier

    Partout

    / Ctrl K
    Rechercher dans tout le cours
    g h
    Accueil
    g 1…7
    Aller à une séance
    n p
    Séance suivante, précédente
    ?
    Cette aide

    Vidéo

    Espace k
    Lecture, pause
    j l
    Reculer, avancer de 10 s
    ← →
    Reculer, avancer de 5 s
    [ ]
    Chapitre précédent, suivant
    c
    Sous-⁠titres
    f
    Plein écran
    m
    Couper le son
    < >
    Vitesse
    0…9
    Aller à 0 %, 10 %… 90 %

    TP dans le navigateur

    Maj Entrée
    Exécuter la cellule
    Ctrl Entrée
    Exécuter sans passer à la suivante