Physique-chimie · Terminale · Enseignement de spécialité · Pour aller plus loin n°2

Chaque atome
joue à pile ou face.

La décroissance radioactive suit une loi exponentielle bien connue — mais cette loi n'est en réalité qu'une moyenne. À l'échelle d'un seul atome, la désintégration est un pur coup de hasard. Tu vas simuler ce hasard atome par atome, et découvrir que le modèle continu n'émerge vraiment que lorsque la population devient suffisamment grande.

decroissance.py — aperçuNrestants = 100
t

Objectif de la fiche : utiliser un langage de programmation pour rendre compte de la décroissance radioactive, en simulant individuellement le comportement aléatoire de chaque atome plutôt qu'en appliquant directement une formule.

Cette fiche est autonome : tu n'as besoin d'aucun autre document. Chaque étape contient un script incomplet à compléter, puis à copier-coller dans Thonny (ou dans la console Basthon tout en bas de la page si tu n'as pas Thonny sous la main).

＋

Contexte : un hasard à l'échelle de l'atome

À savoir
  • La décroissance radioactive est habituellement décrite par une loi continue et déterministe : N(t) = N0·e-t/τ. Pourtant, à l'échelle d'un seul atome, la désintégration est un processus fondamentalement aléatoire : impossible de prédire à quel instant précis un atome donné va se désintégrer, seulement la probabilité qu'il le fasse pendant un intervalle de temps donné.
  • Cette fiche propose de simuler ce processus atome par atome, avec le module random de Python, pour observer à quel point (et à partir de quelle taille de population) le hasard microscopique finit par produire, en moyenne, la loi continue bien connue.
00

Importer le module random

À savoir
  • En plus de numpy et matplotlib.pyplot, cette fiche a besoin du module random, qui permet de générer des tirages aléatoires.
etape0_import.py
import numpy as np
import matplotlib.pyplot as plt
import random
01

La fonction radioactivité

Consigne
  • Définis une fonction radioactivité(NA), qui prend en argument le nombre d'atomes non désintégrés à un instant donné, et renvoie le nombre d'atomes restants un pas de temps plus tard.
  • Pour chaque atome (une boucle for i in range(0, NA) :), effectue un tirage au sort avec random.randint(1, 50) : cette instruction génère un entier aléatoire entre 1 et 50, avec donc une chance sur 50 d'obtenir 1.
  • Si le tirage donne 1, admets que l'atome correspondant s'est désintégré : décrémente le compteur d'atomes restants.
etape1_fonction_radioactivite.py
def radioactivité(NA) :
    Nrestants = __
    for i in range(0, __) :
        if random.randint(_, __) == _ :
            Nrestants = Nrestants - _
    return Nrestants
Indice

Le nombre 50 n'est pas arbitraire : c'est lui qui fixe la « vitesse » de la décroissance simulée — plus ce nombre est petit, plus chaque atome a de chances de se désintégrer à chaque pas, et plus la population totale diminue vite.

02

Simuler l'évolution complète

Consigne
  • Initialise t = 0, une population de départ nb = 100 (garde aussi cette valeur de côté dans n0 = 100, elle servira plus tard), et deux listes vides Nr et Tr.
  • Tant que nb > 0 : ajoute t à Tr et nb à Nr, applique la fonction radioactivité pour faire évoluer nb d'un pas de temps, puis incrémente t.
etape2_simulation.py
t = _
nb = ___
n0 = ___
Nr = []
Tr = []
while nb > _ :
    Tr.append(_)
    Nr.append(__)
    nb = radioactivité(__)
    t = t + _
Résultat attendu

Aucun affichage immédiat : la boucle while tourne jusqu'à ce que tous les atomes se soient désintégrés (ce qui prend, ici, de l'ordre de 150 à 250 pas de temps selon le hasard du tirage).

03

Tracer la décroissance simulée

Consigne
  • Trace Nr en fonction de Tr, en ligne rouge, avec la légende 'Nr(Tr)', une grille et les étiquettes d'axes.
