Spin Chance Analysis

[sleepyone]

Note: all this is contingent on the correctness of Xenocidius's simulator.

I'm a bit surprised this hasn't come up, since it's actually not that difficult a problem to solve directly. Why bother? One, it's much faster than running a high number of trials, and two, it has zero variance. Essentially, what the simulator does is select 4 cards from the deck, rejecting pillars in the first eight iterations, then spin using that smaller pool.

Let's make a first approximation by ignoring the chance of getting pillars altogether. To make the math that follows more concise, I'm going to define the following:
P(N, p, k) = (N choose k) * p^k * (1-p)^N-k = Prob(X=k) for X ~ Binom(N,p)
(look up binomial distribution on wikipedia for more info)

The notation that follows could use some work, but meh.

The probability of a given card appearing k times in the 4 slots is P(4, n/N, k), for n = number of given card in deck, N = total cards in deck.

If said card shows up k times in the pool, then we have a probability (k/4)³ of getting that card on any given spin (since the card needs to come up exactly 3 times). It should be intuitive that the total probability of getting a card from a given spin is the sum from k=1 to 4 (technically 0 to 4, but that first term is 0) of the product of these to terms, i.e.
A := \sum_k=0⁴ P(4, n/N, k) * (k/4)³

Repeat for each card in the deck.

Simply applying this formula to the first deck in the AI3 Droprate Tests thread in the Farming Studies / Statistics subforum [nofollow], we get the following results:

Card	Expected	Simulator results
Lightning	0.0432	0.042
Parallel Universe	0.0236	0.023
Immortal	0.0236	0.023
Dimensional Shield	0.0997	0.097
Lobotomizer	0.0236	0.024
Phase Dragon	0.0432	0.043
Phase Spider	0.0685	0.067
Mindgate	0.0685	0.067
Silence	0.0236	0.023

As a first approximation, this is very good, although you'll notice that it's a bit optimistic overall, since I've assumed that pillars won't appear in the pool.

So what happens if we add back p pillars? This part gets a bit more complicated, although we can still explicitly solve it without even resorting to more complicated mathematical constructs like Markov chains.

Let's start by considering 4 additional events E₅ through E₈, corresponding to 5-8 pillars out of first 8 cards chosen.

Event E_i simply appears with probability P(8, p/(N+p), i).

Given event E_i, the probability that a given non-pillar card appears k times looks like:
\sum_j=0^k P(8-i, n/N, j) * P(i-4, n/(N+p), k-j)
(win j copies of the card in the first 8, then k-j copies in the remaining trials)

Similarly, the probability that a given pillar card appears k times is:
P(i-4, n/(N+p), k)

Let's assemble all these parts now. The probability of winning a card that appears n times in a deck with N non-pillars and p pillars is
(1 - \sum_i=5⁸ P(8, p/(N+p))) * A + \sum_i=5⁸ P(8, p/(N+p), i) \sum_k=0⁴  (k/4)³ \sum_j=0^kP(8-i, n/N, j) * P(i-4, n/(N+P), k-j)
if the card is not a pillar, and
\sum_i=5⁸ \sum_k=0⁴ P(8, p/(N+p), i) * P(i-4, n/(N+P), k)
if it is.

This final formula (as evaluated by the below javascript code) yields the following results on that same ai3 deck:

Card	Expected	Simulator results
Aether Pillar	0.0038	0.004
Lightning	0.0423	0.042
Parallel Universe	0.0232	0.023
Immortal	0.0232	0.023
Dimensional Shield	0.0973	0.097
Lobotomizer	0.0232	0.024
Phase Dragon	0.0423	0.043
Phase Spider	0.0669	0.067
Mindgate	0.0669	0.067
Silence	0.0223	0.023

Hope someone finds this at least entertaining.

Code: [Select]

function choose(n,k) {
    var ret = 1;
    for (var i = 0; i < k; i++) {
        ret = ret * (n - i) / (k - i);
    }
    return ret;
}

function prob(N, p, k) {
    // binomial pdf with parameters N, p
    return choose(N,k) * Math.pow(p, k) * Math.pow(1 - p, N-k);
}

function pillarless_yields(n, N) {
    var sum = 0;
    for (var i = 0; i <= 4; i++) {
        sum += Math.pow(i/4, 3) * prob(4, n/N, i);
    }
    return sum;
}

