Önyargılı bir kalıpla adil bir kalıp simüle et

Önyargılı bir taraflı kalıp verildiğinde , aralığındaki rasgele bir sayı nasıl düzgün bir şekilde oluşturulabilir? Kalıp yüzlerinin olasılık dağılımı bilinmemektedir, bilinen her şey, her yüzün sıfır olmayan bir olasılığa sahip olması ve olasılık dağılımının tüm atışlarda aynı olmasıdır (özellikle atışlar bağımsızdır). Adil sonuçların haksız kalıpla açık bir şekilde genelleştirilmesi budur .$N$$[1,N]$

Bunu bilgisayar bilimleri terimleriyle ifade etmek , sıfırdan farklı ve bağımsız olacak şekilde kalıp rulolarını temsil eden bir kehanetimiz var: . Bu belirleyici bir algoritma için ideal ile parametrelenmişse (yani çağrı yapabilir ) bu şekilde . Algoritma olasılık 1 ile sonlanmalıdır, yani den fazla çağrı yapma olasılığı olarak yaklaşmalıdır .$D : \mathbb{N} \to [1,N]$$p_i = P(D(k)=i)$$k$$A$$D$$A$$D$$P(A()=i) = 1/N$$A$$n$$D$$0$$n\to\infty$

İçin , iyi bilinen bir algoritma vardır (para eğimli bir madeni para ile döndürür adil bir para simüle):$N=2$

• İki atış farklı sonuçlar ((kafalar, kuyruklar) veya (kuyruklar, kafalar)) ortaya çıkıncaya kadar “iki kez çevir” i tekrarlayın. Başka bir deyişle, d ( 2 k + 1 ) ≠ D ( 2 k ) olana kadar için döngü$k = 0..\infty$$D(2k+1) \ne D(2k)$
• Son çift döndürme (kafalar, kuyruklar) ise 0 ve öyleyse 1 (kuyruklar, kafalar) dön. Başka bir deyişle, döndürün ; $D(2k)$burada $k$ , döngünün sonlandığı dizindir.

Önyargılı olandan tarafsız bir kalıp yapmanın basit bir yolu, adil bir para oluşturmak için bozuk para çevirme unbiasing yöntemini kullanmak ve dizileri Unbiasing'de olduğu gibi ret örnekleme ile adil bir kalıp oluşturmaktır . Fakat bu uygun mu (olasılık dağılımının jenerik değerleri için)?

Özellikle, sorum şu: gerektiren bir algoritma nedir en küçük beklenen kahin çağrı sayısı ? Ulaşılabilecek beklenen değerler kümesi açıksa, alt sınır nedir ve bu alt sınıra yaklaşan bir algoritma sınıfı nedir?

Durumda algoritmaların farklı ailelerin neredeyse-fuar zar üzerinde odağını izin farklı olasılık dağılımları için optimal şunlardır: Ben bir algoritma veya dağılımlar için en uygun algoritma ailesini arıyorum öyle ki $\forall i, \bigl|p_i - 1/N\bigr| \lt \epsilon$ bazıları için $\epsilon \gt 0$ .

Aşağıdaki makale bu sorunun yakın bir varyasyonuna cevap vermektedir: Tarafsız Rastgele Bir Sıranın Verimli İnşası, Elias 1972 .

Soru şu gibi görünüyor: Bu önyargılı bağımsız kaynağa erişim verildiğinde , [ 1 , N ] ' de rasgele sayılar dizisi verin ( yalnızca bir çıkış sembolünün talep edildiği sorunuzdan farkı not edin). İstenen çıktı uzunluğu sonsuza geçtikçe, (von Neumann doğal bir genelleme gibi görünüyor) kağıt düzeni "etkinliği" gider 1 entropi bir giriş, ben inanıyoruz anlamı, h dönüştürülür entropinin çıktısı h .$[1,N]$$1$$h$$h$

The question seems much better behaved when phrased this way, rather than requesting a single output digit, because, for instance, if we draw $N$ samples and end up with an output with lots of information (for instance, all $N$ input symbols are distinct), then we can use all of that information to produce many output symbols, whereas with the question as phrased here, any information beyond that used to produce one output symbol goes to waste.

