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

Modélisation de la ruine du joueur

2024-05-21T22:25:20Z

Akulas :

==Modélisation de la ruine du joueur==

Nous nous intéressons à l'étude des gains d'un joueur lors d'une soirée au casino, dans lequel le joueur joue à la roulette russe.

Le joueur commence avec une somme initiale comprise entre 0 et la somme souhaitée, le joueur s'arrête uniquement si :
- il obtient la somme souhaitée
- le joueur est ruiné (la somme est égale à 0)

Pour cela le joueur va jouer à la roulette en misant à chaque fois 1 jeton qu'il peut doubler ou perdre.

==Estimations numériques==

Nous allons prendre pour base le document suivant : [https://perso.eleves.ens-rennes.fr/people/florian.lemonnier/agregation/developpements/Ruine.pdf Ruine]

Notre objectif est de trouver de :

- calculer la probabilité de victoire, soit d'atteindre la somme souhaitée, en partant de la somme de départ.
- calculer la durée de la partie, soit le joueur arrête de jouer, donc il atteint l'une des conditions d'arrêt.

On définit de manière générale p la probabilité de victoire d'une partie et q = (1-p)

===Estimation de la probabilité de gagner===

On veut trouver une formule qui permet de trouver la probabilité de victoire lors d'une soirée au casino selon les paramètres de départ, soit la somme de départ et la somme voulue et la probabilité de victoire.

On commence avec la loi de probabilité totale :

<math> P_k(A) = P_k(A|Y_1 = 1)P_k(Y_1 = 1) + P_k(A|Y_1 = -1)P_k(Y_1 = -1) = P_{k+1}(A)p + P_{k-1}(A)q </math>

Ce qui donne le système suivant :

<math>
\begin{cases}
p_k = p \cdot p_{k+1} + q \cdot p_{k-1}, & \text{pour } 1 \leq k \leq a + b \\
p_0 = 0, \\
p_{a+b} = 1.
\end{cases}
</math>

'''On cherche l'équation quadratique : '''

On a la suite récurrente d'ordre 2 : [https://www.mathieu-mansuy.fr/pdf/PCSI5-complement1.pdf Résoudre une équation linéaire d'ordre 2] 
<math> p_k = p \cdot p_{k+1} + q \cdot p_{k-1} </math> 

On remplace <math> p_k </math> par <math> x^{k} </math> : 
<math> x^{k} = p \cdot x^{k+1} + q \cdot x^{k-1} </math> 

On divise par <math> x^{k-1} </math> : 
<math> x = p \cdot x^{2} + q </math> 

''' On résoult l'équation '''

<math> p \cdot x^{k+1} - x^{k} + q \cdot x^{k-1} = 0 </math>

====Pour p = 1/2 ====

Ca qui donne la solution unique : <math> x = 1 </math>

''' On en déduit les valeurs <math> \alpha \text{ et } \beta </math>''' :
<math>
\begin{cases}
0 = \alpha \\
1 = \alpha + \beta \cdot (a+b) \\
\end{cases}

\iff \begin{cases}
\alpha = 0 \\
\beta = \frac{a}{a+b} \\
\end{cases}
</math>

On a donc formule suivante : <math> p = \frac{a}{a+b} </math>

====Pour p ≠ 1/2====

Ce qui donne les solutions : <math> x_1 = 1 \text{ et } x_2 = \frac{q}{p} </math>

''' On a alors :'''

<math> p_k = \alpha \cdot x_1^{k} + \beta \cdot x_2^{k} </math> 
<math> \iff p_k = \alpha + \beta \cdot (\frac{q}{p})^{k} </math>

''' On en déduit les valeurs <math> \alpha \text{ et } \beta </math>''' :
<math>
\begin{cases}
0 = \alpha + \beta \\
1 = \alpha + \beta \cdot (\frac{q}{p})^{k} \\
\end{cases}

\iff \begin{cases}
\alpha = - \beta \\
1 = - \beta + \beta \cdot (\frac{q}{p})^{k} \\
\end{cases}

\iff \begin{cases}
\alpha = - \beta \\
1 = \beta \left(-1 + \left( \frac{q}{p} \right)^{a+b} \right) \\
\end{cases}

\iff \begin{cases}
\alpha = - \beta \\
\beta = \frac{1}{-1 + \left( \frac{q}{p} \right)^{a+b}} \\
\end{cases}
</math> 

On obtient :
<math>
\alpha = -\left(\frac{1}{-1 + \left( \frac{q}{p} \right)^{a+b}}\right)
\text{ et }
\beta = \frac{1}{-1 + \left( \frac{q}{p} \right)^{a+b}}
</math> 

D'où :
<math>
p_a = -\left(\frac{1}{-1 + \left( \frac{q}{p} \right)^{a+b}}\right)
+ \frac{\left( \frac{q}{p} \right)^{a}}{-1 + \left( \frac{q}{p} \right)^{a+b}}

\iff

p = \frac{\left( \frac{q}{p} \right)^{a} - 1}{\left( \frac{q}{p} \right)^{a+b} - 1}
</math>

On a donc formule suivante : <math> p = \frac{\left( \frac{q}{p} \right)^{a} - 1}{\left( \frac{q}{p} \right)^{a+b} - 1} </math>

===Estimation du temps moyen de jeu===

On commence avec la loi de probabilité totale :

<math> E_k(T) =E_k(T|Y_1 = 1)P(Y_1 = 1) + E_k(A|Y_1 = -1)P(Y_1 = -1) = (1 + E_{k+1}(T))p + (1 + E_{k-1}(T))q </math>

Ce qui donne l'équation :

<math>
\begin{cases}
e_k = 1 + p \cdot e_{k+1} + q \cdot e_{k-1}, & \text{pour } 1 \leq k \leq a + b \\
e_0 = 0, \\
e_{a+b} = 0.
\end{cases}
</math>

On note, pour <math> k \geq 1 , d_k = e_k - e_{k-1} </math>

On a donc la relation de récurence : <math> 0 = 1 + p \cdot d_{k+1} - q \cdot d_k </math>

====Pour p = 1/2 ====

On a <math> \frac{1}{2} \cdot d_{k+1} = \frac{1}{2} \cdot d_{k} - 1 </math>

donc, <math> d_{k+1} = d_k - 2 </math>

d'où <math> d_k = d_1 - 2 \left(k-1 \right) </math>

Alors pour <math> n \geq 1 , e_n = \sum_{k=1}^{n} d_k = n \cdot d_1 - 2 \cdot \sum_{k=0}^{n-1}k = n \cdot d_1 - 2 \cdot \frac{n(n-1)}{2} = n(d_1 - (n - 1)) </math>

