N başarılı olana kadar döndürmeleri nasıl modelleyebilirim?

Sen ve ben sırayla bozuk para çeviren bir oyun oynamaya karar veriyoruz. Toplamda 10 kafa çeviren ilk oyuncu oyunu kazanır. Doğal olarak, önce kimin gitmesi gerektiği konusunda bir tartışma var.

Bu oyunun simülasyonları, ilk çeviren oyuncunun ikinci çeviren oyuncudan% 6 daha fazla kazandığını göstermektedir (ilk oyuncu zamanın yaklaşık% 53'ünü kazanır). Bunu analitik olarak modellemekle ilgileniyorum.

Sabit sayıda deneme olmadığı için bu bir binomial rastgele değişken değildir (biri 10 kafa alana kadar çevirin). Bunu nasıl modelleyebilirim? Negatif binom dağılımı mı?

Sonuçlarımı yeniden oluşturabilmek için işte python kodum:

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)

Ulaşmadan önce kuyruk sayısında dağılımı kafaları olan negatif binom parametrelerle 10 ve 1 / 2 . Let f olasılık fonksiyonu ve olmak G hayatta kalma işlevi: her biri için n ≥ 0 , f ( n ) oyuncunun şans n kuyrukları önce 10 kafa ve G ( n ) oyuncunun şans n daha önce veya daha fazla kuyrukları 10 kafaları.$10$$10$$1/2$$f$$G$$n\ge 0$$f(n)$$n$$10$$G(n)$$n$$10$

Oyuncu, bağımsız bir şekilde rulo için, şans tam olarak alındığı, ilk oyuncu kazanç kuyrukları ikinci oyuncu rulo tesadüfen bu şansı çarpılması ile elde edilir , n veya daha fazla kuyrukları, e eşit f ( n ) G ( n ) .$n$$n$$f(n)G(n)$

Mümkün olan tüm üzerinden toplanmak , ilk oyuncunun kazanma şansını$n$

Bu, yarıdan yaklaşık % daha fazladır.$3\%$

Genel olarak, herhangi bir pozitif tamsayı m ile değiştirmek , cevap Hipergeometrik fonksiyon açısından verilebilir: eşittir$10$$m$

Şans eseri olan önyargılı bir para kullanırken , bu$p$

İşte Rböyle bir milyon oyunun simülasyonu. Bu bir tahmin raporları . Teorik sonuç ile karşılaştırmak için bir binom hipotezi testinin Z skoru - 0.843'tür , ki bu önemsiz bir farktır.$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))

Oyunu şu şekilde modelleyebiliriz:

• $A_1, A_2, \dots$ until they get a total of 10 heads. Let the time index of the 10th heads be the random variable $X$.
• Player B does the same. Let the time index of the 10th heads be the random variable $Y$, which is an iid copy of $X$.
• If $X \le Y$, Player A wins; otherwise Player B wins. That is, $$\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}$$

The gap in the win rates is thus

As you suspected, $X$ (and $Y$) are distributed essentially according to a negative binomial distribution. Notations for this vary, but in Wikipedia's parameterization, we have heads as a "failure" and tails as a "success"; we need $r = 10$ "failures" (heads) before the experiment is stopped, and success probability $p = \tfrac12$. Then the number of "successes," which is $X - 10$, has

Thus Player B's win rate is $\Pr(Y > X) \approx 46.7\%$, and Player A's is $\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.