Wiki du LAMA (UMR 5127) - Contributions [fr]

Modélisation de la ruine du joueur 2020-2021

2021-05-13T16:13:00Z

Emilien Boitouzet : /* Conclusion */

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 <math>a</math>, il souhaite gagner <math>b</math> 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 :
- <math>a</math> la richesse du joueur à l'entrée du casino
- <math>b</math> le gain souhaité par le joueur
- <math>p</math> 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 <math>\frac{1}{2}</math>.

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.

<pre>
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
</pre>

'''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 <math>g=1</math>). 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 <math>p=\frac{18}{37}</math>. 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.

<pre>
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
</pre>

'''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 <math>g=1</math>). 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.

<pre>
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
</pre>

'''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 <math>g=1</math>). 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 mises et les diviser par le nombre de mises.

<pre>
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
</pre>

'''ATTENTION'''

Pour exécuter cette fonction il faut aussi prendre le [[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

<pre>
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
</pre>

'''ATTENTION'''

Pour exécuter cette fonction il faut aussi prendre le [[Code général]].

==Estimations numériques==

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

Nous avons <math>a</math> la richesse initiale, <math>b</math> la somme à gagner

===Pour une partie de "Pile ou Face" <math>p = 1/2</math>===

Pour calculer la valeur théorique de la probabilité de perdre :
<math> \mathbb{P}(S_T=0)=\frac{b}{a+b}</math>.

Pour le calcul de la probabilité de gagner :
<math> \mathbb{P}(S_T=a+b)=\frac{a}{a+b}</math>.

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

===Pour une partie de roulette <math> p \ne 1/2</math>===

Pour faciliter les calculs suivants on note tout d'abord que <math>r=\frac{(1-p)}{p}</math>

Pour calculer la valeur théorique de la probabilité de perdre :
<math> \mathbb{P}(S_T=0)=\frac{r^{a+b}-r^a}{r^{a+b}-1}</math>.

Pour le calcul de la probabilité de gagner :
<math> \mathbb{P}(S_T=a+b)=\frac{r^a-1}{r^{a+b}-1}</math>.

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

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

<pre>
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
</pre>

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===
Nous avons aussi étudié l'évolution des valeurs de la simulation en fonction des valeurs théoriques d'un nombre de soirées <math>nb</math>. On peut voir sur les graphiques ci-dessous que les valeurs des simulations tendent vers les valeurs théoriques.

Pour que la simulation ne prenne pas trop de temps les graphes sont faits à partir de petites valeurs.
- <math>a = 20</math>
- <math>b = 10</math>
- <math>p = 18/37 </math>
- <math>nb = 1000</math> (le nombre de soirée simulé)

[[Fichier:estimation du temps.png|left]][[Fichier:pGagne.png|right]]

[[Fichier:pRuine.png|center]]
----

[[Le code complet du projet]].

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

==Conclusion==
Pour conclure, nous nous apercevons que la probabilité de perdre est plus importante que la probabilité de gagner. Nous constatons, en exécutant le code avec des valeurs différentes que la probabilité de gagner est plus importante ; à condition d'arriver avec une somme de départ conséquente sans espoir de gros gains. Nous pouvons aussi nous apercevoir que le temps de jeu pour gagner est assez important, il y a donc abandon du jeu à un moment par le joueur. Ainsi, pour le casino les recettes demeurent supérieures aux gains des joueurs.

----

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

Modélisation de la ruine du joueur 2020-2021

2021-05-13T16:09:51Z

Emilien Boitouzet : /* CONCLUSION */

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 <math>a</math>, il souhaite gagner <math>b</math> 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 :
- <math>a</math> la richesse du joueur à l'entrée du casino
- <math>b</math> le gain souhaité par le joueur
- <math>p</math> 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 <math>\frac{1}{2}</math>.

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.

<pre>
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
</pre>

'''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 <math>g=1</math>). 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 <math>p=\frac{18}{37}</math>. 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.

<pre>
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
</pre>

'''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 <math>g=1</math>). 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.

<pre>
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
</pre>

'''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 <math>g=1</math>). 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 mises et les diviser par le nombre de mises.

<pre>
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
</pre>

'''ATTENTION'''

Pour exécuter cette fonction il faut aussi prendre le [[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

<pre>
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
</pre>

'''ATTENTION'''

Pour exécuter cette fonction il faut aussi prendre le [[Code général]].

==Estimations numériques==

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

Nous avons <math>a</math> la richesse initiale, <math>b</math> la somme à gagner

===Pour une partie de "Pile ou Face" <math>p = 1/2</math>===

Pour calculer la valeur théorique de la probabilité de perdre :
<math> \mathbb{P}(S_T=0)=\frac{b}{a+b}</math>.

Pour le calcul de la probabilité de gagner :
<math> \mathbb{P}(S_T=a+b)=\frac{a}{a+b}</math>.

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

===Pour une partie de roulette <math> p \ne 1/2</math>===

Pour faciliter les calculs suivants on note tout d'abord que <math>r=\frac{(1-p)}{p}</math>

Pour calculer la valeur théorique de la probabilité de perdre :
<math> \mathbb{P}(S_T=0)=\frac{r^{a+b}-r^a}{r^{a+b}-1}</math>.

Pour le calcul de la probabilité de gagner :
<math> \mathbb{P}(S_T=a+b)=\frac{r^a-1}{r^{a+b}-1}</math>.

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

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

<pre>
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
</pre>

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===
Nous avons aussi étudié l'évolution des valeurs de la simulation en fonction des valeurs théoriques d'un nombre de soirées <math>nb</math>. On peut voir sur les graphiques ci-dessous que les valeurs des simulations tendent vers les valeurs théoriques.

Pour que la simulation ne prenne pas trop de temps les graphes sont faits à partir de petites valeurs.
- <math>a = 20</math>
- <math>b = 10</math>
- <math>p = 18/37 </math>
- <math>nb = 1000</math> (le nombre de soirée simulé)

[[Fichier:estimation du temps.png|left]][[Fichier:pGagne.png|right]]

[[Fichier:pRuine.png|center]]
----

[[Le code complet du projet]].

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

==Conclusion==
Pour conclure, nous nous apercevons que la probabilité de perdre est plus importante que la probabilité de gagner. Nous constatons, en exécutant le code avec des valeurs différentes que la probabilité de gagner est plus importante ; à condition d'arriver avec une somme de départ conséquente sans espoir de gros gains.

----

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

Modélisation de la ruine du joueur 2020-2021

2021-05-13T16:03:59Z

Emilien Boitouzet : /* Graphes */

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 <math>a</math>, il souhaite gagner <math>b</math> 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 :
- <math>a</math> la richesse du joueur à l'entrée du casino
- <math>b</math> le gain souhaité par le joueur
- <math>p</math> 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 <math>\frac{1}{2}</math>.

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.

<pre>
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
</pre>

'''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 <math>g=1</math>). 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 <math>p=\frac{18}{37}</math>. 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.

<pre>
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
</pre>

'''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 <math>g=1</math>). 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.

<pre>
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
</pre>

'''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 <math>g=1</math>). 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 mises et les diviser par le nombre de mises.

<pre>
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
</pre>

'''ATTENTION'''

Pour exécuter cette fonction il faut aussi prendre le [[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

<pre>
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
</pre>

'''ATTENTION'''

Pour exécuter cette fonction il faut aussi prendre le [[Code général]].

==Estimations numériques==

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

Nous avons <math>a</math> la richesse initiale, <math>b</math> la somme à gagner

===Pour une partie de "Pile ou Face" <math>p = 1/2</math>===

Pour calculer la valeur théorique de la probabilité de perdre :
<math> \mathbb{P}(S_T=0)=\frac{b}{a+b}</math>.

Pour le calcul de la probabilité de gagner :
<math> \mathbb{P}(S_T=a+b)=\frac{a}{a+b}</math>.

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

===Pour une partie de roulette <math> p \ne 1/2</math>===

Pour faciliter les calculs suivants on note tout d'abord que <math>r=\frac{(1-p)}{p}</math>

Pour calculer la valeur théorique de la probabilité de perdre :
<math> \mathbb{P}(S_T=0)=\frac{r^{a+b}-r^a}{r^{a+b}-1}</math>.

Pour le calcul de la probabilité de gagner :
<math> \mathbb{P}(S_T=a+b)=\frac{r^a-1}{r^{a+b}-1}</math>.

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

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

<pre>
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
</pre>

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===
Nous avons aussi étudié l'évolution des valeurs de la simulation en fonction des valeurs théoriques d'un nombre de soirées <math>nb</math>. On peut voir sur les graphiques ci-dessous que les valeurs des simulations tendent vers les valeurs théoriques.

Pour que la simulation ne prenne pas trop de temps les graphes sont faits à partir de petites valeurs.
- <math>a = 20</math>
- <math>b = 10</math>
- <math>p = 18/37 </math>
- <math>nb = 1000</math> (le nombre de soirée simulé)

[[Fichier:estimation du temps.png|left]][[Fichier:pGagne.png|right]]

[[Fichier:pRuine.png|center]]
----

[[Le code complet du projet]].

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

==CONCLUSION==

----

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

Modélisation de la ruine du joueur 2020-2021

2021-05-13T16:02:58Z

Emilien Boitouzet : /* Graphes */

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 <math>a</math>, il souhaite gagner <math>b</math> 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 :
- <math>a</math> la richesse du joueur à l'entrée du casino
- <math>b</math> le gain souhaité par le joueur
- <math>p</math> 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 <math>\frac{1}{2}</math>.

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.

<pre>
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
</pre>

'''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 <math>g=1</math>). 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 <math>p=\frac{18}{37}</math>. 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.

<pre>
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
</pre>

'''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 <math>g=1</math>). 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.

<pre>
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
</pre>

'''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 <math>g=1</math>). 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 mises et les diviser par le nombre de mises.

<pre>
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
</pre>

'''ATTENTION'''

