salut , ca sent les chaînes de Markov

L'énoncé est vraiment mal écrit.
Chaque participant  doit donner une boule à un autre participant de son choix , doit donner une boule à un autre participant pris au hasard avec  les probabilités . . .

Salut Verdurin, je pensais que ma phrase était suffisamment compréhensible..
(pas de chaîne de Markov ici nullptr19)

bonjourFlight
merci pour l'exercice
si j'ai bie n lu

 Cliquez pour afficher

X_A prend les valeurs 0,1,2 avec les probabilités  1/21,12/21,8//21

Bonjour,

Que se passe-t-il si un joueur n'a plus de boules ?

salut Veleda , bravo ce sont bien les bonnes réponses , GBZM , si un joueur n'a plus de boules le jeu s'arrete

Il y a une interversion dans la réponse de veleda.

flight, es-tu sûr que ton calcul tient compte du fait que le jeu peut s'arrêter avant k parties ?

effectivement GBZM , il aurait fallu glisser une question du genre" démontrer que le nombre de boules possédées par A au cours du jeu n'est jamais nul et calculer son espérance...

Sauf que A peut très bien se retrouver avec 0 boule au bout de 5 parties ...

On se trouve donc bien finalement avec une chaîne de Markov avec 348 états, dont 72 états absorbants.
Presque sûrement, le jeu se termine avec la ruine d'un des joueurs A, B, C.
On peut se demander : quelle est la probabilité que ce soit A, B ou C ?

j'ai moi même conçu le problème , mais j'en ai pas analysé tout les aspects ,..

pour répondre à ta question j'ai calculé les espérances de gain pour chaque joueur , c'est à dire pour chaque partie le nombre moyen de boules reçues par chacun des joueurs.
pour A : E(nombre de boules reçues)= 1,523 boules par partie
pour B : E(nombre de boules reçues)= 1,166 boules par partie
pour C : E(nombre de boules reçues)= 0,309 boules par partie
intuitivement on peut voir que c'est le joueur "C" qui va se ruiner plus rapidement  
si Na est le nombre de boule que A possède à la fin de la partie k alors  
E(Na) = 5 - k (puisqu'à la partie k il a cédé k boules) + 1,523.k (ce qu'il reçoit en moyenne au bout de k parties) soit E(Na) = 5 + 0,523k
E(Nb) = 12 - k + 1,166.k = 12  + 0,166.k
E(Nc)= 8 - k +  0,309k =  8 - 0,69.k  ( on voit ici que plus le nombre de parties augmente plus C se ruine)

ce vaut ce que ca vaut ...c'est juste une idée grossière

Ça me paraît trop simpliste, et erroné, comme analyse.

Bonsoir,

La preuve que c'est erroné : pour k suffisamment grand E(Na) dépasse 25 et E(Nc) devient négatif.

Si on suit le formalisme des chaînes de Markov avec états absorbants, on trouve que l'espérance du nombre de boules à la fin du jeu (par ruine d'un des joueurs) est :
pour A, environ 11,07 boules
pour B, environ 13,93 boules
pour C, de l'ordre de 3 x 10^(-5).

Tant qu'on y est on a pour le même prix la loi du nombre de boules de A à la fin du jeu :

Probabilité qu'à la fin du jeu A ait
 0 boules :  0.00039%
 1 boules :  0.00003%
 2 boules :  0.00035%
 3 boules :  0.00287%
 4 boules :  0.01956%
 5 boules :  0.11264%
 6 boules :  0.52844%
 7 boules :  1.94693%
 8 boules :  5.49071%
 9 boules : 11.66790%
10 boules : 18.48267%
11 boules : 21.64005%
12 boules : 18.64870%
13 boules : 11.93887%
14 boules :  5.89724%
15 boules :  2.39860%
16 boules :  0.84651%
17 boules :  0.26901%
18 boules :  0.07900%
19 boules :  0.02183%
20 boules :  0.00576%
21 boules :  0.00146%
22 boules :  0.00036%
23 boules :  0.00009%
24 boules :  0.00002%

Bon Dimanche,

Plus personne ne semble s'intéresser à cette question, à commencer par flight.

Il est vrai qu'une fois les choses mises d'aplomb, on quitte le domaine "détente" pour entrer dans le terne domaine mathématique : le problème est un exemple d'application de la théorie des chaînes de Markov absorbantes. On peut trouver cette théorie exposée ici : . Je suivrai les notations de cette référence.
Le plus pénible est d'écrire la matrice de transition P de la chaîne de Markov, c.-à-d. d'écrire les matrices Q et R dans   (comme dans la référence).

On généralise un peu : on travaille avec n boules au total. Un état est repéré par le couple (a,b,c) où a est le nombre de boules de A et b celui de B (celui de C est n-a-b).
Les états non absorbants sont les (i+1,j+1) où . Il y en a (n-2)(n-1)/2, et on les code par les entiers de 0 à ((n-2)(n-1)/2)-1 au moyen de la procédure code(i,j) donnée ci-dessous.
Les états absorbants (ceux dont on ne sort pas) sont les (0,j+1) pour , les (i+1,0) pour et les (i+1,n-1-i) pour .
On écrit la matrice de transition P en fonction des probabilités qu'un joueur donne une boule à un autre joueur : pAB est la probabilité que A donne une boule à B (et 1-pAB celle qu'il la donne à C), etc.
Un fois ceci fait, on calcule et qui donne les informations voulues, par exemple la loi du nombre de boules de A à la fin du jeu en fonction de l'état de départ.