I believe that the scheme repeatedly takes $N$ draws, looks at the sequence, and maps it some outputs or the empty string. Perhaps there is a way to improve the scheme for your question by looking at prefixes and stopping if we have "enough" information to output a symbol? I don't know.

genellemeleri için tanımladığınız yöntem . [ 1 .. N ] ' nin tüm permütasyonlarının taraflı bir kalıpla bile eşit derecede olası olduğunu kullanıyoruz (rulolar bağımsız olduğu için). Bu nedenle, son N rulo gibi bir permütasyon görene ve son ruloyu çıkana kadar ilerlemeye devam edebiliriz .$N=2$$[1..N]$$N$

A general analysis is tricky; it is clear, however, that the expected number of rolls grows quickly in $N$ since the probability of seeing a permutation at any given step is small (and not independent of the steps before and after, hence tricky). It is greater than $0$ for fixed $N$, however, so the procedure terminates almost surely (i.e. with probability $1$).

For fixed $N$ we can construct a Markov chain over the set of Parikh-vectors that sum to $\leq N$, summarising the results of the last $N$ rolls, and determine the expected number of steps until we reach $(1,\dots,1)$ for the first time. This is sufficient since all permutations that share a Parikh-vector are equally likely; the chains and calculations are simpler this way.

Assume we are in state $v=(v_1,\dots,v_N)$ with $\sum_{i=1}^n v_i \leq N$. Then, the probability of gaining an element $i$ (i.e. the next roll is $i$) is always given by

$\qquad\displaystyle \operatorname{Pr}[\text{gain } i] = p_i$.

On the other hand, the propability of dropping an element $i$ from the history is given by

$\qquad\displaystyle \operatorname{Pr}_v[\text{drop } i] = \frac{v_i}{N}$

whenever $\sum_{i=1}^n v_i = N$ (and $0$ otherwise) precisely because all permutations with Parikh-vector $v$ are equally likely. These probabilities are independent (since the rolls are independent), so we can compute the transition probabilities as follows:

$\qquad\begin{align*} &\operatorname{Pr}[v \to (v_1,\dots,v_j + 1,\dots,v_N)] \\ &\qquad=\begin{cases} \operatorname{Pr}[\text{gain } j] &, \sum v < N \\ 0 &, \text{ else} \end{cases}\;,\\[3ex] &\operatorname{Pr}[v \to (v_1,\dots,v_i - 1, \dots v_j + 1,\dots,v_N)] \\ &\qquad=\begin{cases} 0 &, \sum v < N \lor v_i=0 \lor v_j=N \\ \operatorname{Pr}_v[\text{drop } i] \cdot \operatorname{Pr}[\text{gain } j] &, \text{ else} \end{cases}\;\text{ and}\\[3ex] &\operatorname{Pr}[v \to v] \\ &\qquad=\begin{cases} 0 &, \sum v < N \\ \sum_{v_i \neq 0} \operatorname{Pr}_v[\text{drop } i] \cdot \operatorname{Pr}[\text{gain } i] &, \text{ else} \end{cases}\;; \end{align*}$

all other transition probabilities are zero. The single absorbing state is $(1,\dots,1)$, the Parikh-vector of all permutations of $[1..N]$.

For $N=2$ the resulting Markov chain¹ is

^[source]

with expected number of steps until absorption

$\qquad\displaystyle \mathbb{E}\,\text{steps} = 2 p_0 p_1 \cdot 2 + \sum_{i\geq 3} (p_0^{i-1}p_1 + p_1^{i-1}p_0)\cdot i = \frac{1 - p_0 + p_0^2}{p_0-p_0^2}\;,$

using for simplification that $p_1=1-p_0$. If now, as suggested, $p_0 = \frac{1}{2} \pm \epsilon$ for some $\epsilon \in [0,\frac{1}{2})$, then

