¿Cómo puedo modelar flips hasta N éxitos?

Tú y yo decidimos jugar un juego donde nos turnamos para lanzar una moneda. El primer jugador en voltear 10 cabezas en total gana el juego. Naturalmente, hay una discusión sobre quién debería ir primero.

Las simulaciones de este juego muestran que el jugador que voltea primero gana un 6% más que el jugador que voltea segundo (el primer jugador gana aproximadamente el 53% del tiempo). Estoy interesado en modelar esto analíticamente.

Esta no es una variable aleatoria binomial, ya que no hay un número fijo de ensayos (voltea hasta que alguien obtenga 10 caras). ¿Cómo puedo modelar esto? ¿Es la distribución binomial negativa?

Para poder recrear mis resultados, aquí está mi código de 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 distribución del número de colas antes de lograr cabezas es$10$ negativa binomial con parámetros y 1 / 2 . Deje f ser la función de probabilidad y G la función de supervivencia: para cada n ≥ 0 , f ( n ) es la oportunidad del jugador de n colas antes de 10 cabezas y G ( n ) es la oportunidad del jugador de n o más colas antes de 10 cabezas.$10$$1/2$$f$$G$$n\ge 0$$f(n)$$n$$10$$G(n)$$n$$10$

Debido a que los jugadores ruedan de manera independiente, la posibilidad de que el primer jugador gane tirando exactamente colas se obtiene multiplicando esa posibilidad por la posibilidad de que el segundo jugador lance n o más colas, igual a f ( n ) G ( n ) .$n$$n$$f(n)G(n)$

Al sumar todas las posibles , las posibilidades de ganar del primer jugador son$n$

Eso es aproximadamente un más de la mitad del tiempo.$3\%$

En general, reemplazando por cualquier entero positivo m , la respuesta se puede dar en términos de una función hipergeométrica: es igual a$10$$m$

Cuando se usa una moneda sesgada con una probabilidad de caras, esto generaliza a$p$

Aquí hay una Rsimulación de un millón de tales juegos. Informa una estimación de . Una prueba de hipótesis binomial para compararlo con el resultado teórico tiene una puntuación Z de - 0,843 , que es una diferencia 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))

Podemos modelar el juego así:

• El jugador A lanza una moneda repetidamente, obteniendo los resultados $A_1, A_2, \dots$ hasta obtener un total de 10 caras. Deje que el índice de tiempo de las cabezas de 10º la variable aleatoria $X$ .
• El jugador B hace lo mismo. Deje que el índice de tiempo de las cabezas de 10º sea la variable aleatoria $Y$ , que es una copia iid de $X$ .
• Si $X \le Y$ , el jugador A gana; de lo contrario, el jugador B gana. Es decir, $$\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}$$

La brecha en las tasas de ganancia es, por tanto,

Como sospechaba, $X$ (e $Y$ ) se distribuyen esencialmente de acuerdo con una distribución binomial negativa. Las anotaciones para esto varían, pero en la parametrización de Wikipedia , tenemos cabezas como un "fracaso" y colas como un "éxito"; necesitamos $r = 10$ "fallas" (cabezas) antes de que se detenga el experimento, y la probabilidad de éxito $p = \tfrac12$ . Entonces el número de "éxitos", que es$X - 10$, tiene

Por lo tanto, la tasa de ganancia del jugador B es $\Pr(Y > X) \approx 46.7\%$ , y la del jugador A es $\frac{619\,380\,496}{1\,162\,261\,467} \approx 53.3\%$.

$E_{ij}$$X$$\{ hh,ht,th,tt\}$$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}]$

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

$p_{0j}=p_{00}=1$$p_{i0}=0$

$O(i*j)$$O(min(i,j))$ . Aquí hay un pliegue simple implementado en 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> 

$E_{kl}$

$p_{k,l} = 1-1/2*[p_{l,k+1}+p_{l,0}]$$p_{il}=p_{ii}=1, p_{ki}=0$

$i^2$

$n$$\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.