N 성공까지 어떻게 플립을 모델링 할 수 있습니까?

당신과 저는 동전을 뒤집는 게임을하기로 결정했습니다. 총 10 헤드를 뒤집은 첫 번째 플레이어가 게임에서 승리합니다. 당연히 누가 먼저 가야하는지에 대한 논쟁이 있습니다.

이 게임의 시뮬레이션에 따르면 첫 번째로 뒤집는 플레이어는 두 번째로 뒤집는 플레이어보다 6 % 더 많이 이깁니다 (첫 번째 플레이어는 약 53 %의 시간을 이깁니다). 나는 이것을 분석적으로 모델링하는데 관심이있다.

고정 된 횟수의 시행이 없기 때문에 이항 랜덤 변수가 아닙니다 (누군가 10 개의 머리를 얻을 때까지 뒤집기). 이것을 어떻게 모델링 할 수 있습니까? 음 이항 분포입니까?

결과를 다시 만들 수 있도록 파이썬 코드는 다음과 같습니다.

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)

달성 전에 꼬리의 수의 분포 의 머리는 음 이항 매개 변수 (10) 와 1 / 2 . 하자 f를 확률 함수되고 G 생존 기능 : 각 N ≥ 0 , F ( N ) 의 플레이어의 기회 N 꼬리 전에 열 헤드와 G ( N ) 의 플레이어의 기회 N 전에 이상의 꼬리 10 개 헤드.$10$$10$$1/2$$f$$G$$n\ge 0$$f(n)$$n$$10$$G(n)$$n$$10$

플레이어가 독립적으로 굴리기 때문에 첫 번째 플레이어가 정확히 꼬리 를 굴려서 이길 확률은 두 번째 플레이어 가 f ( n ) G ( n ) 과 동일한 n 개 이상의 꼬리를 굴릴 확률을 곱한 결과 입니다.$n$$n$$f(n)G(n)$

가능한 모든 합하면 첫 번째 플레이어의 승리 확률은 다음과 같습니다.$n$

이는 시간의 절반 이상인 약 입니다.$3\%$

일반적으로 을 양의 정수 m으로 바꾸면 하이퍼 지오메트리 함수로 답을 얻을 수 있습니다.$10$$m$

기회가 인 편향 동전을 사용할 때$p$

다음은 R그러한 백만 개의 게임에 대한 시뮬레이션입니다. 추정치는 입니다. 이론적 인 결과를 비교하는 이항 가설 테스트의 Z 점수가 - 0.843 사소한 차이입니다.$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))

다음과 같이 게임을 모델링 할 수 있습니다.

• 플레이어 A는 결과를 얻고, 반복 동전을 뒤집 1 , 2 , ... 그들은 10 개 머리의 총을 얻을 때까지. 10 번째 헤드의 시간 인덱스가 랜덤 변수 X가되도록 합니다.$A_1, A_2, \dots$$X$
• 플레이어 B도 마찬가지입니다. 10 번째 헤드의 시간 인덱스 가 X 의 iid 사본 인 랜덤 변수 $Y$ 되도록하십시오 .$X$
• 경우 $X \le Y$ , 플레이어 A가 승리; 그렇지 않으면 플레이어 B가 이깁니다. 즉, $$\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}$$

승리 속도에 따라서 갭이다

$X$$Y$$r = 10$$p = \tfrac12$$X - 10$

$\Pr(Y > X) \approx 46.7\%$$\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.