Pour exécuter cette fonction il faut aussi prendre le [[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

<pre>
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
</pre>

'''ATTENTION'''

Pour exécuter cette fonction il faut aussi prendre le [[Code général]].

==Estimations numériques==

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

Nous avons <math>a</math> la richesse initiale, <math>b</math> la somme à gagner

===Pour une partie de "Pile ou Face" <math>p = 1/2</math>===

Pour calculer la valeur théorique de la probabilité de perdre :
<math> \mathbb{P}(S_T=0)=\frac{b}{a+b}</math>.

Pour le calcul de la probabilité de gagner :
<math> \mathbb{P}(S_T=a+b)=\frac{a}{a+b}</math>.

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

===Pour une partie de roulette <math> p \ne 1/2</math>===

Pour faciliter les calculs suivants on note tout d'abord que <math>r=\frac{(1-p)}{p}</math>

Pour calculer la valeur théorique de la probabilité de perdre :
<math> \mathbb{P}(S_T=0)=\frac{r^{a+b}-r^a}{r^{a+b}-1}</math>.

Pour le calcul de la probabilité de gagner :
<math> \mathbb{P}(S_T=a+b)=\frac{r^a-1}{r^{a+b}-1}</math>.

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

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

<pre>
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
</pre>

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===
Nous avons aussi étudié l'évolution des valeurs de la simulation en fonction des valeurs théoriques d'un nombre de soirées <math>nb</math>. On peut voir sur les graphiques ci-dessous que les valeurs des simulations tendent vers les valeurs théoriques.

Pour que la simulation ne prenne pas trop de temps les graphes sont faits à partir de petites valeurs.
- <math>a = 20</math>
- <math>b = 10</math>
- <math>p = 18/37 </math>
- <math>nb = 1000</math> (le nombre de soirée simulé)

[[Fichier:estimation du temps.png|left]][[Fichier:pGagne.png|right]]

[[Fichier:pRuine.png|center]]
----

[[Le code complet du projet]].

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

----
'''CONCLUSION'''

----

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

Modélisation de la ruine du joueur 2020-2021

2021-05-13T16:02:24Z

Emilien Boitouzet : /* Graphes */

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 <math>a</math>, il souhaite gagner <math>b</math> 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 :
- <math>a</math> la richesse du joueur à l'entrée du casino
- <math>b</math> le gain souhaité par le joueur
- <math>p</math> 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 <math>\frac{1}{2}</math>.

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.

<pre>
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
</pre>

'''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 <math>g=1</math>). 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 <math>p=\frac{18}{37}</math>. 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.

<pre>
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
</pre>

'''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 <math>g=1</math>). 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.

<pre>
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
</pre>

'''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 <math>g=1</math>). 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 mises et les diviser par le nombre de mises.

<pre>
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
</pre>

'''ATTENTION'''

Pour exécuter cette fonction il faut aussi prendre le [[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

<pre>
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
</pre>

'''ATTENTION'''

Pour exécuter cette fonction il faut aussi prendre le [[Code général]].

==Estimations numériques==

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

Nous avons <math>a</math> la richesse initiale, <math>b</math> la somme à gagner

===Pour une partie de "Pile ou Face" <math>p = 1/2</math>===

Pour calculer la valeur théorique de la probabilité de perdre :
<math> \mathbb{P}(S_T=0)=\frac{b}{a+b}</math>.

Pour le calcul de la probabilité de gagner :
<math> \mathbb{P}(S_T=a+b)=\frac{a}{a+b}</math>.

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

===Pour une partie de roulette <math> p \ne 1/2</math>===

Pour faciliter les calculs suivants on note tout d'abord que <math>r=\frac{(1-p)}{p}</math>

Pour calculer la valeur théorique de la probabilité de perdre :
<math> \mathbb{P}(S_T=0)=\frac{r^{a+b}-r^a}{r^{a+b}-1}</math>.

Pour le calcul de la probabilité de gagner :
<math> \mathbb{P}(S_T=a+b)=\frac{r^a-1}{r^{a+b}-1}</math>.

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

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

<pre>
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
</pre>

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===
Nous avons aussi étudié l'évolution des valeurs de la simulation en fonction des valeurs théoriques d'un nombre de soirées <math>nb</math>. On peut voir sur les graphiques ci-dessous que les valeurs des simulations tendent vers les valeurs théoriques.

Pour que la simulation ne prenne pas trop de temps les graphes sont faits à partir de petites valeurs.
- <math>a = 20</math>
- <math>b = 10</math>
- <math>p = 18/37 </math>
- <math>nb = 1000</math> (le nombre de soirée simulé)

[[Fichier:estimation du temps.png|left]][[Fichier:pGagne.png|right]]

[[Fichier:pRuine.png|center]]
----

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

Modélisation de la ruine du joueur 2020-2021

2021-05-13T16:01:48Z

Emilien Boitouzet : /* Graphes */

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 <math>a</math>, il souhaite gagner <math>b</math> 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 :
- <math>a</math> la richesse du joueur à l'entrée du casino
- <math>b</math> le gain souhaité par le joueur
- <math>p</math> 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 <math>\frac{1}{2}</math>.

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.

<pre>
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
</pre>

'''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 <math>g=1</math>). 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 <math>p=\frac{18}{37}</math>. 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.

<pre>
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
</pre>

'''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 <math>g=1</math>). 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.

<pre>
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
</pre>

'''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 <math>g=1</math>). 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 mises et les diviser par le nombre de mises.

<pre>
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
</pre>

'''ATTENTION'''

Pour exécuter cette fonction il faut aussi prendre le [[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

<pre>
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
</pre>

'''ATTENTION'''

Pour exécuter cette fonction il faut aussi prendre le [[Code général]].

==Estimations numériques==

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

Nous avons <math>a</math> la richesse initiale, <math>b</math> la somme à gagner

===Pour une partie de "Pile ou Face" <math>p = 1/2</math>===

Pour calculer la valeur théorique de la probabilité de perdre :
<math> \mathbb{P}(S_T=0)=\frac{b}{a+b}</math>.

Pour le calcul de la probabilité de gagner :
<math> \mathbb{P}(S_T=a+b)=\frac{a}{a+b}</math>.

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

===Pour une partie de roulette <math> p \ne 1/2</math>===

Pour faciliter les calculs suivants on note tout d'abord que <math>r=\frac{(1-p)}{p}</math>

Pour calculer la valeur théorique de la probabilité de perdre :
<math> \mathbb{P}(S_T=0)=\frac{r^{a+b}-r^a}{r^{a+b}-1}</math>.

Pour le calcul de la probabilité de gagner :
<math> \mathbb{P}(S_T=a+b)=\frac{r^a-1}{r^{a+b}-1}</math>.

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

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

<pre>
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
</pre>

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===
Nous avons aussi étudié l'évolution des valeurs de la simulation en fonction des valeurs théoriques d'un nombre de soirées <math>nb</math>. On peut voir sur les graphiques ci-dessous que les valeurs des simulations tendent vers les valeurs théorique.

Pour que la simulation ne prenne pas trop de temps les graphes sont faite à partir de petite valeur.
- <math>a = 20</math>
- <math>b = 10</math>
- <math>p = 18/37 </math>
- <math>nb = 1000</math> (le nombre de soirée simulé)

[[Fichier:estimation du temps.png|left]][[Fichier:pGagne.png|right]]

[[Fichier:pRuine.png|center]]
----

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

Modélisation de la ruine du joueur 2020-2021

2021-05-13T16:00:47Z

Emilien Boitouzet : /* Pour une partie de roulette p \ne 1/2 */

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 <math>a</math>, il souhaite gagner <math>b</math> 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 :
- <math>a</math> la richesse du joueur à l'entrée du casino
- <math>b</math> le gain souhaité par le joueur
- <math>p</math> 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 <math>\frac{1}{2}</math>.

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.

<pre>
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
</pre>

'''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 <math>g=1</math>). 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 <math>p=\frac{18}{37}</math>. 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.

<pre>
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
</pre>

'''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 <math>g=1</math>). 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.

<pre>
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
</pre>

'''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 <math>g=1</math>). 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 mises et les diviser par le nombre de mises.

<pre>
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
</pre>

'''ATTENTION'''

Pour exécuter cette fonction il faut aussi prendre le [[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

<pre>
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
</pre>

'''ATTENTION'''

Pour exécuter cette fonction il faut aussi prendre le [[Code général]].

==Estimations numériques==

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

Nous avons <math>a</math> la richesse initiale, <math>b</math> la somme à gagner

===Pour une partie de "Pile ou Face" <math>p = 1/2</math>===

Pour calculer la valeur théorique de la probabilité de perdre :
<math> \mathbb{P}(S_T=0)=\frac{b}{a+b}</math>.

Pour le calcul de la probabilité de gagner :
<math> \mathbb{P}(S_T=a+b)=\frac{a}{a+b}</math>.

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

===Pour une partie de roulette <math> p \ne 1/2</math>===

Pour faciliter les calculs suivants on note tout d'abord que <math>r=\frac{(1-p)}{p}</math>

Pour calculer la valeur théorique de la probabilité de perdre :
<math> \mathbb{P}(S_T=0)=\frac{r^{a+b}-r^a}{r^{a+b}-1}</math>.

Pour le calcul de la probabilité de gagner :
<math> \mathbb{P}(S_T=a+b)=\frac{r^a-1}{r^{a+b}-1}</math>.

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

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

<pre>
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
</pre>

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===
Nous avons aussi étudié l'évolution des valeurs de la simulation en fonction des valeurs théoriques d'un nombre de soirée <math>nb</math>. On peut voir sur les graphiques ci-dessous que les valeurs des simulations tendent vers les valeurs théorique.

Pour que la simulation ne prenne pas trop de temps les graphes sont faite à partir de petite valeur.
- <math>a = 20</math>
- <math>b = 10</math>
- <math>p = 18/37 </math>
- <math>nb = 1000</math> (le nombre de soirée simulé)

[[Fichier:estimation du temps.png|left]][[Fichier:pGagne.png|right]]

[[Fichier:pRuine.png|center]]
----

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

Modélisation de la ruine du joueur 2020-2021

2021-05-13T15:59:47Z

Emilien Boitouzet : /* Probabilité de perdre */

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 <math>a</math>, il souhaite gagner <math>b</math> 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 :
- <math>a</math> la richesse du joueur à l'entrée du casino
- <math>b</math> le gain souhaité par le joueur
- <math>p</math> 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 <math>\frac{1}{2}</math>.

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.

<pre>
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
</pre>

'''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 <math>g=1</math>). 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 <math>p=\frac{18}{37}</math>. 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.

<pre>
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
</pre>

'''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 <math>g=1</math>). 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.

<pre>
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
</pre>

'''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 <math>g=1</math>). 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 mises et les diviser par le nombre de mises.

<pre>
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
</pre>

'''ATTENTION'''

