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 fini, et il souhaite gagner une certaine somme d'argent. Le joueur repart soit quand il est ruiné soit quand il a gagner 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é $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 variable :

 - $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 re regarder sur quelle face elle tombe. Les pièces de monnaie étant équilibré la probabilité de tomber sur pile et é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ême règle 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ésultat. Le premier résultat correspond à l'évolution de la richesse du joueur, le deuxième résultat permet de savoir facilement si le joueur à gagner (soit $g=1$). Et le dernier résultat correspond au temps de jeu (c'est à dire le nombre de mise pour gagner ou être ruiné).

Une partie de roulette

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

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

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ésultat. Le premier résultat correspond à l'évolution de la richesse du joueur, le deuxième résultat permet de savoir facilement si le joueur à gagner (soit $g=1$). Et le dernier résultat correspond au temps de jeu (c'est à dire le nombre de mise 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ésultat. Le premier résultat correspond à l'évolution de la richesse du joueur, le deuxième résultat permet de savoir facilement si le joueur à gagner (soit $g=1$). Et le dernier résultat correspond au temps de jeu (c'est à dire le nombre de mise pour gagner ou être ruiné).

Calculs de probabilité

Pour le calcul de la probabilité de gagner et 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 gagner et de perdre pour tous les jeux.

Estimations numériques

L'estimation numérique vari 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)$.

---

CONCLUSION

---

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