Modélisation de la ruine du joueur 2020-2021

Dans le cadre du module de VISI201, nous allons réaliser la modélisation de la ruine d'un joueur. C'est à dire, à l'aide d'un programme, de comprendre comment les casinos arrivent à gagner de l'argent en proposant le jeu de la roulette. La première partie explique qu'est ce que la ruine d'un joueur. Puis nous vous proposons la simulation d'une soirée au casino. Et enfin une partie mathématique avec des calculs de probabilités, du temps moyen de jeu et des estimations numériques.

Qu'est ce que la ruine d'un joueur ?

Un joueur de roulette arrive au casino avec une somme d'argent finie, et il souhaite gagner une certaine somme d'argent. Le joueur repart soit quand il est ruiné soit quand il a gagné le montant qu'il voulait. Le temps est compté et il n'y a aucune stratégie pour gagner c'est un jeu de hasard. Si le joueur n'a pas de somme a atteindre et qu'il a un temps illimité il finira ruiné.

Règles de la roulette

Pour notre modélisation de la ruine d'un joueur, nous avons simplifié les règles de la roulette.

La roulette est constituée de 37 numéros : le 0 est vert, 18 pairs rouges et 18 impairs noirs.

Le joueur arrive avec une richesse initiale notée $a$, il souhaite gagner $b$ euro. A chaque tour le joueur mise un euro sur les nombres pairs, si il tombe sur un nombre pair il gagne 1€ sinon il perd 1€. Si il tombe sur zéro il perd aussi 1€.

Une soirée au casino (simulation)

Pour la simulation nous posons trois variables :

 - $a$ la richesse du joueur à l'entrée du casino
 - $b$ le gain souhaité par le joueur
 - $p$ la probabilité de gagner

Une partie de "Pile ou Face"

La partie de "Pile ou face" a pour but de lancer une pièce et de regarder sur quelle face elle tombe. Les pièces de monnaie étant équilibrées la probabilité de tomber sur pile est égal à la probabilité de tomber sur face, c'est à dire que la probabilité et de ${\frac {1}{2}}$.

Pour la simulation on prend les mêmes règles que pour la roulette : le joueur mise sur une face si il a bon il gagne 1€, sinon il les perd.

def pile_ou_face(a,b):
    """simulation d'une soirée au casino (jeu de la roulette)

            en entrée : a la richesse initiale du joueur
                        b la somme que le joueur veut atteindre
            en sortie : g -> 0 si ruiné sinon 1
                        s le tableau de l'évolution de l'argent du joueur
                        t le temps de la partie """
    c = a   
    s = [a]
    while c != 0 and c < a + b :
        res = random.uniform(0,1) # renvoie un nombre entre 0 et 1
        if res <= 0.5: #Joueur à gagner cette mise
            c = c + 1
        else :       #Joueur à perdu cette mise
            c = c - 1
        s = s + [c]
    if c == 0 :         # Joueur ruiné
        g = 0
    elif c == a + b :   # Joueur a gagné
        g =  1
    t = len(s)          #Temps de jeu
    return s, g, t

ATTENTION : Pour exécuter ce code python il faut importer la librairie random

Cette simulation renvoie trois résultats. Le premier résultat correspond à l'évolution de la richesse du joueur, le deuxième résultat permet de savoir facilement si le joueur a gagné (soit $g=1$). Et le dernier résultat correspond au temps de jeu (c'est à dire le nombre de mises pour gagner ou être ruiné).

Une partie de roulette

Pour la simulation d'une partie de roulette, nous allons prendre les règles simplifiées.

Lors que le joueur mise sur pair il a une probabilité à chaque mise $p={\frac {18}{37}}$. Cette probabilité est dû au fait qu'il y a 37 cases au total et qu'il y a 18 cases gagnantes.

Le code reste le même sauf qu'il faut changer la probabilité de gagner à chaque mise.