Pour exécuter cette fonction il faut aussi prendre le [[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

<pre>
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
</pre>

'''ATTENTION'''

Pour exécuter cette fonction il faut aussi prendre le [[Code général]].

==Estimations numériques==

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

Nous avons <math>a</math> la richesse initiale, <math>b</math> la somme à gagner

===Pour une partie de "Pile ou Face" <math>p = 1/2</math>===

Pour calculer la valeur théorique de la probabilité de perdre :
<math> \mathbb{P}(S_T=0)=\frac{b}{a+b}</math>.

Pour le calcul de la probabilité de gagner :
<math> \mathbb{P}(S_T=a+b)=\frac{a}{a+b}</math>.

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

===Pour une partie de roulette <math> p \ne 1/2</math>===

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

Pour calculer la valeur théorique de la probabilité de perdre :
<math> \mathbb{P}(S_T=0)=\frac{r^{a+b}-r^a}{r^{a+b}-1}</math>.

Pour le calcul de la probabilité de gagner :
<math> \mathbb{P}(S_T=a+b)=\frac{r^a-1}{r^{a+b}-1}</math>.

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

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

<pre>
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
</pre>

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===
Nous avons aussi étudié l'évolution des valeurs de la simulation en fonction des valeurs théoriques d'un nombre de soirée <math>nb</math>. On peut voir sur les graphiques ci-dessous que les valeurs des simulations tendent vers les valeurs théorique.

Pour que la simulation ne prenne pas trop de temps les graphes sont faite à partir de petite valeur.
- <math>a = 20</math>
- <math>b = 10</math>
- <math>p = 18/37 </math>
- <math>nb = 1000</math> (le nombre de soirée simulé)

[[Fichier:estimation du temps.png|left]][[Fichier:pGagne.png|right]]

[[Fichier:pRuine.png|center]]
----

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

Modélisation de la ruine du joueur 2020-2021

2021-05-05T07:32:42Z

Emilien Boitouzet : /* Graphes */

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 <math>a</math>, il souhaite gagner <math>b</math> 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 :
- <math>a</math> la richesse du joueur à l'entrée du casino
- <math>b</math> le gain souhaité par le joueur
- <math>p</math> 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 <math>\frac{1}{2}</math>.

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.

<pre>
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
</pre>

'''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 <math>g=1</math>). 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 <math>p=\frac{18}{37}</math>. 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.

<pre>
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
</pre>

'''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 <math>g=1</math>). 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.

<pre>
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
</pre>

'''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 <math>g=1</math>). 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.

<pre>
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
</pre>

'''ATTENTION'''

Pour exécuter cette fonction il faut aussi prendre le [[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

<pre>
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
</pre>

'''ATTENTION'''

Pour exécuter cette fonction il faut aussi prendre le [[Code général]].

==Estimations numériques==

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

Nous avons <math>a</math> la richesse initiale, <math>b</math> la somme à gagner

===Pour une partie de "Pile ou Face" <math>p = 1/2</math>===

Pour calculer la valeur théorique de la probabilité de perdre :
<math> \mathbb{P}(S_T=0)=\frac{b}{a+b}</math>.

Pour le calcul de la probabilité de gagner :
<math> \mathbb{P}(S_T=a+b)=\frac{a}{a+b}</math>.

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

===Pour une partie de roulette <math> p \ne 1/2</math>===

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

Pour calculer la valeur théorique de la probabilité de perdre :
<math> \mathbb{P}(S_T=0)=\frac{r^{a+b}-r^a}{r^{a+b}-1}</math>.

Pour le calcul de la probabilité de gagner :
<math> \mathbb{P}(S_T=a+b)=\frac{r^a-1}{r^{a+b}-1}</math>.

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

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

<pre>
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
</pre>

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===
Nous avons aussi étudié l'évolution des valeurs de la simulation en fonction des valeurs théoriques d'un nombre de soirée <math>nb</math>. On peut voir sur les graphiques ci-dessous que les valeurs des simulations tendent vers les valeurs théorique.

Pour que la simulation ne prenne pas trop de temps les graphes sont faite à partir de petite valeur.
- <math>a = 20</math>
- <math>b = 10</math>
- <math>p = 18/37 </math>
- <math>nb = 1000</math> (le nombre de soirée simulé)

[[Fichier:estimation du temps.png|left]][[Fichier:pGagne.png|right]]

[[Fichier:pRuine.png|center]]
----

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

Modélisation de la ruine du joueur 2020-2021

2021-05-05T07:32:09Z

Emilien Boitouzet : /* Code */

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 <math>a</math>, il souhaite gagner <math>b</math> 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 :
- <math>a</math> la richesse du joueur à l'entrée du casino
- <math>b</math> le gain souhaité par le joueur
- <math>p</math> 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 <math>\frac{1}{2}</math>.

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.

<pre>
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
</pre>

'''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 <math>g=1</math>). 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 <math>p=\frac{18}{37}</math>. 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.

<pre>
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
</pre>

'''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 <math>g=1</math>). 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.

<pre>
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
</pre>

'''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 <math>g=1</math>). 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.

<pre>
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
</pre>

'''ATTENTION'''

Pour exécuter cette fonction il faut aussi prendre le [[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

<pre>
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
</pre>

'''ATTENTION'''

Pour exécuter cette fonction il faut aussi prendre le [[Code général]].

==Estimations numériques==

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

Nous avons <math>a</math> la richesse initiale, <math>b</math> la somme à gagner

===Pour une partie de "Pile ou Face" <math>p = 1/2</math>===

Pour calculer la valeur théorique de la probabilité de perdre :
<math> \mathbb{P}(S_T=0)=\frac{b}{a+b}</math>.

Pour le calcul de la probabilité de gagner :
<math> \mathbb{P}(S_T=a+b)=\frac{a}{a+b}</math>.

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

===Pour une partie de roulette <math> p \ne 1/2</math>===

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

Pour calculer la valeur théorique de la probabilité de perdre :
<math> \mathbb{P}(S_T=0)=\frac{r^{a+b}-r^a}{r^{a+b}-1}</math>.

Pour le calcul de la probabilité de gagner :
<math> \mathbb{P}(S_T=a+b)=\frac{r^a-1}{r^{a+b}-1}</math>.

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

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

<pre>
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
</pre>

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===
Nous avons aussi étudié l'évolution des valeurs de la simulation en fonction des valeurs théoriques d'un nombre de soirée <math>nb</math>. On peut voir sur les graphiques ci-dessous que les valeurs des simulations tendent vers les valeurs théorique.

Pour que la simulation ne prenne pas trop de temps les graphes sont faite à partir de petite valeur.
- <math>a = 20</math>
- <math>b = 10</math>
- <math>p = 18/37 </math>
- <math>nb = 1000</math> (le nombre de soirée simulé)

[[Fichier:estimation du temps.png]][[Fichier:pGagne.png]]

[[Fichier:pRuine.png|center]]
----

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

Modélisation de la ruine du joueur 2020-2021

2021-05-05T07:30:59Z

Emilien Boitouzet : /* Graphes */

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 <math>a</math>, il souhaite gagner <math>b</math> 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 :
- <math>a</math> la richesse du joueur à l'entrée du casino
- <math>b</math> le gain souhaité par le joueur
- <math>p</math> 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 <math>\frac{1}{2}</math>.

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.

<pre>
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
</pre>

'''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 <math>g=1</math>). 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 <math>p=\frac{18}{37}</math>. 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.

<pre>
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
</pre>

'''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 <math>g=1</math>). 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.

<pre>
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
</pre>

'''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 <math>g=1</math>). 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.

<pre>
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
</pre>

'''ATTENTION'''

Pour exécuter cette fonction il faut aussi prendre le [[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

<pre>
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
</pre>

'''ATTENTION'''

Pour exécuter cette fonction il faut aussi prendre le [[Code général]].

==Estimations numériques==

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

Nous avons <math>a</math> la richesse initiale, <math>b</math> la somme à gagner

===Pour une partie de "Pile ou Face" <math>p = 1/2</math>===

Pour calculer la valeur théorique de la probabilité de perdre :
<math> \mathbb{P}(S_T=0)=\frac{b}{a+b}</math>.

Pour le calcul de la probabilité de gagner :
<math> \mathbb{P}(S_T=a+b)=\frac{a}{a+b}</math>.

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

===Pour une partie de roulette <math> p \ne 1/2</math>===

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

Pour calculer la valeur théorique de la probabilité de perdre :
<math> \mathbb{P}(S_T=0)=\frac{r^{a+b}-r^a}{r^{a+b}-1}</math>.

Pour le calcul de la probabilité de gagner :
<math> \mathbb{P}(S_T=a+b)=\frac{r^a-1}{r^{a+b}-1}</math>.

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

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

<pre>
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
</pre>

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.

[[Fichier:Exemple.jpg]]===Graphes===
Nous avons aussi étudié l'évolution des valeurs de la simulation en fonction des valeurs théoriques d'un nombre de soirée <math>nb</math>. On peut voir sur les graphiques ci-dessous que les valeurs des simulations tendent vers les valeurs théorique.

Pour que la simulation ne prenne pas trop de temps les graphes sont faite à partir de petite valeur.
- <math>a = 20</math>
- <math>b = 10</math>
- <math>p = 18/37 </math>
- <math>nb = 1000</math> (le nombre de soirée simulé)

[[Fichier:estimation du temps.png]][[Fichier:pGagne.png]]

[[Fichier:pRuine.png]]
----

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

Modélisation de la ruine du joueur 2020-2021

2021-05-05T07:29:30Z

Emilien Boitouzet : /* Graphes */

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 <math>a</math>, il souhaite gagner <math>b</math> 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 :
- <math>a</math> la richesse du joueur à l'entrée du casino
- <math>b</math> le gain souhaité par le joueur
- <math>p</math> 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 <math>\frac{1}{2}</math>.

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.

<pre>
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
</pre>

'''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 <math>g=1</math>). 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 <math>p=\frac{18}{37}</math>. 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.

<pre>
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
</pre>

'''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 <math>g=1</math>). 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.

<pre>
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
</pre>

'''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 <math>g=1</math>). 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.

<pre>
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
</pre>

'''ATTENTION'''

