Probability of success in Fudge/ Fate dice rolls considering failures

Question

I'm creating a game system based on Fudge/Fate dice rolls and I need to validate if a have a fair distribution. Since I don't have much contact with this for a long time (since high school), I figure that someone here could help me with this.

For those that don't know, a Fudge/Fate dice is a common 6 sided die (d6) where you have 2 faces for each value (-1, 0, +1): (-1, -1, 0, 0, +1, +1). In a Fudge/Fate die, -1 represents a failure and +1 represents a success and for each roll, a failure cancels a success (and 0 means neither).

Then, consider that we always sum the results.
For example, rolling 4 dices (dices are always rolled simultaneously):

• 4dF {0, 0, +1, -1} = 0
• 4dF {0, 0, +1, +1} = +2
• 4dF {0, 0, -1, -1} = -2

I'm trying to discover the probability of getting, for example, at least +20 in 100 rolls. I want to make a spreadsheet where I have the Y-axis as the number of rolls and X-axis as the desired number.

My goal with that is to establish the player range of success based on the number of rolls he has available.

Answer 1

For nonnegative integers $n$, and integers $x$, let $p(n,x)$ be the probability of getting a score of at least $x$ in $n$ rolls.

Then we have the recursion $$ p(n,x)= \begin{cases} 0&\;\;\;\text{if}\;\,n < x\\[4pt] 1&\;\;\;\text{if}\;\,-n \ge x\\[4pt] \frac{1}{3}p(n-1,x-1)+ +\frac{1}{3}p(n-1,x)+ +\frac{1}{3}p(n-1,x+1) &\;\;\;\text{otherwise}\\ \end{cases} $$ Implementing the recursion in Maple, we get $$p(100,20)=\frac{a}{b}\approx .008336093451$$ where $a,b$ are given by \begin{align*} a&=159119821311220187192678211640711891517682398\\[4pt] b&=19088056323407827075424486287615602692670648963 \end{align*}

Note:$\;$The above recursion yields an exact answer as a fraction, but as you can see, the numerators and denominators can be huge, so this method would require a programming language implementation, e.g., Python, or a CAS, such as Maple, rather than, say, Excel.

Here's an implementation in Maple . . .

Here is a table showing the approximate values of $p(100,x)$, for $1\le x \le 100$ . . .

Answer 2

You are really rolling a d3 with results of $-1,0,+1$. For reasonable numbers of dice the normal approximation is a good one. The mean of a single roll is $0$, so the mean of a number of rolls is as well. The variance of a single roll is $\frac 23$ so the variance of $n$ rolls will be $\frac {2n}3$. If we take those as the parameters of a normal distribution, the variance of $100$ rolls is about $66.67$ and the standard deviation is about $8.165$. Getting $+20$ on $100$ rolls is then about $+2.45 \sigma$. From a cumulative z-score table the chance of doing this well or better is about $0.00714$ or a chance in $140$. If you want to generate this in Excel the Wikipedia article gives it in terms of the error function, which Excel supplies.

Answer 3

This is really a comment on quasi's answer, but it won't fit in a comment.

Unless you are considering very large numbers of dice, you can do the calculations in floating point, without appreciable loss of accuracy. Here's a python implementation:

cache = dict()
def p(n,x):
    if n < x: return 0
    if -n >= x: return 1
    if (n,x) in cache:
        return cache[n,x]
    cache[n,x]= (p(n-1,x-1)+p(n-1, x)+p(n-1,x+1))/3
    return cache[n,x]
print(p(100,20))

0.008336093451070253

The function evaluation is instantaneous, and as you see, the answer agrees with all $12$ decimal places given in quasi's answer.