def casino(a,b):
    """simulation d'une soirée au casino (jeu de la roulette)

            en entrée : a la richesse initiale du joueur
                        b la somme que le joueur veut atteindre
            en sortie : g -> 0 si ruiné sinon 1
                        s le tableau de l'évolution de l'argent du joueur
                        t le temps de la partie """
    c = a   
    s = [a]
    while c != 0 and c < a + b :
        res = random.uniform(0,1) # renvoie un nombre entre 0 et 1
        if res <= 18/37: #Joueur à gagner cette mise
            c = c + 1
        else :       #Joueur à perdu cette mise
            c = c - 1
        s = s + [c]
    if c == 0 :         # Joueur ruiné
        g = 0
    elif c == a + b :   # Joueur a gagné
        g =  1
    t = len(s)          #Temps de jeu
    return s, g, t

ATTENTION : Pour exécuter ce code python il faut importer la librairie random

Cette simulation renvoie trois résultats. Le premier résultat correspond à l'évolution de la richesse du joueur, le deuxième résultat permet de savoir facilement si le joueur a gagné (soit $g=1$). Et le dernier résultat correspond au temps de jeu (c'est à dire le nombre de mises pour gagner ou être ruiné).

Code général

Nous vous proposons un code général qui permet de calculer tout type de jeux qui se font sur plusieurs mises. La deuxième fonction permet d'avoir le même résultat mais trace en plus un graphe de l'évolution de la richesse du joueur.

def ruine(a,b,p):
    """simulation d'une soirée au casino (jeu de la roulette)

            en entrée : a la richesse initiale du joueur
                        b la somme que le joueur veut atteindre
                        p la probabilité de gagner (mise pair)
            en sortie : g -> 0 si ruiné sinon 1
                        s le tableau de l'évolution de l'argent du joueur
                        t le temps de la partie """
    c = a   
    s = [a]
    while c != 0 and c < a + b :
        res = random.uniform(0,1) # renvoie un nombre entre 0 et 1
        if res <= p: #Joueur à gagner cette mise
            c = c + 1
        else :       #Joueur à perdu cette mise
            c = c - 1
        s = s + [c]
    if c == 0 :         # Joueur ruiné
        g = 0
    elif c == a + b :   # Joueur a gagné
        g =  1
    t = len(s)          #Temps de jeu
    return s, g, t

def graphe(a,b,p):
    """fonction qui trace le graphe de l'évolution de la richesse du joueur
            en entrée : a la richesse initiale du joueur
                        b la somme que le joueur veut atteindre
                        p la probabilité de gagner (mise pair)
            en sortie : le graphe """
    
    casino = ruine(a,b,p)
    print(casino)
    plt.clf()                               #pas de graphe antérieur sur la figure
    x = [i for i in range(len(casino[0]))]  #coordonées en x
    y = casino[0]                           #coordonnées en y

    plt.plot(x,y)                           #dessin du graphe
    plt.title("simulation d'une soirée au casino")#titre du graphe
    plt.xlabel("n° de mise")                #titre de l'axe des abscisses
    plt.ylabel("richesse du joueur")        #titre de l'axe des ordonnées

    plt.show()                              #afficher le graphe
    plt.close

ATTENTION :

• Pour exécuter ce code python il faut importer les librairies random et matplotlib.pyplot.
• Pour exécuter la procédure graphe il faut copier les deux fonctions dans un interpréteur python.

Cette simulation renvoie trois résultats. Le premier résultat correspond à l'évolution de la richesse du joueur, le deuxième résultat permet de savoir facilement si le joueur a gagné (soit $g=1$). Et le dernier résultat correspond au temps de jeu (c'est à dire le nombre de mises pour gagner ou être ruiné).

Calculs de probabilités

Pour le calcul de la probabilité de perdre, nous allons nous intéresser seulement à celle d'une soirée d'un casino. Le code est adapté pour calculer la probabilité de perdre pour tous les jeux.

Pour avoir la probabilité de gagner il suffit de soustraire la probabilité de perdre à 1.

Probabilité de perdre

Pour notre calcul de la probabilité de perdre, nous devons simuler plusieurs mise et le divisé par le nombre de mise.