Pour exécuter cette fonction il faut aussi prendre le [[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

<pre>
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
</pre>

'''ATTENTION'''

Pour exécuter cette fonction il faut aussi prendre le [[Code général]].

==Estimations numériques==

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

Nous avons <math>a</math> la richesse initiale, <math>b</math> la somme à gagner

===Pour une partie de "Pile ou Face" <math>p = 1/2</math>===

Pour calculer la valeur théorique de la probabilité de perdre :
<math> \mathbb{P}(S_T=0)=\frac{b}{a+b}</math>.

Pour le calcul de la probabilité de gagner :
<math> \mathbb{P}(S_T=a+b)=\frac{a}{a+b}</math>.

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

===Pour une partie de roulette <math> p \ne 1/2</math>===

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

Pour calculer la valeur théorique de la probabilité de perdre :
<math> \mathbb{P}(S_T=0)=\frac{r^{a+b}-r^a}{r^{a+b}-1}</math>.

Pour le calcul de la probabilité de gagner :
<math> \mathbb{P}(S_T=a+b)=\frac{r^a-1}{r^{a+b}-1}</math>.

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

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

<pre>
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
</pre>

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===
Nous avons aussi étudié l'évolution des valeurs de la simulation en fonction des valeurs théoriques d'un nombre de soirée <math>nb</math>. On peut voir sur les graphiques ci-dessous que les valeurs des simulations tendent vers les valeurs théorique.

Pour que la simulation ne prenne pas trop de temps les graphes sont faite à partir de petite valeur.
- <math>a = 20</math>
- <math>b = 10</math>
- <math>p = 18/37 </math>
- <math>nb = 1000</math> (le nombre de soirée simulé)

[[Fichier:estimation du temps.png]][[Fichier:pGagne.png]]

[[Fichier:pRuine.png]]
----

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

Modélisation de la ruine du joueur 2020-2021

2021-05-05T07:29:18Z

Emilien Boitouzet : /* Graphes */

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 <math>a</math>, il souhaite gagner <math>b</math> 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 :
- <math>a</math> la richesse du joueur à l'entrée du casino
- <math>b</math> le gain souhaité par le joueur
- <math>p</math> 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 <math>\frac{1}{2}</math>.

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.

<pre>
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
</pre>

'''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 <math>g=1</math>). 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 <math>p=\frac{18}{37}</math>. 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.

<pre>
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
</pre>

'''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 <math>g=1</math>). 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.

<pre>
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
</pre>

'''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 <math>g=1</math>). 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.

<pre>
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
</pre>

'''ATTENTION'''

Pour exécuter cette fonction il faut aussi prendre le [[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

<pre>
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
</pre>

'''ATTENTION'''

Pour exécuter cette fonction il faut aussi prendre le [[Code général]].

==Estimations numériques==

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

Nous avons <math>a</math> la richesse initiale, <math>b</math> la somme à gagner

===Pour une partie de "Pile ou Face" <math>p = 1/2</math>===

Pour calculer la valeur théorique de la probabilité de perdre :
<math> \mathbb{P}(S_T=0)=\frac{b}{a+b}</math>.

Pour le calcul de la probabilité de gagner :
<math> \mathbb{P}(S_T=a+b)=\frac{a}{a+b}</math>.

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

===Pour une partie de roulette <math> p \ne 1/2</math>===

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

Pour calculer la valeur théorique de la probabilité de perdre :
<math> \mathbb{P}(S_T=0)=\frac{r^{a+b}-r^a}{r^{a+b}-1}</math>.

Pour le calcul de la probabilité de gagner :
<math> \mathbb{P}(S_T=a+b)=\frac{r^a-1}{r^{a+b}-1}</math>.

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

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

<pre>
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
</pre>

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===
Nous avons aussi étudié l'évolution des valeurs de la simulation en fonction des valeurs théoriques d'un nombre de soirée <math>nb</math>. On peut voir sur les graphiques ci-dessous que les valeurs des simulations tendent vers les valeurs théorique.

Pour que la simulation ne prenne pas trop de temps les graphes sont faite à partir de petite valeur.
- <math>a = 20</math>
- <math>b = 10</math>
- <math>p = 18/37 </math>
- <math>nb = 1000</math> (le nombre de soirée simulé)

[[Fichier:estimation du temps.png]][[Fichier:pGagne.png]]

[[Fichier:pRuine.png],center]
----

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

Modélisation de la ruine du joueur 2020-2021

2021-05-04T12:02:14Z

Emilien Boitouzet : /* Calcul du temps moyen de jeu */

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 <math>a</math>, il souhaite gagner <math>b</math> 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 :
- <math>a</math> la richesse du joueur à l'entrée du casino
- <math>b</math> le gain souhaité par le joueur
- <math>p</math> 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 <math>\frac{1}{2}</math>.

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.

<pre>
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
</pre>

'''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 <math>g=1</math>). 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 <math>p=\frac{18}{37}</math>. 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.

<pre>
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
</pre>

'''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 <math>g=1</math>). 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.

<pre>
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
</pre>

'''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 <math>g=1</math>). 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.

<pre>
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
</pre>

'''ATTENTION'''

Pour exécuter cette fonction il faut aussi prendre le [[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

<pre>
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
</pre>

'''ATTENTION'''

Pour exécuter cette fonction il faut aussi prendre le [[Code général]].

==Estimations numériques==

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

Nous avons <math>a</math> la richesse initiale, <math>b</math> la somme à gagner

===Pour une partie de "Pile ou Face" <math>p = 1/2</math>===

Pour calculer la valeur théorique de la probabilité de perdre :
<math> \mathbb{P}(S_T=0)=\frac{b}{a+b}</math>.

Pour le calcul de la probabilité de gagner :
<math> \mathbb{P}(S_T=a+b)=\frac{a}{a+b}</math>.

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

===Pour une partie de roulette <math> p \ne 1/2</math>===

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

Pour calculer la valeur théorique de la probabilité de perdre :
<math> \mathbb{P}(S_T=0)=\frac{r^{a+b}-r^a}{r^{a+b}-1}</math>.

Pour le calcul de la probabilité de gagner :
<math> \mathbb{P}(S_T=a+b)=\frac{r^a-1}{r^{a+b}-1}</math>.

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

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

<pre>
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
</pre>

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===
Nous avons aussi étudié l'évolution des valeurs de la simulation en fonction des valeurs théoriques d'un nombre de soirée <math>nb</math>. On peut voir sur les graphiques ci-dessous que les valeurs des simulations tendent vers les valeurs théorique.

Pour que la simulation ne prenne pas trop de temps les graphes sont faite à partir de petite valeur.
- <math>a = 20</math>
- <math>b = 10</math>
- <math>p = 18/37 </math>
- <math>nb = 1000</math> (le nombre de soirée simulé)

[[Fichier:estimation du temps.png]][[Fichier:pGagne.png]][[Fichier:pRuine.png]]
----

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

Modélisation de la ruine du joueur 2020-2021

2021-05-04T12:01:55Z

Emilien Boitouzet : /* Probabilité de perdre */

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 <math>a</math>, il souhaite gagner <math>b</math> 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 :
- <math>a</math> la richesse du joueur à l'entrée du casino
- <math>b</math> le gain souhaité par le joueur
- <math>p</math> 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 <math>\frac{1}{2}</math>.

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.

<pre>
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
</pre>

'''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 <math>g=1</math>). 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 <math>p=\frac{18}{37}</math>. 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.

<pre>
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
</pre>

'''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 <math>g=1</math>). 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.

<pre>
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
</pre>

'''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 <math>g=1</math>). 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.

<pre>
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
</pre>

'''ATTENTION'''

Pour exécuter cette fonction il faut aussi prendre le [[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

<pre>
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
</pre>

'''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 <math>a</math> la richesse initiale, <math>b</math> la somme à gagner

===Pour une partie de "Pile ou Face" <math>p = 1/2</math>===

Pour calculer la valeur théorique de la probabilité de perdre :
<math> \mathbb{P}(S_T=0)=\frac{b}{a+b}</math>.

Pour le calcul de la probabilité de gagner :
<math> \mathbb{P}(S_T=a+b)=\frac{a}{a+b}</math>.

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

===Pour une partie de roulette <math> p \ne 1/2</math>===

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

Pour calculer la valeur théorique de la probabilité de perdre :
<math> \mathbb{P}(S_T=0)=\frac{r^{a+b}-r^a}{r^{a+b}-1}</math>.

Pour le calcul de la probabilité de gagner :
<math> \mathbb{P}(S_T=a+b)=\frac{r^a-1}{r^{a+b}-1}</math>.

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

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

<pre>
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
</pre>

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===
Nous avons aussi étudié l'évolution des valeurs de la simulation en fonction des valeurs théoriques d'un nombre de soirée <math>nb</math>. On peut voir sur les graphiques ci-dessous que les valeurs des simulations tendent vers les valeurs théorique.

Pour que la simulation ne prenne pas trop de temps les graphes sont faite à partir de petite valeur.
- <math>a = 20</math>
- <math>b = 10</math>
- <math>p = 18/37 </math>
- <math>nb = 1000</math> (le nombre de soirée simulé)

[[Fichier:estimation du temps.png]][[Fichier:pGagne.png]][[Fichier:pRuine.png]]
----

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

Modélisation de la ruine du joueur 2020-2021

2021-05-04T12:01:18Z

Emilien Boitouzet : /* Calcul du temps moyen de jeu */

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 <math>a</math>, il souhaite gagner <math>b</math> 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 :
- <math>a</math> la richesse du joueur à l'entrée du casino
- <math>b</math> le gain souhaité par le joueur
- <math>p</math> 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 <math>\frac{1}{2}</math>.

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.

<pre>
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
</pre>

'''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 <math>g=1</math>). 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 <math>p=\frac{18}{37}</math>. 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.

<pre>
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
</pre>

'''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 <math>g=1</math>). 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.

<pre>
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
</pre>

'''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 <math>g=1</math>). 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.

<pre>
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
</pre>

'''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

<pre>
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
</pre>

'''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 <math>a</math> la richesse initiale, <math>b</math> la somme à gagner

===Pour une partie de "Pile ou Face" <math>p = 1/2</math>===

Pour calculer la valeur théorique de la probabilité de perdre :
<math> \mathbb{P}(S_T=0)=\frac{b}{a+b}</math>.

Pour le calcul de la probabilité de gagner :
<math> \mathbb{P}(S_T=a+b)=\frac{a}{a+b}</math>.

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

===Pour une partie de roulette <math> p \ne 1/2</math>===

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

Pour calculer la valeur théorique de la probabilité de perdre :
<math> \mathbb{P}(S_T=0)=\frac{r^{a+b}-r^a}{r^{a+b}-1}</math>.

Pour le calcul de la probabilité de gagner :
<math> \mathbb{P}(S_T=a+b)=\frac{r^a-1}{r^{a+b}-1}</math>.

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

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

<pre>
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
</pre>

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===
Nous avons aussi étudié l'évolution des valeurs de la simulation en fonction des valeurs théoriques d'un nombre de soirée <math>nb</math>. On peut voir sur les graphiques ci-dessous que les valeurs des simulations tendent vers les valeurs théorique.

Pour que la simulation ne prenne pas trop de temps les graphes sont faite à partir de petite valeur.
- <math>a = 20</math>
- <math>b = 10</math>
- <math>p = 18/37 </math>
- <math>nb = 1000</math> (le nombre de soirée simulé)

[[Fichier:estimation du temps.png]][[Fichier:pGagne.png]][[Fichier:pRuine.png]]
----

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

Modélisation de la ruine du joueur 2020-2021

2021-05-04T12:01:10Z

Emilien Boitouzet : /* Probabilité de perdre */

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 <math>a</math>, il souhaite gagner <math>b</math> 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 :
- <math>a</math> la richesse du joueur à l'entrée du casino
- <math>b</math> le gain souhaité par le joueur
- <math>p</math> 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 <math>\frac{1}{2}</math>.

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.

<pre>
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
</pre>

'''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 <math>g=1</math>). 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 <math>p=\frac{18}{37}</math>. 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.

