# Russian roulette: a mathematical analysis

A pompous title, because the underlying math isn't that complicated, but still, here we go.

The game of Russian roulette is played as follows:

We have a revolver with ap-round cylinder loaded with only one round. The cylinder is spun so that the round lies in a position which is assumed to be random. We havenplayers numbered 0, 1, 2, ...,n-1 standing in a circle. Each player, starting at player 0, will try to shoot himself in the head. If the player dies, the game stops. If the player misses, they pass the revolver to the next player (playern-1 passes to player 0).

There are two main variants: either players don't spin the cylinder when they give it to the next player, or they spin it (and we assume that it puts the bullet in a new random position chosen uniformly at random and independently from other draws).

## Players spin

In this version, the cylinder is spun before passing the revolver.
This is equivalent to each player rolling a q-sided die, or drawing from
an urn *with replacement*. In this section, we will write
*f* = 1/*p* for brevity.

Here is my take at solving this one. Let us denote by
*q _{i}* the probability that player

*i*is the one to die. Notice that this game is

*memoryless*in the sense that if a certain number

*k*of rounds have been played without anyone dying, then the situation is exactly the same as in the beginning of the game (except the revolver might be in someone else's hands). For this reason, we have

*q*= (1 -

_{i}*f*)·

*q*

_{i-1}for all

*i*: a player's odds of dying are that of the previous player times the probability of the revolver

*not*firing. It isn't very hard to see that this is true for the first round, and the observation about the game being memoryless explains why this continues to be true.

Now, we use the fact that the probabilities sum to one, ie.
*q*_{0} + *q*_{1} + ⋯ +
*q*_{n-1} = 1. This means that
*q*_{0} + *q*_{0}(1 - *f*) + ⋯ +
*q*_{0}(1 - *f*)^{n-1}, which is
*q*_{0}((1 - *f*)^{0} + (1 -
*f*)^{1} + ⋯ + (1 - *f*)^{n-1}), is equal
to 1. Using the geometric
series formulae, we can write that *q*_{0}(1 - (1 -
*f*)^{n}) = 1 - (1 - *f*) = *f*.
Now that we know *q*_{0} and can express
*q*_{i} as a function of *q*_{0},
we have the general solution:

q_{i}=f(1 -f)^{i}/ (1 - (1 -f)^{n})

Notice that for an (countable) infinite number of players, the
denominator becomes 1, and the formula *q*_{i} =
*f*(1 - *f*)^{i}. This makes sense: for
an infinite number of players, each players gets the revolver at most
once, and their odds of dying is the odds that each of the previous
players survived times the odds that they die. Also note that,
obviously, the game is not fair, and that for *i* < *j*,
*q*_{i} > *q*_{j}. Of
course, the game is more unfair for larger values of *f* (because
the penalty for being among the first to play is higher if the
probability of dying is higher and the number of expected rounds is
lower).

## Players don't spin

This would be the version where players draw from an urn *without
replacement*.

At first glance, this might seem more complicated, because the game
isn't memoryless anymore. You might be tempted to think of it as a tree:
either player 1 dies with probability 1/*p*, or player 2 dies
with probability (1 - 1/*p*) · (1/(*p*-1)) = 1/*p*
(interesting!), or player 3 dies with probability (1 - 1/*p*) ·
(1 - 1/(*p*-1)) · (1/(*p*-2)) = 1/*p* (very interesting!),
and a pattern seems to emerge...

Well, this is not at all the right way to think about the problem,
and I am ashamed to admit that I did not see why before someone
explained to me. The right way to see things is that when you're
spinning the cylinder at the beginning, you are effectively choosing
which player will die, uniformly at random. If *p* ≤ *n*,
then it is now obvious that the first *p* players have
probability 1/*p* of dying and the others have probability 0. If
*p* > *n*, then it's harder to write but not much more
complicated: writing *p* = *u n* + *v* (where
*u* is the quotient and *v* the remainder), we have
*q*_{i} = (*u* + 1)/*p* for *i* <
*v* and *q*_{i} = *u*/*p* for
*i* ≥ *v*.

As a consequence, this variant is fair if (and only if) *p* is
a multiple of *n*.