Làm thế nào tôi có thể mô hình lật cho đến khi N thành công?

Bạn và tôi quyết định chơi một trò chơi trong đó chúng tôi thay phiên nhau lật một đồng xu. Người chơi đầu tiên lật 10 đầu trong tổng số trận thắng. Đương nhiên, có một cuộc tranh luận về việc ai nên đi trước.

Mô phỏng của trò chơi này cho thấy người chơi lật đầu tiên thắng nhiều hơn 6% so với người chơi lật thứ hai (người chơi thứ nhất thắng khoảng 53% thời gian). Tôi quan tâm đến việc mô hình hóa phân tích này.

Đây không phải là biến ngẫu nhiên nhị thức, vì không có số lượng thử nghiệm cố định (lật cho đến khi ai đó nhận được 10 đầu). Làm thế nào tôi có thể mô hình này? Có phải là phân phối nhị thức âm?

Vì vậy, để có thể tạo lại kết quả của tôi, đây là mã python của tôi:

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)

Sự phân bố số lượng đuôi trước khi đạt được đầu là nhị thức âm với các tham số $10$$10$ và . Gọi f là hàm xác suất và G là hàm sinh tồn: với mỗi n ≥ 0 , f ( n ) là cơ hội của người chơi n đuôi trước 10 đầu và G ( n ) là cơ hội của người chơi có n hoặc nhiều đuôi trước 10 đầu.$1/2$$f$$G$$n\ge 0$$f(n)$$n$$10$$G(n)$$n$$10$

Bởi vì người chơi cuộn độc lập, cơ hội người chơi thứ nhất chiến thắng bằng cách lăn chính xác đuôi có được bằng cách nhân cơ hội đó với cơ hội người chơi thứ hai cuộn n hoặc nhiều đuôi, bằng f ( n ) G ( n ) .$n$$n$$f(n)G(n)$

Tổng kết trên tất cả các khả năng mang lại cơ hội chiến thắng cho người chơi đầu tiên như$n$

Đó là khoảng hơn một nửa thời gian.$3\%$

Nói chung, thay thế bằng bất kỳ số nguyên dương m nào , câu trả lời có thể được đưa ra dưới dạng hàm Hypergeometric: nó bằng với$10$$m$

Khi sử dụng đồng xu thiên vị với cơ hội đầu, điều này khái quát đến$p$

Đây là một Rmô phỏng của một triệu trò chơi như vậy. Nó báo cáo một ước tính . Một thử nghiệm giả thuyết nhị thức để so sánh nó với kết quả lý thuyết có điểm Z là - 0,843 , đây là một sự khác biệt không đáng kể.$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))

Chúng ta có thể mô hình hóa trò chơi như thế này:

• Người chơi A flips một xu nhiều lần, nhận được kết quả $A_1, A_2, \dots$ cho đến khi họ nhận được tổng cộng 10 người đứng đầu. Hãy chỉ số thời gian của người đứng đầu 10 là biến ngẫu nhiên $X$ .
• Người chơi B cũng làm như vậy. Hãy chỉ số thời gian của người đứng đầu 10 là biến ngẫu nhiên $Y$ , đó là một bản sao iid của $X$ .
• Nếu $X \le Y$ , Người chơi A thắng; nếu không thì người chơi B thắng. Đó là, $$\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}$$

Chênh lệch về tỷ lệ chiến thắng là do đó

Như bạn nghi ngờ, $X$ (và $Y$ ) được phân phối chủ yếu theo phân phối nhị thức âm. Các ký hiệu cho điều này khác nhau, nhưng trong tham số hóa của Wikipedia , chúng ta có đầu là "thất bại" và đuôi là "thành công"; chúng ta cần $r = 10$ "thất bại" (người đứng đầu) trước khi thử nghiệm bị dừng và xác suất thành công $p = \tfrac12$ . Khi đó số "thành công" là$X - 10$, có

Do đó, tỷ lệ thắng của Người chơi B là $\Pr(Y > X) \approx 46.7\%$ , và Người chơi A là$\frac{619\,380\,496}{1\,162\,261\,467} \approx 53.3\%$ .

Đặt $E_{ij}$ là sự kiện mà người chơi đang lật tôi đứng trước khi người chơi khác lật đầu j và để $X$ là hai lần lật đầu tiên có không gian mẫu $\{ hh,ht,th,tt\}$ trong đó h có nghĩa là đầu và đuôi t, và cho $p_{ij} \equiv Pr(E_{ij})$ .

Khi đó $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)$

Giả sử một đồng xu tiêu chuẩn $Pr(X=*)=1/4$ phương tiện mà $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$, 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.