<pre>
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
</pre>

'''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 <math>g=1</math>). 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.

<pre>
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
</pre>

'''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 <math>g=1</math>). 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.

<pre>
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
</pre>

'''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

<pre>
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
</pre>

'''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 <math>a</math> la richesse initiale, <math>b</math> la somme à gagner

===Pour une partie de "Pile ou Face" <math>p = 1/2</math>===

Pour calculer la valeur théorique de la probabilité de perdre :
<math> \mathbb{P}(S_T=0)=\frac{b}{a+b}</math>.

Pour le calcul de la probabilité de gagner :
<math> \mathbb{P}(S_T=a+b)=\frac{a}{a+b}</math>.

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

===Pour une partie de roulette <math> p \ne 1/2</math>===

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

Pour calculer la valeur théorique de la probabilité de perdre :
<math> \mathbb{P}(S_T=0)=\frac{r^{a+b}-r^a}{r^{a+b}-1}</math>.

Pour le calcul de la probabilité de gagner :
<math> \mathbb{P}(S_T=a+b)=\frac{r^a-1}{r^{a+b}-1}</math>.

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

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

<pre>
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
</pre>

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===
Nous avons aussi étudié l'évolution des valeurs de la simulation en fonction des valeurs théoriques d'un nombre de soirée <math>nb</math>. On peut voir sur les graphiques ci-dessous que les valeurs des simulations tendent vers les valeurs théorique.

Pour que la simulation ne prenne pas trop de temps les graphes sont faite à partir de petite valeur.
- <math>a = 20</math>
- <math>b = 10</math>
- <math>p = 18/37 </math>
- <math>nb = 1000</math> (le nombre de soirée simulé)

[[Fichier:estimation du temps.png]][[Fichier:pGagne.png]][[Fichier:pRuine.png]]
----

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

Fichier:PRuine.png

2021-05-04T12:00:11Z

Emilien Boitouzet : Emilien Boitouzet a téléversé une nouvelle version de Fichier:PRuine.png

Fichier:PRuine.png

2021-05-04T11:59:43Z

Emilien Boitouzet :

Fichier:PGagne.png

2021-05-04T11:59:12Z

Emilien Boitouzet : Emilien Boitouzet a téléversé une nouvelle version de Fichier:PGagne.png

Fichier:PGagne.png

2021-05-04T11:58:36Z

Emilien Boitouzet :

Modélisation de la ruine du joueur 2020-2021

2021-05-04T11:58:26Z

Emilien Boitouzet : /* Graphes */

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 <math>a</math>, il souhaite gagner <math>b</math> 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 :
- <math>a</math> la richesse du joueur à l'entrée du casino
- <math>b</math> le gain souhaité par le joueur
- <math>p</math> 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 <math>\frac{1}{2}</math>.

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.

<pre>
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
</pre>

'''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 <math>g=1</math>). 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 <math>p=\frac{18}{37}</math>. 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.

<pre>
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
</pre>

'''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 <math>g=1</math>). 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.

<pre>
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
</pre>

'''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 <math>g=1</math>). 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.

<pre>
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
</pre>

'''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

<pre>
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
</pre>

'''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 <math>a</math> la richesse initiale, <math>b</math> la somme à gagner

===Pour une partie de "Pile ou Face" <math>p = 1/2</math>===

Pour calculer la valeur théorique de la probabilité de perdre :
<math> \mathbb{P}(S_T=0)=\frac{b}{a+b}</math>.

Pour le calcul de la probabilité de gagner :
<math> \mathbb{P}(S_T=a+b)=\frac{a}{a+b}</math>.

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

===Pour une partie de roulette <math> p \ne 1/2</math>===

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

Pour calculer la valeur théorique de la probabilité de perdre :
<math> \mathbb{P}(S_T=0)=\frac{r^{a+b}-r^a}{r^{a+b}-1}</math>.

Pour le calcul de la probabilité de gagner :
<math> \mathbb{P}(S_T=a+b)=\frac{r^a-1}{r^{a+b}-1}</math>.

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

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

<pre>
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
</pre>

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===
Nous avons aussi étudié l'évolution des valeurs de la simulation en fonction des valeurs théoriques d'un nombre de soirée <math>nb</math>. On peut voir sur les graphiques ci-dessous que les valeurs des simulations tendent vers les valeurs théorique.

Pour que la simulation ne prenne pas trop de temps les graphes sont faite à partir de petite valeur.
- <math>a = 20</math>
- <math>b = 10</math>
- <math>p = 18/37 </math>
- <math>nb = 1000</math> (le nombre de soirée simulé)

[[Fichier:estimation du temps.png]][[Fichier:pGagne.png]][[Fichier:pRuine.png]]
----

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

Modélisation de la ruine du joueur 2020-2021

2021-05-04T11:57:46Z

Emilien Boitouzet : /* Graphes */

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 <math>a</math>, il souhaite gagner <math>b</math> 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 :
- <math>a</math> la richesse du joueur à l'entrée du casino
- <math>b</math> le gain souhaité par le joueur
- <math>p</math> 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 <math>\frac{1}{2}</math>.

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.

<pre>
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
</pre>

'''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 <math>g=1</math>). 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 <math>p=\frac{18}{37}</math>. 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.

<pre>
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
</pre>

'''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 <math>g=1</math>). 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.

<pre>
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
</pre>

'''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 <math>g=1</math>). 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.

<pre>
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
</pre>

'''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

<pre>
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
</pre>

'''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 <math>a</math> la richesse initiale, <math>b</math> la somme à gagner

===Pour une partie de "Pile ou Face" <math>p = 1/2</math>===

Pour calculer la valeur théorique de la probabilité de perdre :
<math> \mathbb{P}(S_T=0)=\frac{b}{a+b}</math>.

Pour le calcul de la probabilité de gagner :
<math> \mathbb{P}(S_T=a+b)=\frac{a}{a+b}</math>.

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

===Pour une partie de roulette <math> p \ne 1/2</math>===

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

Pour calculer la valeur théorique de la probabilité de perdre :
<math> \mathbb{P}(S_T=0)=\frac{r^{a+b}-r^a}{r^{a+b}-1}</math>.

Pour le calcul de la probabilité de gagner :
<math> \mathbb{P}(S_T=a+b)=\frac{r^a-1}{r^{a+b}-1}</math>.

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

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

<pre>
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
</pre>

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===
Nous avons aussi étudié l'évolution des valeurs de la simulation en fonction des valeurs théoriques d'un nombre de soirée <math>nb</math>. On peut voir sur les graphiques ci-dessous que les valeurs des simulations tendent vers les valeurs théorique.

Pour que la simulation ne prenne pas trop de temps les graphes sont faite à partir de petite valeur.
- <math>a = 20</math>
- <math>b = 10</math>
- <math>p = 18/37 </math>
- <math>nb = 1000</math> (le nombre de soirée simulé)

[[Fichier:estimation du temps.png]]
----

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

Modélisation de la ruine du joueur 2020-2021

2021-05-04T11:51:10Z

Emilien Boitouzet : /* Graphes */

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 <math>a</math>, il souhaite gagner <math>b</math> 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 :
- <math>a</math> la richesse du joueur à l'entrée du casino
- <math>b</math> le gain souhaité par le joueur
- <math>p</math> 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 <math>\frac{1}{2}</math>.

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.

<pre>
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
</pre>

'''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 <math>g=1</math>). 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 <math>p=\frac{18}{37}</math>. 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.

<pre>
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
</pre>

'''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 <math>g=1</math>). 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.

<pre>
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
</pre>

'''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 <math>g=1</math>). 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.

<pre>
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
</pre>

'''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

<pre>
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
</pre>

'''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 <math>a</math> la richesse initiale, <math>b</math> la somme à gagner

===Pour une partie de "Pile ou Face" <math>p = 1/2</math>===

Pour calculer la valeur théorique de la probabilité de perdre :
<math> \mathbb{P}(S_T=0)=\frac{b}{a+b}</math>.

Pour le calcul de la probabilité de gagner :
<math> \mathbb{P}(S_T=a+b)=\frac{a}{a+b}</math>.

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

===Pour une partie de roulette <math> p \ne 1/2</math>===

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

Pour calculer la valeur théorique de la probabilité de perdre :
<math> \mathbb{P}(S_T=0)=\frac{r^{a+b}-r^a}{r^{a+b}-1}</math>.

Pour le calcul de la probabilité de gagner :
<math> \mathbb{P}(S_T=a+b)=\frac{r^a-1}{r^{a+b}-1}</math>.

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

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

<pre>
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
</pre>

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===
Nous avons aussi étudié l'évolution des valeurs de la simulation en fonction des valeurs théoriques. On peut voir sur les graphiques ci-dessous que les valeurs des simulations tendent vers les valeurs théorique. Pour que la simulation ne prenne pas trop de temps les graphes sont faite à partir de petite valeur.

[[Fichier:estimation du temps.png]]
----

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

Fichier:Estimation du temps.png

2021-05-04T11:49:41Z

Emilien Boitouzet :

Modélisation de la ruine du joueur 2020-2021

2021-05-04T11:48:18Z

Emilien Boitouzet : /* Graphes */

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 <math>a</math>, il souhaite gagner <math>b</math> 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 :
- <math>a</math> la richesse du joueur à l'entrée du casino
- <math>b</math> le gain souhaité par le joueur
- <math>p</math> 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 <math>\frac{1}{2}</math>.

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.

<pre>
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
</pre>

'''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 <math>g=1</math>). 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 <math>p=\frac{18}{37}</math>. 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.

<pre>
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
</pre>

'''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 <math>g=1</math>). 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.

<pre>
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
</pre>

'''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 <math>g=1</math>). 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.

<pre>
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
</pre>

'''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

<pre>
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
</pre>

'''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 <math>a</math> la richesse initiale, <math>b</math> la somme à gagner

===Pour une partie de "Pile ou Face" <math>p = 1/2</math>===

Pour calculer la valeur théorique de la probabilité de perdre :
<math> \mathbb{P}(S_T=0)=\frac{b}{a+b}</math>.

Pour le calcul de la probabilité de gagner :
<math> \mathbb{P}(S_T=a+b)=\frac{a}{a+b}</math>.

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

===Pour une partie de roulette <math> p \ne 1/2</math>===

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

Pour calculer la valeur théorique de la probabilité de perdre :
<math> \mathbb{P}(S_T=0)=\frac{r^{a+b}-r^a}{r^{a+b}-1}</math>.

Pour le calcul de la probabilité de gagner :
<math> \mathbb{P}(S_T=a+b)=\frac{r^a-1}{r^{a+b}-1}</math>.

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

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

