The probability of never discarding any die is $$\left(\frac{11}{12}\frac{19}{20}\frac{29}{30}\right)^8$$
The probability of discarding the $12$-die only is $$\sum_{k=0}^7\left(\frac{11}{12}\frac{19}{20}\frac{29}{30}\right)^k\left(\frac{1}{12}\frac{19}{20}\frac{29}{30}\right)\left(\frac{19}{20}\frac{29}{30}\right)^{9-k}$$
The probability of discarding the $12$-die first and the $20$-die second is $$\sum_{k=0}^7\sum_{l=0}^{9-k}\left(\frac{11}{12}\frac{19}{20}\frac{29}{30}\right)^k\left(\frac{1}{12}\frac{19}{20}\frac{29}{30}\right)\left(\frac{19}{20}\frac{29}{30}\right)^l \left(\frac{1}{20}\frac{29}{30}\right)\left(\frac{29}{30}\right)^{10-k-l}$$
The probability of discarding the $12$-die and the $20$-die simultaneously, and never discarding the $30$-die is $$\sum_{k=0}^7\left(\frac{11}{12}\frac{19}{20}\frac{29}{30}\right)^k\left(\frac{1}{12}\frac{1}{20}\frac{29}{30}\right)\left(\frac{29}{30}\right)^{11-k}$$
From these formulas and their symmetric versions (discarding the $20$-die only, etc.) you can work out the probability of the complementary event.
Note that the formulas can be simplified a bit, e.g. the one with a double sum is $$\left(\frac{29}{30}\right)^{12}\left(\frac{1}{12}\frac{19}{20}\frac{1}{20}\right)
\sum_{k=0}^7
\left(\frac{11}{12}\frac{19}{20}\right)^k\cdot
\sum_{l=0}^{9-k}
\left(\frac{19}{20}\right)^l $$
An efficient pool evaluation algorithm
In general, if the function that scores a pool (or in this case, a pair of pools) is allowed to depend on the entire ordered rolled sequence, then the function would have to be evaluated on all possible such sequences, the number of which is exponential in the number of dice. Even if we restrict ourselves to functions that only depend on unordered rolled sequences (or equivalently, the sequence after sorting each pool), the number of such sequences grows as a high order polynomial (this can be derived from e.g. comments on this answer to another question).
However, it turns out that if we can phrase the pool scoring function as a state transition over tuples (outcome, number of dice in each pool that rolled that outcome) with not too many states, we can reduce the time complexity to a polynomial of reasonable order. Here's a fuller explanation of the algorithm. This RISK-like scoring can indeed be expressed like this.
Expressing a single stage
I implemented this approach as part of my hdroller Python library. You can try this computation in your
browser using this JupyterLite notebook.
The first step is to express a single stage of a RISK-like pool evaluation as a state transition function as defined above. Given the number of dice on each side, this computes the distribution of the number of remaining dice on each side after a single stage.
class EvalRiskAttrition(hdroller.EvalPool):
def next_state(self, state, outcome, a, b):
if state is None:
score_a, score_b, advantage = 0, 0, 0
else:
score_a, score_b, advantage = state
# Advantage is the number of unpaired dice that rolled a previous (higher) number.
# If positive, it favors side A, otherwise it favors side B.
# We pair them off with newly-rolled dice of the disadvantaged side.
if advantage > 0:
score_a += min(b, advantage)
elif advantage < 0:
score_b += min(a, -advantage)
advantage += a - b
return score_a, score_b, advantage
def final_outcome(self, final_state, pool_a, pool_b):
score_a, score_b, advantage = final_state
if score_a == 0 and score_b == 0:
# No change. Eliminate this outcome to prevent infinite looping.
# This is equivalent to rerolling the contest until at least one die is removed.
return hdroller.Reroll
# Each side loses dice equal to the other's hits.
# The result is the number of remaining dice on each side.
return pool_a.num_dice() - score_b, pool_b.num_dice() - score_a
def direction(self, *_):
# See outcomes in descending order.
return -1
eval_risk = EvalRiskAttrition().bind_dice(hdroller.d6, hdroller.d6)
Finding the fixed point
Since we reroll each stage until at least one die is eliminated, the number of stages is bounded by the total number of dice. Therefore we can then repeatedly apply this attrition until everything reaches an absorbing state. We could compute the maximum number of stages explicitly, or just look for a fixed point.
def risk_attrition(a, b):
if a == 0 or b == 0:
# If one side has run out of dice, no more rolling is necessary.
return a, b
else:
# Otherwise, run the contest.
return eval_risk(a, b)
# 4 dice vs. 3 dice.
a = 4
b = 3
# Construct a die that always rolls the tuple (4, 3).
# Then, apply the risk_attrition function recursively until reaching a fixed point.
result = hdroller.Die((a, b)).sub(risk_attrition, max_depth=None, denominator_method='reduce')
# The result is how many dice are remaining at the end.
# The loser has 0 dice, and the winner has 1 or more dice.
print(result)
Denominator: 350190883979307611136000
| Outcome[0] |
Outcome[1] |
Weight |
Probability |
| 0 |
1 |
11215262070269292175045 |
3.202614% |
| 0 |
2 |
26208104640905472978960 |
7.483948% |
| 0 |
3 |
44739780296050462334400 |
12.775827% |
| 1 |
0 |
11215262070269292175045 |
3.202614% |
| 2 |
0 |
28634396560615778884510 |
8.176797% |
| 3 |
0 |
60745546693229402315592 |
17.346410% |
| 4 |
0 |
167432531647967910272448 |
47.811790% |
If you just want to know the winner:
print(result.sub(lambda a, b: 'a' if a > 0 else 'b').reduce())
Denominator: 2244741412001587200
| Outcome |
Weight |
Probability |
| a |
1718071452659096719 |
76.537611% |
| b |
526669959342490481 |
23.462389% |
This can compute a dozen dice on each side without much issue, though the denominator can get quite massive.
Best Answer
For the second part of the question, we have $4$ different states: nothing (the initial state), one pair, one pair and a distinct singleton, and two distinct pairs (the absorbing winning state). Let’s number them $0$ through $3$ in that order. Then the transition matrix is
$$ 6^{-4}\pmatrix{ 6\cdot5\cdot4\cdot3&0&0&0\\ 6\cdot1\cdot1\cdot1&6^2\cdot1\cdot1&0&0\\ 6\cdot5\cdot4\cdot\binom42+6\cdot5\cdot4&6^2\cdot6\cdot5&6^3\cdot5&0\\ 6\cdot5\cdot\binom32&6^2\cdot5&6^3\cdot1&6^4} = 6^{-3}\pmatrix{ 60&0&0&0\\ 1&6&0&0\\ 140&180&180&0\\ 15&30&36&216 }\;. $$
We can let Wolfram|Alpha compute the third power of this matrix:
$$ 6^{-7}\pmatrix{ 6000&0&0&0\\ 111&6&0&0\\ 183230&167580&162000&0\\ 90595&112350&117936&279936 }\;. $$
The probability that the absorbing winning state is reached in three rounds from the initial state is the bottom left entry,
$$ \frac{90595}{279936}\approx0.3236\;. $$
Roughly, you have a $1$ in $3$ chance to get two distinct pairs, a $2$ in $3$ chance to get one pair and a distinct singleton, and a negligible chance to get nothing or only one pair.