Dada una moneda con sesgo desconocido, genera variaciones de una moneda justa de manera eficiente

Dada una moneda con sesgo desconocido , ¿cómo puedo generar variables, de la manera más eficiente posible, que estén distribuidas por Bernoulli con probabilidad 0.5? Es decir, usar el número mínimo de vueltas por variante generada.$p$

Este es un problema bien conocido con varias soluciones agradables que se han discutido aquí y en stackoverflow (parece que no puedo publicar más de un enlace, pero una búsqueda rápida en Google le ofrece algunas entradas interesantes). Echa un vistazo a la entrada de wikipedia

http://en.wikipedia.org/wiki/Fair_coin#Fair_results_from_a_limited_coin

Este es un problema clásico, creo atribuido originalmente a von Neumann. Una solución es seguir lanzando la moneda en pares hasta que los pares sean diferentes, y luego diferir el resultado de la primera moneda en el par.

Sea explícitamente el resultado del lanzamiento i , siendo X i la primera moneda e Y i la segunda moneda. Cada moneda tiene probabilidad p de caras. Entonces P ( X i = H | X i ≠ Y i ) = P ( X i = T | X i ≠ Y i ) debido a la simetría, lo que implica P $(X_i,Y_i)$$i$$X_i$$Y_i$$p$$P(X_i=H|X_i\neq Y_i)=P(X_i=T|X_i\neq Y_i)$ . Para ver explícitamente esta simetría, tenga en cuenta que X i ≠ Y i implica que los resultados son ( H , T ) o ( T , H ) , los cuales son igualmente probables debido a la independencia.$P(X_i=H|X_i\neq Y_i)=1/2$$X_i\neq Y_i$$(H,T)$$(T,H)$

Empíricamente, el tiempo de espera hasta un par tan desigual es

que explota cuando se acerca a 0 o 1 (lo cual tiene sentido).$p$

No estoy seguro de cómo resumir los términos de manera eficiente, pero podemos detenernos siempre que el número total de tiradas y el número total de éxitos t sean tales que ($n$$t$ se debe a que podemos dividir los diferentes ordenamientos que podríamos haber logradonyten dos grupos de igual probabilidad, cada uno correspondiente a una etiqueta de salida diferente. Debemos tener cuidado de no habernos detenido para estos elementos, es decir, que ningún elemento tenga un prefijo de longitudn'cont′éxitos tales que ( n$\binom{n}{t}$$n$$t$$n'$$t'$es par. No estoy seguro de cómo convertir esto en un número esperado de lanzamientos.$\binom{n'}{t'}$

Para ilustrar:

Podemos detenernos en TH o HT ya que estos tienen la misma probabilidad. Moviendo hacia abajo el triángulo de Pascal, los siguientes términos pares están en la cuarta fila: 4, 6, 4. Lo que significa que podemos parar después de los rollos si ha aparecido una cabeza ya que podemos crear una coincidencia bipartita: HHHT con HHTH, y técnicamente HTHH con THHH aunque ya nos habríamos detenido por eso. Del mismo modo, produce el HHTT correspondiente con TTHH (el resto, ya nos habríamos detenido antes de llegar a ellos).$\binom42$

Para , todas las secuencias tienen prefijos detenidos. Se pone un poco más interesante en ($\binom52$ donde hacemos coincidir FFFFTTFT con FFFFTTTF.$\binom83$

Para después de 8 tiradas, la posibilidad de no haberse detenido es$p=\frac12$ con un número esperado de rollos si nos hemos detenido de$\frac1{128}$ . Para la solución donde seguimos rodando pares hasta que difieren, la posibilidad de no haberse detenido es$\frac{53}{16}$ con un número esperado de lanzamientos si nos hemos detenido de 4. Por recursividad, un límite superior en los lanzamientos esperados para el algoritmo presentado es$\frac{1}{16}$. $\frac{128}{127} \cdot \frac{53}{16} = \frac{424}{127} < 4$

Escribí un programa de Python para imprimir los puntos de parada:

import scipy.misc
from collections import defaultdict


bins = defaultdict(list)


def go(depth, seq=[], k=0):
    n = len(seq)
    if scipy.misc.comb(n, k, True) % 2 == 0:
        bins[(n,k)].append("".join("T" if x else "F"
                                   for x in seq))
        return
    if n < depth:
        for i in range(2):
            seq.append(i)
            go(depth, seq, k+i)
            seq.pop()

go(8)

for key, value in sorted(bins.items()):
    for i, v in enumerate(value):
        print(v, "->", "F" if i < len(value) // 2 else "T")
    print()

huellas dactilares:

FT -> F
TF -> T

FFFT -> F
FFTF -> T

FFTT -> F
TTFF -> T

TTFT -> F
TTTF -> T

FFFFFT -> F
FFFFTF -> T

TTTTFT -> F
TTTTTF -> T

FFFFFFFT -> F
FFFFFFTF -> T

FFFFFFTT -> F
FFFFTTFF -> T

FFFFTTFT -> F
FFFFTTTF -> T

FFFFTTTT -> F
TTTTFFFF -> T

TTTTFFFT -> F
TTTTFFTF -> T

TTTTFFTT -> F
TTTTTTFF -> T

TTTTTTFT -> F
TTTTTTTF -> T