Should You Roll 1 or 2 Dice in Risk Defense?

TL;DR: The defender should roll two dice.

Last week I was playing Risk with a couple friends, and we got into a bit of a debate on defensive strategies. In particular, the number of dice that you should roll when defending with two or more armies. For those of you who don’t know the rules of Risk, the attacking player can roll up to three dice, assuming they have four or more troops in the territory that they are attacking from, and the defender can roll two dice as long as they have two or more defending units. The defender then compares their highest roll with the attacker’s highest, and their second highest (if they rolled two) with the attacker’s second highest (if the attacker rolled two or three). Players lose a unit for each matchup in which the opponent has a better roll, so the possible results if the defender rolls two dice are that the attacker loses two, the defender loses two, or each player loses one. However if the defender only rolls one, then they can lose a unit or the attacker can lose a unit. Importantly, the defender wins ties.

Lord of the Rings Risk staging area where you put the unit pieces that each dice represents

There is obviously a thrill to taking out two attacking units as a defender, but due to how the board is set up initially you are often defending with only two units, so losing both in a single roll is devastating. But my intuition was that a defender, due to winning ties, has a better chance at taking out at least one attacking unit if they roll close to as many dice as the attacker. An alternative way of thinking about it was that rolling two at once only allowed the attacker three rolls to beat the defender’s two, as opposed to the six they would get if the defender only rolled one at a time. But, of course, my friend did not accept these arguments as incontrovertible facts, so I left the table on a mission to prove that two was better than one.

I decided to go with a brute force method rather than proving it analytically because my stats skills are rusty and it seemed easier to understand, and therefore more convincing. My code is below, but essentially the program just tallies up the different outcomes for every possible result of the 3v1 battle and the 3v2 battle. I would like to sit down at some point and actually prove it, and maybe come up with a general formula for the odds of any n vs. m battle.

It turns out that I was correct that the defender should roll two dice, although the expected results are fairly similar. If the defender rolls one dice, their expected outcome is to lose .32 units, and if they roll two, their expected outcome is to lose .16 units. So one dice is almost twice as bad as two dice, but the difference is fairly small in absolute numbers. Interestingly, if you played with dice that have 16 or more sides, the defender is better off only rolling one dice.

Here are the total number of roll results that lead to the various outcomes (the attacker is rolling three dice in all of these situations).

Defender rolls one die, kills one attacker: 441
Defender rolls one die, loses one troop: 855

Defender rolls two die, kills two attackers: 2275
Defender rolls two die, splits: 2611
Defender rolls two die, loses two troops: 2890

And here is my (hastily written, non-optimized) code:

import heapq
numbers = [1,2,3,4,5,6]
#0th index is number of results where defender wins
#1st index is number of results where attacker wins
one_die = [0,0]
#0th index is number of results where attacker loses two
#1st index is number of splits
#2nd index is number of results where defender loses two
two_die = [0,0,0]
for a1 in numbers:
 for a2 in numbers:
  for a3 in numbers:
   top_two = heapq.nlargest(2, [a1, a2, a3])
   for d1 in numbers:
    #If defender rolls one, match it up with highest attacking die
    if (d1 >= top_two[0]):
     one_die[0]+=1
    else:
     one_die[1]+=1
    for d2 in numbers:
     sorted_d = heapq.nlargest(2, [d1, d2])
     ind = 0
     #If defender rolls two, match up dice in sorted order
     for i in [0,1]:
      if (sorted_d[i] < top_two[i]):
       ind += 1
     two_die[ind]+=1
ev_one = (one_die[0] + one_die[1]*-1) / sum(one_die)
print(ev_one)
ev_two = (two_die[0] * 2 + two_die[2] * -2) / sum(two_die)
print(ev_two)

P.S. Apparently dice is both the singular and the plural of the word, and “die” is no longer the singular.