L’étude des marches aléatoires constitue un pont fondamental entre l’analyse des suites et surtout le calcul des probabilités, deux piliers du programme de mathématiques en ECG. À travers cet article, nous allons explorer la modélisation de ce phénomène, sa traduction en langage Python et les méthodes de simulation de Monte-Carlo qui permettent d’estimer des probabilités parfois complexes à obtenir par le calcul direct. Nous introduirons le problème en lui-même et quelques résultats mathématiques fondamentaux, avant de simuler une trajectoire de partie avec Python, puis la probabilité moyenne de ruine par la méthode de Monte-Carlo. Pour ceux qui le désirent, il sera possible d’aller plus loin en estimant le temps moyen de jeu.
Introduction au problème et résultats fondamentaux
Le problème de la ruine du joueur est un classique des concours ECG. Il repose sur l’étude d’une marche aléatoire sur \(\mathbb{Z}\). Un joueur possède un capital initial \(S_0\). À chaque étape, il gagne 1 € avec une probabilité \(p\) et perd 1 € avec une probabilité \(q = 1-p\).
Le capital au temps \(n\) est défini par :
\[ S_n = S_0 + \sum_{i=1}^n X_i \]
Où les \((X_i)\) sont des variables aléatoires indépendantes et de même loi (loi de Bernoulli décalée, cette dernière est hors programme, mais puisqu’elle revient très souvent dans les sujets, il est intéressant de la retenir).
Le jeu s’arrête lorsque le capital atteint \(0\) (ruine) ou un plafond \(M\) (objectif de gain). Mathématiquement, la probabilité de ruine \(u_k\) en commençant avec un capital \(k\) vérifie la relation de récurrence :
\[ u_k = p \cdot u_{k+1} + q \cdot u_{k-1} \]
Nous ne reviendrons pas sur la démonstration de cette suite récurrente linéaire d’ordre 2. Ainsi, pour conclure cette partie, voici quelques sujets qui traitent de la ruine du joueur et qui te permettront de démontrer les principaux résultats relatifs à ce cas de figure : EMLyon ECE 2022, EDHEC 2014 ECS, EDHEC 2021 Maths Approfondies, Ecricome 2015 ECE.
Simulation d’une trajectoire en Python
Nous cherchons ici à simuler graphiquement une trajectoire possible d’un tel jeu. Voici une proposition de code pour réaliser cela, que nous allons décrypter :
On obtient alors le graphique suivant :
On voit, par exemple, que l’on aboutit ici à la ruine. Mais, en l’occurrence, le graphique changerait à chaque fois que l’on exécuterait ce code, donc inutile de chercher à obtenir le même graph qu’ici.
Voici l’explication du code :
- On crée d’abord une fonction simulation_ruine qui prend en compte la probabilité de succès, le capital de départ, mais également le montant de capital maximal à partir duquel le jeu s’arrête. On simule ainsi une partie avec la boucle While, car l’on continue à jouer tant que le capital est positif et inférieur à notre montant maximal. trajectoire est alors un vecteur constitué de toutes les valeurs que le capital a pris à chaque partie du jeu.
- On produit ensuite simplement un graph à l’aide de plt.plot et on peut également tracer des lignes pour visualiser \(M\) et le seuil de 0 pour apercevoir « la tranche » dans laquelle le capital doit se situer pour continuer le jeu.
Estimation de la probabilité moyenne de ruine par la méthode de Monte-Carlo
Pour estimer la probabilité moyenne de ruine, on simule \(N\) parties indépendantes et on applique la loi des grands nombres. Le script parcourt un grand nombre de simulations et comptabilise les cas où le dernier élément de la trajectoire est égal à zéro.
Attention, on ne calcule pas ici la probabilité exacte, mais une estimation de cette dernière grâce à la loi forte des grands nombres !
NB : la fonction simulation_ruine est celle que nous avions présentée dans le script précédent, qui calcule une trajectoire possible du jeu.
Approfondissements : temps de sortie
Temps moyen de jeu
Le nombre de tours avant l’arrêt du jeu est une variable aléatoire \(T\). Dans le cas d’un jeu équilibré (\(p=1/2\)), on démontre que l’espérance du temps de jeu est donnée par la formule \(E(T) = S_0 \times (M – S_0)\).
Réalisons alors une estimation empirique de ce résultat avec Python. Pour rappel, le jeu continue tant que le capital est situé entre 0 et \(M\). Voici alors un exemple de script qui permet de simuler ce temps moyen de jeu :
La ligne 2 permet de créer un vecteur vide qui va contenir par la suite les temps totaux de durées de \(N\) parties jouées pour voir en combien de temps en moyenne le jeu s’arrête (soit parce que l’on a atteint le plafond \(M\) de capital, soit parce que le joueur est ruiné).
À la ligne 4, on convoque la fonction simulation_ruine codée précédemment qui renvoie pour rappel un vecteur \([S_0;…;S_T]\) du capital à chaque instant. Ce vecteur est de longueur \(T+1\) auquel on doit déduire le temps 0 puisqu’aucune partie n’a été jouée. Le temps de jeu est donc de len(simulation_ruine(S0,M,p))-1.
Une fois le vecteur temps_totaux rempli, on estime le temps moyen de ruine en réalisant la moyenne des valeurs de ce vecteur.
Conclusion
En définitive, le problème de la ruine du joueur est une notion récurrente abordée dans les sujets d’écrits par l’EDHEC, ECRICOME ou encore l’EMLYON. Ainsi, il est très important de se familiariser avec ce problème pour comprendre, une fois l’énoncé appréhendé, les principaux enjeux dont découlent les questions tant mathématiques que de simulation Python.
Tu peux retrouver ici le méga-répertoire qui contient toutes les annales de concours et les corrigés. Tu peux également accéder ici à toutes nos autres ressources mathématiques !
