Come posso modellare i flip fino a N successi?

Decidiamo tu e io di giocare una partita in cui a turno lanciamo una moneta. Il primo giocatore che lancia 10 teste in totale vince la partita. Naturalmente, c'è una discussione su chi dovrebbe andare per primo.

Le simulazioni di questo gioco mostrano che il giocatore che lancia per primo vince il 6% in più rispetto al giocatore che lancia per secondo (il primo giocatore vince circa il 53% delle volte). Sono interessato a modellarlo analiticamente.

Questa non è una variabile casuale binomiale, in quanto non esiste un numero fisso di prove (capovolgi fino a quando qualcuno ottiene 10 teste). Come posso modellarlo? È la distribuzione binomiale negativa?

Per poter ricreare i miei risultati, ecco il mio codice 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 distribuzione del numero di code prima di raggiungere teste è negativa binomiale con parametri 10 e 1 / 2 . Sia f la funzione di probabilità e G la funzione di sopravvivenza: per ogni n ≥ 0 , f ( n ) è la possibilità del giocatore di n code prima di 10 teste e G ( n ) è la possibilità del giocatore di n o più code prima di 10 teste.$10$$10$$1/2$$f$$G$$n\ge 0$$f(n)$$n$$10$$G(n)$$n$$10$

Poiché i giocatori rotolano in modo indipendente, la probabilità che il primo giocatore vinca tirando esattamente code si ottiene moltiplicando quella possibilità per la probabilità che il secondo giocatore tira n o più code, pari a f ( n ) G ( n ) .$n$$n$$f(n)G(n)$

Sommando tutte le possibili danno le possibilità di vincita del primo giocatore come$n$

Questo è circa il più della metà delle volte.$3\%$

In generale, sostituendo con qualsiasi numero intero positivo m , la risposta può essere data in termini di una funzione ipergeometrica: è uguale a$10$$m$

Quando si utilizza una moneta distorta con una probabilità di teste, questo si generalizza a$p$

Ecco una Rsimulazione di un milione di tali giochi. Riporta una stima di . Un test di ipotesi binomiale per confrontarlo con il risultato teorico ha un punteggio Z di - 0,843 , che è una differenza insignificante.$0.5325$$-0.843$

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

Possiamo modellare il gioco in questo modo:

• Il giocatore A lancia ripetutamente una moneta, ottenendo i risultati $A_1, A_2, \dots$ fino a quando non ottengono un totale di 10 teste. Lasciate che l'indice di tempo delle teste 10 ° sia la variabile casuale $X$ .
• Il giocatore B fa lo stesso. Lasciare l'indice temporale delle teste 10a la variabile casuale $Y$ , che è una copia IID $X$ .
• Se $X \le Y$ , il giocatore A vince; altrimenti vince il giocatore B. Cioè, $$\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}$$

Il divario nelle percentuali di vincita è quindi

Come sospettavi, $X$ (e $Y$ ) sono distribuiti essenzialmente in base a una distribuzione binomiale negativa. Notazioni per questo variano, ma nella parametrizzazione di Wikipedia , abbiamo le teste come un "fallimento" e le code come un "successo"; abbiamo bisogno di $r = 10$ "fallimenti" (testine) prima che l'esperimento venga interrotto e probabilità di successo $p = \tfrac12$ . Quindi il numero di "successi", che è$X - 10$, ha

Pertanto, la percentuale di vincita del giocatore B è $\Pr(Y > X) \approx 46.7\%$ e quella del giocatore A è $\frac{619\,380\,496}{1\,162\,261\,467} \approx 53.3\%$.

Sia $E_{ij}$ l'evento che il giocatore lancia lanci i prima che l'altro giocatore lanci j teste e $X$ sia i primi due lanci con spazio campione $\{ hh,ht,th,tt\}$ dove h significa testa e croce, e lascia $p_{ij} \equiv Pr(E_{ij})$ .

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

$Pr(X=*)=1/4$$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.