def est_ruine(a,b,p,nb):
    """Fonction qui compte le nombre de fois ou le joueur est ruiné

            en entrée : a la richesse initiale du joueur
                        b la somme que le joueur veut atteindre
                        p la probabilité de gagner (mise pair)
                        nb le nombre de soirée
            en sortie : une probabilité, le nombre de fois ou le joueur repart ruiné"""
    i = 0
    res = 0
    while nb > i :
        
        if ruine(a,b,p)[1] != 1:
            res = res + 1
        i = i + 1
    return res / nb

ATTENTION Pour exécuter cette fonction il faut aussi prendre la fonction Code général.

Calcul du temps moyen de jeu

Le calcul du temps moyen se fait comme le calcul de la probabilité de perdre. Nous simulons une soirée avec plusieurs mises, nous regardons le temps de jeu, et nous divisons par le nombre de mises.

Le code suivant permet de calculer le temps moyen de jeu

def temps_moy(a,b,p,nb):
    """Fonction qui calcul le temps moyen d'une soirée au casino

        en entrée : a la richesse initiale du joueur
                        b la somme que le joueur veut atteindre
                        p la probabilité de gagner (mise pair)
                        nb le nombre de soirée
        en sortie : un entier, le temps moyen passé au casino"""
    d = 0
    c = 0 
    for i in range (nb):
        c = ruine(a,b,p)[2]
        
        d = d + c
       
    res = d / nb
    return res

ATTENTION Pour exécuter cette fonction il faut aussi prendre la fonction Code général.

Estimations numériques

L'estimation numérique varie en fonction de la probabilité.

Nous avons $a$ la richesse initiale, $b$ la somme à gagner

Pour une partie de "Pile ou Face" $p=1/2$

Pour calculer la valeur théorique de la probabilité de perdre : $\mathbb {P} (S_{T}=0)={\frac {b}{a+b}}$.

Pour le calcul de la probabilité de gagner : $\mathbb {P} (S_{T}=a+b)={\frac {a}{a+b}}$.

Pour le calcul de l'estimation du temps de jeu : $\mathbb {E} [T]=ab$.

Pour une partie de roulette $p\neq 1/2$

Pour faciliter les calculs suivant on note tout d'abord que $r={\frac {(1-p)}{p}}$

Pour calculer la valeur théorique de la probabilité de perdre : $\mathbb {P} (S_{T}=0)={\frac {r^{a+b}-r^{a}}{r^{a+b}-1}}$.

Pour le calcul de la probabilité de gagner : $\mathbb {P} (S_{T}=a+b)={\frac {r^{a}-1}{r^{a+b}-1}}$.

Pour le calcul de l'estimation du temps de jeu : $\mathbb {E} [T]={\frac {1}{2p-1}}\left({\frac {(a+b)(1-r^{a})}{1-r^{a+b}}}-a\right)$.

Code

Le code suivant permet de calculer les différentes valeurs théoriques :

def theorie(a,b,p):
    """Fonction qui nous donne les résultats théoriques

            en entrée : a, la richesse initiale du joueur
                        b, la somme que le joueur veut atteindre
                        p, la probabilité de gagner
            en sortie : des flottants """
    if p == 1/2 :               #Probabilité de gagner
        pRuine = b /(a + b)     #Proba théorique de perdre
        pGagne = a / (a + b)    #Proba théorique de gagner
        eT = a*b                #Estimation théorique du temps de jeu
        res = (pRuine, pGagne, eT)
    else :
        r = (1 - p) / p
        pRuine = (r**(a+b)-r**a)/(r**(a+b)-1)
        pGagne = (r**a-1)/(r**(a+b)-1)
        eT = 1/(2*p-1)*((((a+b)*(1-r**a))/(1-r**(a+b)))-a)
        res = (pRuine, pGagne, eT)
    
    return res

Cette fonction renvoie un tuple. La première valeur correspond à la valeur théorique de la probabilité de perdre, la deuxième valeur est la valeur théorique de la probabilité de gagner et enfin la dernière valeur est la valeur théorique de l'estimation du temps.

Graphes

---

Le code complet du projet.

Le code compote les fonctions pour créer les graphes en fonction de vos valeurs initiale

---

CONCLUSION

---

Ce projet à été réalisé par BOITOUZET Emilien (Tuteur : LABART Céline)