etape3_trace.py
plt.plot(__, __, '__', label='______')
plt.legend(loc='____')
plt.xlabel('_')
plt.ylabel('________________________')
plt.grid()
plt.show()
Résultat attendu

Une courbe en escalier qui décroît globalement, mais de façon irrégulière — pas une exponentielle lisse. Relance l'ensemble du script (étapes 2 et 3) plusieurs fois : la courbe change d'allure à chaque exécution, une conséquence directe du caractère aléatoire du processus microscopique simulé.

04

Comparer au modèle exponentiel continu

Consigne
  • Définis une fonction Nthéo(u), qui renvoie n0*np.exp(-u/50) — le modèle continu associé, où la constante 50 correspond au même paramètre que dans le tirage aléatoire de l'étape 1.
  • Crée une base de temps fine avec np.linspace, entre t0 = 0. et tf = 400., avec N = 10000 pas.
  • Trace sur un même graphe la courbe simulée Nr(Tr) et la courbe théorique Nthéo en fonction de cette nouvelle base de temps.
etape4_modele_continu.py
def Nthéo(u) :
    return __*(np.exp(-u/__))

t0, tf = 0., 400.
N = 10000
t = np.linspace(__, __, N+1)

plt.figure()
plt.plot(Tr, Nr, '__', label='______')
plt.plot(_, Nthéo(_), '__', label='_________________')
plt.legend(loc='____')
plt.xlabel('_')
plt.ylabel('________________________')
plt.grid()
plt.show()
Résultat attendu

Les deux courbes ont globalement la même allure, mais la courbe rouge simulée s'écarte visiblement de la courbe bleue théorique par endroits — le modèle exponentiel ne traduit qu'imparfaitement la réalité pour une population aussi petite que 100 atomes.

05

Et avec beaucoup plus d'atomes ?

Consigne
  • Reprends les étapes 2 à 4, mais remplace la population initiale : nb = 5000 et n0 = 5000 (au lieu de 100).
etape5_grande_population.py
t = 0
nb = ____
n0 = ____
Nr = []
Tr = []
while nb > 0 :
    Tr.append(t)
    Nr.append(nb)
    nb = radioactivité(nb)
    t = t + 1
Résultat attendu

Avec n0 = 5000, les deux courbes (simulée et théorique) deviennent quasiment indiscernables à l'œil : le modèle continu, qui n'était qu'une approximation grossière pour 100 atomes, devient excellent pour une population suffisamment grande.

＋

Conclusion

À retenir
  • Cette simulation illustre concrètement la loi des grands nombres : un processus individuellement imprévisible (la désintégration d'un atome donné) devient, à l'échelle d'une population suffisamment grande, quasiment prévisible en moyenne.
  • C'est à la fois une belle illustration de la puissance prédictive des modèles continus (équations différentielles, lois exponentielles…), et une mise en garde : ces modèles ne sont que des approximations, dont la validité dépend du contexte — ici, de la taille de la population considérée. Le nombre d'atomes dans un échantillon réel de matière radioactive (de l'ordre de 10²³) explique pourquoi la loi exponentielle continue y est si excellente.

Pense-bête — simuler un processus aléatoire

random.randint(a,b)entier aléatoire entre a et b inclus
def f(x): ... return ...fonction qui renvoie une valeur calculée
while condition :boucle tant que la condition est vraie
petite populationfortes fluctuations autour du modèle continu
grande populationconvergence vers le modèle continu
loi des grands nombresla moyenne devient prévisible même si l'individu ne l'est pas

Pas de Thonny sous la main ? Utilise Basthon

Ouvrir dans un nouvel onglet ↗
Basthon est une console Python qui tourne directement dans le navigateur, sans rien installer. Colle ici (avec Ctrl+V ou Cmd+V) le code copié avec les boutons « Copier le code » ci-dessus, puis appuie sur Entrée pour l'exécuter.