$\qquad\displaystyle \mathbb{E}\,\text{steps} = \frac{3 + 4\epsilon^2}{1 - 4\epsilon^2}$.

For $N \leq 6$ and uniform distributions (the best case) I have performed the calculations with computer algebra²; since the state space explodes quickly, larger values are hard to evaluate. The results (rounded upwards) are

^{Plots show $\mathbb{E}\,\text{steps}$ as a function of $N$; to the left a regular and to the right a logarithmic plot.}

The growth seems to be exponential but the values are too small to give good estimates.

As for stability against perturbations of the $p_i$ we can look at the situation for $N=3$:

^{Plot shows $\mathbb{E}\,\text{steps}$ as a function of $p_0$ and $p_1$; naturally, $p_2 = 1 - p_0 - p_1$.}

Assuming similar pictures for larger $N$ (kernel crashes computing symbolic results even for $N=4$), the expected number of steps seems to be quite stable for all but the most extreme choices (almost all or none mass at some $p_i$).

For comparison, simulating an $\epsilon$-biased coin (e.g. by assigning die results to $0$ and $1$ as evenly as possible), using this to simulate a fair coin and finally performing bit-wise rejection sampling requires at most

$\qquad\displaystyle 2\lceil \log N \rceil \cdot \frac{3 + 4\epsilon^2}{1 - 4\epsilon^2}$

die rolls in expectation -- you should probably stick with that.

1. Since the chain is absorbing in $(11)$ the edges hinted at in gray are never traversed and do not influence the calculations. I include them merely for completeness and illustrative purposes.
2. Implementation in Mathematica 10 (Notebook, Bare Source); sorry, it's what I know for these kinds of problems.

Just a quick comment regarding the case $N = 2$. Take some large number $m$, and sample $m$ throws of the die. If you got $k$ heads then you can extract $\log \binom{m}{k}$ bits. Assuming the die is $p$ biased, the average amount of information is

You can use the same method for general $N$, and you will probably get the same $H(\vec{p})$. These algorithms are only optimal in the limit, and there might be algorithms reaching the limit faster than these. In fact, I neglected to compute the speed of convergence - it might be an interesting exercise.

I would hazard the following answer.

The specific case of 2 you mentioned above is the specific case of expanding $(p + q)^2$ (where $p$ is prob of head and $q$ prob of tail) which gives you a term $2pq$ This means you can get $pq$ for one case and $qp$ for the other case. You will need to repeat sampling until you see either $pq$ or $qp$ (head-tail or tail-head) Using them as simulation, you will give equal probability.

When $N=3$ you have the expansion $(p + q + r)^3$ which gives you the term $pqr$. In this case, you do the same thing, sampling until you see all 3 outcomes $q$, $p$, $r$ in some order in 3 consecutive trials.

The same thing apply for the general case. Thinking carefully, I have to say the case of 2 is the best case where one can work things out in the expansion. When $N=3$ there are 6 different sequences for $pqr$ and there are many other terms in the expansion. I would feel quite uncomfortable with other terms where there are many more outcomes.

.

Extra:

This makes me think about the idea of simply sampling a lot to estimate the probability of each outcome of the dice. In this simplest case of one layer model with no hidden layer (a known model), we can work out a bound to conclude that the estimation converges quickly. In fact Chernoff bound shows us that the error goes down exponentially as sampling increases (linearly).

Now that a good estimation of the probabilities for each side of the dice is known, there are many options. One option is that we can do the expansion above again, but this time we can potentially use many other terms in the expansion that have the same value as $\prod_{i=1}^{i=n} p_i$ (or any term that you use as based sequence). This will be a bit more efficient because more terms in the expansion will be used. But I admit I don't know if this will result in the smallest number of calls to the oracle to have a guarantee on whatever preconditions (such as confidence parameter), if they are given.

Nevertheless, this approach is an answer to different flavor of the question. The question asks for guaranteed perfect unbiased-ness at the cost of potentially large sampling (though low prob). This approach only uses finite sampling with bound on confidence parameter. So I don't think this approach is appropriate to this question even though it is very interesting.