<pre>
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
</pre>

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===
Nous avons aussi étudié l'évolution des valeurs de la simulation en fonction des valeurs théoriques. On peut voir sur les graphiques ci-dessous que les valeurs des simulations tendent vers les valeurs théorique. Pour que la simulation ne prenne pas trop de temps les graphes sont faite à partir de petite valeur.

----

[[Le code complet du projet]].

Le code compote les fonctions pour créer les graphes en fonction de vos valeurs initiale
[[Fichier:estimation du temps.jpg]]
----
'''CONCLUSION'''

----

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

Modélisation de la ruine du joueur 2020-2021

2021-05-04T11:40:07Z

Emilien Boitouzet : /* Estimations numériques */

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 <math>a</math>, il souhaite gagner <math>b</math> 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 :
- <math>a</math> la richesse du joueur à l'entrée du casino
- <math>b</math> le gain souhaité par le joueur
- <math>p</math> 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 <math>\frac{1}{2}</math>.

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.

<pre>
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
</pre>

'''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 <math>g=1</math>). 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 <math>p=\frac{18}{37}</math>. 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.

<pre>
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
</pre>

'''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 <math>g=1</math>). 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.

<pre>
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
</pre>

'''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 <math>g=1</math>). 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.

<pre>
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
</pre>

'''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

<pre>
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
</pre>

'''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 <math>a</math> la richesse initiale, <math>b</math> la somme à gagner

===Pour une partie de "Pile ou Face" <math>p = 1/2</math>===

Pour calculer la valeur théorique de la probabilité de perdre :
<math> \mathbb{P}(S_T=0)=\frac{b}{a+b}</math>.

Pour le calcul de la probabilité de gagner :
<math> \mathbb{P}(S_T=a+b)=\frac{a}{a+b}</math>.

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

===Pour une partie de roulette <math> p \ne 1/2</math>===

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

Pour calculer la valeur théorique de la probabilité de perdre :
<math> \mathbb{P}(S_T=0)=\frac{r^{a+b}-r^a}{r^{a+b}-1}</math>.

Pour le calcul de la probabilité de gagner :
<math> \mathbb{P}(S_T=a+b)=\frac{r^a-1}{r^{a+b}-1}</math>.

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

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

<pre>
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
</pre>

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)

Le code complet du projet

2021-05-04T11:37:09Z

Emilien Boitouzet : Page créée avec « <pre> ## BOITOUZET Emilien ## CMI-INFO ## La ruine d'un joueur import random import matplotlib.pyplot as plt import numpy as np # simulation d'une partie de jeu équi... »

<pre>
## BOITOUZET Emilien
## CMI-INFO
## La ruine d'un joueur

import random
import matplotlib.pyplot as plt
import numpy as np

# simulation d'une partie de jeu équilibré
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 ruineG(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

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

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

# Partie théorique

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

def graphe_pRuine (a,b,p,nb):
"""Fonction qui trace le graphe de la probabilité d'être ruiné et
la droite de la valeur théorique"""
pas = 1
res2 = []
i = 1
while i < nb+1 :
res2 = res2 + [est_ruine(a,b,p,i)]
i = i + pas

plt.clf()
x = [i for i in range(1,nb+1,pas)]
y1 = res2
y2 = [theorie(a,b,p)[0]]*len(x)
plt.plot(x,y1)
plt.plot(x,y2)
plt.title("Évolution de la probabilité d'être ruiné")
plt.xlabel("n° de la partie")
plt.ylabel("probabilité d'être ruiné")
plt.show()

def graphe_pGagne (a,b,p,nb):
"""Fonction qui trace le graphe de la probabilité de gagné et
la droite de la valeur théorique"""
pas = 1
res = []
i = 1
while i < nb+1 :
res = res + [1-(est_ruine(a,b,p,i))]
i = i + pas

plt.clf()
x = [i for i in range(1,nb+1,pas)]
y1 = res
y2 = [theorie(a,b,p)[1]]*len(x)
plt.plot(x,y1)
plt.plot(x,y2)
plt.title("Évolution de la probabilité de gagner")
plt.xlabel("n° de la partie")
plt.ylabel("probabilité de gagner")
plt.show()

def graphe_eT(a,b,p,nb):
"""fonction qui trace la courbe représentative du temps de jeux et le
temps théorique du temps de jeux"""
pas = 1
res = []
i = 1

while i < nb+1 :
res = res + [temps_moy(a,b,p,i)]
i = i + pas

plt.clf()
x = [i for i in range(1,nb+1,pas)]
y1 = res
y2 = [theorie(a,b,p)[2]]*len(x)
plt.plot(x,y1)
plt.plot(x,y2)
plt.title("Évolution du temps de jeu")
plt.xlabel("n° de la partie")
plt.ylabel("Temps de jeu")
plt.show()

def graphe (a,b,p,nb):
"""fonction qui trace tous les graphes ci-dessus"""
graphe_pRuine(a,b,p,nb)
graphe_pGagne(a,b,p,nb)
graphe_eT(a,b,p,nb)

</pre>

Modélisation de la ruine du joueur 2020-2021

2021-05-04T11:36:31Z

Emilien Boitouzet : /* Code */

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 <math>a</math>, il souhaite gagner <math>b</math> 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 :
- <math>a</math> la richesse du joueur à l'entrée du casino
- <math>b</math> le gain souhaité par le joueur
- <math>p</math> 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 <math>\frac{1}{2}</math>.

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.

<pre>
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
</pre>

'''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 <math>g=1</math>). 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 <math>p=\frac{18}{37}</math>. 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.

<pre>
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
</pre>

'''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 <math>g=1</math>). 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.

<pre>
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
</pre>

'''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 <math>g=1</math>). 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.

<pre>
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
</pre>

'''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

<pre>
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
</pre>

'''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 <math>a</math> la richesse initiale, <math>b</math> la somme à gagner

===Pour une partie de "Pile ou Face" <math>p = 1/2</math>===

Pour calculer la valeur théorique de la probabilité de perdre :
<math> \mathbb{P}(S_T=0)=\frac{b}{a+b}</math>.

Pour le calcul de la probabilité de gagner :
<math> \mathbb{P}(S_T=a+b)=\frac{a}{a+b}</math>.

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

===Pour une partie de roulette <math> p \ne 1/2</math>===

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

Pour calculer la valeur théorique de la probabilité de perdre :
<math> \mathbb{P}(S_T=0)=\frac{r^{a+b}-r^a}{r^{a+b}-1}</math>.

Pour le calcul de la probabilité de gagner :
<math> \mathbb{P}(S_T=a+b)=\frac{r^a-1}{r^{a+b}-1}</math>.

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

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

<pre>
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
</pre>

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.

----

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

Modélisation de la ruine du joueur 2020-2021

2021-05-04T11:36:17Z

Emilien Boitouzet : /* Code */

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 <math>a</math>, il souhaite gagner <math>b</math> 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 :
- <math>a</math> la richesse du joueur à l'entrée du casino
- <math>b</math> le gain souhaité par le joueur
- <math>p</math> 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 <math>\frac{1}{2}</math>.

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.

<pre>
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
</pre>

'''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 <math>g=1</math>). 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 <math>p=\frac{18}{37}</math>. 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.

<pre>
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
</pre>

'''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 <math>g=1</math>). 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.

<pre>
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
</pre>

'''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 <math>g=1</math>). 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.

<pre>
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
</pre>

'''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

<pre>
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
</pre>

'''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 <math>a</math> la richesse initiale, <math>b</math> la somme à gagner

===Pour une partie de "Pile ou Face" <math>p = 1/2</math>===

Pour calculer la valeur théorique de la probabilité de perdre :
<math> \mathbb{P}(S_T=0)=\frac{b}{a+b}</math>.

Pour le calcul de la probabilité de gagner :
<math> \mathbb{P}(S_T=a+b)=\frac{a}{a+b}</math>.

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

===Pour une partie de roulette <math> p \ne 1/2</math>===

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

Pour calculer la valeur théorique de la probabilité de perdre :
<math> \mathbb{P}(S_T=0)=\frac{r^{a+b}-r^a}{r^{a+b}-1}</math>.

Pour le calcul de la probabilité de gagner :
<math> \mathbb{P}(S_T=a+b)=\frac{r^a-1}{r^{a+b}-1}</math>.

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

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

<pre>
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
</pre>

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.

----

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

Modélisation de la ruine du joueur 2020-2021

2021-05-04T11:33:56Z

Emilien Boitouzet : /* Calculs de probabilité */

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 <math>a</math>, il souhaite gagner <math>b</math> 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 :
- <math>a</math> la richesse du joueur à l'entrée du casino
- <math>b</math> le gain souhaité par le joueur
- <math>p</math> 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 <math>\frac{1}{2}</math>.

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.

<pre>
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
</pre>

'''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 <math>g=1</math>). 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 <math>p=\frac{18}{37}</math>. 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.

<pre>
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
</pre>

'''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 <math>g=1</math>). 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.

<pre>
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
</pre>

'''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 <math>g=1</math>). 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.

<pre>
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
</pre>

'''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

<pre>
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
</pre>

'''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 <math>a</math> la richesse initiale, <math>b</math> la somme à gagner

===Pour une partie de "Pile ou Face" <math>p = 1/2</math>===

Pour calculer la valeur théorique de la probabilité de perdre :
<math> \mathbb{P}(S_T=0)=\frac{b}{a+b}</math>.

Pour le calcul de la probabilité de gagner :
<math> \mathbb{P}(S_T=a+b)=\frac{a}{a+b}</math>.

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

===Pour une partie de roulette <math> p \ne 1/2</math>===

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

Pour calculer la valeur théorique de la probabilité de perdre :
<math> \mathbb{P}(S_T=0)=\frac{r^{a+b}-r^a}{r^{a+b}-1}</math>.

Pour le calcul de la probabilité de gagner :
<math> \mathbb{P}(S_T=a+b)=\frac{r^a-1}{r^{a+b}-1}</math>.

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

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

<pre>
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
</pre>

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.

----
'''CONCLUSION'''

----

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

Modélisation de la ruine du joueur 2020-2021

2021-05-04T11:33:09Z

Emilien Boitouzet : /* Probabilité de perdre */

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 <math>a</math>, il souhaite gagner <math>b</math> 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 :
- <math>a</math> la richesse du joueur à l'entrée du casino
- <math>b</math> le gain souhaité par le joueur
- <math>p</math> 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 <math>\frac{1}{2}</math>.

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.

<pre>
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
</pre>

'''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 <math>g=1</math>). 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 <math>p=\frac{18}{37}</math>. 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.

<pre>
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
</pre>

'''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 <math>g=1</math>). 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.

<pre>
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
</pre>

'''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 <math>g=1</math>). 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é==

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.

<pre>
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
</pre>

'''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

<pre>
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
</pre>