function yields(n, N, P, pillar) {
    // pillar is true if this item is a pillar.
    var psum = 0;
    var sum = 0;
    for (var i = 5; i <= 8; i++) {
        var p = prob(8, P/(N+P), i);
        psum += p;
        for (var k = 0; k < 4; k++) {
            if (!pillar) {
                for (var j = 0; j <= k; j++) {
                    sum += p * Math.pow(k/4, 3) * prob(8-i, n/N, j) * prob(i-4, n/(N+P), k-j);
                }
            } else {
                sum += p * Math.pow(k/4, 3) * prob(i-4, n/(N+P), k);
            }
        }
    }
    if (!pillar) {
        sum += pillarless_yields(n, N) * (1-psum);
    }
    return sum;
}


// These are the distribution of cards in the ai3 aether deck.
var arr = [3,2,2,5,2,3,4,4,2];

console.log(arr.map(function (x) {return 3*yields(x, 27, 15, false);}).join('\n'));;
console.log(3*yields(15, 27, 15, true));


[10 men]

You are absolutely right that Xeno's Simulator is kinda inelegant for determining all the droprates. Back when we investigated drop rates in the wake of the FG farming study, we used the exact numbers as well.

[sleepyone]

Interesting, I guess I completely missed that thread. I just played a game in the trainer and confirmed in the actual game that more than four unique cards can come up in the same set of spins. If I had to guess, this means that either the spins are independent but the model is correct (best-case scenario), or the model is simply incorrect (e.g. pool is larger than four cards).

edit: if the model still needs confirming, obviously the bonus electrum (first two slots are the same) is more frequent than bonus card, which yields a lower relative variance (so fewer trials needed to be more certain). The problem is actually gathering the data in the first case, I suppose.

[10 men]

If I had to guess, this means that either the spins are independent but the model is correct

Yes, that is the case. For each spin the algorithm is performed seperately. Fwiw the algorithm was pulled directly from the game code by Dark Weaver. Of course it's possible that the algorithm changed in the last 3 years, but I'm pretty sure it didn't - there weren't many updates since then and I also didn't notice any differences in spin behavior.

[CuCN]

Overall this looks correct.

Your javascript code does this correctly, but there's a mistake in the formula posted here. The fourth sum, across j, is missing.

Let's assemble all these parts now. The probability of winning a card that appears n times in a deck with N non-pillars and p pillars is
(1 - \sum_i=5⁸ P(8, p/(N+p))) * A + \sum_i=5⁸ P(8, p/(N+p), i) \sum_k=0⁴ (k/4)³ * P(8-i, n/N, k) * P(i-4, n/(N+P), k)
if the card is not a pillar

[sleepyone]

Good catch, I guess I just got a bit overzealous with the copy-pasting. Fixed in the original post.

[CuCN]

I've found a minor mistake in your program that affects the numbers by about 0.0001. In the "yields" function, the loop for k should have "k <= 4", not "k < 4".

The summations can be reduced to polynomials in two variables.
Let x=n/(N+p) and let y=p/(N+p). Then the probability of winning a card is
(1/16)(x(1+y+y²+y³+y⁴+y⁵-13y⁶+15y⁷-5y⁸)+x²(9+18y+27y²+36y³+45y⁴+54y⁵-189y⁶+72y⁷+15y⁸)+x³(6+18y+36y²+60y³+90y⁴+126y⁵-84y⁶-36y⁷-6y⁸))
if the card is not a pillar, and otherwise:
(1/16)(x(14y⁵-28y⁶+20y⁷-5y⁸)+x²(42y⁶-48y⁷+15y⁸)+x³(12y⁷-6y⁸))

The polynomials in y only need to be calculated once for each deck, so it comes down to a cubic equation in x.

For example, when y=15/42 (as for the ai3 deck with 15 pillars in 42 cards), the probability of a card that isn't a pillar is
(1/23612624896)(2265548601x+31321258539x²+32094593346x³)
and for a pillar
(1/23612624896)(54221875x+81984375x²+10781250x³)

giving the results:

Card	Copies	Calculated (x3)
Aether Pillar	15	0.00385132
Lightning	3	0.042349
Parallel Universe	2	0.0231705
Immortal	2	0.0231705
Dimensional Shield	5	0.0975435
Lobotomizer	2	0.0231705
Phase Dragon	3	0.042349
Phase Spider	4	0.0670299
Mindgate	4	0.0670299
Silence	2	0.0231705