Or <math> e_{a+b} = 0 = (a+b)(d_1 + (a + b - 1)), \text{d'où } d_1 = a + b - 1 </math>

Donc <math> E[T] = e_a = a(a + b - 1 - (a - 1)) = ab </math>

====Pour p ≠ 1/2 ====

On pose le réel l qui verifie <math> 0 = pl - ql </math> qui est donc <math> l = \frac{1}{q-p} </math>

La relation devient donc <math> 0 = p(d_{k+1} - l) - q(d_k - l) </math>

Par conséquent, <math> d_{k+1} - l = \frac{q}{p}(d_k - l) , \text{et donc } d_k - l = \left( \frac{q}{p} \right) ^{k-1} (d_1 - l) </math>

Donc pour <math> n \geq 1 </math>, on a :

<math> e_n = \sum_{k=1}^{n}d_k + e_0 = \sum_{k=1}^{n} \left( l + \left( \frac{q}{p} \right) ^{k-1} \cdot (d_1 - l) \right) = nl + (d_1 - l) \cdot \sum_{k=0}^{n-1}\left( \frac{q}{p} \right) ^{k} = nl + (d_1 - l) \cdot \frac{1 - \left( \frac{q}{p} \right) ^{n}}{1 - \frac{q}{p}}</math>

Or <math> e_{a+b} = 0 = (a+b)l + (d_1 - l) \cdot \frac{1 - \left( \frac{q}{p} \right) ^{a+b}}{1 - \frac{q}{p}} \text{par conséquent :} \frac{d_1 - l}{1 - \frac{q}{p}} = -\frac{(a+b)l}{1 - \left( \frac{q}{p} \right) ^{a+b} }</math>

Donc <math> E[T] = e_a = al - \left( 1 - \left( \frac{q}{p} \right)^{a} \right) \cdot \frac{(a+b)l}{1 - \left( \frac{q}{p} \right) ^{a+b}} = \frac{1}{q-p} \cdot \left( a - (a+b) \cdot \frac{1 - \left( \frac{q}{p} \right) ^{a} }{1 - \left( \frac{q}{p} \right) ^{a+b} } \right) = \frac{(a+b)p-a}{p-q} </math>

==Simulation d'une partie==

Afin de modéliser la ruine du joueur on peut utiliser ce programme python :

=== Bases du Programme ===

On commence par initialiser nos valeurs que l'on va utiliser :
<pre>
from random import random
from matplotlib import pyplot as plt

PROBABILITE = (18/37) #18/37 Pour la roulette
SOMME_DEPART = 10
GAIN_FIN = 10 # Le gain souhaité

#Faire varier Nombre de Parties

NOMBRE_PARTIES = 1000

</pre>

=== Simulation d'une soirée ===

On commence par simuler une soirée au casino :

<pre>
def simule_soiree(initial:int = SOMME_DEPART, fin:int= GAIN_FIN, prob:int= PROBABILITE) -> tuple:
""" Simule une soirée au casino """

tab = [initial]
somme = initial

while somme > 0 and somme < initial + fin:
aleatoire = random()
if aleatoire <= prob:
somme += 1
else:
somme -= 1
tab = tab + [somme]

if somme == initial + fin:
res = True
else:
res = False

return (tab, res)

</pre>

On peut afficher le résultat d'une soirée :

<pre>
# Permet d'afficher une partie jouée.

def affiche_graphe() -> None:
""" Affiche le graphe d'une soirée au casino """

y = simule_soiree()[0]
x = [[i] for i in range(len(y))]
plt.title("Graphe d'une soirée au casino")
plt.xlabel("Instant I")
plt.ylabel("Somme instant I")
plt.plot(x,y)
plt.show()

affiche_graphe()

</pre>

[[Fichier:Simulation soiree 1.png]]

[[Fichier:Simulation soiree 2.png]]

[[Fichier:Simulation soiree 3.png]]

=== Verifications de nos estimations numériques ===

Pour cette partie nous commençons à 10 jetons et on veut doubler cette somme.

On peut implémenter nos estimations numériques :

<pre>
R = (1-PROBABILITE) / (PROBABILITE)

def calcule_proba_victoire_theorique() -> float:
"""Renvoie la probabilité de victoire théorique"""

if PROBABILITE == 0.5:
res = (SOMME_DEPART) / (SOMME_DEPART + GAIN_FIN)

else:
numerateur = R**(SOMME_DEPART) - 1
denumerateur = (R**(SOMME_DEPART + GAIN_FIN) - 1)
res = numerateur / denumerateur

return res

def calcule_duree_partie_theorique() -> float:
"""Renvoie la durée theorique d'une partie"""

if PROBABILITE == 0.5:
res = SOMME_DEPART * GAIN_FIN

else:
numerateur = (SOMME_DEPART + GAIN_FIN) * (1 - R**SOMME_DEPART)
denumerateur = 1 - R**(SOMME_DEPART + GAIN_FIN)

res = (1 / (2 * PROBABILITE - 1)) * ((numerateur / denumerateur) - SOMME_DEPART)

return res

</pre>

On va utiliser la méthode de comptage pour observer nos simulations :

<pre>
def calcule_nombre_victoire(tab_parties = SIMULATION_N_SOIREE) -> int:
""" Renvoie le nombre de victoires dans les soirées simulées"""
compteur = 0

for res_partie in tab_parties:
if res_partie[1] == True:
compteur = compteur + 1

return compteur

def calcule_proba_victoire(tab_parties = SIMULATION_N_SOIREE) -> float:
"""Renvoie la probabilité de victoire sur M soirées"""

nb_victoires = calcule_nombre_victoire(tab_parties)
res = nb_victoires/len(tab_parties)

return res

def calcule_duree_moyenne():
""" Renvoie la durée moyenne sur M soirées simulées"""
somme = 0
for partie in SIMULATION_N_SOIREE:
duree_partie = len(partie[0])
somme += duree_partie
res = somme / NOMBRE_PARTIES
return res

</pre>

On peut maintenant comparer nos résultats :
<pre>
Voici les valeurs theoriques :

La probabilité de victoire : 0.3680312223171822
Durée partie moyenne theorique : 97.65689548528538

Voici les valeurs avec nos resultats :

La probabilité de victoire : 0.347
Durée partie moyenne : 95.984

</pre>

Nous pouvons ainsi voir que nos formules qui servent à estimer la probabilité de victoire sont assez bonnes.

Nous pouvons dresser un graphe de l'évolution de la probabilité de victoire et la durée selon le nombre de parties simulées.

[[Fichier:Graphe proba selon nb parties.png|600px]]

En bleu, nous avons la probabilité de victoire théorique.

[[Fichier:Graphe duree selon nb parties.png|600px]]

En bleu, nous avons la durée théorique.
== Autres Graphes ==

Nous pouvons aussi faire des graphes pour modeliser l'évolution de la probabilité et de la durée selon la somme de départ.

Dans notre cas nous allons faire varier la somme de départ de 1 à 19. La somme souhaité est donc 20.

La ligne bleu représente la valeur "juste" qui est le millieu entre les deux conditions d'arrêt.

=== Graphe probabilité ===

Nous avons ci-dessous le graphe de l'évolution de la probabilité de victoire.

[[Fichier:Graphe proba selon a.png|600px]]

Nous pouvons voir que l'évolution de la probabilité de victoire est assez linéaire.

=== Graphe durée ===

Nous avons ci-dessous le graphe de l'évolution de la durée.

[[Fichier:Graphe duree selon a.png|600px]]

Nous pouvons voir que l'évolution de la durée est en forme de parabolle plutot favorable à la défaite.

== Conclusion ==

Nous avons vu qu'il est possible de modéliser l'évolution des gains d'un joueur lors d'une soirée.

Les résultats montrent que la chance de victoire est grandement défavorable pour le joueur.

Pour analyser le sujet plus profondément on pourrait changer la valeur des mises et passer à 1 ou 2.

Modélisation de la ruine du joueur

2024-05-21T22:22:25Z

Akulas : /* Autres Graphes */

Modélisation de la ruine du joueur

2024-05-21T22:20:31Z

Akulas : /* Autres Graphes */

==Modélisation de la ruine du joueur==

Nous nous intéressons à l'étude des gains d'un joueur lors d'une soirée au casino, dans lequel le joueur joue à la roulette russe.

Le joueur commence avec une somme initiale comprise entre 0 et la somme souhaitée, le joueur s'arrête uniquement si :
- il obtient la somme souhaitée
- le joueur est ruiné (la somme est égale à 0)

Pour cela le joueur va jouer à la roulette en misant à chaque fois 1 jeton qu'il peut doubler ou perdre.

==Estimations numériques==

Nous allons prendre pour base le document suivant : [https://perso.eleves.ens-rennes.fr/people/florian.lemonnier/agregation/developpements/Ruine.pdf Ruine]

Notre objectif est de trouver de :

- calculer la probabilité de victoire, soit d'atteindre la somme souhaitée, en partant de la somme de départ.
- calculer la durée de la partie, soit le joueur arrête de jouer, donc il atteint l'une des conditions d'arrêt.

On définit de manière générale p la probabilité de victoire d'une partie et q = (1-p)

===Estimation de la probabilité de gagner===

On veut trouver une formule qui permet de trouver la probabilité de victoire lors d'une soirée au casino selon les paramètres de départ, soit la somme de départ et la somme voulue et la probabilité de victoire.

On commence avec la loi de probabilité totale :

<math> P_k(A) = P_k(A|Y_1 = 1)P_k(Y_1 = 1) + P_k(A|Y_1 = -1)P_k(Y_1 = -1) = P_{k+1}(A)p + P_{k-1}(A)q </math>

Ce qui donne le système suivant :

<math>
\begin{cases}
p_k = p \cdot p_{k+1} + q \cdot p_{k-1}, & \text{pour } 1 \leq k \leq a + b \\
p_0 = 0, \\
p_{a+b} = 1.
\end{cases}
</math>

'''On cherche l'équation quadratique : '''

On a la suite récurrente d'ordre 2 : [https://www.mathieu-mansuy.fr/pdf/PCSI5-complement1.pdf Résoudre une équation linéaire d'ordre 2] 
<math> p_k = p \cdot p_{k+1} + q \cdot p_{k-1} </math> 

On remplace <math> p_k </math> par <math> x^{k} </math> : 
<math> x^{k} = p \cdot x^{k+1} + q \cdot x^{k-1} </math> 

On divise par <math> x^{k-1} </math> : 
<math> x = p \cdot x^{2} + q </math> 

''' On résoult l'équation '''

<math> p \cdot x^{k+1} - x^{k} + q \cdot x^{k-1} = 0 </math>

====Pour p = 1/2 ====

Ca qui donne la solution unique : <math> x = 1 </math>

''' On en déduit les valeurs <math> \alpha \text{ et } \beta </math>''' :
<math>
\begin{cases}
0 = \alpha \\
1 = \alpha + \beta \cdot (a+b) \\
\end{cases}

\iff \begin{cases}
\alpha = 0 \\
\beta = \frac{a}{a+b} \\
\end{cases}
</math>

On a donc formule suivante : <math> p = \frac{a}{a+b} </math>

====Pour p ≠ 1/2====

Ce qui donne les solutions : <math> x_1 = 1 \text{ et } x_2 = \frac{q}{p} </math>

''' On a alors :'''

<math> p_k = \alpha \cdot x_1^{k} + \beta \cdot x_2^{k} </math> 
<math> \iff p_k = \alpha + \beta \cdot (\frac{q}{p})^{k} </math>

''' On en déduit les valeurs <math> \alpha \text{ et } \beta </math>''' :
<math>
\begin{cases}
0 = \alpha + \beta \\
1 = \alpha + \beta \cdot (\frac{q}{p})^{k} \\
\end{cases}

\iff \begin{cases}
\alpha = - \beta \\
1 = - \beta + \beta \cdot (\frac{q}{p})^{k} \\
\end{cases}

\iff \begin{cases}
\alpha = - \beta \\
1 = \beta \left(-1 + \left( \frac{q}{p} \right)^{a+b} \right) \\
\end{cases}

\iff \begin{cases}
\alpha = - \beta \\
\beta = \frac{1}{-1 + \left( \frac{q}{p} \right)^{a+b}} \\
\end{cases}
</math> 

On obtient :
<math>
\alpha = -\left(\frac{1}{-1 + \left( \frac{q}{p} \right)^{a+b}}\right)
\text{ et }
\beta = \frac{1}{-1 + \left( \frac{q}{p} \right)^{a+b}}
</math> 

D'où :
<math>
p_a = -\left(\frac{1}{-1 + \left( \frac{q}{p} \right)^{a+b}}\right)
+ \frac{\left( \frac{q}{p} \right)^{a}}{-1 + \left( \frac{q}{p} \right)^{a+b}}

\iff

p = \frac{\left( \frac{q}{p} \right)^{a} - 1}{\left( \frac{q}{p} \right)^{a+b} - 1}
</math>

On a donc formule suivante : <math> p = \frac{\left( \frac{q}{p} \right)^{a} - 1}{\left( \frac{q}{p} \right)^{a+b} - 1} </math>

===Estimation du temps moyen de jeu===

On commence avec la loi de probabilité totale :

<math> E_k(T) =E_k(T|Y_1 = 1)P(Y_1 = 1) + E_k(A|Y_1 = -1)P(Y_1 = -1) = (1 + E_{k+1}(T))p + (1 + E_{k-1}(T))q </math>

Ce qui donne l'équation :

<math>
\begin{cases}
e_k = 1 + p \cdot e_{k+1} + q \cdot e_{k-1}, & \text{pour } 1 \leq k \leq a + b \\
e_0 = 0, \\
e_{a+b} = 0.
\end{cases}
</math>

On note, pour <math> k \geq 1 , d_k = e_k - e_{k-1} </math>

On a donc la relation de récurence : <math> 0 = 1 + p \cdot d_{k+1} - q \cdot d_k </math>

====Pour p = 1/2 ====

On a <math> \frac{1}{2} \cdot d_{k+1} = \frac{1}{2} \cdot d_{k} - 1 </math>

donc, <math> d_{k+1} = d_k - 2 </math>

d'où <math> d_k = d_1 - 2 \left(k-1 \right) </math>

Alors pour <math> n \geq 1 , e_n = \sum_{k=1}^{n} d_k = n \cdot d_1 - 2 \cdot \sum_{k=0}^{n-1}k = n \cdot d_1 - 2 \cdot \frac{n(n-1)}{2} = n(d_1 - (n - 1)) </math>

Or <math> e_{a+b} = 0 = (a+b)(d_1 + (a + b - 1)), \text{d'où } d_1 = a + b - 1 </math>

Donc <math> E[T] = e_a = a(a + b - 1 - (a - 1)) = ab </math>

====Pour p ≠ 1/2 ====

On pose le réel l qui verifie <math> 0 = pl - ql </math> qui est donc <math> l = \frac{1}{q-p} </math>

La relation devient donc <math> 0 = p(d_{k+1} - l) - q(d_k - l) </math>

Par conséquent, <math> d_{k+1} - l = \frac{q}{p}(d_k - l) , \text{et donc } d_k - l = \left( \frac{q}{p} \right) ^{k-1} (d_1 - l) </math>

Donc pour <math> n \geq 1 </math>, on a :

<math> e_n = \sum_{k=1}^{n}d_k + e_0 = \sum_{k=1}^{n} \left( l + \left( \frac{q}{p} \right) ^{k-1} \cdot (d_1 - l) \right) = nl + (d_1 - l) \cdot \sum_{k=0}^{n-1}\left( \frac{q}{p} \right) ^{k} = nl + (d_1 - l) \cdot \frac{1 - \left( \frac{q}{p} \right) ^{n}}{1 - \frac{q}{p}}</math>

Or <math> e_{a+b} = 0 = (a+b)l + (d_1 - l) \cdot \frac{1 - \left( \frac{q}{p} \right) ^{a+b}}{1 - \frac{q}{p}} \text{par conséquent :} \frac{d_1 - l}{1 - \frac{q}{p}} = -\frac{(a+b)l}{1 - \left( \frac{q}{p} \right) ^{a+b} }</math>

Donc <math> E[T] = e_a = al - \left( 1 - \left( \frac{q}{p} \right)^{a} \right) \cdot \frac{(a+b)l}{1 - \left( \frac{q}{p} \right) ^{a+b}} = \frac{1}{q-p} \cdot \left( a - (a+b) \cdot \frac{1 - \left( \frac{q}{p} \right) ^{a} }{1 - \left( \frac{q}{p} \right) ^{a+b} } \right) = \frac{(a+b)p-a}{p-q} </math>

==Simulation d'une partie==

Afin de modéliser la ruine du joueur on peut utiliser ce programme python :

=== Bases du Programme ===

On commence par initialiser nos valeurs que l'on va utiliser :
<pre>
from random import random
from matplotlib import pyplot as plt

PROBABILITE = (18/37) #18/37 Pour la roulette
SOMME_DEPART = 10
GAIN_FIN = 10 # Le gain souhaité

#Faire varier Nombre de Parties

NOMBRE_PARTIES = 1000

</pre>

=== Simulation d'une soirée ===

On commence par simuler une soirée au casino :

<pre>
def simule_soiree(initial:int = SOMME_DEPART, fin:int= GAIN_FIN, prob:int= PROBABILITE) -> tuple:
""" Simule une soirée au casino """

tab = [initial]
somme = initial

while somme > 0 and somme < initial + fin:
aleatoire = random()
if aleatoire <= prob:
somme += 1
else:
somme -= 1
tab = tab + [somme]

if somme == initial + fin:
res = True
else:
res = False

return (tab, res)

</pre>

On peut afficher le résultat d'une soirée :

<pre>
# Permet d'afficher une partie jouée.

def affiche_graphe() -> None:
""" Affiche le graphe d'une soirée au casino """

y = simule_soiree()[0]
x = [[i] for i in range(len(y))]
plt.title("Graphe d'une soirée au casino")
plt.xlabel("Instant I")
plt.ylabel("Somme instant I")
plt.plot(x,y)
plt.show()

affiche_graphe()

</pre>

[[Fichier:Simulation soiree 1.png]]

[[Fichier:Simulation soiree 2.png]]

[[Fichier:Simulation soiree 3.png]]

=== Verifications de nos estimations numériques ===

Pour cette partie nous commençons à 10 jetons et on veut doubler cette somme.

On peut implémenter nos estimations numériques :

<pre>
R = (1-PROBABILITE) / (PROBABILITE)

def calcule_proba_victoire_theorique() -> float:
"""Renvoie la probabilité de victoire théorique"""

if PROBABILITE == 0.5:
res = (SOMME_DEPART) / (SOMME_DEPART + GAIN_FIN)

else:
numerateur = R**(SOMME_DEPART) - 1
denumerateur = (R**(SOMME_DEPART + GAIN_FIN) - 1)
res = numerateur / denumerateur

return res

def calcule_duree_partie_theorique() -> float:
"""Renvoie la durée theorique d'une partie"""

if PROBABILITE == 0.5:
res = SOMME_DEPART * GAIN_FIN

else:
numerateur = (SOMME_DEPART + GAIN_FIN) * (1 - R**SOMME_DEPART)
denumerateur = 1 - R**(SOMME_DEPART + GAIN_FIN)

res = (1 / (2 * PROBABILITE - 1)) * ((numerateur / denumerateur) - SOMME_DEPART)

return res

</pre>

On va utiliser la méthode de comptage pour observer nos simulations :

<pre>
def calcule_nombre_victoire(tab_parties = SIMULATION_N_SOIREE) -> int:
""" Renvoie le nombre de victoires dans les soirées simulées"""
compteur = 0

for res_partie in tab_parties:
if res_partie[1] == True:
compteur = compteur + 1

return compteur

def calcule_proba_victoire(tab_parties = SIMULATION_N_SOIREE) -> float:
"""Renvoie la probabilité de victoire sur M soirées"""

nb_victoires = calcule_nombre_victoire(tab_parties)
res = nb_victoires/len(tab_parties)

return res

def calcule_duree_moyenne():
""" Renvoie la durée moyenne sur M soirées simulées"""
somme = 0
for partie in SIMULATION_N_SOIREE:
duree_partie = len(partie[0])
somme += duree_partie
res = somme / NOMBRE_PARTIES
return res

</pre>

On peut maintenant comparer nos résultats :
<pre>
Voici les valeurs theoriques :

La probabilité de victoire : 0.3680312223171822
Durée partie moyenne theorique : 97.65689548528538

Voici les valeurs avec nos resultats :

La probabilité de victoire : 0.347
Durée partie moyenne : 95.984

</pre>

Nous pouvons ainsi voir que nos formules qui servent à estimer la probabilité de victoire sont assez bonnes.

Nous pouvons dresser un graphe de l'évolution de la probabilité de victoire et la durée selon le nombre de parties simulées.

[[Fichier:Graphe proba selon nb parties.png|600px]]

En bleu, nous avons la probabilité de victoire théorique.

[[Fichier:Graphe duree selon nb parties.png|600px]]

En bleu, nous avons la durée théorique.
== Autres Graphes ==

Nous pouvons aussi faire des graphes pour modeliser l'évolution de la probabilité et de la durée selon la somme de départ.

Dans notre cas nous allons faire varier la somme de départ de 1 à 19. La somme souhaité est donc 20.

La ligne bleu représente la valeur "juste" qui est le millieu entre les deux conditions d'arrêt.

Nous avons ci-dessous le graphe de l'évolution de la probabilité de victoire.

[[Fichier:Graphe proba selon a.png|600px]]

Nous avons ci-dessous le graphe de l'évolution de la durée.

[[Fichier:Graphe duree selon a.png|600px]]

Nous pouvons voir que l'évolution de la probabilité de victoire est assez linéaire.

Modélisation de la ruine du joueur

2024-05-21T22:17:43Z

Akulas :

==Modélisation de la ruine du joueur==

Nous nous intéressons à l'étude des gains d'un joueur lors d'une soirée au casino, dans lequel le joueur joue à la roulette russe.

Le joueur commence avec une somme initiale comprise entre 0 et la somme souhaitée, le joueur s'arrête uniquement si :
- il obtient la somme souhaitée
- le joueur est ruiné (la somme est égale à 0)

Pour cela le joueur va jouer à la roulette en misant à chaque fois 1 jeton qu'il peut doubler ou perdre.

==Estimations numériques==

Nous allons prendre pour base le document suivant : [https://perso.eleves.ens-rennes.fr/people/florian.lemonnier/agregation/developpements/Ruine.pdf Ruine]

Notre objectif est de trouver de :

- calculer la probabilité de victoire, soit d'atteindre la somme souhaitée, en partant de la somme de départ.
- calculer la durée de la partie, soit le joueur arrête de jouer, donc il atteint l'une des conditions d'arrêt.

On définit de manière générale p la probabilité de victoire d'une partie et q = (1-p)

===Estimation de la probabilité de gagner===

On veut trouver une formule qui permet de trouver la probabilité de victoire lors d'une soirée au casino selon les paramètres de départ, soit la somme de départ et la somme voulue et la probabilité de victoire.

On commence avec la loi de probabilité totale :

<math> P_k(A) = P_k(A|Y_1 = 1)P_k(Y_1 = 1) + P_k(A|Y_1 = -1)P_k(Y_1 = -1) = P_{k+1}(A)p + P_{k-1}(A)q </math>

Ce qui donne le système suivant :

<math>
\begin{cases}
p_k = p \cdot p_{k+1} + q \cdot p_{k-1}, & \text{pour } 1 \leq k \leq a + b \\
p_0 = 0, \\
p_{a+b} = 1.
\end{cases}
</math>

'''On cherche l'équation quadratique : '''

On a la suite récurrente d'ordre 2 : [https://www.mathieu-mansuy.fr/pdf/PCSI5-complement1.pdf Résoudre une équation linéaire d'ordre 2] 
<math> p_k = p \cdot p_{k+1} + q \cdot p_{k-1} </math> 

On remplace <math> p_k </math> par <math> x^{k} </math> : 
<math> x^{k} = p \cdot x^{k+1} + q \cdot x^{k-1} </math> 

On divise par <math> x^{k-1} </math> : 
<math> x = p \cdot x^{2} + q </math> 

''' On résoult l'équation '''

<math> p \cdot x^{k+1} - x^{k} + q \cdot x^{k-1} = 0 </math>

====Pour p = 1/2 ====

Ca qui donne la solution unique : <math> x = 1 </math>

''' On en déduit les valeurs <math> \alpha \text{ et } \beta </math>''' :
<math>
\begin{cases}
0 = \alpha \\
1 = \alpha + \beta \cdot (a+b) \\
\end{cases}

\iff \begin{cases}
\alpha = 0 \\
\beta = \frac{a}{a+b} \\
\end{cases}
</math>

On a donc formule suivante : <math> p = \frac{a}{a+b} </math>

====Pour p ≠ 1/2====

Ce qui donne les solutions : <math> x_1 = 1 \text{ et } x_2 = \frac{q}{p} </math>

''' On a alors :'''

<math> p_k = \alpha \cdot x_1^{k} + \beta \cdot x_2^{k} </math> 
<math> \iff p_k = \alpha + \beta \cdot (\frac{q}{p})^{k} </math>

''' On en déduit les valeurs <math> \alpha \text{ et } \beta </math>''' :
<math>
\begin{cases}
0 = \alpha + \beta \\
1 = \alpha + \beta \cdot (\frac{q}{p})^{k} \\
\end{cases}

\iff \begin{cases}
\alpha = - \beta \\
1 = - \beta + \beta \cdot (\frac{q}{p})^{k} \\
\end{cases}

\iff \begin{cases}
\alpha = - \beta \\
1 = \beta \left(-1 + \left( \frac{q}{p} \right)^{a+b} \right) \\
\end{cases}

\iff \begin{cases}
\alpha = - \beta \\
\beta = \frac{1}{-1 + \left( \frac{q}{p} \right)^{a+b}} \\
\end{cases}
</math> 

On obtient :
<math>
\alpha = -\left(\frac{1}{-1 + \left( \frac{q}{p} \right)^{a+b}}\right)
\text{ et }
\beta = \frac{1}{-1 + \left( \frac{q}{p} \right)^{a+b}}
</math> 

D'où :
<math>
p_a = -\left(\frac{1}{-1 + \left( \frac{q}{p} \right)^{a+b}}\right)
+ \frac{\left( \frac{q}{p} \right)^{a}}{-1 + \left( \frac{q}{p} \right)^{a+b}}

\iff

p = \frac{\left( \frac{q}{p} \right)^{a} - 1}{\left( \frac{q}{p} \right)^{a+b} - 1}
</math>

On a donc formule suivante : <math> p = \frac{\left( \frac{q}{p} \right)^{a} - 1}{\left( \frac{q}{p} \right)^{a+b} - 1} </math>

===Estimation du temps moyen de jeu===

On commence avec la loi de probabilité totale :

<math> E_k(T) =E_k(T|Y_1 = 1)P(Y_1 = 1) + E_k(A|Y_1 = -1)P(Y_1 = -1) = (1 + E_{k+1}(T))p + (1 + E_{k-1}(T))q </math>

Ce qui donne l'équation :

<math>
\begin{cases}
e_k = 1 + p \cdot e_{k+1} + q \cdot e_{k-1}, & \text{pour } 1 \leq k \leq a + b \\
e_0 = 0, \\
e_{a+b} = 0.
\end{cases}
</math>

On note, pour <math> k \geq 1 , d_k = e_k - e_{k-1} </math>

On a donc la relation de récurence : <math> 0 = 1 + p \cdot d_{k+1} - q \cdot d_k </math>

====Pour p = 1/2 ====

On a <math> \frac{1}{2} \cdot d_{k+1} = \frac{1}{2} \cdot d_{k} - 1 </math>

donc, <math> d_{k+1} = d_k - 2 </math>

d'où <math> d_k = d_1 - 2 \left(k-1 \right) </math>

Alors pour <math> n \geq 1 , e_n = \sum_{k=1}^{n} d_k = n \cdot d_1 - 2 \cdot \sum_{k=0}^{n-1}k = n \cdot d_1 - 2 \cdot \frac{n(n-1)}{2} = n(d_1 - (n - 1)) </math>

Or <math> e_{a+b} = 0 = (a+b)(d_1 + (a + b - 1)), \text{d'où } d_1 = a + b - 1 </math>

Donc <math> E[T] = e_a = a(a + b - 1 - (a - 1)) = ab </math>

====Pour p ≠ 1/2 ====

On pose le réel l qui verifie <math> 0 = pl - ql </math> qui est donc <math> l = \frac{1}{q-p} </math>

La relation devient donc <math> 0 = p(d_{k+1} - l) - q(d_k - l) </math>

Par conséquent, <math> d_{k+1} - l = \frac{q}{p}(d_k - l) , \text{et donc } d_k - l = \left( \frac{q}{p} \right) ^{k-1} (d_1 - l) </math>

Donc pour <math> n \geq 1 </math>, on a :

<math> e_n = \sum_{k=1}^{n}d_k + e_0 = \sum_{k=1}^{n} \left( l + \left( \frac{q}{p} \right) ^{k-1} \cdot (d_1 - l) \right) = nl + (d_1 - l) \cdot \sum_{k=0}^{n-1}\left( \frac{q}{p} \right) ^{k} = nl + (d_1 - l) \cdot \frac{1 - \left( \frac{q}{p} \right) ^{n}}{1 - \frac{q}{p}}</math>

Or <math> e_{a+b} = 0 = (a+b)l + (d_1 - l) \cdot \frac{1 - \left( \frac{q}{p} \right) ^{a+b}}{1 - \frac{q}{p}} \text{par conséquent :} \frac{d_1 - l}{1 - \frac{q}{p}} = -\frac{(a+b)l}{1 - \left( \frac{q}{p} \right) ^{a+b} }</math>

Donc <math> E[T] = e_a = al - \left( 1 - \left( \frac{q}{p} \right)^{a} \right) \cdot \frac{(a+b)l}{1 - \left( \frac{q}{p} \right) ^{a+b}} = \frac{1}{q-p} \cdot \left( a - (a+b) \cdot \frac{1 - \left( \frac{q}{p} \right) ^{a} }{1 - \left( \frac{q}{p} \right) ^{a+b} } \right) = \frac{(a+b)p-a}{p-q} </math>

==Simulation d'une partie==

Afin de modéliser la ruine du joueur on peut utiliser ce programme python :

=== Bases du Programme ===

On commence par initialiser nos valeurs que l'on va utiliser :
<pre>
from random import random
from matplotlib import pyplot as plt

PROBABILITE = (18/37) #18/37 Pour la roulette
SOMME_DEPART = 10
GAIN_FIN = 10 # Le gain souhaité

#Faire varier Nombre de Parties

NOMBRE_PARTIES = 1000

</pre>

=== Simulation d'une soirée ===

On commence par simuler une soirée au casino :

<pre>
def simule_soiree(initial:int = SOMME_DEPART, fin:int= GAIN_FIN, prob:int= PROBABILITE) -> tuple:
""" Simule une soirée au casino """

tab = [initial]
somme = initial

while somme > 0 and somme < initial + fin:
aleatoire = random()
if aleatoire <= prob:
somme += 1
else:
somme -= 1
tab = tab + [somme]

if somme == initial + fin:
res = True
else:
res = False

return (tab, res)

</pre>

On peut afficher le résultat d'une soirée :

<pre>
# Permet d'afficher une partie jouée.

def affiche_graphe() -> None:
""" Affiche le graphe d'une soirée au casino """

y = simule_soiree()[0]
x = [[i] for i in range(len(y))]
plt.title("Graphe d'une soirée au casino")
plt.xlabel("Instant I")
plt.ylabel("Somme instant I")
plt.plot(x,y)
plt.show()

affiche_graphe()

</pre>

[[Fichier:Simulation soiree 1.png]]

[[Fichier:Simulation soiree 2.png]]

[[Fichier:Simulation soiree 3.png]]

=== Verifications de nos estimations numériques ===

Pour cette partie nous commençons à 10 jetons et on veut doubler cette somme.

On peut implémenter nos estimations numériques :

<pre>
R = (1-PROBABILITE) / (PROBABILITE)

def calcule_proba_victoire_theorique() -> float:
"""Renvoie la probabilité de victoire théorique"""

if PROBABILITE == 0.5:
res = (SOMME_DEPART) / (SOMME_DEPART + GAIN_FIN)

else:
numerateur = R**(SOMME_DEPART) - 1
denumerateur = (R**(SOMME_DEPART + GAIN_FIN) - 1)
res = numerateur / denumerateur

return res

def calcule_duree_partie_theorique() -> float:
"""Renvoie la durée theorique d'une partie"""

if PROBABILITE == 0.5:
res = SOMME_DEPART * GAIN_FIN

else:
numerateur = (SOMME_DEPART + GAIN_FIN) * (1 - R**SOMME_DEPART)
denumerateur = 1 - R**(SOMME_DEPART + GAIN_FIN)

res = (1 / (2 * PROBABILITE - 1)) * ((numerateur / denumerateur) - SOMME_DEPART)

return res

</pre>

On va utiliser la méthode de comptage pour observer nos simulations :

<pre>
def calcule_nombre_victoire(tab_parties = SIMULATION_N_SOIREE) -> int:
""" Renvoie le nombre de victoires dans les soirées simulées"""
compteur = 0

for res_partie in tab_parties:
if res_partie[1] == True:
compteur = compteur + 1

return compteur

def calcule_proba_victoire(tab_parties = SIMULATION_N_SOIREE) -> float:
"""Renvoie la probabilité de victoire sur M soirées"""

nb_victoires = calcule_nombre_victoire(tab_parties)
res = nb_victoires/len(tab_parties)

return res

def calcule_duree_moyenne():
""" Renvoie la durée moyenne sur M soirées simulées"""
somme = 0
for partie in SIMULATION_N_SOIREE:
duree_partie = len(partie[0])
somme += duree_partie
res = somme / NOMBRE_PARTIES
return res

</pre>

On peut maintenant comparer nos résultats :
<pre>
Voici les valeurs theoriques :

La probabilité de victoire : 0.3680312223171822
Durée partie moyenne theorique : 97.65689548528538

Voici les valeurs avec nos resultats :

La probabilité de victoire : 0.347
Durée partie moyenne : 95.984

</pre>

Nous pouvons ainsi voir que nos formules qui servent à estimer la probabilité de victoire sont assez bonnes.

Nous pouvons dresser un graphe de l'évolution de la probabilité de victoire et la durée selon le nombre de parties simulées.

[[Fichier:Graphe proba selon nb parties.png|600px]]

En bleu, nous avons la probabilité de victoire théorique.

[[Fichier:Graphe duree selon nb parties.png|600px]]

En bleu, nous avons la durée théorique.
== Autres Graphes ==

Nous pouvons aussi faire des graphes pour modeliser l'évolution de la probabilité et de la durée selon la somme de départ.

Dans notre cas nous allons faire varier la somme de départ de 1 à 19. La somme souhaité est donc 20.

Nous avons ci-dessous le graphe de l'évolution de la probabilité de victoire.

[[Fichier:Graphe proba selon a.png|600px]]

Nous avons ci-dessous le graphe de l'évolution de la durée.

[[Fichier:Graphe duree selon a.png|600px]]

Fichier:Graphe duree selon a.png

2024-05-21T22:14:57Z

Akulas :

Fichier:Graphe proba selon a.png

2024-05-21T22:14:01Z

Akulas :

Modélisation de la ruine du joueur

2024-05-21T19:56:30Z

Akulas : /* Verifications de nos estimations numériques */

Fichier:Graphe duree selon nb parties.png

2024-05-21T19:55:06Z

Akulas :

Modélisation de la ruine du joueur

2024-05-21T18:33:41Z

Akulas : /* Estimation du temps moyen de jeu */

==Modélisation de la ruine du joueur==

Nous nous intéressons à l'étude des gains d'un joueur lors d'une soirée au casino, dans lequel le joueur joue à la roulette russe.

Le joueur commence avec une somme initiale comprise entre 0 et la somme souhaitée, le joueur s'arrête uniquement si :
- il obtient la somme souhaitée
- le joueur est ruiné (la somme est égale à 0)

Pour cela le joueur va jouer à la roulette en misant à chaque fois 1 jeton qu'il peut doubler ou perdre.

==Estimations numériques==

Nous allons prendre pour base le document suivant : [https://perso.eleves.ens-rennes.fr/people/florian.lemonnier/agregation/developpements/Ruine.pdf Ruine]

Notre objectif est de trouver de :

- calculer la probabilité de victoire, soit d'atteindre la somme souhaitée, en partant de la somme de départ.
- calculer la durée de la partie, soit le joueur arrête de jouer, donc il atteint l'une des conditions d'arrêt.

On définit de manière générale p la probabilité de victoire d'une partie et q = (1-p)

===Estimation de la probabilité de gagner===

On veut trouver une formule qui permet de trouver la probabilité de victoire lors d'une soirée au casino selon les paramètres de départ, soit la somme de départ et la somme voulue et la probabilité de victoire.

On commence avec la loi de probabilité totale :

<math> P_k(A) = P_k(A|Y_1 = 1)P_k(Y_1 = 1) + P_k(A|Y_1 = -1)P_k(Y_1 = -1) = P_{k+1}(A)p + P_{k-1}(A)q </math>

Ce qui donne le système suivant :

<math>
\begin{cases}
p_k = p \cdot p_{k+1} + q \cdot p_{k-1}, & \text{pour } 1 \leq k \leq a + b \\
p_0 = 0, \\
p_{a+b} = 1.
\end{cases}
</math>

'''On cherche l'équation quadratique : '''

On a la suite récurrente d'ordre 2 : [https://www.mathieu-mansuy.fr/pdf/PCSI5-complement1.pdf Résoudre une équation linéaire d'ordre 2] 
<math> p_k = p \cdot p_{k+1} + q \cdot p_{k-1} </math> 

On remplace <math> p_k </math> par <math> x^{k} </math> : 
<math> x^{k} = p \cdot x^{k+1} + q \cdot x^{k-1} </math> 

On divise par <math> x^{k-1} </math> : 
<math> x = p \cdot x^{2} + q </math> 

''' On résoult l'équation '''

<math> p \cdot x^{k+1} - x^{k} + q \cdot x^{k-1} = 0 </math>

====Pour p = 1/2 ====

Ca qui donne la solution unique : <math> x = 1 </math>

''' On en déduit les valeurs <math> \alpha \text{ et } \beta </math>''' :
<math>
\begin{cases}
0 = \alpha \\
1 = \alpha + \beta \cdot (a+b) \\
\end{cases}

\iff \begin{cases}
\alpha = 0 \\
\beta = \frac{a}{a+b} \\
\end{cases}
</math>

On a donc formule suivante : <math> p = \frac{a}{a+b} </math>

====Pour p ≠ 1/2====

Ce qui donne les solutions : <math> x_1 = 1 \text{ et } x_2 = \frac{q}{p} </math>

''' On a alors :'''

<math> p_k = \alpha \cdot x_1^{k} + \beta \cdot x_2^{k} </math> 
<math> \iff p_k = \alpha + \beta \cdot (\frac{q}{p})^{k} </math>

''' On en déduit les valeurs <math> \alpha \text{ et } \beta </math>''' :
<math>
\begin{cases}
0 = \alpha + \beta \\
1 = \alpha + \beta \cdot (\frac{q}{p})^{k} \\
\end{cases}

\iff \begin{cases}
\alpha = - \beta \\
1 = - \beta + \beta \cdot (\frac{q}{p})^{k} \\
\end{cases}

\iff \begin{cases}
\alpha = - \beta \\
1 = \beta \left(-1 + \left( \frac{q}{p} \right)^{a+b} \right) \\
\end{cases}

\iff \begin{cases}
\alpha = - \beta \\
\beta = \frac{1}{-1 + \left( \frac{q}{p} \right)^{a+b}} \\
\end{cases}
</math> 

On obtient :
<math>
\alpha = -\left(\frac{1}{-1 + \left( \frac{q}{p} \right)^{a+b}}\right)
\text{ et }
\beta = \frac{1}{-1 + \left( \frac{q}{p} \right)^{a+b}}
</math> 

D'où :
<math>
p_a = -\left(\frac{1}{-1 + \left( \frac{q}{p} \right)^{a+b}}\right)
+ \frac{\left( \frac{q}{p} \right)^{a}}{-1 + \left( \frac{q}{p} \right)^{a+b}}

\iff

p = \frac{\left( \frac{q}{p} \right)^{a} - 1}{\left( \frac{q}{p} \right)^{a+b} - 1}
</math>

On a donc formule suivante : <math> p = \frac{\left( \frac{q}{p} \right)^{a} - 1}{\left( \frac{q}{p} \right)^{a+b} - 1} </math>

===Estimation du temps moyen de jeu===

On commence avec la loi de probabilité totale :

<math> E_k(T) =E_k(T|Y_1 = 1)P(Y_1 = 1) + E_k(A|Y_1 = -1)P(Y_1 = -1) = (1 + E_{k+1}(T))p + (1 + E_{k-1}(T))q </math>

Ce qui donne l'équation :

<math>
\begin{cases}
e_k = 1 + p \cdot e_{k+1} + q \cdot e_{k-1}, & \text{pour } 1 \leq k \leq a + b \\
e_0 = 0, \\
e_{a+b} = 0.
\end{cases}
</math>

On note, pour <math> k \geq 1 , d_k = e_k - e_{k-1} </math>

On a donc la relation de récurence : <math> 0 = 1 + p \cdot d_{k+1} - q \cdot d_k </math>

====Pour p = 1/2 ====

On a <math> \frac{1}{2} \cdot d_{k+1} = \frac{1}{2} \cdot d_{k} - 1 </math>

donc, <math> d_{k+1} = d_k - 2 </math>

d'où <math> d_k = d_1 - 2 \left(k-1 \right) </math>

Alors pour <math> n \geq 1 , e_n = \sum_{k=1}^{n} d_k = n \cdot d_1 - 2 \cdot \sum_{k=0}^{n-1}k = n \cdot d_1 - 2 \cdot \frac{n(n-1)}{2} = n(d_1 - (n - 1)) </math>

Or <math> e_{a+b} = 0 = (a+b)(d_1 + (a + b - 1)), \text{d'où } d_1 = a + b - 1 </math>

Donc <math> E[T] = e_a = a(a + b - 1 - (a - 1)) = ab </math>

====Pour p ≠ 1/2 ====

On pose le réel l qui verifie <math> 0 = pl - ql </math> qui est donc <math> l = \frac{1}{q-p} </math>

La relation devient donc <math> 0 = p(d_{k+1} - l) - q(d_k - l) </math>

Par conséquent, <math> d_{k+1} - l = \frac{q}{p}(d_k - l) , \text{et donc } d_k - l = \left( \frac{q}{p} \right) ^{k-1} (d_1 - l) </math>

Donc pour <math> n \geq 1 </math>, on a :

<math> e_n = \sum_{k=1}^{n}d_k + e_0 = \sum_{k=1}^{n} \left( l + \left( \frac{q}{p} \right) ^{k-1} \cdot (d_1 - l) \right) = nl + (d_1 - l) \cdot \sum_{k=0}^{n-1}\left( \frac{q}{p} \right) ^{k} = nl + (d_1 - l) \cdot \frac{1 - \left( \frac{q}{p} \right) ^{n}}{1 - \frac{q}{p}}</math>

Or <math> e_{a+b} = 0 = (a+b)l + (d_1 - l) \cdot \frac{1 - \left( \frac{q}{p} \right) ^{a+b}}{1 - \frac{q}{p}} \text{par conséquent :} \frac{d_1 - l}{1 - \frac{q}{p}} = -\frac{(a+b)l}{1 - \left( \frac{q}{p} \right) ^{a+b} }</math>

Donc <math> E[T] = e_a = al - \left( 1 - \left( \frac{q}{p} \right)^{a} \right) \cdot \frac{(a+b)l}{1 - \left( \frac{q}{p} \right) ^{a+b}} = \frac{1}{q-p} \cdot \left( a - (a+b) \cdot \frac{1 - \left( \frac{q}{p} \right) ^{a} }{1 - \left( \frac{q}{p} \right) ^{a+b} } \right) = \frac{(a+b)p-a}{p-q} </math>

==Simulation d'une partie==

Afin de modéliser la ruine du joueur on peut utiliser ce programme python :

=== Bases du Programme ===

On commence par initialiser nos valeurs que l'on va utiliser :
<pre>
from random import random
from matplotlib import pyplot as plt

PROBABILITE = (18/37) #18/37 Pour la roulette
SOMME_DEPART = 10
GAIN_FIN = 10 # Le gain souhaité

#Faire varier Nombre de Parties

NOMBRE_PARTIES = 1000

</pre>

=== Simulation d'une soirée ===

On commence par simuler une soirée au casino :

<pre>
def simule_soiree(initial:int = SOMME_DEPART, fin:int= GAIN_FIN, prob:int= PROBABILITE) -> tuple:
""" Simule une soirée au casino """

tab = [initial]
somme = initial

while somme > 0 and somme < initial + fin:
aleatoire = random()
if aleatoire <= prob:
somme += 1
else:
somme -= 1
tab = tab + [somme]

if somme == initial + fin:
res = True
else:
res = False

return (tab, res)

</pre>

On peut afficher le résultat d'une soirée :

<pre>
# Permet d'afficher une partie jouée.

def affiche_graphe() -> None:
""" Affiche le graphe d'une soirée au casino """

y = simule_soiree()[0]
x = [[i] for i in range(len(y))]
plt.title("Graphe d'une soirée au casino")
plt.xlabel("Instant I")
plt.ylabel("Somme instant I")
plt.plot(x,y)
plt.show()

affiche_graphe()

</pre>

[[Fichier:Simulation soiree 1.png]]

[[Fichier:Simulation soiree 2.png]]

[[Fichier:Simulation soiree 3.png]]

=== Verifications de nos estimations numériques ===

Pour cette partie nous commençons à 10 jetons et on veut doubler cette somme.

On peut implémenter nos estimations numériques :

<pre>
R = (1-PROBABILITE) / (PROBABILITE)

def calcule_proba_victoire_theorique() -> float:
"""Renvoie la probabilité de victoire théorique"""

if PROBABILITE == 0.5:
res = (SOMME_DEPART) / (SOMME_DEPART + GAIN_FIN)

else:
numerateur = R**(SOMME_DEPART) - 1
denumerateur = (R**(SOMME_DEPART + GAIN_FIN) - 1)
res = numerateur / denumerateur

return res

def calcule_duree_partie_theorique() -> float:
"""Renvoie la durée theorique d'une partie"""

if PROBABILITE == 0.5:
res = SOMME_DEPART * GAIN_FIN

else:
numerateur = (SOMME_DEPART + GAIN_FIN) * (1 - R**SOMME_DEPART)
denumerateur = 1 - R**(SOMME_DEPART + GAIN_FIN)

res = (1 / (2 * PROBABILITE - 1)) * ((numerateur / denumerateur) - SOMME_DEPART)

return res

</pre>

On va utiliser la méthode de comptage pour observer nos simulations :

<pre>
def calcule_nombre_victoire(tab_parties = SIMULATION_N_SOIREE) -> int:
""" Renvoie le nombre de victoires dans les soirées simulées"""
compteur = 0

for res_partie in tab_parties:
if res_partie[1] == True:
compteur = compteur + 1

return compteur

def calcule_proba_victoire(tab_parties = SIMULATION_N_SOIREE) -> float:
"""Renvoie la probabilité de victoire sur M soirées"""

nb_victoires = calcule_nombre_victoire(tab_parties)
res = nb_victoires/len(tab_parties)

return res

def calcule_duree_moyenne():
""" Renvoie la durée moyenne sur M soirées simulées"""
somme = 0
for partie in SIMULATION_N_SOIREE:
duree_partie = len(partie[0])
somme += duree_partie
res = somme / NOMBRE_PARTIES
return res

</pre>

On peut maintenant comparer nos résultats :
<pre>
Voici les valeurs theoriques :

La probabilité de victoire : 0.3680312223171822
Durée partie moyenne theorique : 97.65689548528538

Voici les valeurs avec nos resultats :

La probabilité de victoire : 0.347
Durée partie moyenne : 95.984

</pre>

Nous pouvons ainsi voir que nos formules qui servent à estimer la probabilité de victoire sont assez bonnes.

Nous pouvons dresser un graphe de l'évolution de la probabilité de victoire selon le nombre de parties simulées.

[[Fichier:Graphe proba selon nb parties.png|600px]]

En bleu, nous avons la probabilité de victoire théorique.

Nous pouvons remarquer que on converge vers cette valeur plus on simule de parties.

Modélisation de la ruine du joueur

2024-05-21T18:33:17Z

Akulas : /* Estimation de la probabilité de gagner */

==Modélisation de la ruine du joueur==

Nous nous intéressons à l'étude des gains d'un joueur lors d'une soirée au casino, dans lequel le joueur joue à la roulette russe.

Le joueur commence avec une somme initiale comprise entre 0 et la somme souhaitée, le joueur s'arrête uniquement si :
- il obtient la somme souhaitée
- le joueur est ruiné (la somme est égale à 0)

Pour cela le joueur va jouer à la roulette en misant à chaque fois 1 jeton qu'il peut doubler ou perdre.

==Estimations numériques==

Nous allons prendre pour base le document suivant : [https://perso.eleves.ens-rennes.fr/people/florian.lemonnier/agregation/developpements/Ruine.pdf Ruine]

Notre objectif est de trouver de :

- calculer la probabilité de victoire, soit d'atteindre la somme souhaitée, en partant de la somme de départ.
- calculer la durée de la partie, soit le joueur arrête de jouer, donc il atteint l'une des conditions d'arrêt.

On définit de manière générale p la probabilité de victoire d'une partie et q = (1-p)

===Estimation de la probabilité de gagner===

On veut trouver une formule qui permet de trouver la probabilité de victoire lors d'une soirée au casino selon les paramètres de départ, soit la somme de départ et la somme voulue et la probabilité de victoire.

On commence avec la loi de probabilité totale :

<math> P_k(A) = P_k(A|Y_1 = 1)P_k(Y_1 = 1) + P_k(A|Y_1 = -1)P_k(Y_1 = -1) = P_{k+1}(A)p + P_{k-1}(A)q </math>

Ce qui donne le système suivant :

<math>
\begin{cases}
p_k = p \cdot p_{k+1} + q \cdot p_{k-1}, & \text{pour } 1 \leq k \leq a + b \\
p_0 = 0, \\
p_{a+b} = 1.
\end{cases}
</math>

'''On cherche l'équation quadratique : '''

On a la suite récurrente d'ordre 2 : [https://www.mathieu-mansuy.fr/pdf/PCSI5-complement1.pdf Résoudre une équation linéaire d'ordre 2] 
<math> p_k = p \cdot p_{k+1} + q \cdot p_{k-1} </math> 

On remplace <math> p_k </math> par <math> x^{k} </math> : 
<math> x^{k} = p \cdot x^{k+1} + q \cdot x^{k-1} </math> 

On divise par <math> x^{k-1} </math> : 
<math> x = p \cdot x^{2} + q </math> 

''' On résoult l'équation '''

<math> p \cdot x^{k+1} - x^{k} + q \cdot x^{k-1} = 0 </math>

====Pour p = 1/2 ====

Ca qui donne la solution unique : <math> x = 1 </math>

''' On en déduit les valeurs <math> \alpha \text{ et } \beta </math>''' :
<math>
\begin{cases}
0 = \alpha \\
1 = \alpha + \beta \cdot (a+b) \\
\end{cases}

\iff \begin{cases}
\alpha = 0 \\
\beta = \frac{a}{a+b} \\
\end{cases}
</math>

On a donc formule suivante : <math> p = \frac{a}{a+b} </math>

====Pour p ≠ 1/2====

Ce qui donne les solutions : <math> x_1 = 1 \text{ et } x_2 = \frac{q}{p} </math>

''' On a alors :'''

<math> p_k = \alpha \cdot x_1^{k} + \beta \cdot x_2^{k} </math> 
<math> \iff p_k = \alpha + \beta \cdot (\frac{q}{p})^{k} </math>

''' On en déduit les valeurs <math> \alpha \text{ et } \beta </math>''' :
<math>
\begin{cases}
0 = \alpha + \beta \\
1 = \alpha + \beta \cdot (\frac{q}{p})^{k} \\
\end{cases}

\iff \begin{cases}
\alpha = - \beta \\
1 = - \beta + \beta \cdot (\frac{q}{p})^{k} \\
\end{cases}

\iff \begin{cases}
\alpha = - \beta \\
1 = \beta \left(-1 + \left( \frac{q}{p} \right)^{a+b} \right) \\
\end{cases}

\iff \begin{cases}
\alpha = - \beta \\
\beta = \frac{1}{-1 + \left( \frac{q}{p} \right)^{a+b}} \\
\end{cases}
</math> 

On obtient :
<math>
\alpha = -\left(\frac{1}{-1 + \left( \frac{q}{p} \right)^{a+b}}\right)
\text{ et }
\beta = \frac{1}{-1 + \left( \frac{q}{p} \right)^{a+b}}
</math> 

D'où :
<math>
p_a = -\left(\frac{1}{-1 + \left( \frac{q}{p} \right)^{a+b}}\right)
+ \frac{\left( \frac{q}{p} \right)^{a}}{-1 + \left( \frac{q}{p} \right)^{a+b}}

\iff

p = \frac{\left( \frac{q}{p} \right)^{a} - 1}{\left( \frac{q}{p} \right)^{a+b} - 1}
</math>

On a donc formule suivante : <math> p = \frac{\left( \frac{q}{p} \right)^{a} - 1}{\left( \frac{q}{p} \right)^{a+b} - 1} </math>

===Estimation du temps moyen de jeu===

On commence avec la loi de probabilité totale :

<math> E_k(T) =E_k(T|Y_1 = 1)P(Y_1 = 1) + E_k(A|Y_1 = -1)P(Y_1 = -1) = (1 + E_{k+1}(T))p + (1 + E_{k-1}(T))q </math>

Ce qui donne l'équation :

<math>
\begin{cases}
e_k = 1 + p \cdot e_{k+1} + q \cdot e_{k-1}, & \text{pour } 1 \leq k \leq a + b \\
e_0 = 0, \\
e_{a+b} = 0.
\end{cases}
</math>

On note, pour <math> k \geq 1 , d_k = e_k - e_{k-1} </math>

On a donc la relation de récurence : <math> 0 = 1 + p \cdot d_{k+1} - q \cdot d_k </math>

====Pour p = 1/2 ====

On a <math> \frac{1}{2} \cdot d_{k+1} = \frac{1}{2} \cdot d_{k} - 1 </math>

donc, <math> d_{k+1} = d_k - 2 </math>

d'où <math> d_k = d_1 - 2 \left(k-1 \right) </math>

Alors pour <math> n \geq 1 , e_n = \sum_{k=1}^{n} d_k = n \cdot d_1 - 2 \cdot \sum_{k=0}^{n-1}k = n \cdot d_1 - 2 \cdot \frac{n(n-1)}{2} = n(d_1 - (n - 1)) </math>

Or <math> e_{a+b} = 0 = (a+b)(d_1 + (a + b - 1)), \text{d'où } d_1 = a + b - 1 </math>

Donc <math> E[T] = e_a = a(a + b - 1 - (a - 1)) = ab </math>

====Pour les autres probabilités====

On pose le réel l qui verifie <math> 0 = pl - ql </math> qui est donc <math> l = \frac{1}{q-p} </math>

La relation devient donc <math> 0 = p(d_{k+1} - l) - q(d_k - l) </math>

Par conséquent, <math> d_{k+1} - l = \frac{q}{p}(d_k - l) , \text{et donc } d_k - l = \left( \frac{q}{p} \right) ^{k-1} (d_1 - l) </math>

Donc pour <math> n \geq 1 </math>, on a :

<math> e_n = \sum_{k=1}^{n}d_k + e_0 = \sum_{k=1}^{n} \left( l + \left( \frac{q}{p} \right) ^{k-1} \cdot (d_1 - l) \right) = nl + (d_1 - l) \cdot \sum_{k=0}^{n-1}\left( \frac{q}{p} \right) ^{k} = nl + (d_1 - l) \cdot \frac{1 - \left( \frac{q}{p} \right) ^{n}}{1 - \frac{q}{p}}</math>

Or <math> e_{a+b} = 0 = (a+b)l + (d_1 - l) \cdot \frac{1 - \left( \frac{q}{p} \right) ^{a+b}}{1 - \frac{q}{p}} \text{par conséquent :} \frac{d_1 - l}{1 - \frac{q}{p}} = -\frac{(a+b)l}{1 - \left( \frac{q}{p} \right) ^{a+b} }</math>

Donc <math> E[T] = e_a = al - \left( 1 - \left( \frac{q}{p} \right)^{a} \right) \cdot \frac{(a+b)l}{1 - \left( \frac{q}{p} \right) ^{a+b}} = \frac{1}{q-p} \cdot \left( a - (a+b) \cdot \frac{1 - \left( \frac{q}{p} \right) ^{a} }{1 - \left( \frac{q}{p} \right) ^{a+b} } \right) = \frac{(a+b)p-a}{p-q} </math>

==Simulation d'une partie==

Afin de modéliser la ruine du joueur on peut utiliser ce programme python :

=== Bases du Programme ===

On commence par initialiser nos valeurs que l'on va utiliser :
<pre>
from random import random
from matplotlib import pyplot as plt

PROBABILITE = (18/37) #18/37 Pour la roulette
SOMME_DEPART = 10
GAIN_FIN = 10 # Le gain souhaité

#Faire varier Nombre de Parties

NOMBRE_PARTIES = 1000

</pre>

=== Simulation d'une soirée ===

On commence par simuler une soirée au casino :

<pre>
def simule_soiree(initial:int = SOMME_DEPART, fin:int= GAIN_FIN, prob:int= PROBABILITE) -> tuple:
""" Simule une soirée au casino """

tab = [initial]
somme = initial

while somme > 0 and somme < initial + fin:
aleatoire = random()
if aleatoire <= prob:
somme += 1
else:
somme -= 1
tab = tab + [somme]

if somme == initial + fin:
res = True
else:
res = False

return (tab, res)

</pre>

On peut afficher le résultat d'une soirée :

<pre>
# Permet d'afficher une partie jouée.

def affiche_graphe() -> None:
""" Affiche le graphe d'une soirée au casino """

y = simule_soiree()[0]
x = [[i] for i in range(len(y))]
plt.title("Graphe d'une soirée au casino")
plt.xlabel("Instant I")
plt.ylabel("Somme instant I")
plt.plot(x,y)
plt.show()

affiche_graphe()

</pre>

[[Fichier:Simulation soiree 1.png]]

[[Fichier:Simulation soiree 2.png]]

[[Fichier:Simulation soiree 3.png]]

=== Verifications de nos estimations numériques ===

Pour cette partie nous commençons à 10 jetons et on veut doubler cette somme.

On peut implémenter nos estimations numériques :

<pre>
R = (1-PROBABILITE) / (PROBABILITE)

def calcule_proba_victoire_theorique() -> float:
"""Renvoie la probabilité de victoire théorique"""

if PROBABILITE == 0.5:
res = (SOMME_DEPART) / (SOMME_DEPART + GAIN_FIN)

else:
numerateur = R**(SOMME_DEPART) - 1
denumerateur = (R**(SOMME_DEPART + GAIN_FIN) - 1)
res = numerateur / denumerateur

return res

def calcule_duree_partie_theorique() -> float:
"""Renvoie la durée theorique d'une partie"""

if PROBABILITE == 0.5:
res = SOMME_DEPART * GAIN_FIN

else:
numerateur = (SOMME_DEPART + GAIN_FIN) * (1 - R**SOMME_DEPART)
denumerateur = 1 - R**(SOMME_DEPART + GAIN_FIN)

res = (1 / (2 * PROBABILITE - 1)) * ((numerateur / denumerateur) - SOMME_DEPART)

return res

</pre>

On va utiliser la méthode de comptage pour observer nos simulations :

<pre>
def calcule_nombre_victoire(tab_parties = SIMULATION_N_SOIREE) -> int:
""" Renvoie le nombre de victoires dans les soirées simulées"""
compteur = 0

for res_partie in tab_parties:
if res_partie[1] == True:
compteur = compteur + 1

return compteur

def calcule_proba_victoire(tab_parties = SIMULATION_N_SOIREE) -> float:
"""Renvoie la probabilité de victoire sur M soirées"""

nb_victoires = calcule_nombre_victoire(tab_parties)
res = nb_victoires/len(tab_parties)

return res

def calcule_duree_moyenne():
""" Renvoie la durée moyenne sur M soirées simulées"""
somme = 0
for partie in SIMULATION_N_SOIREE:
duree_partie = len(partie[0])
somme += duree_partie
res = somme / NOMBRE_PARTIES
return res

</pre>

On peut maintenant comparer nos résultats :
<pre>
Voici les valeurs theoriques :

La probabilité de victoire : 0.3680312223171822
Durée partie moyenne theorique : 97.65689548528538

Voici les valeurs avec nos resultats :

La probabilité de victoire : 0.347
Durée partie moyenne : 95.984

</pre>

Nous pouvons ainsi voir que nos formules qui servent à estimer la probabilité de victoire sont assez bonnes.

Nous pouvons dresser un graphe de l'évolution de la probabilité de victoire selon le nombre de parties simulées.

[[Fichier:Graphe proba selon nb parties.png|600px]]

En bleu, nous avons la probabilité de victoire théorique.

Nous pouvons remarquer que on converge vers cette valeur plus on simule de parties.

Modélisation de la ruine du joueur

2024-05-21T00:38:41Z

Akulas :

==Modélisation de la ruine du joueur==

Nous nous intéressons à l'étude des gains d'un joueur lors d'une soirée au casino, dans lequel le joueur joue à la roulette russe.

Le joueur commence avec une somme initiale comprise entre 0 et la somme souhaitée, le joueur s'arrête uniquement si :
- il obtient la somme souhaitée
- le joueur est ruiné (la somme est égale à 0)

Pour cela le joueur va jouer à la roulette en misant à chaque fois 1 jeton qu'il peut doubler ou perdre.

==Estimations numériques==

Nous allons prendre pour base le document suivant : [https://perso.eleves.ens-rennes.fr/people/florian.lemonnier/agregation/developpements/Ruine.pdf Ruine]

Notre objectif est de trouver de :

- calculer la probabilité de victoire, soit d'atteindre la somme souhaitée, en partant de la somme de départ.
- calculer la durée de la partie, soit le joueur arrête de jouer, donc il atteint l'une des conditions d'arrêt.

On définit de manière générale p la probabilité de victoire d'une partie et q = (1-p)

===Estimation de la probabilité de gagner===

On veut trouver une formule qui permet de trouver la probabilité de victoire lors d'une soirée au casino selon les paramètres de départ, soit la somme de départ et la somme voulue et la probabilité de victoire.

On commence avec la loi de probabilité totale :

<math> P_k(A) = P_k(A|Y_1 = 1)P_k(Y_1 = 1) + P_k(A|Y_1 = -1)P_k(Y_1 = -1) = P_{k+1}(A)p + P_{k-1}(A)q </math>

Ce qui donne le système suivant :

<math>
\begin{cases}
p_k = p \cdot p_{k+1} + q \cdot p_{k-1}, & \text{pour } 1 \leq k \leq a + b \\
p_0 = 0, \\
p_{a+b} = 1.
\end{cases}
</math>

'''On cherche l'équation quadratique : '''

On a la suite récurrente d'ordre 2 : [https://www.mathieu-mansuy.fr/pdf/PCSI5-complement1.pdf Résoudre une équation linéaire d'ordre 2] 
<math> p_k = p \cdot p_{k+1} + q \cdot p_{k-1} </math> 

On remplace <math> p_k </math> par <math> x^{k} </math> : 
<math> x^{k} = p \cdot x^{k+1} + q \cdot x^{k-1} </math> 

On divise par <math> x^{k-1} </math> : 
<math> x = p \cdot x^{2} + q </math> 

''' On résoult l'équation '''

<math> p \cdot x^{k+1} - x^{k} + q \cdot x^{k-1} = 0 </math>

====Pour p = 1/2 ====

Ca qui donne la solution unique : <math> x = 1 </math>

''' On en déduit les valeurs <math> \alpha \text{ et } \beta </math>''' :
<math>
\begin{cases}
0 = \alpha \\
1 = \alpha + \beta \cdot (a+b) \\
\end{cases}

\iff \begin{cases}
\alpha = 0 \\
\beta = \frac{a}{a+b} \\
\end{cases}
</math>

On a donc formule suivante : <math> p = \frac{a}{a+b} </math>

====Pour les autres probabilités====

Ce qui donne les solutions : <math> x_1 = 1 \text{ et } x_2 = \frac{q}{p} </math>

''' On a alors :'''

<math> p_k = \alpha \cdot x_1^{k} + \beta \cdot x_2^{k} </math> 
<math> \iff p_k = \alpha + \beta \cdot (\frac{q}{p})^{k} </math>

''' On en déduit les valeurs <math> \alpha \text{ et } \beta </math>''' :
<math>
\begin{cases}
0 = \alpha + \beta \\
1 = \alpha + \beta \cdot (\frac{q}{p})^{k} \\
\end{cases}

\iff \begin{cases}
\alpha = - \beta \\
1 = - \beta + \beta \cdot (\frac{q}{p})^{k} \\
\end{cases}

\iff \begin{cases}
\alpha = - \beta \\
1 = \beta \left(-1 + \left( \frac{q}{p} \right)^{a+b} \right) \\
\end{cases}

\iff \begin{cases}
\alpha = - \beta \\
\beta = \frac{1}{-1 + \left( \frac{q}{p} \right)^{a+b}} \\
\end{cases}
</math> 

On obtient :
<math>
\alpha = -\left(\frac{1}{-1 + \left( \frac{q}{p} \right)^{a+b}}\right)
\text{ et }
\beta = \frac{1}{-1 + \left( \frac{q}{p} \right)^{a+b}}
</math> 

D'où :
<math>
p_a = -\left(\frac{1}{-1 + \left( \frac{q}{p} \right)^{a+b}}\right)
+ \frac{\left( \frac{q}{p} \right)^{a}}{-1 + \left( \frac{q}{p} \right)^{a+b}}

\iff

p = \frac{\left( \frac{q}{p} \right)^{a} - 1}{\left( \frac{q}{p} \right)^{a+b} - 1}
</math>

On a donc formule suivante : <math> p = \frac{\left( \frac{q}{p} \right)^{a} - 1}{\left( \frac{q}{p} \right)^{a+b} - 1} </math>

===Estimation du temps moyen de jeu===

On commence avec la loi de probabilité totale :

<math> E_k(T) =E_k(T|Y_1 = 1)P(Y_1 = 1) + E_k(A|Y_1 = -1)P(Y_1 = -1) = (1 + E_{k+1}(T))p + (1 + E_{k-1}(T))q </math>

Ce qui donne l'équation :

<math>
\begin{cases}
e_k = 1 + p \cdot e_{k+1} + q \cdot e_{k-1}, & \text{pour } 1 \leq k \leq a + b \\
e_0 = 0, \\
e_{a+b} = 0.
\end{cases}
</math>

On note, pour <math> k \geq 1 , d_k = e_k - e_{k-1} </math>

On a donc la relation de récurence : <math> 0 = 1 + p \cdot d_{k+1} - q \cdot d_k </math>

====Pour p = 1/2 ====

On a <math> \frac{1}{2} \cdot d_{k+1} = \frac{1}{2} \cdot d_{k} - 1 </math>

donc, <math> d_{k+1} = d_k - 2 </math>

d'où <math> d_k = d_1 - 2 \left(k-1 \right) </math>

Alors pour <math> n \geq 1 , e_n = \sum_{k=1}^{n} d_k = n \cdot d_1 - 2 \cdot \sum_{k=0}^{n-1}k = n \cdot d_1 - 2 \cdot \frac{n(n-1)}{2} = n(d_1 - (n - 1)) </math>

Or <math> e_{a+b} = 0 = (a+b)(d_1 + (a + b - 1)), \text{d'où } d_1 = a + b - 1 </math>

Donc <math> E[T] = e_a = a(a + b - 1 - (a - 1)) = ab </math>

====Pour les autres probabilités====

On pose le réel l qui verifie <math> 0 = pl - ql </math> qui est donc <math> l = \frac{1}{q-p} </math>

La relation devient donc <math> 0 = p(d_{k+1} - l) - q(d_k - l) </math>

Par conséquent, <math> d_{k+1} - l = \frac{q}{p}(d_k - l) , \text{et donc } d_k - l = \left( \frac{q}{p} \right) ^{k-1} (d_1 - l) </math>

Donc pour <math> n \geq 1 </math>, on a :

<math> e_n = \sum_{k=1}^{n}d_k + e_0 = \sum_{k=1}^{n} \left( l + \left( \frac{q}{p} \right) ^{k-1} \cdot (d_1 - l) \right) = nl + (d_1 - l) \cdot \sum_{k=0}^{n-1}\left( \frac{q}{p} \right) ^{k} = nl + (d_1 - l) \cdot \frac{1 - \left( \frac{q}{p} \right) ^{n}}{1 - \frac{q}{p}}</math>

Or <math> e_{a+b} = 0 = (a+b)l + (d_1 - l) \cdot \frac{1 - \left( \frac{q}{p} \right) ^{a+b}}{1 - \frac{q}{p}} \text{par conséquent :} \frac{d_1 - l}{1 - \frac{q}{p}} = -\frac{(a+b)l}{1 - \left( \frac{q}{p} \right) ^{a+b} }</math>

Donc <math> E[T] = e_a = al - \left( 1 - \left( \frac{q}{p} \right)^{a} \right) \cdot \frac{(a+b)l}{1 - \left( \frac{q}{p} \right) ^{a+b}} = \frac{1}{q-p} \cdot \left( a - (a+b) \cdot \frac{1 - \left( \frac{q}{p} \right) ^{a} }{1 - \left( \frac{q}{p} \right) ^{a+b} } \right) = \frac{(a+b)p-a}{p-q} </math>

==Simulation d'une partie==

Afin de modéliser la ruine du joueur on peut utiliser ce programme python :

=== Bases du Programme ===

On commence par initialiser nos valeurs que l'on va utiliser :
<pre>
from random import random
from matplotlib import pyplot as plt

PROBABILITE = (18/37) #18/37 Pour la roulette
SOMME_DEPART = 10
GAIN_FIN = 10 # Le gain souhaité

#Faire varier Nombre de Parties

NOMBRE_PARTIES = 1000

</pre>

=== Simulation d'une soirée ===

On commence par simuler une soirée au casino :

<pre>
def simule_soiree(initial:int = SOMME_DEPART, fin:int= GAIN_FIN, prob:int= PROBABILITE) -> tuple:
""" Simule une soirée au casino """

tab = [initial]
somme = initial

while somme > 0 and somme < initial + fin:
aleatoire = random()
if aleatoire <= prob:
somme += 1
else:
somme -= 1
tab = tab + [somme]

if somme == initial + fin:
res = True
else:
res = False

return (tab, res)

</pre>

On peut afficher le résultat d'une soirée :

<pre>
# Permet d'afficher une partie jouée.

def affiche_graphe() -> None:
""" Affiche le graphe d'une soirée au casino """

y = simule_soiree()[0]
x = [[i] for i in range(len(y))]
plt.title("Graphe d'une soirée au casino")
plt.xlabel("Instant I")
plt.ylabel("Somme instant I")
plt.plot(x,y)
plt.show()

affiche_graphe()

</pre>

[[Fichier:Simulation soiree 1.png]]

[[Fichier:Simulation soiree 2.png]]

[[Fichier:Simulation soiree 3.png]]

=== Verifications de nos estimations numériques ===

Pour cette partie nous commençons à 10 jetons et on veut doubler cette somme.

On peut implémenter nos estimations numériques :

<pre>
R = (1-PROBABILITE) / (PROBABILITE)

def calcule_proba_victoire_theorique() -> float:
"""Renvoie la probabilité de victoire théorique"""

if PROBABILITE == 0.5:
res = (SOMME_DEPART) / (SOMME_DEPART + GAIN_FIN)

else:
numerateur = R**(SOMME_DEPART) - 1
denumerateur = (R**(SOMME_DEPART + GAIN_FIN) - 1)
res = numerateur / denumerateur

return res

def calcule_duree_partie_theorique() -> float:
"""Renvoie la durée theorique d'une partie"""

if PROBABILITE == 0.5:
res = SOMME_DEPART * GAIN_FIN

else:
numerateur = (SOMME_DEPART + GAIN_FIN) * (1 - R**SOMME_DEPART)
denumerateur = 1 - R**(SOMME_DEPART + GAIN_FIN)

res = (1 / (2 * PROBABILITE - 1)) * ((numerateur / denumerateur) - SOMME_DEPART)

return res

</pre>

On va utiliser la méthode de comptage pour observer nos simulations :

<pre>
def calcule_nombre_victoire(tab_parties = SIMULATION_N_SOIREE) -> int:
""" Renvoie le nombre de victoires dans les soirées simulées"""
compteur = 0

for res_partie in tab_parties:
if res_partie[1] == True:
compteur = compteur + 1

return compteur

def calcule_proba_victoire(tab_parties = SIMULATION_N_SOIREE) -> float:
"""Renvoie la probabilité de victoire sur M soirées"""

nb_victoires = calcule_nombre_victoire(tab_parties)
res = nb_victoires/len(tab_parties)

return res

def calcule_duree_moyenne():
""" Renvoie la durée moyenne sur M soirées simulées"""
somme = 0
for partie in SIMULATION_N_SOIREE:
duree_partie = len(partie[0])
somme += duree_partie
res = somme / NOMBRE_PARTIES
return res

</pre>

On peut maintenant comparer nos résultats :
<pre>
Voici les valeurs theoriques :

La probabilité de victoire : 0.3680312223171822
Durée partie moyenne theorique : 97.65689548528538

Voici les valeurs avec nos resultats :

La probabilité de victoire : 0.347
Durée partie moyenne : 95.984

</pre>

Nous pouvons ainsi voir que nos formules qui servent à estimer la probabilité de victoire sont assez bonnes.

Nous pouvons dresser un graphe de l'évolution de la probabilité de victoire selon le nombre de parties simulées.

[[Fichier:Graphe proba selon nb parties.png|600px]]

En bleu, nous avons la probabilité de victoire théorique.

Nous pouvons remarquer que on converge vers cette valeur plus on simule de parties.

Modélisation de la ruine du joueur

2024-05-21T00:30:53Z

Akulas : Ajout images

==Modélisation de la ruine du joueur==

Nous nous intéressons à l'étude des gains d'un joueur lors d'une soirée au casino, dans lequel le joueur joue à la roulette russe.

Le joueur commence avec une somme initiale comprise entre 0 et la somme souhaitée, le joueur s'arrête uniquement si :
- il obtient la somme souhaitée
- le joueur est ruiné (la somme est égale à 0)

Pour cela le joueur va jouer à la roulette en misant à chaque fois 1 jeton qu'il peut doubler ou perdre.

==Estimations numériques==

Nous allons prendre pour base le document suivant : [https://perso.eleves.ens-rennes.fr/people/florian.lemonnier/agregation/developpements/Ruine.pdf Ruine]

Notre objectif est de trouver de :

- calculer la probabilité de victoire, soit d'atteindre la somme souhaitée, en partant de la somme de départ.
- calculer la durée de la partie, soit le joueur arrête de jouer, donc il atteint l'une des conditions d'arrêt.

On définit de manière générale p la probabilité de victoire d'une partie et q = (1-p)

===Estimation de la probabilité de gagner===

On veut trouver une formule qui permet de trouver la probabilité de victoire lors d'une soirée au casino selon les paramètres de départ, soit la somme de départ et la somme voulue et la probabilité de victoire.

On commence avec la loi de probabilité totale :

<math> P_k(A) = P_k(A|Y_1 = 1)P_k(Y_1 = 1) + P_k(A|Y_1 = -1)P_k(Y_1 = -1) = P_{k+1}(A)p + P_{k-1}(A)q </math>

Ce qui donne le système suivant :

<math>
\begin{cases}
p_k = p \cdot p_{k+1} + q \cdot p_{k-1}, & \text{pour } 1 \leq k \leq a + b \\
p_0 = 0, \\
p_{a+b} = 1.
\end{cases}
</math>

'''On cherche l'équation quadratique : '''

On a la suite récurrente d'ordre 2 : [https://www.mathieu-mansuy.fr/pdf/PCSI5-complement1.pdf Résoudre une équation linéaire d'ordre 2] 
<math> p_k = p \cdot p_{k+1} + q \cdot p_{k-1} </math> 

On remplace <math> p_k </math> par <math> x^{k} </math> : 
<math> x^{k} = p \cdot x^{k+1} + q \cdot x^{k-1} </math> 

On divise par <math> x^{k-1} </math> : 
<math> x = p \cdot x^{2} + q </math> 

''' On résoult l'équation '''

<math> p \cdot x^{k+1} - x^{k} + q \cdot x^{k-1} = 0 </math>

====Pour p = 1/2 ====

Ca qui donne la solution unique : <math> x = 1 </math>

''' On en déduit les valeurs <math> \alpha \text{ et } \beta </math>''' :
<math>
\begin{cases}
0 = \alpha \\
1 = \alpha + \beta \cdot (a+b) \\
\end{cases}

\iff \begin{cases}
\alpha = 0 \\
\beta = \frac{a}{a+b} \\
\end{cases}
</math>

On a donc formule suivante : <math> p = \frac{a}{a+b} </math>

====Pour les autres probabilités====

Ce qui donne les solutions : <math> x_1 = 1 \text{ et } x_2 = \frac{q}{p} </math>

''' On a alors :'''

<math> p_k = \alpha \cdot x_1^{k} + \beta \cdot x_2^{k} </math> 
<math> \iff p_k = \alpha + \beta \cdot (\frac{q}{p})^{k} </math>

''' On en déduit les valeurs <math> \alpha \text{ et } \beta </math>''' :
<math>
\begin{cases}
0 = \alpha + \beta \\
1 = \alpha + \beta \cdot (\frac{q}{p})^{k} \\
\end{cases}

\iff \begin{cases}
\alpha = - \beta \\
1 = - \beta + \beta \cdot (\frac{q}{p})^{k} \\
\end{cases}

\iff \begin{cases}
\alpha = - \beta \\
1 = \beta \left(-1 + \left( \frac{q}{p} \right)^{a+b} \right) \\
\end{cases}

\iff \begin{cases}
\alpha = - \beta \\
\beta = \frac{1}{-1 + \left( \frac{q}{p} \right)^{a+b}} \\
\end{cases}
</math> 

On obtient :
<math>
\alpha = -\left(\frac{1}{-1 + \left( \frac{q}{p} \right)^{a+b}}\right)
\text{ et }
\beta = \frac{1}{-1 + \left( \frac{q}{p} \right)^{a+b}}
</math> 

D'où :
<math>
p_a = -\left(\frac{1}{-1 + \left( \frac{q}{p} \right)^{a+b}}\right)
+ \frac{\left( \frac{q}{p} \right)^{a}}{-1 + \left( \frac{q}{p} \right)^{a+b}}

\iff

p = \frac{\left( \frac{q}{p} \right)^{a} - 1}{\left( \frac{q}{p} \right)^{a+b} - 1}
</math>

On a donc formule suivante : <math> p = \frac{\left( \frac{q}{p} \right)^{a} - 1}{\left( \frac{q}{p} \right)^{a+b} - 1} </math>

===Estimation du temps moyen de jeu===

On commence avec la loi de probabilité totale :

<math> E_k(T) =E_k(T|Y_1 = 1)P(Y_1 = 1) + E_k(A|Y_1 = -1)P(Y_1 = -1) = (1 + E_{k+1}(T))p + (1 + E_{k-1}(T))q </math>

Ce qui donne l'équation :

<math>
\begin{cases}
e_k = 1 + p \cdot e_{k+1} + q \cdot e_{k-1}, & \text{pour } 1 \leq k \leq a + b \\
e_0 = 0, \\
e_{a+b} = 0.
\end{cases}
</math>

On note, pour <math> k \geq 1 , d_k = e_k - e_{k-1} </math>

On a donc la relation de récurence : <math> 0 = 1 + p \cdot d_{k+1} - q \cdot d_k </math>

====Pour p = 1/2 ====

On a <math> \frac{1}{2} \cdot d_{k+1} = \frac{1}{2} \cdot d_{k} - 1 </math>

donc, <math> d_{k+1} = d_k - 2 </math>

d'où <math> d_k = d_1 - 2 \left(k-1 \right) </math>

Alors pour <math> n \geq 1 , e_n = \sum_{k=1}^{n} d_k = n \cdot d_1 - 2 \cdot \sum_{k=0}^{n-1}k = n \cdot d_1 - 2 \cdot \frac{n(n-1)}{2} = n(d_1 - (n - 1)) </math>

Or <math> e_{a+b} = 0 = (a+b)(d_1 + (a + b - 1)), \text{d'où } d_1 = a + b - 1 </math>

Donc <math> E[T] = e_a = a(a + b - 1 - (a - 1)) = ab </math>

====Pour les autres probabilités====

On pose le réel l qui verifie <math> 0 = pl - ql </math> qui est donc <math> l = \frac{1}{q-p} </math>

La relation devient donc <math> 0 = p(d_{k+1} - l) - q(d_k - l) </math>

Par conséquent, <math> d_{k+1} - l = \frac{q}{p}(d_k - l) , \text{et donc } d_k - l = \left( \frac{q}{p} \right) ^{k-1} (d_1 - l) </math>

Donc pour <math> n \geq 1 </math>, on a :

<math> e_n = \sum_{k=1}^{n}d_k + e_0 = \sum_{k=1}^{n} \left( l + \left( \frac{q}{p} \right) ^{k-1} \cdot (d_1 - l) \right) = nl + (d_1 - l) \cdot \sum_{k=0}^{n-1}\left( \frac{q}{p} \right) ^{k} = nl + (d_1 - l) \cdot \frac{1 - \left( \frac{q}{p} \right) ^{n}}{1 - \frac{q}{p}}</math>

Or <math> e_{a+b} = 0 = (a+b)l + (d_1 - l) \cdot \frac{1 - \left( \frac{q}{p} \right) ^{a+b}}{1 - \frac{q}{p}} \text{par conséquent :} \frac{d_1 - l}{1 - \frac{q}{p}} = -\frac{(a+b)l}{1 - \left( \frac{q}{p} \right) ^{a+b} }</math>

Donc <math> E[T] = e_a = al - \left( 1 - \left( \frac{q}{p} \right)^{a} \right) \cdot \frac{(a+b)l}{1 - \left( \frac{q}{p} \right) ^{a+b}} = \frac{1}{q-p} \cdot \left( a - (a+b) \cdot \frac{1 - \left( \frac{q}{p} \right) ^{a} }{1 - \left( \frac{q}{p} \right) ^{a+b} } \right) = \frac{(a+b)p-a}{p-q} </math>

==Simulation d'une partie==

Afin de modéliser la ruine du joueur on peut utiliser ce programme python :

=== Bases du Programme ===

On commence par initialiser nos valeurs que l'on va utiliser :
<pre>
from random import random
from matplotlib import pyplot as plt

PROBABILITE = (18/37) #18/37 Pour la roulette
SOMME_DEPART = 10
GAIN_FIN = 5 # Le gain souhaité

#Faire varier Nombre de Parties

NOMBRE_PARTIES = 1000

</pre>

=== Simulation d'une soirée ===

On commence par simuler une soirée au casino :

<pre>
def simule_soiree(initial:int = SOMME_DEPART, fin:int= GAIN_FIN, prob:int= PROBABILITE) -> tuple:
""" Simule une soirée au casino """

tab = [initial]
somme = initial

while somme > 0 and somme < initial + fin:
aleatoire = random()
if aleatoire <= prob:
somme += 1
else:
somme -= 1
tab = tab + [somme]

if somme == initial + fin:
res = True
else:
res = False

return (tab, res)

</pre>

On peut afficher le résultat d'une soirée :

<pre>
# Permet d'afficher une partie jouée.

def affiche_graphe() -> None:
""" Affiche le graphe d'une soirée au casino """

y = simule_soiree()[0]
x = [[i] for i in range(len(y))]
plt.title("Graphe d'une soirée au casino")
plt.xlabel("Instant I")
plt.ylabel("Somme instant I")
plt.plot(x,y)
plt.show()

affiche_graphe()

</pre>

[[Fichier:Simulation soiree 1.png]]

[[Fichier:Simulation soiree 2.png]]

[[Fichier:Simulation soiree 3.png]]

=== Verifications de nos estimations numériques ===

On peut implémenter nos estimations numériques :

<pre>
R = (1-PROBABILITE) / (PROBABILITE)

def calcule_proba_victoire_theorique() -> float:
"""Renvoie la probabilité de victoire théorique"""

if PROBABILITE == 0.5:
res = (SOMME_DEPART) / (SOMME_DEPART + GAIN_FIN)

else:
numerateur = R**(SOMME_DEPART) - 1
denumerateur = (R**(SOMME_DEPART + GAIN_FIN) - 1)
res = numerateur / denumerateur

return res

def calcule_duree_partie_theorique() -> float:
"""Renvoie la durée theorique d'une partie"""

if PROBABILITE == 0.5:
res = SOMME_DEPART * GAIN_FIN

else:
numerateur = (SOMME_DEPART + GAIN_FIN) * (1 - R**SOMME_DEPART)
denumerateur = 1 - R**(SOMME_DEPART + GAIN_FIN)

res = (1 / (2 * PROBABILITE - 1)) * ((numerateur / denumerateur) - SOMME_DEPART)

return res

</pre>

On va utiliser la méthode de comptage pour observer nos simulations :

<pre>
def calcule_nombre_victoire(tab_parties = SIMULATION_N_SOIREE) -> int:
""" Renvoie le nombre de victoires dans les soirées simulées"""
compteur = 0

for res_partie in tab_parties:
if res_partie[1] == True:
compteur = compteur + 1

return compteur

def calcule_proba_victoire(tab_parties = SIMULATION_N_SOIREE) -> float:
"""Renvoie la probabilité de victoire sur M soirées"""

nb_victoires = calcule_nombre_victoire(tab_parties)
res = nb_victoires/len(tab_parties)

return res

def calcule_duree_moyenne():
""" Renvoie la durée moyenne sur M soirées simulées"""
somme = 0
for partie in SIMULATION_N_SOIREE:
duree_partie = len(partie[0])
somme += duree_partie
res = somme / NOMBRE_PARTIES
return res

</pre>

On peut maintenant comparer nos résultats :
<pre>
Voici les valeurs theoriques :

La probabilité de victoire : 0.5812626435530369
La probabilité de defaite : 0.4187373564469631
Durée partie moyenne theorique : 1334.2610407391421

Voici les valeurs avec nos resultats :

La probabilité de victoire : 0.592
La probabilité de defaite : 0.408
Durée partie moyenne : 1358.222

</pre>

[[Fichier:Graphe proba selon nb parties.png|600px]]

Fichier:Simulation soiree 3.png

2024-05-21T00:30:18Z

Akulas :

Fichier:Simulation soiree 2.png

2024-05-21T00:29:36Z

Akulas :

Fichier:Simulation soiree 1.png

2024-05-21T00:28:42Z

Akulas :

Fichier:Graphe proba selon nb parties.png

2024-05-21T00:27:12Z

Akulas :

Modélisation de la ruine du joueur

2024-05-20T23:19:08Z

Akulas :

==Modélisation de la ruine du joueur==

Nous nous intéressons à l'étude des gains d'un joueur lors d'une soirée au casino, dans lequel le joueur joue à la roulette russe.

Le joueur commence avec une somme initiale comprise entre 0 et la somme souhaitée, le joueur s'arrête uniquement si :
- il obtient la somme souhaitée
- le joueur est ruiné (la somme est égale à 0)

Pour cela le joueur va jouer à la roulette en misant à chaque fois 1 jeton qu'il peut doubler ou perdre.

==Estimations numériques==

Nous allons prendre pour base le document suivant : [https://perso.eleves.ens-rennes.fr/people/florian.lemonnier/agregation/developpements/Ruine.pdf Ruine]

Notre objectif est de trouver de :

- calculer la probabilité de victoire, soit d'atteindre la somme souhaitée, en partant de la somme de départ.
- calculer la durée de la partie, soit le joueur arrête de jouer, donc il atteint l'une des conditions d'arrêt.

On définit de manière générale p la probabilité de victoire d'une partie et q = (1-p)

===Estimation de la probabilité de gagner===

On veut trouver une formule qui permet de trouver la probabilité de victoire lors d'une soirée au casino selon les paramètres de départ, soit la somme de départ et la somme voulue et la probabilité de victoire.

On commence avec la loi de probabilité totale :

<math> P_k(A) = P_k(A|Y_1 = 1)P_k(Y_1 = 1) + P_k(A|Y_1 = -1)P_k(Y_1 = -1) = P_{k+1}(A)p + P_{k-1}(A)q </math>

Ce qui donne le système suivant :

<math>
\begin{cases}
p_k = p \cdot p_{k+1} + q \cdot p_{k-1}, & \text{pour } 1 \leq k \leq a + b \\
p_0 = 0, \\
p_{a+b} = 1.
\end{cases}
</math>

'''On cherche l'équation quadratique : '''

On a la suite récurrente d'ordre 2 : [https://www.mathieu-mansuy.fr/pdf/PCSI5-complement1.pdf Résoudre une équation linéaire d'ordre 2] 
<math> p_k = p \cdot p_{k+1} + q \cdot p_{k-1} </math> 

On remplace <math> p_k </math> par <math> x^{k} </math> : 
<math> x^{k} = p \cdot x^{k+1} + q \cdot x^{k-1} </math> 

On divise par <math> x^{k-1} </math> : 
<math> x = p \cdot x^{2} + q </math> 

''' On résoult l'équation '''

<math> p \cdot x^{k+1} - x^{k} + q \cdot x^{k-1} = 0 </math>

====Pour p = 1/2 ====

Ca qui donne la solution unique : <math> x = 1 </math>

''' On en déduit les valeurs <math> \alpha \text{ et } \beta </math>''' :
<math>
\begin{cases}
0 = \alpha \\
1 = \alpha + \beta \cdot (a+b) \\
\end{cases}

\iff \begin{cases}
\alpha = 0 \\
\beta = \frac{a}{a+b} \\
\end{cases}
</math>

On a donc formule suivante : <math> p = \frac{a}{a+b} </math>

====Pour les autres probabilités====

Ce qui donne les solutions : <math> x_1 = 1 \text{ et } x_2 = \frac{q}{p} </math>

''' On a alors :'''

<math> p_k = \alpha \cdot x_1^{k} + \beta \cdot x_2^{k} </math> 
<math> \iff p_k = \alpha + \beta \cdot (\frac{q}{p})^{k} </math>

''' On en déduit les valeurs <math> \alpha \text{ et } \beta </math>''' :
<math>
\begin{cases}
0 = \alpha + \beta \\
1 = \alpha + \beta \cdot (\frac{q}{p})^{k} \\
\end{cases}

\iff \begin{cases}
\alpha = - \beta \\
1 = - \beta + \beta \cdot (\frac{q}{p})^{k} \\
\end{cases}

\iff \begin{cases}
\alpha = - \beta \\
1 = \beta \left(-1 + \left( \frac{q}{p} \right)^{a+b} \right) \\
\end{cases}

\iff \begin{cases}
\alpha = - \beta \\
\beta = \frac{1}{-1 + \left( \frac{q}{p} \right)^{a+b}} \\
\end{cases}
</math> 

On obtient :
<math>
\alpha = -\left(\frac{1}{-1 + \left( \frac{q}{p} \right)^{a+b}}\right)
\text{ et }
\beta = \frac{1}{-1 + \left( \frac{q}{p} \right)^{a+b}}
</math> 

D'où :
<math>
p_a = -\left(\frac{1}{-1 + \left( \frac{q}{p} \right)^{a+b}}\right)
+ \frac{\left( \frac{q}{p} \right)^{a}}{-1 + \left( \frac{q}{p} \right)^{a+b}}

\iff

p = \frac{\left( \frac{q}{p} \right)^{a} - 1}{\left( \frac{q}{p} \right)^{a+b} - 1}
</math>

On a donc formule suivante : <math> p = \frac{\left( \frac{q}{p} \right)^{a} - 1}{\left( \frac{q}{p} \right)^{a+b} - 1} </math>

===Estimation du temps moyen de jeu===

On commence avec la loi de probabilité totale :

<math> E_k(T) =E_k(T|Y_1 = 1)P(Y_1 = 1) + E_k(A|Y_1 = -1)P(Y_1 = -1) = (1 + E_{k+1}(T))p + (1 + E_{k-1}(T))q </math>

Ce qui donne l'équation :

<math>
\begin{cases}
e_k = 1 + p \cdot e_{k+1} + q \cdot e_{k-1}, & \text{pour } 1 \leq k \leq a + b \\
e_0 = 0, \\
e_{a+b} = 0.
\end{cases}
</math>

On note, pour <math> k \geq 1 , d_k = e_k - e_{k-1} </math>

On a donc la relation de récurence : <math> 0 = 1 + p \cdot d_{k+1} - q \cdot d_k </math>

====Pour p = 1/2 ====

On a <math> \frac{1}{2} \cdot d_{k+1} = \frac{1}{2} \cdot d_{k} - 1 </math>

donc, <math> d_{k+1} = d_k - 2 </math>

d'où <math> d_k = d_1 - 2 \left(k-1 \right) </math>

Alors pour <math> n \geq 1 , e_n = \sum_{k=1}^{n} d_k = n \cdot d_1 - 2 \cdot \sum_{k=0}^{n-1}k = n \cdot d_1 - 2 \cdot \frac{n(n-1)}{2} = n(d_1 - (n - 1)) </math>

Or <math> e_{a+b} = 0 = (a+b)(d_1 + (a + b - 1)), \text{d'où } d_1 = a + b - 1 </math>

Donc <math> E[T] = e_a = a(a + b - 1 - (a - 1)) = ab </math>

====Pour les autres probabilités====

On pose le réel l qui verifie <math> 0 = pl - ql </math> qui est donc <math> l = \frac{1}{q-p} </math>

La relation devient donc <math> 0 = p(d_{k+1} - l) - q(d_k - l) </math>

Par conséquent, <math> d_{k+1} - l = \frac{q}{p}(d_k - l) , \text{et donc } d_k - l = \left( \frac{q}{p} \right) ^{k-1} (d_1 - l) </math>

Donc pour <math> n \geq 1 </math>, on a :

<math> e_n = \sum_{k=1}^{n}d_k + e_0 = \sum_{k=1}^{n} \left( l + \left( \frac{q}{p} \right) ^{k-1} \cdot (d_1 - l) \right) = nl + (d_1 - l) \cdot \sum_{k=0}^{n-1}\left( \frac{q}{p} \right) ^{k} = nl + (d_1 - l) \cdot \frac{1 - \left( \frac{q}{p} \right) ^{n}}{1 - \frac{q}{p}}</math>

Or <math> e_{a+b} = 0 = (a+b)l + (d_1 - l) \cdot \frac{1 - \left( \frac{q}{p} \right) ^{a+b}}{1 - \frac{q}{p}} \text{par conséquent :} \frac{d_1 - l}{1 - \frac{q}{p}} = -\frac{(a+b)l}{1 - \left( \frac{q}{p} \right) ^{a+b} }</math>

Donc <math> E[T] = e_a = al - \left( 1 - \left( \frac{q}{p} \right)^{a} \right) \cdot \frac{(a+b)l}{1 - \left( \frac{q}{p} \right) ^{a+b}} = \frac{1}{q-p} \cdot \left( a - (a+b) \cdot \frac{1 - \left( \frac{q}{p} \right) ^{a} }{1 - \left( \frac{q}{p} \right) ^{a+b} } \right) = \frac{(a+b)p-a}{p-q} </math>

==Simulation d'une partie==

Afin de modéliser la ruine du joueur on peut utiliser ce programme python :

=== Bases du Programme ===

On commence par initialiser nos valeurs que l'on va utiliser :
<pre>
from random import random
from matplotlib import pyplot as plt

PROBABILITE = (18/37) #18/37 Pour la roulette
SOMME_DEPART = 10
GAIN_FIN = 5 # Le gain souhaité

#Faire varier Nombre de Parties

NOMBRE_PARTIES = 1000

</pre>

=== Simulation d'une soirée ===

On commence par simuler une soirée au casino :

<pre>
def simule_soiree(initial:int = SOMME_DEPART, fin:int= GAIN_FIN, prob:int= PROBABILITE) -> tuple:
""" Simule une soirée au casino """

tab = [initial]
somme = initial

while somme > 0 and somme < initial + fin:
aleatoire = random()
if aleatoire <= prob:
somme += 1
else:
somme -= 1
tab = tab + [somme]

if somme == initial + fin:
res = True
else:
res = False

return (tab, res)

</pre>

On peut afficher le résultat d'une soirée :

<pre>
# Permet d'afficher une partie jouée.

def affiche_graphe() -> None:
""" Affiche le graphe d'une soirée au casino """

y = simule_soiree()[0]
x = [[i] for i in range(len(y))]
plt.title("Graphe d'une soirée au casino")
plt.xlabel("Instant I")
plt.ylabel("Somme instant I")
plt.plot(x,y)
plt.show()

affiche_graphe()

</pre>

=== Verifications de nos estimations numériques ===

On peut implémenter nos estimations numériques :

<pre>
R = (1-PROBABILITE) / (PROBABILITE)

def calcule_proba_victoire_theorique() -> float:
"""Renvoie la probabilité de victoire théorique"""

if PROBABILITE == 0.5:
res = (SOMME_DEPART) / (SOMME_DEPART + GAIN_FIN)

else:
numerateur = R**(SOMME_DEPART) - 1
denumerateur = (R**(SOMME_DEPART + GAIN_FIN) - 1)
res = numerateur / denumerateur

return res

def calcule_duree_partie_theorique() -> float:
"""Renvoie la durée theorique d'une partie"""

if PROBABILITE == 0.5:
res = SOMME_DEPART * GAIN_FIN

else:
numerateur = (SOMME_DEPART + GAIN_FIN) * (1 - R**SOMME_DEPART)
denumerateur = 1 - R**(SOMME_DEPART + GAIN_FIN)

res = (1 / (2 * PROBABILITE - 1)) * ((numerateur / denumerateur) - SOMME_DEPART)

return res

</pre>

On va utiliser la méthode de comptage pour observer nos simulations :

<pre>
def calcule_nombre_victoire(tab_parties = SIMULATION_N_SOIREE) -> int:
""" Renvoie le nombre de victoires dans les soirées simulées"""
compteur = 0

for res_partie in tab_parties:
if res_partie[1] == True:
compteur = compteur + 1

return compteur

def calcule_proba_victoire(tab_parties = SIMULATION_N_SOIREE) -> float:
"""Renvoie la probabilité de victoire sur M soirées"""

nb_victoires = calcule_nombre_victoire(tab_parties)
res = nb_victoires/len(tab_parties)

return res

def calcule_duree_moyenne():
""" Renvoie la durée moyenne sur M soirées simulées"""
somme = 0
for partie in SIMULATION_N_SOIREE:
duree_partie = len(partie[0])
somme += duree_partie
res = somme / NOMBRE_PARTIES
return res

</pre>

On peut maintenant comparer nos résultats :
<pre>
Voici les valeurs theoriques :

La probabilité de victoire : 0.5812626435530369
La probabilité de defaite : 0.4187373564469631
Durée partie moyenne theorique : 1334.2610407391421

Voici les valeurs avec nos resultats :

La probabilité de victoire : 0.592
La probabilité de defaite : 0.408
Durée partie moyenne : 1358.222

</pre>

Modélisation de la ruine du joueur

2024-05-20T23:17:31Z

Akulas :

==Modélisation de la ruine du joueur==

Nous nous intéressons à l'étude des gains d'un joueur lors d'une soirée au casino, dans lequel le joueur joue à la roulette russe.

Le joueur commence avec une somme initiale comprise entre 0 et la somme souhaitée, le joueur s'arrête uniquement si :
- il obtient la somme souhaitée
- le joueur est ruiné (la somme est égale à 0)

Pour cela le joueur va jouer à la roulette en misant à chaque fois 1 jeton qu'il peut doubler ou perdre.

==Estimations numériques==

Nous allons prendre pour base le document suivant : [https://perso.eleves.ens-rennes.fr/people/florian.lemonnier/agregation/developpements/Ruine.pdf Ruine]

Notre objectif est de trouver de :

- calculer la probabilité de victoire, soit d'atteindre la somme souhaitée, en partant de la somme de départ.
- calculer la durée de la partie, soit le joueur arrête de jouer, donc il atteint l'une des conditions d'arrêt.

On définit de manière générale p la probabilité de victoire d'une partie et q = (1-p)

===Estimation de la probabilité de gagner===

On veut trouver une formule qui permet de trouver la probabilité de victoire lors d'une soirée au casino selon les paramètres de départ, soit la somme de départ et la somme voulue et la probabilité de victoire.

On commence avec la loi de probabilité totale :

<math> P_k(A) = P_k(A|Y_1 = 1)P_k(Y_1 = 1) + P_k(A|Y_1 = -1)P_k(Y_1 = -1) = P_{k+1}(A)p + P_{k-1}(A)q </math>

Ce qui donne le système suivant :

<math>
\begin{cases}
p_k = p \cdot p_{k+1} + q \cdot p_{k-1}, & \text{pour } 1 \leq k \leq a + b \\
p_0 = 0, \\
p_{a+b} = 1.
\end{cases}
</math>

'''On cherche l'équation quadratique : '''

On a la suite récurrente d'ordre 2 : [https://www.mathieu-mansuy.fr/pdf/PCSI5-complement1.pdf Résoudre une équation linéaire d'ordre 2] 
<math> p_k = p \cdot p_{k+1} + q \cdot p_{k-1} </math> 

On remplace <math> p_k </math> par <math> x^{k} </math> : 
<math> x^{k} = p \cdot x^{k+1} + q \cdot x^{k-1} </math> 

On divise par <math> x^{k-1} </math> : 
<math> x = p \cdot x^{2} + q </math> 

''' On résoult l'équation '''

<math> p \cdot x^{k+1} - x^{k} + q \cdot x^{k-1} = 0 </math>

====Pour p = 1/2 ====

Ca qui donne la solution unique : <math> x = 1 </math>

''' On en déduit les valeurs <math> \alpha \text{ et } \beta </math>''' :
<math>
\begin{cases}
0 = \alpha \\
1 = \alpha + \beta \cdot (a+b) \\
\end{cases}

\iff \begin{cases}
\alpha = 0 \\
\beta = \frac{a}{a+b} \\
\end{cases}
</math>

On a donc formule suivante : <math> p = \frac{a}{a+b} </math>

====Pour les autres probabilités====

Ce qui donne les solutions : <math> x_1 = 1 \text{ et } x_2 = \frac{q}{p} </math>

''' On a alors :'''

<math> p_k = \alpha \cdot x_1^{k} + \beta \cdot x_2^{k} </math> 
<math> \iff p_k = \alpha + \beta \cdot (\frac{q}{p})^{k} </math>

''' On en déduit les valeurs <math> \alpha \text{ et } \beta </math>''' :
<math>
\begin{cases}
0 = \alpha + \beta \\
1 = \alpha + \beta \cdot (\frac{q}{p})^{k} \\
\end{cases}

\iff \begin{cases}
\alpha = - \beta \\
1 = - \beta + \beta \cdot (\frac{q}{p})^{k} \\
\end{cases}

\iff \begin{cases}
\alpha = - \beta \\
1 = \beta \left(-1 + \left( \frac{q}{p} \right)^{a+b} \right) \\
\end{cases}

\iff \begin{cases}
\alpha = - \beta \\
\beta = \frac{1}{-1 + \left( \frac{q}{p} \right)^{a+b}} \\
\end{cases}
</math> 

On obtient :
<math>
\alpha = -\left(\frac{1}{-1 + \left( \frac{q}{p} \right)^{a+b}}\right)
\text{ et }
\beta = \frac{1}{-1 + \left( \frac{q}{p} \right)^{a+b}}
</math> 

D'où :
<math>
p_a = -\left(\frac{1}{-1 + \left( \frac{q}{p} \right)^{a+b}}\right)
+ \frac{\left( \frac{q}{p} \right)^{a}}{-1 + \left( \frac{q}{p} \right)^{a+b}}

\iff

p = \frac{\left( \frac{q}{p} \right)^{a} - 1}{\left( \frac{q}{p} \right)^{a+b} - 1}
</math>

On a donc formule suivante : <math> p = \frac{\left( \frac{q}{p} \right)^{a} - 1}{\left( \frac{q}{p} \right)^{a+b} - 1} </math>

===Estimation du temps moyen de jeu===

<math> E_k(T) =E_k(T|Y_1 = 1)P(Y_1 = 1) + E_k(A|Y_1 = -1)P(Y_1 = -1) = (1 + E_{k+1}(T))p + (1 + E_{k-1}(T))q </math>

Ce qui donne l'équation :

<math>
\begin{cases}
e_k = 1 + p \cdot e_{k+1} + q \cdot e_{k-1}, & \text{pour } 1 \leq k \leq a + b \\
e_0 = 0, \\
e_{a+b} = 0.
\end{cases}
</math>

On note, pour <math> k \geq 1 , d_k = e_k - e_{k-1} </math>

On a donc la relation de récurence : <math> 0 = 1 + p \cdot d_{k+1} - q \cdot d_k </math>

====Pour p = 1/2 ====

On a <math> \frac{1}{2} \cdot d_{k+1} = \frac{1}{2} \cdot d_{k} - 1 </math>

donc, <math> d_{k+1} = d_k - 2 </math>

d'où <math> d_k = d_1 - 2 \left(k-1 \right) </math>

Alors pour <math> n \geq 1 , e_n = \sum_{k=1}^{n} d_k = n \cdot d_1 - 2 \cdot \sum_{k=0}^{n-1}k = n \cdot d_1 - 2 \cdot \frac{n(n-1)}{2} = n(d_1 - (n - 1)) </math>

Or <math> e_{a+b} = 0 = (a+b)(d_1 + (a + b - 1)), \text{d'où } d_1 = a + b - 1 </math>

Donc <math> E[T] = e_a = a(a + b - 1 - (a - 1)) = ab </math>

====Pour les autres probabilités====

On pose le réel l qui verifie <math> 0 = pl - ql </math> qui est donc <math> l = \frac{1}{q-p} </math>

La relation devient donc <math> 0 = p(d_{k+1} - l) - q(d_k - l) </math>

Par conséquent, <math> d_{k+1} - l = \frac{q}{p}(d_k - l) , \text{et donc } d_k - l = \left( \frac{q}{p} \right) ^{k-1} (d_1 - l) </math>

Donc pour <math> n \geq 1 </math>, on a :

<math> e_n = \sum_{k=1}^{n}d_k + e_0 = \sum_{k=1}^{n} \left( l + \left( \frac{q}{p} \right) ^{k-1} \cdot (d_1 - l) \right) = nl + (d_1 - l) \cdot \sum_{k=0}^{n-1}\left( \frac{q}{p} \right) ^{k} = nl + (d_1 - l) \cdot \frac{1 - \left( \frac{q}{p} \right) ^{n}}{1 - \frac{q}{p}}</math>

Or <math> e_{a+b} = 0 = (a+b)l + (d_1 - l) \cdot \frac{1 - \left( \frac{q}{p} \right) ^{a+b}}{1 - \frac{q}{p}} \text{par conséquent :} \frac{d_1 - l}{1 - \frac{q}{p}} = -\frac{(a+b)l}{1 - \left( \frac{q}{p} \right) ^{a+b} }</math>

Donc <math> E[T] = e_a = al - \left( 1 - \left( \frac{q}{p} \right)^{a} \right) \cdot \frac{(a+b)l}{1 - \left( \frac{q}{p} \right) ^{a+b}} = \frac{1}{q-p} \cdot \left( a - (a+b) \cdot \frac{1 - \left( \frac{q}{p} \right) ^{a} }{1 - \left( \frac{q}{p} \right) ^{a+b} } \right) = \frac{(a+b)p-a}{p-q} </math>

==Simulation d'une partie==

Afin de modéliser la ruine du joueur on peut utiliser ce programme python :

=== Bases du Programme ===

On commence par initialiser nos valeurs que l'on va utiliser :
<pre>
from random import random
from matplotlib import pyplot as plt

PROBABILITE = (18/37) #18/37 Pour la roulette
SOMME_DEPART = 10
GAIN_FIN = 5 # Le gain souhaité

#Faire varier Nombre de Parties

NOMBRE_PARTIES = 1000

</pre>

=== Simulation d'une soirée ===

On commence par simuler une soirée au casino :

<pre>
def simule_soiree(initial:int = SOMME_DEPART, fin:int= GAIN_FIN, prob:int= PROBABILITE) -> tuple:
""" Simule une soirée au casino """

tab = [initial]
somme = initial

while somme > 0 and somme < initial + fin:
aleatoire = random()
if aleatoire <= prob:
somme += 1
else:
somme -= 1
tab = tab + [somme]

if somme == initial + fin:
res = True
else:
res = False

return (tab, res)

</pre>

On peut afficher le résultat d'une soirée :

<pre>
# Permet d'afficher une partie jouée.

def affiche_graphe() -> None:
""" Affiche le graphe d'une soirée au casino """

y = simule_soiree()[0]
x = [[i] for i in range(len(y))]
plt.title("Graphe d'une soirée au casino")
plt.xlabel("Instant I")
plt.ylabel("Somme instant I")
plt.plot(x,y)
plt.show()

affiche_graphe()

</pre>

=== Verifications de nos estimations numériques ===

On peut implémenter nos estimations numériques :

<pre>
R = (1-PROBABILITE) / (PROBABILITE)

def calcule_proba_victoire_theorique() -> float:
"""Renvoie la probabilité de victoire théorique"""

if PROBABILITE == 0.5:
res = (SOMME_DEPART) / (SOMME_DEPART + GAIN_FIN)

else:
numerateur = R**(SOMME_DEPART) - 1
denumerateur = (R**(SOMME_DEPART + GAIN_FIN) - 1)
res = numerateur / denumerateur

return res

def calcule_duree_partie_theorique() -> float:
"""Renvoie la durée theorique d'une partie"""

if PROBABILITE == 0.5:
res = SOMME_DEPART * GAIN_FIN

else:
numerateur = (SOMME_DEPART + GAIN_FIN) * (1 - R**SOMME_DEPART)
denumerateur = 1 - R**(SOMME_DEPART + GAIN_FIN)

res = (1 / (2 * PROBABILITE - 1)) * ((numerateur / denumerateur) - SOMME_DEPART)

return res

</pre>

On va utiliser la méthode de comptage pour observer nos simulations :

<pre>
def calcule_nombre_victoire(tab_parties = SIMULATION_N_SOIREE) -> int:
""" Renvoie le nombre de victoires dans les soirées simulées"""
compteur = 0

for res_partie in tab_parties:
if res_partie[1] == True:
compteur = compteur + 1

return compteur

def calcule_proba_victoire(tab_parties = SIMULATION_N_SOIREE) -> float:
"""Renvoie la probabilité de victoire sur M soirées"""

nb_victoires = calcule_nombre_victoire(tab_parties)
res = nb_victoires/len(tab_parties)

return res

def calcule_duree_moyenne():
""" Renvoie la durée moyenne sur M soirées simulées"""
somme = 0
for partie in SIMULATION_N_SOIREE:
duree_partie = len(partie[0])
somme += duree_partie
res = somme / NOMBRE_PARTIES
return res

</pre>

On peut maintenant comparer nos résultats :
<pre>
Voici les valeurs theoriques :

La probabilité de victoire : 0.5812626435530369
La probabilité de defaite : 0.4187373564469631
Durée partie moyenne theorique : 1334.2610407391421

Voici les valeurs avec nos resultats :

La probabilité de victoire : 0.592
La probabilité de defaite : 0.408
Durée partie moyenne : 1358.222

</pre>

Modélisation de la ruine du joueur

2024-05-20T23:16:31Z

Akulas :

==Modélisation de la ruine du joueur==

Nous nous intéressons à l'étude des gains d'un joueur lors d'une soirée au casino, dans lequel le joueur joue à la roulette russe.

Le joueur commence avec une somme initiale comprise entre 0 et la somme souhaitée, le joueur s'arrête uniquement si :
- il obtient la somme souhaitée
- le joueur est ruiné (la somme est égale à 0)

Pour cela le joueur va jouer à la roulette en misant à chaque fois 1 jeton qu'il peut doubler ou perdre.

==Estimations numériques==

Nous allons prendre pour base le document suivant : [https://perso.eleves.ens-rennes.fr/people/florian.lemonnier/agregation/developpements/Ruine.pdf Ruine]

Notre objectif est de trouver de :

- calculer la probabilité de victoire, soit d'atteindre la somme souhaitée, en partant de la somme de départ.
- calculer la durée de la partie, soit le joueur arrête de jouer, donc il atteint l'une des conditions d'arrêt.

On définit de manière générale p la probabilité de victoire d'une partie et q = (1-p)

===Estimation de la probabilité de gagner===

On veut trouver une formule qui permet de trouver la probabilité de victoire lors d'une soirée au casino selon les paramètres de départ, soit la somme de départ et la somme voulue et la probabilité de victoire.

On commence avec la loi de probabilité totale :

<math> P_k(A) = P_k(A|Y_1 = 1)P_k(Y_1 = 1) + P_k(A|Y_1 = -1)P_k(Y_1 = -1) = P_{k+1}(A)p + P_{k-1}(A)q </math>

Ce qui donne le système suivant :

<math>
\begin{cases}
p_k = p \cdot p_{k+1} + q \cdot p_{k-1}, & \text{pour } 1 \leq k \leq a + b \\
p_0 = 0, \\
p_{a+b} = 1.
\end{cases}
</math>

'''On cherche l'équation quadratique : '''

On a l'équation : 
<math> p_k = p \cdot p_{k+1} + q \cdot p_{k-1} </math> 

On remplace <math> p_k </math> par <math> x^{k} </math> : 
<math> x^{k} = p \cdot x^{k+1} + q \cdot x^{k-1} </math> 

On divise par <math> x^{k-1} </math> : 
<math> x = p \cdot x^{2} + q </math> 

''' On résoult l'équation '''

<math> p \cdot x^{k+1} - x^{k} + q \cdot x^{k-1} = 0 </math>

====Pour p = 1/2 ====

Ca qui donne la solution unique : <math> x = 1 </math>

''' On en déduit les valeurs <math> \alpha \text{ et } \beta </math>''' :
<math>
\begin{cases}
0 = \alpha \\
1 = \alpha + \beta \cdot (a+b) \\
\end{cases}

\iff \begin{cases}
\alpha = 0 \\
\beta = \frac{a}{a+b} \\
\end{cases}
</math>

On a donc formule suivante : <math> p = \frac{a}{a+b} </math>

====Pour les autres probabilités====

Ce qui donne les solutions : <math> x_1 = 1 \text{ et } x_2 = \frac{q}{p} </math>

''' On a alors :'''

<math> p_k = \alpha \cdot x_1^{k} + \beta \cdot x_2^{k} </math> 
<math> \iff p_k = \alpha + \beta \cdot (\frac{q}{p})^{k} </math>

''' On en déduit les valeurs <math> \alpha \text{ et } \beta </math>''' :
<math>
\begin{cases}
0 = \alpha + \beta \\
1 = \alpha + \beta \cdot (\frac{q}{p})^{k} \\
\end{cases}

\iff \begin{cases}
\alpha = - \beta \\
1 = - \beta + \beta \cdot (\frac{q}{p})^{k} \\
\end{cases}

\iff \begin{cases}
\alpha = - \beta \\
1 = \beta \left(-1 + \left( \frac{q}{p} \right)^{a+b} \right) \\
\end{cases}

\iff \begin{cases}
\alpha = - \beta \\
\beta = \frac{1}{-1 + \left( \frac{q}{p} \right)^{a+b}} \\
\end{cases}
</math> 

On obtient :
<math>
\alpha = -\left(\frac{1}{-1 + \left( \frac{q}{p} \right)^{a+b}}\right)
\text{ et }
\beta = \frac{1}{-1 + \left( \frac{q}{p} \right)^{a+b}}
</math> 

D'où :
<math>
p_a = -\left(\frac{1}{-1 + \left( \frac{q}{p} \right)^{a+b}}\right)
+ \frac{\left( \frac{q}{p} \right)^{a}}{-1 + \left( \frac{q}{p} \right)^{a+b}}

\iff

p = \frac{\left( \frac{q}{p} \right)^{a} - 1}{\left( \frac{q}{p} \right)^{a+b} - 1}
</math>

On a donc formule suivante : <math> p = \frac{\left( \frac{q}{p} \right)^{a} - 1}{\left( \frac{q}{p} \right)^{a+b} - 1} </math>

===Estimation du temps moyen de jeu===

<math> E_k(T) =E_k(T|Y_1 = 1)P(Y_1 = 1) + E_k(A|Y_1 = -1)P(Y_1 = -1) = (1 + E_{k+1}(T))p + (1 + E_{k-1}(T))q </math>

Ce qui donne l'équation :

<math>
\begin{cases}
e_k = 1 + p \cdot e_{k+1} + q \cdot e_{k-1}, & \text{pour } 1 \leq k \leq a + b \\
e_0 = 0, \\
e_{a+b} = 0.
\end{cases}
</math>

On note, pour <math> k \geq 1 , d_k = e_k - e_{k-1} </math>

On a donc la relation de récurence : <math> 0 = 1 + p \cdot d_{k+1} - q \cdot d_k </math>

====Pour p = 1/2 ====

On a <math> \frac{1}{2} \cdot d_{k+1} = \frac{1}{2} \cdot d_{k} - 1 </math>

donc, <math> d_{k+1} = d_k - 2 </math>

d'où <math> d_k = d_1 - 2 \left(k-1 \right) </math>

Alors pour <math> n \geq 1 , e_n = \sum_{k=1}^{n} d_k = n \cdot d_1 - 2 \cdot \sum_{k=0}^{n-1}k = n \cdot d_1 - 2 \cdot \frac{n(n-1)}{2} = n(d_1 - (n - 1)) </math>

Or <math> e_{a+b} = 0 = (a+b)(d_1 + (a + b - 1)), \text{d'où } d_1 = a + b - 1 </math>

Donc <math> E[T] = e_a = a(a + b - 1 - (a - 1)) = ab </math>

====Pour les autres probabilités====

On pose le réel l qui verifie <math> 0 = pl - ql </math> qui est donc <math> l = \frac{1}{q-p} </math>

La relation devient donc <math> 0 = p(d_{k+1} - l) - q(d_k - l) </math>

Par conséquent, <math> d_{k+1} - l = \frac{q}{p}(d_k - l) , \text{et donc } d_k - l = \left( \frac{q}{p} \right) ^{k-1} (d_1 - l) </math>

Donc pour <math> n \geq 1 </math>, on a :

<math> e_n = \sum_{k=1}^{n}d_k + e_0 = \sum_{k=1}^{n} \left( l + \left( \frac{q}{p} \right) ^{k-1} \cdot (d_1 - l) \right) = nl + (d_1 - l) \cdot \sum_{k=0}^{n-1}\left( \frac{q}{p} \right) ^{k} = nl + (d_1 - l) \cdot \frac{1 - \left( \frac{q}{p} \right) ^{n}}{1 - \frac{q}{p}}</math>

Or <math> e_{a+b} = 0 = (a+b)l + (d_1 - l) \cdot \frac{1 - \left( \frac{q}{p} \right) ^{a+b}}{1 - \frac{q}{p}} \text{par conséquent :} \frac{d_1 - l}{1 - \frac{q}{p}} = -\frac{(a+b)l}{1 - \left( \frac{q}{p} \right) ^{a+b} }</math>

Donc <math> E[T] = e_a = al - \left( 1 - \left( \frac{q}{p} \right)^{a} \right) \cdot \frac{(a+b)l}{1 - \left( \frac{q}{p} \right) ^{a+b}} = \frac{1}{q-p} \cdot \left( a - (a+b) \cdot \frac{1 - \left( \frac{q}{p} \right) ^{a} }{1 - \left( \frac{q}{p} \right) ^{a+b} } \right) = \frac{(a+b)p-a}{p-q} </math>

==Simulation d'une partie==

Afin de modéliser la ruine du joueur on peut utiliser ce programme python :

=== Bases du Programme ===

On commence par initialiser nos valeurs que l'on va utiliser :
<pre>
from random import random
from matplotlib import pyplot as plt

PROBABILITE = (18/37) #18/37 Pour la roulette
SOMME_DEPART = 10
GAIN_FIN = 5 # Le gain souhaité

#Faire varier Nombre de Parties

NOMBRE_PARTIES = 1000

</pre>

=== Simulation d'une soirée ===

On commence par simuler une soirée au casino :

<pre>
def simule_soiree(initial:int = SOMME_DEPART, fin:int= GAIN_FIN, prob:int= PROBABILITE) -> tuple:
""" Simule une soirée au casino """

tab = [initial]
somme = initial

while somme > 0 and somme < initial + fin:
aleatoire = random()
if aleatoire <= prob:
somme += 1
else:
somme -= 1
tab = tab + [somme]

if somme == initial + fin:
res = True
else:
res = False

return (tab, res)

</pre>

On peut afficher le résultat d'une soirée :

<pre>
# Permet d'afficher une partie jouée.

def affiche_graphe() -> None:
""" Affiche le graphe d'une soirée au casino """

y = simule_soiree()[0]
x = [[i] for i in range(len(y))]
plt.title("Graphe d'une soirée au casino")
plt.xlabel("Instant I")
plt.ylabel("Somme instant I")
plt.plot(x,y)
plt.show()

affiche_graphe()

</pre>

=== Verifications de nos estimations numériques ===

On peut implémenter nos estimations numériques :

<pre>
R = (1-PROBABILITE) / (PROBABILITE)

def calcule_proba_victoire_theorique() -> float:
"""Renvoie la probabilité de victoire théorique"""

if PROBABILITE == 0.5:
res = (SOMME_DEPART) / (SOMME_DEPART + GAIN_FIN)

else:
numerateur = R**(SOMME_DEPART) - 1
denumerateur = (R**(SOMME_DEPART + GAIN_FIN) - 1)
res = numerateur / denumerateur

return res

def calcule_duree_partie_theorique() -> float:
"""Renvoie la durée theorique d'une partie"""

if PROBABILITE == 0.5:
res = SOMME_DEPART * GAIN_FIN

else:
numerateur = (SOMME_DEPART + GAIN_FIN) * (1 - R**SOMME_DEPART)
denumerateur = 1 - R**(SOMME_DEPART + GAIN_FIN)

res = (1 / (2 * PROBABILITE - 1)) * ((numerateur / denumerateur) - SOMME_DEPART)

return res

</pre>

On va utiliser la méthode de comptage pour observer nos simulations :

<pre>
def calcule_nombre_victoire(tab_parties = SIMULATION_N_SOIREE) -> int:
""" Renvoie le nombre de victoires dans les soirées simulées"""
compteur = 0

for res_partie in tab_parties:
if res_partie[1] == True:
compteur = compteur + 1

return compteur

def calcule_proba_victoire(tab_parties = SIMULATION_N_SOIREE) -> float:
"""Renvoie la probabilité de victoire sur M soirées"""

nb_victoires = calcule_nombre_victoire(tab_parties)
res = nb_victoires/len(tab_parties)

return res

def calcule_duree_moyenne():
""" Renvoie la durée moyenne sur M soirées simulées"""
somme = 0
for partie in SIMULATION_N_SOIREE:
duree_partie = len(partie[0])
somme += duree_partie
res = somme / NOMBRE_PARTIES
return res

</pre>

On peut maintenant comparer nos résultats :
<pre>
Voici les valeurs theoriques :

La probabilité de victoire : 0.5812626435530369
La probabilité de defaite : 0.4187373564469631
Durée partie moyenne theorique : 1334.2610407391421

Voici les valeurs avec nos resultats :

La probabilité de victoire : 0.592
La probabilité de defaite : 0.408
Durée partie moyenne : 1358.222

</pre>

Modélisation de la ruine du joueur

2024-05-14T20:40:13Z

Akulas : Ajout partie Python

==Modélisation de la ruine du joueur==

Nous nous intéressons à l'étude des gains d'un joueur lors d'une soirée au casino, dans lequel le joueur joue à la roulette russe.

Le joueur commence avec une somme initiale comprise entre 0 et la somme souhaitée, le joueur s'arrête uniquement si :
- il obtient la somme souhaitée
- le joueur est ruiné (la somme est égale à 0)

Pour cela le joueur va jouer à la roulette en misant à chaque fois 1 jeton qu'il peut doubler ou perdre.

==Estimations numériques==

Nous allons prendre pour base le document suivant : [https://perso.eleves.ens-rennes.fr/people/florian.lemonnier/agregation/developpements/Ruine.pdf Ruine]

Notre objectif est de trouver de :

- calculer la probabilité de victoire, soit d'atteindre la somme souhaitée, en partant de la somme de départ.
- calculer la durée de la partie, soit le joueur arrête de jouer, donc il atteint l'une des conditions d'arrêt.

On définit de manière générale p la probabilité de victoire d'une partie et q = (1-p)

===Estimation de la probabilité de gagner===

On veut trouver une formule qui permet de trouver la probabilité de victoire lors d'une soirée au casino selon les paramètres de départs, soit la somme de départ et la somme voulue et la probabilité de victoire.

On commence avec la loi de probabilité totale :

<math> P_k(A) = P_k(A|Y_1 = 1)P_k(Y_1 = 1) + P_k(A|Y_1 = -1)P_k(Y_1 = -1) = P_{k+1}(A)p + P_{k-1}(A)q </math>

Ce qui donne le système suivant :

<math>
\begin{cases}
p_k = p \cdot p_{k+1} + q \cdot p_{k-1}, & \text{pour } 1 \leq k \leq a + b \\
p_0 = 0, \\
p_{a+b} = 1.
\end{cases}
</math>

'''On cherche l'équation quadratique : '''

On a l'équation : 
<math> p_k = p \cdot p_{k+1} + q \cdot p_{k-1} </math> 

On remplace <math> p_k </math> par <math> x^{k} </math> : 
<math> x^{k} = p \cdot x^{k+1} + q \cdot x^{k-1} </math> 

On divise par <math> x^{k-1} </math> : 
<math> x = p \cdot x^{2} + q </math> 

''' On résoult l'équation '''

<math> p \cdot x^{k+1} - x^{k} + q \cdot x^{k-1} = 0 </math>

====Pour p = 1/2 ====

Ca qui donne la solution unique : <math> x = 1 </math>

''' On en déduit les valeurs <math> \alpha \text{ et } \beta </math>''' :
<math>
\begin{cases}
0 = \alpha \\
1 = \alpha + \beta \cdot (a+b) \\
\end{cases}

\iff \begin{cases}
\alpha = 0 \\
\beta = \frac{a}{a+b} \\
\end{cases}
</math>

On a donc formule suivante : <math> p = \frac{a}{a+b} </math>

====Pour les autres probabilités====

Ce qui donne les solutions : <math> x_1 = 1 \text{ et } x_2 = \frac{q}{p} </math>

''' On a alors :'''

<math> p_k = \alpha \cdot x_1^{k} + \beta \cdot x_2^{k} </math> 
<math> \iff p_k = \alpha + \beta \cdot (\frac{q}{p})^{k} </math>

''' On en déduit les valeurs <math> \alpha \text{ et } \beta </math>''' :
<math>
\begin{cases}
0 = \alpha + \beta \\
1 = \alpha + \beta \cdot (\frac{q}{p})^{k} \\
\end{cases}

\iff \begin{cases}
\alpha = - \beta \\
1 = - \beta + \beta \cdot (\frac{q}{p})^{k} \\
\end{cases}

\iff \begin{cases}
\alpha = - \beta \\
1 = \beta \left(-1 + \left( \frac{q}{p} \right)^{a+b} \right) \\
\end{cases}

\iff \begin{cases}
\alpha = - \beta \\
\beta = \frac{1}{-1 + \left( \frac{q}{p} \right)^{a+b}} \\
\end{cases}
</math> 

On obtient :
<math>
\alpha = -\left(\frac{1}{-1 + \left( \frac{q}{p} \right)^{a+b}}\right)
\text{ et }
\beta = \frac{1}{-1 + \left( \frac{q}{p} \right)^{a+b}}
</math> 

D'où :
<math>
p_a = -\left(\frac{1}{-1 + \left( \frac{q}{p} \right)^{a+b}}\right)
+ \frac{\left( \frac{q}{p} \right)^{a}}{-1 + \left( \frac{q}{p} \right)^{a+b}}

\iff

p = \frac{\left( \frac{q}{p} \right)^{a} - 1}{\left( \frac{q}{p} \right)^{a+b} - 1}
</math>

On a donc formule suivante : <math> p = \frac{\left( \frac{q}{p} \right)^{a} - 1}{\left( \frac{q}{p} \right)^{a+b} - 1} </math>

===Estimation du temps moyen de jeu===

<math> E_k(T) =E_k(T|Y_1 = 1)P(Y_1 = 1) + E_k(A|Y_1 = -1)P(Y_1 = -1) = (1 + E_{k+1}(T))p + (1 + E_{k-1}(T))q </math>

Ce qui donne l'équation :

<math>
\begin{cases}
e_k = 1 + p \cdot e_{k+1} + q \cdot e_{k-1}, & \text{pour } 1 \leq k \leq a + b \\
e_0 = 0, \\
e_{a+b} = 0.
\end{cases}
</math>

On note, pour <math> k \geq 1 , d_k = e_k - e_{k-1} </math>

On a donc la relation de récurence : <math> 0 = 1 + p \cdot d_{k+1} - q \cdot d_k </math>

====Pour p = 1/2 ====

On a <math> \frac{1}{2} \cdot d_{k+1} = \frac{1}{2} \cdot d_{k} - 1 </math>

donc, <math> d_{k+1} = d_k - 2 </math>

d'où <math> d_k = d_1 - 2 \left(k-1 \right) </math>

Alors pour <math> n \geq 1 , e_n = \sum_{k=1}^{n} d_k = n \cdot d_1 - 2 \cdot \sum_{k=0}^{n-1}k = n \cdot d_1 - 2 \cdot \frac{n(n-1)}{2} = n(d_1 - (n - 1)) </math>

Or <math> e_{a+b} = 0 = (a+b)(d_1 + (a + b - 1)), \text{d'où } d_1 = a + b - 1 </math>

Donc <math> E[T] = e_a = a(a + b - 1 - (a - 1)) = ab </math>

====Pour les autres probabilités====

On pose le réel l qui verifie <math> 0 = pl - ql </math> qui est donc <math> l = \frac{1}{q-p} </math>

La relation devient donc <math> 0 = p(d_{k+1} - l) - q(d_k - l) </math>

Par conséquent, <math> d_{k+1} - l = \frac{q}{p}(d_k - l) , \text{et donc } d_k - l = \left( \frac{q}{p} \right) ^{k-1} (d_1 - l) </math>

Donc pour <math> n \geq 1 </math>, on a :

<math> e_n = \sum_{k=1}^{n}d_k + e_0 = \sum_{k=1}^{n} \left( l + \left( \frac{q}{p} \right) ^{k-1} \cdot (d_1 - l) \right) = nl + (d_1 - l) \cdot \sum_{k=0}^{n-1}\left( \frac{q}{p} \right) ^{k} = nl + (d_1 - l) \cdot \frac{1 - \left( \frac{q}{p} \right) ^{n}}{1 - \frac{q}{p}}</math>

Or <math> e_{a+b} = 0 = (a+b)l + (d_1 - l) \cdot \frac{1 - \left( \frac{q}{p} \right) ^{a+b}}{1 - \frac{q}{p}} \text{par conséquent :} \frac{d_1 - l}{1 - \frac{q}{p}} = -\frac{(a+b)l}{1 - \left( \frac{q}{p} \right) ^{a+b} }</math>

Donc <math> E[T] = e_a = al - \left( 1 - \left( \frac{q}{p} \right)^{a} \right) \cdot \frac{(a+b)l}{1 - \left( \frac{q}{p} \right) ^{a+b}} = \frac{1}{q-p} \cdot \left( a - (a+b) \cdot \frac{1 - \left( \frac{q}{p} \right) ^{a} }{1 - \left( \frac{q}{p} \right) ^{a+b} } \right) = \frac{(a+b)p-a}{p-q} </math>

==Simulation d'une partie==

Afin de modéliser la ruine du joueur on peut utiliser ce programme python :

=== Bases du Programme ===

On commence par initialiser nos valeurs que l'on va utiliser :
<pre>
from random import random
from matplotlib import pyplot as plt

PROBABILITE = (18/37) #18/37 Pour la roulette
SOMME_DEPART = 10
GAIN_FIN = 5 # Le gain souhaité

#Faire varier Nombre de Parties

NOMBRE_PARTIES = 1000

</pre>

=== Simulation d'une soirée ===

On commence par simuler une soirée au casino :

<pre>
def simule_soiree(initial:int = SOMME_DEPART, fin:int= GAIN_FIN, prob:int= PROBABILITE) -> tuple:
""" Simule une soirée au casino """

tab = [initial]
somme = initial

while somme > 0 and somme < initial + fin:
aleatoire = random()
if aleatoire <= prob:
somme += 1
else:
somme -= 1
tab = tab + [somme]

if somme == initial + fin:
res = True
else:
res = False

return (tab, res)

</pre>

On peut afficher le résultat d'une soirée :

<pre>
# Permet d'afficher une partie jouée.

def affiche_graphe() -> None:
""" Affiche le graphe d'une soirée au casino """

y = simule_soiree()[0]
x = [[i] for i in range(len(y))]
plt.title("Graphe d'une soirée au casino")
plt.xlabel("Instant I")
plt.ylabel("Somme instant I")
plt.plot(x,y)
plt.show()

affiche_graphe()

</pre>

=== Verifications de nos estimations numériques ===

On peut implémenter nos estimations numériques :

<pre>
R = (1-PROBABILITE) / (PROBABILITE)

def calcule_proba_victoire_theorique() -> float:
"""Renvoie la probabilité de victoire théorique"""

if PROBABILITE == 0.5:
res = (SOMME_DEPART) / (SOMME_DEPART + GAIN_FIN)

else:
numerateur = R**(SOMME_DEPART) - 1
denumerateur = (R**(SOMME_DEPART + GAIN_FIN) - 1)
res = numerateur / denumerateur

return res

def calcule_duree_partie_theorique() -> float:
"""Renvoie la durée theorique d'une partie"""

if PROBABILITE == 0.5:
res = SOMME_DEPART * GAIN_FIN

else:
numerateur = (SOMME_DEPART + GAIN_FIN) * (1 - R**SOMME_DEPART)
denumerateur = 1 - R**(SOMME_DEPART + GAIN_FIN)

res = (1 / (2 * PROBABILITE - 1)) * ((numerateur / denumerateur) - SOMME_DEPART)

return res

</pre>

On va utiliser la méthode de comptage pour observer nos simulations :

<pre>
def calcule_nombre_victoire(tab_parties = SIMULATION_N_SOIREE) -> int:
""" Renvoie le nombre de victoires dans les soirées simulées"""
compteur = 0

for res_partie in tab_parties:
if res_partie[1] == True:
compteur = compteur + 1

return compteur

def calcule_proba_victoire(tab_parties = SIMULATION_N_SOIREE) -> float:
"""Renvoie la probabilité de victoire sur M soirées"""

nb_victoires = calcule_nombre_victoire(tab_parties)
res = nb_victoires/len(tab_parties)

return res

def calcule_duree_moyenne():
""" Renvoie la durée moyenne sur M soirées simulées"""
somme = 0
for partie in SIMULATION_N_SOIREE:
duree_partie = len(partie[0])
somme += duree_partie
res = somme / NOMBRE_PARTIES
return res

</pre>

On peut maintenant comparer nos résultats :
<pre>
Voici les valeurs theoriques :

La probabilité de victoire : 0.5812626435530369
La probabilité de defaite : 0.4187373564469631
Durée partie moyenne theorique : 1334.2610407391421

Voici les valeurs avec nos resultats :

La probabilité de victoire : 0.592
La probabilité de defaite : 0.408
Durée partie moyenne : 1358.222

</pre>

Modélisation de la ruine du joueur

2024-05-14T20:36:25Z

Akulas : /* Simulation d'une partie */

==Modélisation de la ruine du joueur==

Nous nous intéressons à l'étude des gains d'un joueur lors d'une soirée au casino, dans lequel le joueur joue à la roulette russe.

Le joueur commence avec une somme initiale comprise entre 0 et la somme souhaitée, le joueur s'arrête uniquement si :
- il obtient la somme souhaitée
- le joueur est ruiné (la somme est égale à 0)

Pour cela le joueur va jouer à la roulette en misant à chaque fois 1 jeton qu'il peut doubler ou perdre.

==Estimations numériques==

Nous allons prendre pour base le document suivant : [https://perso.eleves.ens-rennes.fr/people/florian.lemonnier/agregation/developpements/Ruine.pdf Ruine]

Notre objectif est de trouver de :

- calculer la probabilité de victoire, soit d'atteindre la somme souhaitée, en partant de la somme de départ.
- calculer la durée de la partie, soit le joueur arrête de jouer, donc il atteint l'une des conditions d'arrêt.

On définit de manière générale p la probabilité de victoire d'une partie et q = (1-p)

===Estimation de la probabilité de gagner===

On veut trouver une formule qui permet de trouver la probabilité de victoire lors d'une soirée au casino selon les paramètres de départs, soit la somme de départ et la somme voulue et la probabilité de victoire.

On commence avec la loi de probabilité totale :

<math> P_k(A) = P_k(A|Y_1 = 1)P_k(Y_1 = 1) + P_k(A|Y_1 = -1)P_k(Y_1 = -1) = P_{k+1}(A)p + P_{k-1}(A)q </math>

Ce qui donne le système suivant :

<math>
\begin{cases}
p_k = p \cdot p_{k+1} + q \cdot p_{k-1}, & \text{pour } 1 \leq k \leq a + b \\
p_0 = 0, \\
p_{a+b} = 1.
\end{cases}
</math>

'''On cherche l'équation quadratique : '''

On a l'équation : 
<math> p_k = p \cdot p_{k+1} + q \cdot p_{k-1} </math> 

On remplace <math> p_k </math> par <math> x^{k} </math> : 
<math> x^{k} = p \cdot x^{k+1} + q \cdot x^{k-1} </math> 

On divise par <math> x^{k-1} </math> : 
<math> x = p \cdot x^{2} + q </math> 

''' On résoult l'équation '''

<math> p \cdot x^{k+1} - x^{k} + q \cdot x^{k-1} = 0 </math>

====Pour p = 1/2 ====

Ca qui donne la solution unique : <math> x = 1 </math>

''' On en déduit les valeurs <math> \alpha \text{ et } \beta </math>''' :
<math>
\begin{cases}
0 = \alpha \\
1 = \alpha + \beta \cdot (a+b) \\
\end{cases}

\iff \begin{cases}
\alpha = 0 \\
\beta = \frac{a}{a+b} \\
\end{cases}
</math>

On a donc formule suivante : <math> p = \frac{a}{a+b} </math>

====Pour les autres probabilités====

Ce qui donne les solutions : <math> x_1 = 1 \text{ et } x_2 = \frac{q}{p} </math>

''' On a alors :'''

<math> p_k = \alpha \cdot x_1^{k} + \beta \cdot x_2^{k} </math> 
<math> \iff p_k = \alpha + \beta \cdot (\frac{q}{p})^{k} </math>

''' On en déduit les valeurs <math> \alpha \text{ et } \beta </math>''' :
<math>
\begin{cases}
0 = \alpha + \beta \\
1 = \alpha + \beta \cdot (\frac{q}{p})^{k} \\
\end{cases}

\iff \begin{cases}
\alpha = - \beta \\
1 = - \beta + \beta \cdot (\frac{q}{p})^{k} \\
\end{cases}

\iff \begin{cases}
\alpha = - \beta \\
1 = \beta \left(-1 + \left( \frac{q}{p} \right)^{a+b} \right) \\
\end{cases}

\iff \begin{cases}
\alpha = - \beta \\
\beta = \frac{1}{-1 + \left( \frac{q}{p} \right)^{a+b}} \\
\end{cases}
</math> 

On obtient :
<math>
\alpha = -\left(\frac{1}{-1 + \left( \frac{q}{p} \right)^{a+b}}\right)
\text{ et }
\beta = \frac{1}{-1 + \left( \frac{q}{p} \right)^{a+b}}
</math> 

D'où :
<math>
p_a = -\left(\frac{1}{-1 + \left( \frac{q}{p} \right)^{a+b}}\right)
+ \frac{\left( \frac{q}{p} \right)^{a}}{-1 + \left( \frac{q}{p} \right)^{a+b}}

\iff

p = \frac{\left( \frac{q}{p} \right)^{a} - 1}{\left( \frac{q}{p} \right)^{a+b} - 1}
</math>

On a donc formule suivante : <math> p = \frac{\left( \frac{q}{p} \right)^{a} - 1}{\left( \frac{q}{p} \right)^{a+b} - 1} </math>

===Estimation du temps moyen de jeu===

<math> E_k(T) =E_k(T|Y_1 = 1)P(Y_1 = 1) + E_k(A|Y_1 = -1)P(Y_1 = -1) = (1 + E_{k+1}(T))p + (1 + E_{k-1}(T))q </math>

Ce qui donne l'équation :

<math>
\begin{cases}
e_k = 1 + p \cdot e_{k+1} + q \cdot e_{k-1}, & \text{pour } 1 \leq k \leq a + b \\
e_0 = 0, \\
e_{a+b} = 0.
\end{cases}
</math>

On note, pour <math> k \geq 1 , d_k = e_k - e_{k-1} </math>

On a donc la relation de récurence : <math> 0 = 1 + p \cdot d_{k+1} - q \cdot d_k </math>

====Pour p = 1/2 ====

On a <math> \frac{1}{2} \cdot d_{k+1} = \frac{1}{2} \cdot d_{k} - 1 </math>

donc, <math> d_{k+1} = d_k - 2 </math>

d'où <math> d_k = d_1 - 2 \left(k-1 \right) </math>

Alors pour <math> n \geq 1 , e_n = \sum_{k=1}^{n} d_k = n \cdot d_1 - 2 \cdot \sum_{k=0}^{n-1}k = n \cdot d_1 - 2 \cdot \frac{n(n-1)}{2} = n(d_1 - (n - 1)) </math>

Or <math> e_{a+b} = 0 = (a+b)(d_1 + (a + b - 1)), \text{d'où } d_1 = a + b - 1 </math>

Donc <math> E[T] = e_a = a(a + b - 1 - (a - 1)) = ab </math>

====Pour les autres probabilités====

On pose le réel l qui verifie <math> 0 = pl - ql </math> qui est donc <math> l = \frac{1}{q-p} </math>

La relation devient donc <math> 0 = p(d_{k+1} - l) - q(d_k - l) </math>

Par conséquent, <math> d_{k+1} - l = \frac{q}{p}(d_k - l) , \text{et donc } d_k - l = \left( \frac{q}{p} \right) ^{k-1} (d_1 - l) </math>

Donc pour <math> n \geq 1 </math>, on a :

<math> e_n = \sum_{k=1}^{n}d_k + e_0 = \sum_{k=1}^{n} \left( l + \left( \frac{q}{p} \right) ^{k-1} \cdot (d_1 - l) \right) = nl + (d_1 - l) \cdot \sum_{k=0}^{n-1}\left( \frac{q}{p} \right) ^{k} = nl + (d_1 - l) \cdot \frac{1 - \left( \frac{q}{p} \right) ^{n}}{1 - \frac{q}{p}}</math>

Or <math> e_{a+b} = 0 = (a+b)l + (d_1 - l) \cdot \frac{1 - \left( \frac{q}{p} \right) ^{a+b}}{1 - \frac{q}{p}} \text{par conséquent :} \frac{d_1 - l}{1 - \frac{q}{p}} = -\frac{(a+b)l}{1 - \left( \frac{q}{p} \right) ^{a+b} }</math>

Donc <math> E[T] = e_a = al - \left( 1 - \left( \frac{q}{p} \right)^{a} \right) \cdot \frac{(a+b)l}{1 - \left( \frac{q}{p} \right) ^{a+b}} = \frac{1}{q-p} \cdot \left( a - (a+b) \cdot \frac{1 - \left( \frac{q}{p} \right) ^{a} }{1 - \left( \frac{q}{p} \right) ^{a+b} } \right) = \frac{(a+b)p-a}{p-q} </math>

==Simulation d'une partie==

Afin de modéliser la ruine du joueur on peut utiliser ce programme python :

On commence par initialiser nos valeurs que l'on va utiliser :
<pre>

from random import random
from matplotlib import pyplot as plt

PROBABILITE = (18/37) #18/37 Pour la roulette
SOMME_DEPART = 10
GAIN_FIN = 5

#Faire varier Nombre de Parties

NOMBRE_PARTIES = 1000

</pre>

On commence par simuler une soirée au casino :

<pre>

def simule_soiree(initial:int = SOMME_DEPART, fin:int= GAIN_FIN, prob:int= PROBABILITE) -> tuple:
""" Simule une soirée au casino """

tab = [initial]
somme = initial

while somme > 0 and somme < initial + fin:
aleatoire = random()
if aleatoire <= prob:
somme += 1
else:
somme -= 1
tab = tab + [somme]

if somme == initial + fin:
res = True
else:
res = False

return (tab, res)

</pre>

On peut afficher le résultat d'une soirée :

<pre>

# Permet d'afficher une partie jouée.

def affiche_graphe() -> None:
""" Affiche le graphe d'une soirée au casino """

y = simule_soiree()[0]
x = [[i] for i in range(len(y))]
plt.title("Graphe d'une soirée au casino")
plt.xlabel("Instant I")
plt.ylabel("Somme instant I")
plt.plot(x,y)
plt.show()

affiche_graphe()

</pre>

On peut implémenter nos estimations numériques :

<pre>

R = (1-PROBABILITE) / (PROBABILITE)

def calcule_proba_victoire_theorique() -> float:
"""Renvoie la probabilité de victoire théorique"""

if PROBABILITE == 0.5:
res = (SOMME_DEPART) / (SOMME_DEPART + GAIN_FIN)

else:
numerateur = R**(SOMME_DEPART) - 1
denumerateur = (R**(SOMME_DEPART + GAIN_FIN) - 1)
res = numerateur / denumerateur

return res

def calcule_duree_partie_theorique() -> float:
"""Renvoie la durée theorique d'une partie"""

if PROBABILITE == 0.5:
res = SOMME_DEPART * GAIN_FIN

else:
numerateur = (SOMME_DEPART + GAIN_FIN) * (1 - R**SOMME_DEPART)
denumerateur = 1 - R**(SOMME_DEPART + GAIN_FIN)

res = (1 / (2 * PROBABILITE - 1)) * ((numerateur / denumerateur) - SOMME_DEPART)

return res

</pre>

On va utiliser la méthode de comptage pour observer nos simulations :

<pre>

def calcule_nombre_victoire(tab_parties = SIMULATION_N_SOIREE) -> int:
""" Renvoie le nombre de victoires dans les soirées simulées"""
compteur = 0

for res_partie in tab_parties:
if res_partie[1] == True:
compteur = compteur + 1

return compteur

def calcule_proba_victoire(tab_parties = SIMULATION_N_SOIREE) -> float:
"""Renvoie la probabilité de victoire sur M soirées"""

nb_victoires = calcule_nombre_victoire(tab_parties)
res = nb_victoires/len(tab_parties)

return res

def calcule_duree_moyenne():
""" Renvoie la durée moyenne sur M soirées simulées"""
somme = 0
for partie in SIMULATION_N_SOIREE:
duree_partie = len(partie[0])
somme += duree_partie
res = somme / NOMBRE_PARTIES
return res

</pre>

On peut maintenant comparer nos résultats :

<pre>

Voici les valeurs theoriques :

La probabilité de victoire : 0.5812626435530369
La probabilité de defaite : 0.4187373564469631
Durée partie moyenne theorique : 1334.2610407391421

Voici les valeurs avec nos resultats :

La probabilité de victoire : 0.592
La probabilité de defaite : 0.408
Durée partie moyenne : 1358.222

</pre>

Modélisation de la ruine du joueur

2024-05-14T20:21:59Z

Akulas : /* Simulation d'une partie */

==Modélisation de la ruine du joueur==

Nous nous intéressons à l'étude des gains d'un joueur lors d'une soirée au casino, dans lequel le joueur joue à la roulette russe.

Le joueur commence avec une somme initiale comprise entre 0 et la somme souhaitée, le joueur s'arrête uniquement si :
- il obtient la somme souhaitée
- le joueur est ruiné (la somme est égale à 0)

Pour cela le joueur va jouer à la roulette en misant à chaque fois 1 jeton qu'il peut doubler ou perdre.

==Estimations numériques==

Nous allons prendre pour base le document suivant : [https://perso.eleves.ens-rennes.fr/people/florian.lemonnier/agregation/developpements/Ruine.pdf Ruine]

Notre objectif est de trouver de :

- calculer la probabilité de victoire, soit d'atteindre la somme souhaitée, en partant de la somme de départ.
- calculer la durée de la partie, soit le joueur arrête de jouer, donc il atteint l'une des conditions d'arrêt.

On définit de manière générale p la probabilité de victoire d'une partie et q = (1-p)

===Estimation de la probabilité de gagner===

On veut trouver une formule qui permet de trouver la probabilité de victoire lors d'une soirée au casino selon les paramètres de départs, soit la somme de départ et la somme voulue et la probabilité de victoire.

On commence avec la loi de probabilité totale :

<math> P_k(A) = P_k(A|Y_1 = 1)P_k(Y_1 = 1) + P_k(A|Y_1 = -1)P_k(Y_1 = -1) = P_{k+1}(A)p + P_{k-1}(A)q </math>

Ce qui donne le système suivant :

<math>
\begin{cases}
p_k = p \cdot p_{k+1} + q \cdot p_{k-1}, & \text{pour } 1 \leq k \leq a + b \\
p_0 = 0, \\
p_{a+b} = 1.
\end{cases}
</math>

'''On cherche l'équation quadratique : '''

On a l'équation : 
<math> p_k = p \cdot p_{k+1} + q \cdot p_{k-1} </math> 

On remplace <math> p_k </math> par <math> x^{k} </math> : 
<math> x^{k} = p \cdot x^{k+1} + q \cdot x^{k-1} </math> 

On divise par <math> x^{k-1} </math> : 
<math> x = p \cdot x^{2} + q </math> 

''' On résoult l'équation '''

<math> p \cdot x^{k+1} - x^{k} + q \cdot x^{k-1} = 0 </math>

====Pour p = 1/2 ====

Ca qui donne la solution unique : <math> x = 1 </math>

''' On en déduit les valeurs <math> \alpha \text{ et } \beta </math>''' :
<math>
\begin{cases}
0 = \alpha \\
1 = \alpha + \beta \cdot (a+b) \\
\end{cases}

\iff \begin{cases}
\alpha = 0 \\
\beta = \frac{a}{a+b} \\
\end{cases}
</math>

On a donc formule suivante : <math> p = \frac{a}{a+b} </math>

====Pour les autres probabilités====

Ce qui donne les solutions : <math> x_1 = 1 \text{ et } x_2 = \frac{q}{p} </math>

''' On a alors :'''

<math> p_k = \alpha \cdot x_1^{k} + \beta \cdot x_2^{k} </math> 
<math> \iff p_k = \alpha + \beta \cdot (\frac{q}{p})^{k} </math>

''' On en déduit les valeurs <math> \alpha \text{ et } \beta </math>''' :
<math>
\begin{cases}
0 = \alpha + \beta \\
1 = \alpha + \beta \cdot (\frac{q}{p})^{k} \\
\end{cases}

\iff \begin{cases}
\alpha = - \beta \\
1 = - \beta + \beta \cdot (\frac{q}{p})^{k} \\
\end{cases}

\iff \begin{cases}
\alpha = - \beta \\
1 = \beta \left(-1 + \left( \frac{q}{p} \right)^{a+b} \right) \\
\end{cases}

\iff \begin{cases}
\alpha = - \beta \\
\beta = \frac{1}{-1 + \left( \frac{q}{p} \right)^{a+b}} \\
\end{cases}
</math> 

On obtient :
<math>
\alpha = -\left(\frac{1}{-1 + \left( \frac{q}{p} \right)^{a+b}}\right)
\text{ et }
\beta = \frac{1}{-1 + \left( \frac{q}{p} \right)^{a+b}}
</math> 

D'où :
<math>
p_a = -\left(\frac{1}{-1 + \left( \frac{q}{p} \right)^{a+b}}\right)
+ \frac{\left( \frac{q}{p} \right)^{a}}{-1 + \left( \frac{q}{p} \right)^{a+b}}

\iff

p = \frac{\left( \frac{q}{p} \right)^{a} - 1}{\left( \frac{q}{p} \right)^{a+b} - 1}
</math>

On a donc formule suivante : <math> p = \frac{\left( \frac{q}{p} \right)^{a} - 1}{\left( \frac{q}{p} \right)^{a+b} - 1} </math>

===Estimation du temps moyen de jeu===

<math> E_k(T) =E_k(T|Y_1 = 1)P(Y_1 = 1) + E_k(A|Y_1 = -1)P(Y_1 = -1) = (1 + E_{k+1}(T))p + (1 + E_{k-1}(T))q </math>

Ce qui donne l'équation :

<math>
\begin{cases}
e_k = 1 + p \cdot e_{k+1} + q \cdot e_{k-1}, & \text{pour } 1 \leq k \leq a + b \\
e_0 = 0, \\
e_{a+b} = 0.
\end{cases}
</math>

On note, pour <math> k \geq 1 , d_k = e_k - e_{k-1} </math>

On a donc la relation de récurence : <math> 0 = 1 + p \cdot d_{k+1} - q \cdot d_k </math>

====Pour p = 1/2 ====

On a <math> \frac{1}{2} \cdot d_{k+1} = \frac{1}{2} \cdot d_{k} - 1 </math>

donc, <math> d_{k+1} = d_k - 2 </math>

d'où <math> d_k = d_1 - 2 \left(k-1 \right) </math>

Alors pour <math> n \geq 1 , e_n = \sum_{k=1}^{n} d_k = n \cdot d_1 - 2 \cdot \sum_{k=0}^{n-1}k = n \cdot d_1 - 2 \cdot \frac{n(n-1)}{2} = n(d_1 - (n - 1)) </math>

Or <math> e_{a+b} = 0 = (a+b)(d_1 + (a + b - 1)), \text{d'où } d_1 = a + b - 1 </math>

Donc <math> E[T] = e_a = a(a + b - 1 - (a - 1)) = ab </math>

====Pour les autres probabilités====

On pose le réel l qui verifie <math> 0 = pl - ql </math> qui est donc <math> l = \frac{1}{q-p} </math>

La relation devient donc <math> 0 = p(d_{k+1} - l) - q(d_k - l) </math>

Par conséquent, <math> d_{k+1} - l = \frac{q}{p}(d_k - l) , \text{et donc } d_k - l = \left( \frac{q}{p} \right) ^{k-1} (d_1 - l) </math>

Donc pour <math> n \geq 1 </math>, on a :

<math> e_n = \sum_{k=1}^{n}d_k + e_0 = \sum_{k=1}^{n} \left( l + \left( \frac{q}{p} \right) ^{k-1} \cdot (d_1 - l) \right) = nl + (d_1 - l) \cdot \sum_{k=0}^{n-1}\left( \frac{q}{p} \right) ^{k} = nl + (d_1 - l) \cdot \frac{1 - \left( \frac{q}{p} \right) ^{n}}{1 - \frac{q}{p}}</math>

Or <math> e_{a+b} = 0 = (a+b)l + (d_1 - l) \cdot \frac{1 - \left( \frac{q}{p} \right) ^{a+b}}{1 - \frac{q}{p}} \text{par conséquent :} \frac{d_1 - l}{1 - \frac{q}{p}} = -\frac{(a+b)l}{1 - \left( \frac{q}{p} \right) ^{a+b} }</math>

Donc <math> E[T] = e_a = al - \left( 1 - \left( \frac{q}{p} \right)^{a} \right) \cdot \frac{(a+b)l}{1 - \left( \frac{q}{p} \right) ^{a+b}} = \frac{1}{q-p} \cdot \left( a - (a+b) \cdot \frac{1 - \left( \frac{q}{p} \right) ^{a} }{1 - \left( \frac{q}{p} \right) ^{a+b} } \right) = \frac{(a+b)p-a}{p-q} </math>

==Simulation d'une partie==

Afin de modéliser la ruine du joueur on peut utiliser ce programme python :

<pre>

from random import random
from matplotlib import pyplot as plt

PROBABILITE = (18/37) #18/37 Pour la roulette
SOMME_DEPART = 10
GAIN_FIN = 5

#Faire varier Nombre de Parties

NOMBRE_PARTIES = 1000

def simule_soiree(initial:int = SOMME_DEPART, fin:int= GAIN_FIN, prob:int= PROBABILITE) -> tuple:
""" Simule une soirée au casino """

tab = [initial]
somme = initial

while somme > 0 and somme < initial + fin:
aleatoire = random()
if aleatoire <= prob:
somme += 1
else:
somme -= 1
tab = tab + [somme]

if somme == initial + fin:
res = True
else:
res = False

return (tab, res)

def simule_nombre_parties(n:int = NOMBRE_PARTIES) -> list:
"""Renvoie un tableau de longueur n avec le resultat de chaque partie"""
res = []
for i in range(n):
res = res + [simule_soiree()]
return res

# Permet d'afficher une partie jouée.

def affiche_graphe() -> None:
""" Affiche le graphe d'une soirée au casino """

y = simule_soiree()[0]
x = [[i] for i in range(len(y))]
plt.title("Graphe d'une soirée au casino")
plt.xlabel("Instant I")
plt.ylabel("Somme instant I")
plt.plot(x,y)
plt.show()

affiche_graphe()

R = (1-PROBABILITE) / (PROBABILITE)

def calcule_proba_defaite_theorique() -> float:
"""Renvoie la probabilité de defaite théorique"""

if PROBABILITE == 0.5:
res = (GAIN_FIN) / (SOMME_DEPART + GAIN_FIN)

else:
numerateur = (R**(SOMME_DEPART + GAIN_FIN) - R**(SOMME_DEPART))
denumerateur = (R**(SOMME_DEPART + GAIN_FIN) - 1)
res = numerateur / denumerateur

return res

def calcule_proba_victoire_theorique() -> float:
"""Renvoie la probabilité de victoire théorique"""

if PROBABILITE == 0.5:
res = (SOMME_DEPART) / (SOMME_DEPART + GAIN_FIN)

else:
numerateur = R**(SOMME_DEPART) - 1
denumerateur = (R**(SOMME_DEPART + GAIN_FIN) - 1)
res = numerateur / denumerateur

return res

def calcule_duree_partie_theorique() -> float:
"""Renvoie la durée theorique d'une partie"""

if PROBABILITE == 0.5:
res = SOMME_DEPART * GAIN_FIN

else:
numerateur = (SOMME_DEPART + GAIN_FIN) * (1 - R**SOMME_DEPART)
denumerateur = 1 - R**(SOMME_DEPART + GAIN_FIN)

res = (1 / (2 * PROBABILITE - 1)) * ((numerateur / denumerateur) - SOMME_DEPART)

return res

def calcule_nombre_victoire(tab_parties = SIMULATION_N_SOIREE) -> int:
""" Renvoie le nombre de victoires dans les parties jouées"""
compteur = 0

for res_partie in tab_parties:
if res_partie[1] == True:
compteur = compteur + 1

return compteur

def calcule_proba_victoire(tab_parties = SIMULATION_N_SOIREE) -> float:
"""Renvoie la probabilité de victoire sur M parties"""

nb_victoires = calcule_nombre_victoire(tab_parties)
res = nb_victoires/len(tab_parties)

return res

def calcule_proba_defaite(tab_parties = SIMULATION_N_SOIREE) -> float:
"""Renvoie la probabilité de défaite sur M parties"""
res = (NOMBRE_PARTIES - calcule_nombre_victoire(tab_parties)) / len(tab_parties)
return res

def calcule_duree_moyenne():
somme = 0
for partie in SIMULATION_N_SOIREE:
duree_partie = len(partie[0])
somme += duree_partie
res = somme / NOMBRE_PARTIES
return res

Voici les valeurs theoriques :

La probabilité de victoire : 0.5812626435530369
La probabilité de defaite : 0.4187373564469631
Durée partie moyenne theorique : 1334.2610407391421
Voici les valeurs avec nos resultats :

La probabilité de victoire : 0.592
La probabilité de defaite : 0.408
Durée partie moyenne : 1358.222

TAB_NB_PARTIES = [1, 5, 10 ,20, 50, 100, 200, 500]

def simule_proba_selon_n(nb_partie = TAB_NB_PARTIES):
res = []
for n in nb_partie :
tab = simule_nombre_parties(n)
proba_victoire = calcule_proba_victoire(tab)
res += [proba_victoire]
return res

def affiche_proba_nb_partie (parties: list):
tab = []
for ele in parties:
print(ele)
tab = tab + [ele]

vict_theorique = calcule_proba_victoire_theorique()
theorique_depart = [vict_theorique] * len(tab)

x = [[i] for i in range(len(tab))]
plt.title("Graphe d'une soirée au casino")
plt.xlabel("N Parties")
plt.ylabel("Proba victoire sur N parties")

plt.plot(x,theorique_depart)
plt.plot(x,tab)
default_x_ticks = range(len(x))
plt.xticks(default_x_ticks, TAB_NB_PARTIES)
plt.show()

proba_selon_n = simule_proba_selon_n()
affiche_proba_nb_partie(proba_selon_n)

</pre>

Modélisation de la ruine du joueur

2024-05-14T20:03:01Z

Akulas : /* Estimations numériques */

Modélisation de la ruine du joueur

2024-05-14T19:59:02Z

Akulas : Fin Estimation Durée

Modélisation de la ruine du joueur

2024-05-13T21:17:11Z

Akulas : Debut estimation temps moyen

Modélisation de la ruine du joueur

2024-05-13T21:07:20Z

Akulas : Ajout proba 1/2

Modélisation de la ruine du joueur

2024-05-13T20:43:44Z

Akulas :

Modélisation de la ruine du joueur

2024-05-08T19:26:45Z

Akulas : /* Estimation de la probabilité de gagner */

Modélisation de la ruine du joueur

2024-05-08T19:24:29Z

Akulas : Estimation probabilité Victoire

Utilisateur:Akulas

2024-04-26T21:10:01Z

Akulas :

==Modélisation de la ruine du joueur==

Nous nous intéressons à l'étude des gains d'un joueur lors d'une soirée au casino, dans lequel le joueur joue à la roulette russe.

Le joueur commence avec une somme initiale comprise entre 0 et la somme souhaitée, le joueur s'arrête uniquement si :
- il obtient la somme souhaitée
- le joueur est ruiné (la somme est égale à 0)

Pour cela le joueur va jouer à la roulette en misant à chaque fois 1 jeton qu'il peut doubler ou perdre.

==Estimations numériques==

Notre objectif est de trouver de :

- calculer la probabilité de victoire, soit d'atteindre la somme souhaitée, en partant de la somme de départ.
- calculer la durée de la partie, soit le joueur arrête de jouer, donc il atteint l'une des conditions d'arrêt.

==Simulation d'une partie==

Afin de modéliser la ruine du joueur on peut utiliser ce programme python :

...

==Estimation de la probabilité de gagner==

...

==Estimation du temps moyen de jeu==

...

Utilisateur:Akulas

2024-04-26T21:09:51Z

Akulas : Page blanchie

Modélisation de la ruine du joueur

2024-04-26T21:09:43Z

Akulas : Redirection supprimée vers Modélisation de la ruine du joueur 2020-2021

Utilisateur:Akulas

2024-04-26T21:04:08Z

Akulas : Page créée avec « ==Modélisation de la ruine du joueur== Nous nous intéressons à l'étude des gains d'un joueur lors d'une soirée au casino, dans lequel le joueur joue à la roulette russe. Le joueur commence avec une somme initiale comprise entre 0 et la somme souhaitée, le joueur s'arrête uniquement si : - il obtient la somme souhaitée - le joueur est ruiné (la somme est égale à 0) Pour cela le joueur va jouer à la roulette en misa... »

Modélisation de la ruine du joueur

2024-04-26T20:30:49Z

Akulas : Akulas a déplacé la page Modélisation de la ruine du joueur vers Modélisation de la ruine du joueur 2020-2021 : Projet réaliser par un ancien élève en 2020-2021

#REDIRECTION [[Modélisation de la ruine du joueur 2020-2021]]

Modélisation de la ruine du joueur 2020-2021

2024-04-26T20:30:48Z

Akulas : Akulas a déplacé la page Modélisation de la ruine du joueur vers Modélisation de la ruine du joueur 2020-2021 : Projet réaliser par un ancien élève en 2020-2021

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

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

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

===Règles de la roulette===

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

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

Le joueur arrive avec une richesse initiale notée <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)