Comment puis-je modéliser des flips jusqu'à N succès?

Vous et moi décidons de jouer à un jeu où nous lançons à tour de rôle une pièce. Le premier joueur à retourner 10 têtes au total remporte la partie. Naturellement, il y a un débat sur qui devrait aller en premier.

Les simulations de ce jeu montrent que le joueur qui retourne en premier gagne 6% de plus que le joueur qui retourne en deuxième (le premier joueur gagne environ 53% du temps). Je suis intéressé par la modélisation analytique.

Ce n'est pas une variable aléatoire binomiale, car il n'y a pas de nombre fixe d'essais (retournez jusqu'à ce que quelqu'un obtienne 10 têtes). Comment puis-je modéliser cela? Est-ce la distribution binomiale négative?

Afin de pouvoir recréer mes résultats, voici mon code python:

import numpy as np
from numba import jit


@jit
def sim(N):

    P1_wins = 0
    P2_wins = 0

    for i in range(N):

        P1_heads = 0
        P2_heads = 0
        while True:

            P1_heads += np.random.randint(0,2)

            if P1_heads == 10:
                P1_wins+=1
                break

            P2_heads+= np.random.randint(0,2)
            if P2_heads==10:
                P2_wins+=1
                break
    return P1_wins/N, P2_wins/N


a,b = sim(1000000)

La distribution du nombre de queues avant d' atteindre la tête est binomiale négative avec les paramètres 10 et une / deux . Soit f la fonction de probabilité et G la fonction de survie: pour chaque n ≥ 0 , f ( n ) est la chance du joueur d'avoir n queues avant 10 têtes et G ( $10$$10$$1/2$$f$$G$$n\ge 0$$f(n)$$n$$10$ est la chance du joueur d'avoir n ou plusieurs queues avant 10 têtes.$G(n)$$n$$10$

Parce que les joueurs roulent indépendamment, la chance que le premier joueur gagne en roulant exactement queues est obtenue en multipliant cette chance par la chance que le deuxième joueur roule n ou plusieurs queues, égal à f ( n ) G ( n ) .$n$$n$$f(n)G(n)$

La somme de tous les possibles donne au premier joueur des chances de gagner$n$

C'est environ plus que la moitié du temps.$3\%$

En général, remplacer par tout entier positif m , la réponse peut être donnée en fonction d'une fonction hypergéométrique: elle est égale à$10$$m$

Lorsque vous utilisez une pièce biaisée avec une chance de têtes, cela se généralise pour$p$

Voici une Rsimulation d'un million de ces jeux. Il rapporte une estimation de . Un test d'hypothèse binomiale pour le comparer au résultat théorique a un score Z de - $0.5325$$-0.843$ , ce qui est une différence insignifiante.

n.sim <- 1e6
set.seed(17)
xy <- matrix(rnbinom(2*n.sim, 10, 1/2), nrow=2)
p <- mean(xy[1,] <= xy[2,])
cat("Estimate:", signif(p, 4), 
    "Z-score:", signif((p - 0.532909774) / sqrt(p*(1-p)) * sqrt(n.sim), 3))

Nous pouvons modéliser le jeu comme ceci:

• Le joueur A lance une pièce à plusieurs reprises, obtenant les résultats $A_1, A_2, \dots$ jusqu'à ce qu'ils obtiennent un total de 10 têtes. Soit l'indice de temps des 10èmes têtes la variable aléatoire $X$ .
• Le joueur B fait de même. Soit l'indice de temps des 10èmes têtes la variable aléatoire $Y$ , qui est une copie iid de $X$ .
• Si $X \le Y$ , le joueur A gagne; sinon le joueur B gagne. Autrement dit, $$\begin{align} \Pr(A\text{ wins})&= \Pr(X \ge Y) = \Pr(X > Y) + \Pr(X = Y)\\ \Pr(B\text{ wins})&= \Pr(Y > X) = \Pr(X > Y). \end{align}$$

L'écart dans les taux de gain est donc

Comme vous le soupçonniez, $X$ (et $Y$ ) sont distribués essentiellement selon une distribution binomiale négative. Les notations varient, mais dans le paramétrage de Wikipedia , nous avons les têtes comme un "échec" et les queues comme un "succès"; nous avons besoin de $r = 10$ "échecs" (têtes) avant l'arrêt de l'expérience, et probabilité de réussite $p = \tfrac12$ . Alors le nombre de "succès", qui est$X - 10$, a

Ainsi, le taux de victoire du joueur B est $\Pr(Y > X) \approx 46.7\%$ , et le joueur A est $\frac{619\,380\,496}{1\,162\,261\,467} \approx 53.3\%$.

Let $E_{ij}$ be the event that the player on roll flips i heads before the other player flips j heads, and let $X$ be the first two flips having sample space $\{ hh,ht,th,tt\}$ where h means heads and t tails, and let $p_{ij} \equiv Pr(E_{ij})$.

Then $p_{ij}=Pr(E_{i-1j-1}|X=hh)*Pr(X=hh)+Pr(E_{i-1j}|X=ht)*Pr(X=ht)+Pr(E_{ij-1}|X=th)*Pr(X=th)+Pr(E_{ij}|X=tt)*Pr(X=tt)$

Assuming a standard coin $Pr(X=*)=1/4$ means that $p_{ij}=1/4*[p_{i-1j-1}+p_{i-1j}+p_{ij-1}+p_{ij}]$

solving for $p_{ij}$, $= 1/3*[p_{i-1j-1}+p_{i-1j}+p_{ij-1}]$

But $p_{0j}=p_{00}=1$ and $p_{i0}=0$, implying that the recursion fully terminates. However, a direct naive recursive implementation will yield poor performance because the branches intersect.

An efficient implementation will have complexity $O(i*j)$ and memory complexity $O(min(i,j))$. Here's a simple fold implemented in Haskell:

Prelude> let p i j = last. head. drop j $ iterate ((1:).(f 1)) start where
  start = 1 : replicate i 0;
  f c v = case v of (a:[]) -> [];
                    (a:b:rest) -> sum : f sum (b:rest) where
                     sum = (a+b+c)/3 
Prelude> p 0 0
1.0
Prelude> p 1 0
0.0
Prelude> p 10 10
0.5329097742513388
Prelude> 

UPDATE: Someone in the comments above asked whether one was suppose to roll 10 heads in a row or not. So let $E_{kl}$ be the event that the player on roll flips i heads in a row before the other player flips i heads in a row, given that they already flipped k and l consecutive heads respectively.

Proceeding as before above, but this time conditioning on the first flip only, $p_{k,l} = 1-1/2*[p_{l,k+1}+p_{l,0}]$ where $p_{il}=p_{ii}=1, p_{ki}=0$

This is a linear system with $i^2$ unknowns and one unique solution.

To convert it into an iterative scheme, simply add an iterate number $n$ and a sensitivity factor $\epsilon$:

$p_{k,l,n+1} = 1/(1+\epsilon)*[\epsilon*p_{k,l,n} +1-1/2*(p_{l,k+1,n}+p_{l,0,n})]$

Choose $\epsilon$ and $p_{k,l,0}$ wisely and run the iteration for a few steps and monitor the correction term.