Bagaimana saya bisa memodelkan membalik sampai N berhasil?

Anda dan saya memutuskan untuk memainkan permainan di mana kami bergiliran membalik koin. Pemain pertama yang membalikkan 10 kepala total memenangkan permainan. Tentu saja, ada argumen tentang siapa yang harus pergi dulu.

Simulasi permainan ini menunjukkan bahwa pemain yang membalik pertama menang 6% lebih banyak daripada pemain yang membalik kedua (pemain pertama menang kira-kira 53% dari waktu). Saya tertarik untuk memodelkan ini secara analitis.

Ini bukan variabel acak binomial, karena tidak ada jumlah percobaan tetap (balik sampai seseorang mendapatkan 10 kepala). Bagaimana saya bisa memodelkan ini? Apakah ini distribusi binomial negatif?

Agar dapat membuat ulang hasil saya, berikut adalah kode python saya:

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)

Distribusi jumlah ekor sebelum mencapai kepala adalah negatif Binomial dengan parameter 10 dan 1 / 2 . Biarkan f menjadi fungsi probabilitas dan G fungsi bertahan hidup: untuk setiap n ≥ 0 , f ( n ) adalah peluang pemain untuk n ekor sebelum 10 kepala dan G ( n ) adalah peluang pemain untuk n atau lebih banyak ekor sebelum 10 kepala.$10$$10$$1/2$$f$$G$$n\ge 0$$f(n)$$n$$10$$G(n)$$n$$10$

Karena para pemain berguling secara independen, peluang pemain pertama menang dengan menggulirkan tepat ekor diperoleh dengan mengalikan peluang itu dengan kesempatan pemain kedua menggulir n atau lebih, sama dengan f ( n ) G ( n ) .$n$$n$$f(n)G(n)$

Menjumlahkan semua kemungkinan memberikan peluang kemenangan pemain pertama sebagai$n$

Itu sekitar lebih dari separuh waktu.$3\%$

Secara umum, mengganti $10$ dengan bilangan bulat positif , jawabannya dapat diberikan dalam hal fungsi Hypergeometric: sama dengan$m$

Saat menggunakan koin bias dengan kesempatan kepala, ini digeneralisasi ke$p$

Berikut ini adalah Rsimulasi dari sejuta game semacam itu. Ini melaporkan perkiraan . Uji hipotesis binomial untuk membandingkannya dengan hasil teoretis memiliki skor-Z sebesar - 0,843 , yang merupakan perbedaan yang tidak signifikan.$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))

Kami dapat memodelkan game seperti ini:

• Pemain A membalik koin berulang kali, mendapatkan hasil $A_1, A_2, \dots$ sampai mereka mendapatkan total 10 kepala. Biarkan indeks waktu dari kepala ke-10 menjadi variabel acak $X$ .
• Pemain B melakukan hal yang sama. Biarkan indeks waktu dari kepala ke-10 menjadi variabel acak $Y$ , yang merupakan salinan X dari $X$ .
• Jika $X \le Y$ , Pemain A menang; jika tidak, Pemain B menang. Yaitu, $$\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}$$

Kesenjangan dalam tingkat kemenangan demikian

Seperti yang Anda duga, $X$ (dan $Y$ ) didistribusikan pada dasarnya sesuai dengan distribusi binomial negatif. Notasi untuk ini berbeda-beda, tetapi dalam parameterisasi Wikipedia , kami memiliki kepala sebagai "kegagalan" dan berbuntut sebagai "sukses"; kita perlu $r = 10$ "kegagalan" (kepala) sebelum percobaan dihentikan, dan probabilitas keberhasilan $p = \tfrac12$ . Maka jumlah "sukses", yaitu$X - 10$, memiliki

Dengan demikian tingkat kemenangan Pemain B adalah $\Pr(Y > X) \approx 46.7\%$ , dan Pemain A adalah $\frac{619\,380\,496}{1\,162\,261\,467} \approx 53.3\%$.

Mari $E_{ij}$ menjadi peristiwa yang pemain di roll membalik kepala saya sebelum pemain lain membalik kepala j, dan membiarkan $X$ menjadi yang pertama dua membalik memiliki ruang sampel $\{ hh,ht,th,tt\}$ di mana h berarti kepala dan t ekor, dan biarkan $p_{ij} \equiv Pr(E_{ij})$ .

Kemudian $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}]$

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.