'''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 <math>a</math> la richesse initiale, <math>b</math> la somme à gagner

===Pour une partie de "Pile ou Face" <math>p = 1/2</math>===

Pour calculer la valeur théorique de la probabilité de perdre :
<math> \mathbb{P}(S_T=0)=\frac{b}{a+b}</math>.

Pour le calcul de la probabilité de gagner :
<math> \mathbb{P}(S_T=a+b)=\frac{a}{a+b}</math>.

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

===Pour une partie de roulette <math> p \ne 1/2</math>===

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

Pour calculer la valeur théorique de la probabilité de perdre :
<math> \mathbb{P}(S_T=0)=\frac{r^{a+b}-r^a}{r^{a+b}-1}</math>.

Pour le calcul de la probabilité de gagner :
<math> \mathbb{P}(S_T=a+b)=\frac{r^a-1}{r^{a+b}-1}</math>.

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

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

<pre>
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
</pre>

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.

----
'''CONCLUSION'''

----

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

Modélisation de la ruine du joueur 2020-2021

2021-05-04T11:33:01Z

Emilien Boitouzet : /* Calcul du temps moyen de jeu */

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 <math>a</math>, il souhaite gagner <math>b</math> 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 :
- <math>a</math> la richesse du joueur à l'entrée du casino
- <math>b</math> le gain souhaité par le joueur
- <math>p</math> 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 <math>\frac{1}{2}</math>.

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.

<pre>
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
</pre>

'''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 <math>g=1</math>). 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 <math>p=\frac{18}{37}</math>. 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.

<pre>
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
</pre>

'''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 <math>g=1</math>). 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.

<pre>
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
</pre>

'''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 <math>g=1</math>). 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é==

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.

<pre>
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
</pre>

'''ATTENTION'''

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

<pre>
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
</pre>

'''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 <math>a</math> la richesse initiale, <math>b</math> la somme à gagner

===Pour une partie de "Pile ou Face" <math>p = 1/2</math>===

Pour calculer la valeur théorique de la probabilité de perdre :
<math> \mathbb{P}(S_T=0)=\frac{b}{a+b}</math>.

Pour le calcul de la probabilité de gagner :
<math> \mathbb{P}(S_T=a+b)=\frac{a}{a+b}</math>.

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

===Pour une partie de roulette <math> p \ne 1/2</math>===

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

Pour calculer la valeur théorique de la probabilité de perdre :
<math> \mathbb{P}(S_T=0)=\frac{r^{a+b}-r^a}{r^{a+b}-1}</math>.

Pour le calcul de la probabilité de gagner :
<math> \mathbb{P}(S_T=a+b)=\frac{r^a-1}{r^{a+b}-1}</math>.

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

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

<pre>
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
</pre>

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.

----
'''CONCLUSION'''

----

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

Modélisation de la ruine du joueur 2020-2021

2021-05-04T11:32:35Z

Emilien Boitouzet : /* Probabilité de perdre */

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 <math>a</math>, il souhaite gagner <math>b</math> 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 :
- <math>a</math> la richesse du joueur à l'entrée du casino
- <math>b</math> le gain souhaité par le joueur
- <math>p</math> 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 <math>\frac{1}{2}</math>.

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.

<pre>
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
</pre>

'''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 <math>g=1</math>). 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 <math>p=\frac{18}{37}</math>. 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.

<pre>
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
</pre>

'''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 <math>g=1</math>). 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.

<pre>
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
</pre>

'''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 <math>g=1</math>). 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é==

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.

<pre>
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
</pre>

'''ATTENTION'''

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

<pre>
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
</pre>

'''ATTENTION'''
Pour exécuter ce code 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 <math>a</math> la richesse initiale, <math>b</math> la somme à gagner

===Pour une partie de "Pile ou Face" <math>p = 1/2</math>===

Pour calculer la valeur théorique de la probabilité de perdre :
<math> \mathbb{P}(S_T=0)=\frac{b}{a+b}</math>.

Pour le calcul de la probabilité de gagner :
<math> \mathbb{P}(S_T=a+b)=\frac{a}{a+b}</math>.

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

===Pour une partie de roulette <math> p \ne 1/2</math>===

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

Pour calculer la valeur théorique de la probabilité de perdre :
<math> \mathbb{P}(S_T=0)=\frac{r^{a+b}-r^a}{r^{a+b}-1}</math>.

Pour le calcul de la probabilité de gagner :
<math> \mathbb{P}(S_T=a+b)=\frac{r^a-1}{r^{a+b}-1}</math>.

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

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

<pre>
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
</pre>

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.

----
'''CONCLUSION'''

----

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

Code général

2021-05-04T11:29:51Z

Emilien Boitouzet : Page créée avec « <pre> 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... »

<pre>
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
</pre>

Modélisation de la ruine du joueur 2020-2021

2021-05-04T11:29:00Z

Emilien Boitouzet : /* Calcul du temps moyen de jeu */

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 <math>a</math>, il souhaite gagner <math>b</math> 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 :
- <math>a</math> la richesse du joueur à l'entrée du casino
- <math>b</math> le gain souhaité par le joueur
- <math>p</math> 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 <math>\frac{1}{2}</math>.

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.

<pre>
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
</pre>

'''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 <math>g=1</math>). 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 <math>p=\frac{18}{37}</math>. 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.

<pre>
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
</pre>

'''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 <math>g=1</math>). 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.

<pre>
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
</pre>

'''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 <math>g=1</math>). 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é==

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.

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

<pre>
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
</pre>

'''ATTENTION'''
Pour exécuter ce code 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 <math>a</math> la richesse initiale, <math>b</math> la somme à gagner

===Pour une partie de "Pile ou Face" <math>p = 1/2</math>===

Pour calculer la valeur théorique de la probabilité de perdre :
<math> \mathbb{P}(S_T=0)=\frac{b}{a+b}</math>.

Pour le calcul de la probabilité de gagner :
<math> \mathbb{P}(S_T=a+b)=\frac{a}{a+b}</math>.

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

===Pour une partie de roulette <math> p \ne 1/2</math>===

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

Pour calculer la valeur théorique de la probabilité de perdre :
<math> \mathbb{P}(S_T=0)=\frac{r^{a+b}-r^a}{r^{a+b}-1}</math>.

Pour le calcul de la probabilité de gagner :
<math> \mathbb{P}(S_T=a+b)=\frac{r^a-1}{r^{a+b}-1}</math>.

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

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

<pre>
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
</pre>

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.

----
'''CONCLUSION'''

----

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

Modélisation de la ruine du joueur 2020-2021

2021-05-04T11:27:19Z

Emilien Boitouzet : /* Calcul du temps moyen de jeu */

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 <math>a</math>, il souhaite gagner <math>b</math> 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 :
- <math>a</math> la richesse du joueur à l'entrée du casino
- <math>b</math> le gain souhaité par le joueur
- <math>p</math> 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 <math>\frac{1}{2}</math>.

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.

<pre>
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
</pre>

'''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 <math>g=1</math>). 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 <math>p=\frac{18}{37}</math>. 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.

<pre>
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
</pre>

'''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 <math>g=1</math>). 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.

<pre>
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
</pre>

'''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 <math>g=1</math>). 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é==

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.

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

<pre>
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
</pre>

'''ATTENTION'''
Pour exécuter ce code il faut aussi prendre la fonction ruine.

==Estimations numériques==

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

Nous avons <math>a</math> la richesse initiale, <math>b</math> la somme à gagner

===Pour une partie de "Pile ou Face" <math>p = 1/2</math>===

Pour calculer la valeur théorique de la probabilité de perdre :
<math> \mathbb{P}(S_T=0)=\frac{b}{a+b}</math>.

Pour le calcul de la probabilité de gagner :
<math> \mathbb{P}(S_T=a+b)=\frac{a}{a+b}</math>.

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

===Pour une partie de roulette <math> p \ne 1/2</math>===

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

Pour calculer la valeur théorique de la probabilité de perdre :
<math> \mathbb{P}(S_T=0)=\frac{r^{a+b}-r^a}{r^{a+b}-1}</math>.

Pour le calcul de la probabilité de gagner :
<math> \mathbb{P}(S_T=a+b)=\frac{r^a-1}{r^{a+b}-1}</math>.

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

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

<pre>
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
</pre>

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.

----
'''CONCLUSION'''

----

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

Modélisation de la ruine du joueur 2020-2021

2021-05-04T11:19:27Z

Emilien Boitouzet : /* Calcul du temps moyen de jeu */

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 <math>a</math>, il souhaite gagner <math>b</math> 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 :
- <math>a</math> la richesse du joueur à l'entrée du casino
- <math>b</math> le gain souhaité par le joueur
- <math>p</math> 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 <math>\frac{1}{2}</math>.

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.

<pre>
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
</pre>

'''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 <math>g=1</math>). 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 <math>p=\frac{18}{37}</math>. 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.

<pre>
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
</pre>

'''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 <math>g=1</math>). 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.

<pre>
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
</pre>

'''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 <math>g=1</math>). 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é==

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.

==Calcul du temps moyen de jeu==

<pre>
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
</pre>

==Estimations numériques==

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

Nous avons <math>a</math> la richesse initiale, <math>b</math> la somme à gagner

===Pour une partie de "Pile ou Face" <math>p = 1/2</math>===

Pour calculer la valeur théorique de la probabilité de perdre :
<math> \mathbb{P}(S_T=0)=\frac{b}{a+b}</math>.

Pour le calcul de la probabilité de gagner :
<math> \mathbb{P}(S_T=a+b)=\frac{a}{a+b}</math>.

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

===Pour une partie de roulette <math> p \ne 1/2</math>===

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

Pour calculer la valeur théorique de la probabilité de perdre :
<math> \mathbb{P}(S_T=0)=\frac{r^{a+b}-r^a}{r^{a+b}-1}</math>.

Pour le calcul de la probabilité de gagner :
<math> \mathbb{P}(S_T=a+b)=\frac{r^a-1}{r^{a+b}-1}</math>.

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

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

<pre>
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
</pre>

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.

----
'''CONCLUSION'''

----

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

Modélisation de la ruine du joueur 2020-2021

2021-05-04T11:18:13Z

Emilien Boitouzet : /* Code */

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 <math>a</math>, il souhaite gagner <math>b</math> 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 :
- <math>a</math> la richesse du joueur à l'entrée du casino
- <math>b</math> le gain souhaité par le joueur
- <math>p</math> 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 <math>\frac{1}{2}</math>.

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.

<pre>
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
</pre>

'''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 <math>g=1</math>). 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 <math>p=\frac{18}{37}</math>. 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.

<pre>
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
</pre>

'''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 <math>g=1</math>). 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.

<pre>
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
</pre>

'''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 <math>g=1</math>). 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é==

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.