Voici les procédures Python qui font ça :

import numpy as np

def code(i,j) :
    return ((i+j)*(i+j+1))//2 +j

def FinJeu(n,pAB,pBC,pCA) :
    l=(n-1)*(n-2)//2 ; c=3*(n-1)
    Q=np.zeros((l,l))
    R=np.zeros((l,c))
    I=np.identity(l)
    for i in range(n-2):
        for j in range(n-2-i):
            Q[code(i,j),code(i,j)]=pAB*pBC*pCA+(1-pAB)*(1-pBC)*(1-pCA)
    for j in range(n-2):
        R[code(0,j),j]=(1-pAB)*pBC*(1-pCA)
        R[code(0,j),j+1]=pAB*pBC*(1-pCA)
        for i in range(1,n-2-j):
            Q[code(i,j),code(i-1,j)]=(1-pAB)*pBC*(1-pCA)
            Q[code(i,j),code(i-1,j+1)]=pAB*pBC*(1-pCA)
    for i in range(n-2):
        R[code(i,0),n-1+i]=(1-pAB)*pBC*pCA
        R[code(i,0),n+i]=(1-pAB)*(1-pBC)*pCA
        for j in range(1,n-2-i):
            Q[code(i,j),code(i,j-1)]=(1-pAB)*pBC*pCA
            Q[code(i,j),code(i+1,j-1)]=(1-pAB)*(1-pBC)*pCA
    for i in range(n-2):
        R[code(i,n-3-i),2*(n-1)+i]=pAB*(1-pBC)*(1-pCA)
        R[code(i,n-3-i),2*n-1+i]=pAB*(1-pBC)*pCA
        for j in range(n-3-i):
            Q[code(i,j),code(i,j+1)]=pAB*(1-pBC)*(1-pCA)
            Q[code(i,j),code(i+1,j)]=pAB*(1-pBC)*pCA
    N=np.linalg.inv(I-Q)
    return N@R

def LoiA(n,pAB,pBC,pCA,a,b):
    F=FinJeu(n,pAB,pBC,pCA)
    probas=F[code(a-1,b-1)]
    loiA=[sum(probas[0:n-1])]
    for i in range(n-1) :
        loiA.append(probas[n-1+i]+probas[2*(n-1)+i])
    return loiA

def DonneLoiA(n,pAB,pBC,pCA,a,b) :
    L=LoiA(n,pAB,pBC,pCA,a,b)
    print("{0} boules, au départ {1} à A, {2} à B, {3} à C"
          .format(n,a,b,n-a-b))
    print("Proba qu'a chaque tour\n\
    A donne à B : {0:>9.5%}\n\
    B donne à C : {1:>9.5%}\n\
    C donne à A : {2:>9.5%}".format(pAB,pBC,pCA))
    print("Probabilité qu'à la fin du jeu A ait")
    for i in range(n) :
        print("{0:2d} boules : {1:>9.5%}".format(i,L[i]))
    print("Espérance du nombre de boules de A à la fin du jeu :\n\
    {:.5f}".format(sum([i*L[i] for i in range(n)])))

DonneLoiA(25,5/6,1/7,2/3,5,12)

DonneLoiA(24,1/2,1/2,1/2,8,8)

24 boules, au départ 8 à A, 8 à B, 8 à C
Proba qu'a chaque tour
    A donne à B : 50.00000%
    B donne à C : 50.00000%
    C donne à A : 50.00000%
Probabilité qu'à la fin du jeu A ait
 0 boules : 33.33333%
 1 boules :  0.06596%
 2 boules :  0.26385%
 3 boules :  0.59361%
 4 boules :  1.05479%
 5 boules :  1.64527%
 6 boules :  2.35809%
 7 boules :  3.17540%
 8 boules :  4.05888%
 9 boules :  4.93898%
10 boules :  5.71062%
11 boules :  6.24744%
12 boules :  6.44087%
13 boules :  6.24744%
14 boules :  5.71062%
15 boules :  4.93898%
16 boules :  4.05888%
17 boules :  3.17540%
18 boules :  2.35809%
19 boules :  1.64527%
20 boules :  1.05479%
21 boules :  0.59361%
22 boules :  0.26385%
23 boules :  0.06596%
Espérance du nombre de boules de A à la fin du jeu :
    8.00000

Une coquille dans le message précédent : lire
"Un état est repéré par le couple (a,b)"

Un petit complément. On peut très facilement répondre à la question : quel est le temps d'attente (en nombre de tours) de la fin du jeu ? On voit, en lisant la référence que j'ai donnée, que ça se lit immédiatement sur la matrice N calculée.
Dans la situation décrite par flight, ce temps d'attente est à peu près 11.586. Dans la situation symétrique que j'ai décrite plus haut, il est d'à peu près 85.333.

bonjour GBZM

et merci pour ce t instructif prolongement tant du point de vu théorique que informatique ...

j'ai cependant justement une question sur le return de la fonction Finjeu:

elle renvoie N@R

mais que signifie cela ?

merci par avance

Merci pour l'intérêt.

N@R est simplement le produit des deux matrices. J'aurais pu utiliser le plus classique N.dot(R), mais c'est plus long.  

ha oui !! ok merci

c'est peut-être un des rares (ou le seul) défaut de python : ne pas posséder une "vraie" structure tableau ou matrice ...

Il y a numpy pour ça.