==Calcul du temps moyen de jeu==

==Estimations numériques==

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

Nous avons <math>a</math> la richesse initiale, <math>b</math> la somme à gagner

===Pour une partie de "Pile ou Face" <math>p = 1/2</math>===

Pour calculer la valeur théorique de la probabilité de perdre :
<math> \mathbb{P}(S_T=0)=\frac{b}{a+b}</math>.

Pour le calcul de la probabilité de gagner :
<math> \mathbb{P}(S_T=a+b)=\frac{a}{a+b}</math>.

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

===Pour une partie de roulette <math> p \ne 1/2</math>===

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

Pour calculer la valeur théorique de la probabilité de perdre :
<math> \mathbb{P}(S_T=0)=\frac{r^{a+b}-r^a}{r^{a+b}-1}</math>.

Pour le calcul de la probabilité de gagner :
<math> \mathbb{P}(S_T=a+b)=\frac{r^a-1}{r^{a+b}-1}</math>.

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

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

<pre>
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
</pre>

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.

----
'''CONCLUSION'''

----

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

Modélisation de la ruine du joueur 2020-2021

2021-05-04T11:17:59Z

Emilien Boitouzet : /* Code */

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 <math>a</math>, il souhaite gagner <math>b</math> 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 :
- <math>a</math> la richesse du joueur à l'entrée du casino
- <math>b</math> le gain souhaité par le joueur
- <math>p</math> 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 <math>\frac{1}{2}</math>.

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.

<pre>
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
</pre>

'''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 <math>g=1</math>). 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 <math>p=\frac{18}{37}</math>. 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.

<pre>
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
</pre>

'''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 <math>g=1</math>). 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.

<pre>
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
</pre>

'''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 <math>g=1</math>). 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é==

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.

==Calcul du temps moyen de jeu==

==Estimations numériques==

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

Nous avons <math>a</math> la richesse initiale, <math>b</math> la somme à gagner

===Pour une partie de "Pile ou Face" <math>p = 1/2</math>===

Pour calculer la valeur théorique de la probabilité de perdre :
<math> \mathbb{P}(S_T=0)=\frac{b}{a+b}</math>.

Pour le calcul de la probabilité de gagner :
<math> \mathbb{P}(S_T=a+b)=\frac{a}{a+b}</math>.

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

===Pour une partie de roulette <math> p \ne 1/2</math>===

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

Pour calculer la valeur théorique de la probabilité de perdre :
<math> \mathbb{P}(S_T=0)=\frac{r^{a+b}-r^a}{r^{a+b}-1}</math>.

Pour le calcul de la probabilité de gagner :
<math> \mathbb{P}(S_T=a+b)=\frac{r^a-1}{r^{a+b}-1}</math>.

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

===Code===
Le code suivant permet de calculer les différentes valeurs théorique :

<pre>
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
</pre>

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.

----
'''CONCLUSION'''

----

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

Modélisation de la ruine du joueur 2020-2021

2021-05-04T11:15:49Z

Emilien Boitouzet : /* Code */

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 <math>a</math>, il souhaite gagner <math>b</math> 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 :
- <math>a</math> la richesse du joueur à l'entrée du casino
- <math>b</math> le gain souhaité par le joueur
- <math>p</math> 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 <math>\frac{1}{2}</math>.

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.

<pre>
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
</pre>

'''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 <math>g=1</math>). 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 <math>p=\frac{18}{37}</math>. 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.

<pre>
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
</pre>

'''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 <math>g=1</math>). 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.

<pre>
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
</pre>

'''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 <math>g=1</math>). 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é==

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.

==Calcul du temps moyen de jeu==

==Estimations numériques==

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

Nous avons <math>a</math> la richesse initiale, <math>b</math> la somme à gagner

===Pour une partie de "Pile ou Face" <math>p = 1/2</math>===

Pour calculer la valeur théorique de la probabilité de perdre :
<math> \mathbb{P}(S_T=0)=\frac{b}{a+b}</math>.

Pour le calcul de la probabilité de gagner :
<math> \mathbb{P}(S_T=a+b)=\frac{a}{a+b}</math>.

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

===Pour une partie de roulette <math> p \ne 1/2</math>===

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

Pour calculer la valeur théorique de la probabilité de perdre :
<math> \mathbb{P}(S_T=0)=\frac{r^{a+b}-r^a}{r^{a+b}-1}</math>.

Pour le calcul de la probabilité de gagner :
<math> \mathbb{P}(S_T=a+b)=\frac{r^a-1}{r^{a+b}-1}</math>.

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

===Code===
Le code suivant permet de calculer les différentes valeurs théorique :

<pre>
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
</pre>

Cette fonction renvoie un tuple.

<code>
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
</code>

----
'''CONCLUSION'''

----

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

Modélisation de la ruine du joueur 2020-2021

2021-05-04T11:13:58Z

Emilien Boitouzet : /* Code */

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 <math>a</math>, il souhaite gagner <math>b</math> 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 :
- <math>a</math> la richesse du joueur à l'entrée du casino
- <math>b</math> le gain souhaité par le joueur
- <math>p</math> 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 <math>\frac{1}{2}</math>.

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.

<pre>
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
</pre>

'''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 <math>g=1</math>). 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 <math>p=\frac{18}{37}</math>. 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.

<pre>
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
</pre>

'''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 <math>g=1</math>). 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.

<pre>
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
</pre>

'''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 <math>g=1</math>). 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é==

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.

==Calcul du temps moyen de jeu==

==Estimations numériques==

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

Nous avons <math>a</math> la richesse initiale, <math>b</math> la somme à gagner

===Pour une partie de "Pile ou Face" <math>p = 1/2</math>===

Pour calculer la valeur théorique de la probabilité de perdre :
<math> \mathbb{P}(S_T=0)=\frac{b}{a+b}</math>.

Pour le calcul de la probabilité de gagner :
<math> \mathbb{P}(S_T=a+b)=\frac{a}{a+b}</math>.

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

===Pour une partie de roulette <math> p \ne 1/2</math>===

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

Pour calculer la valeur théorique de la probabilité de perdre :
<math> \mathbb{P}(S_T=0)=\frac{r^{a+b}-r^a}{r^{a+b}-1}</math>.

Pour le calcul de la probabilité de gagner :
<math> \mathbb{P}(S_T=a+b)=\frac{r^a-1}{r^{a+b}-1}</math>.

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

===Code===
Le code suivant permet de calculer les différentes valeurs théorique :

<pre>
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
</pre>

<code>
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
</code>

----
'''CONCLUSION'''

----

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

Modélisation de la ruine du joueur 2020-2021

2021-05-04T11:11:28Z

Emilien Boitouzet : /* Estimations numériques */

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 <math>a</math>, il souhaite gagner <math>b</math> 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 :
- <math>a</math> la richesse du joueur à l'entrée du casino
- <math>b</math> le gain souhaité par le joueur
- <math>p</math> 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 <math>\frac{1}{2}</math>.

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.

<pre>
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
</pre>

'''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 <math>g=1</math>). 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 <math>p=\frac{18}{37}</math>. 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.

<pre>
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
</pre>

'''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 <math>g=1</math>). 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.

<pre>
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
</pre>

'''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 <math>g=1</math>). 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é==

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.

==Calcul du temps moyen de jeu==

==Estimations numériques==

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

Nous avons <math>a</math> la richesse initiale, <math>b</math> la somme à gagner

===Pour une partie de "Pile ou Face" <math>p = 1/2</math>===

Pour calculer la valeur théorique de la probabilité de perdre :
<math> \mathbb{P}(S_T=0)=\frac{b}{a+b}</math>.

Pour le calcul de la probabilité de gagner :
<math> \mathbb{P}(S_T=a+b)=\frac{a}{a+b}</math>.

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

===Pour une partie de roulette <math> p \ne 1/2</math>===

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

Pour calculer la valeur théorique de la probabilité de perdre :
<math> \mathbb{P}(S_T=0)=\frac{r^{a+b}-r^a}{r^{a+b}-1}</math>.

Pour le calcul de la probabilité de gagner :
<math> \mathbb{P}(S_T=a+b)=\frac{r^a-1}{r^{a+b}-1}</math>.

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

===Code===

----
'''CONCLUSION'''

----

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

Modélisation de la ruine du joueur 2020-2021

2021-05-04T11:02:36Z

Emilien Boitouzet : /* Calculs de probabilité */

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 <math>a</math>, il souhaite gagner <math>b</math> 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 :
- <math>a</math> la richesse du joueur à l'entrée du casino
- <math>b</math> le gain souhaité par le joueur
- <math>p</math> 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 <math>\frac{1}{2}</math>.

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.

<pre>
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
</pre>

'''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 <math>g=1</math>). 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 <math>p=\frac{18}{37}</math>. 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.

<pre>
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
</pre>

'''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 <math>g=1</math>). 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.

<pre>
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
</pre>

'''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 <math>g=1</math>). 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é==

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.

==Calcul du temps moyen de jeu==

==Estimations numériques==

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

Nous avons <math>a</math> la richesse initiale, <math>b</math> la somme à gagner

===Pour une partie de "Pile ou Face" <math>p = 1/2</math>===

Pour calculer la valeur théorique de la probabilité de perdre :
<math> \mathbb{P}(S_T=0)=\frac{b}{a+b}</math>.

Pour le calcul de la probabilité de gagner :
<math> \mathbb{P}(S_T=a+b)=\frac{a}{a+b}</math>.

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

===Pour une partie de roulette <math> p \ne 1/2</math>===

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

Pour calculer la valeur théorique de la probabilité de perdre :
<math> \mathbb{P}(S_T=0)=\frac{r^{a+b}-r^a}{r^{a+b}-1}</math>.

Pour le calcul de la probabilité de gagner :
<math> \mathbb{P}(S_T=a+b)=\frac{r^a-1}{r^{a+b}-1}</math>.

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

----
'''CONCLUSION'''

----

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

Modélisation de la ruine du joueur 2020-2021

2021-05-04T10:57:47Z

Emilien Boitouzet : /* Code général */

Modélisation de la ruine du joueur 2020-2021

2021-05-02T18:26:02Z

Emilien Boitouzet : /* Estimations numériques */

Modélisation de la ruine du joueur 2020-2021

2021-05-02T18:24:56Z

Emilien Boitouzet : /* Code général */

Modélisation de la ruine du joueur 2020-2021

2021-05-02T18:23:58Z

Emilien Boitouzet : /* Une partie de roulette */

Modélisation de la ruine du joueur 2020-2021

2021-05-02T18:22:51Z

Emilien Boitouzet : /* Une partie de "Pile ou Face" */

Modélisation de la ruine du joueur 2020-2021

2021-05-02T18:21:04Z

Emilien Boitouzet : /* Une soirée au casino (simulation) */