# Playing With a Game

In a recent comment (that I sadly cannot find any longer) in https://www.reddit.com/r/math/, someone mentioned the following game. There are *n* players, and they each independently choose a natural number. The player with the lowest unique number wins the game. So if two people choose 1, a third chooses 2, and a fourth chooses 5, then the third player wins: the 1s were not unique, so 2 was the least among the unique numbers chosen. (Presumably, though this wasn’t specified in the comment, if there is no unique number among all players, then no one wins).

I got nerd-sniped, so I’ll share my investigation.

For me, since the solution to the general problem wasn’t obvious, it made sense to specialize. Let’s say there are *n* players, and just to make the game finite, let’s say that instead of choosing *any* natural number, you choose a number from 1 to *m*. Choosing very large numbers is surely a bad strategy anyway, so intuitively I expect any reasonably large choice of *m* to give very similar results.

*n* = 2

Let’s start with the case where *n* = 2. This one turns out to be easy: you should always pick 1, daring your opponent to pick 1, as well. We can induct on *m* to prove this. If *m* = 1, then you are required to pick 1 by the rules. But if *m* > 1, suppose you pick *m*. Either your opponent also picks *m* and you both lose, or your opponent picks a number smaller than *m* and you still lose. Clearly, this is a bad strategy, and you always do at least as well choosing one of the first *m - *1 options instead. This reduces the game to one where we already know the best strategy is to pick 1.

That wasn’t very interesting, so let’s try more players.

## n = 3, m = 2

Suppose there are three players, each choosing either 1 or 2. It’s impossible for all three players to choose a different number! If you do manage to pick a unique number, then, you will be the only player to do so, so it will always be the *least* unique number simply because it’s the *only* one!

If you don’t think your opponents will have figured this out, you might be tempted to pick 2, in hopes that your opponents go for 1 to try to get the least number, and you’ll be the only one choosing 2. But this makes you predictable, so the other players can try to take advantage. But if one of the other players reasons the same way, you both are guaranteed to lose! What we want here is a Nash equilibrium: a strategy for all players such that no single player can do better by deviating from that strategy.

It’s not hard to see that all players should flip a coin, choosing either 1 or 2 with equal probability. There’s a 25% chance each that a player picks the unique number and wins, and there’s a 25% chance that they all choose the same number and all lose. Regrettable, but anything you do to try to avoid that outcome just makes your play more predictable so that the other players could exploit that.

It’s interesting to look at the actual computation. When computing a Nash equilibrium, we generally rely on the indifference principle: a player should always be indifferent between any choice that they make at random, since otherwise, they would take the one with the better outcome and always play that instead.

This is a bit counter-intuitive! Naively, you might think that the optimal strategy is the one that gives the best expected result, but when a Nash equilibrium involves a random choice— known as a *mixed* strategy — then any single player actually does equally well against other optimal players no matter which mix of those random choices they make! In this game, though, predictability is a weakness. Just as a poker player tries to avoid ‘tells’ that give away the strength of their hand, players in this number-choosing game need to be unpredictable. The reason for playing the Nash equilibrium *isn’t* that it gives the best expected result against optimal opponents, but rather that it can’t be *exploited* by an opponent.

Let’s apply this indifference principle. This game is completely symmetric — there’s no order of turns, and all players have the same choices and payoffs available — so an optimal strategy ought to be the same for any player. Then, let’s say *p* is the probability that any single player will choose 1. Then if *you* choose 1, you will win with probability (1 — *p*)², while if you choose 2, you’ll win with probability *p*². If you set these equal to each other as per the indifference principle, and solve the equation, you get *p* = 0.5, as we reasoned above.

## n = 3, m = 3

Things get more interesting if each player can choose 1, 2, or 3. Now it’s possible for each player to choose uniquely, so it starts to matter *which* unique number you pick. Let’s say each player chooses 1, 2, and 3 with the probabilities *p*, *q*, and *r* respectively. We can analyze the probability of winning with each choice.

- If you pick 1, then you always win
*unless*someone else also picks a 1. Your chance of winning, then, is (*q*+*r*)². - If you pick 2, then for you to win, either
*both*other players need to pick 1 (eliminating each other because of uniqueness and leaving you to win by default), or*both*other players need to pick 3, so that you’ve picked the least number. Your chance of winning is*p*²*r*². - If you pick 3, then you need your opponents to pick the same different number: either 1 or 2. Your chance of winning is
*p*²*q*².

Setting these equal to each other immediately shows us that since *p*²* *+* q*² = *p*²* *+* r*², we must conclude that *q* = *r.* Then *p*²* *+* q*² = (*q* + *r*)² = 4*q*², so *p*² = 3*q*² = 3*r*². Together with *p* + *q* + *r* = 1, we can conclude that *p* = 2√3 - 3 ≈ 0.464, while *q* = *r* = 2 - √3 ≈ 0.268.

This is our first really interesting result. Can we generalize?

## n = 3, in general

The reasoning above generalizes well. If there are three players, and you pick a number *k*, you are betting that either the other two players will pick the same number less than *k*, or they will each pick numbers greater than *k* (regardless of whether they are the same one).

I’ll switch notation here for convenience. Let *X* be a random variable representing a choice by a player from the Nash equilibrium strategy. Then if you choose *k*, your probability of winning is P(*X*=1)² + … + P(*X*=*k*-1)² + P(*X>k*)². The indifference principle tells us that this should be equal for any choice of *k*. Equivalently, for any *k* from 1 to *m *- 1, the probability of winning when choosing *k* is the same as the probability when choosing *k* + 1. So:

- P(
*X*=1)² + … + P(*X*=*k*-1)² + P(*X>k*)² = P(*X*=1)² + … + P(*X*=*k*)² + P(*X>k*+1)² - Cancelling the common terms: P(
*X>k*)² = P(*X*=*k*)² + P(*X>k*+1)² - Rearranging: P(
*X*=*k*) = √(P(*X≥k*+1)² - P(*X>k*+1)²)

This gives us a recursive formula that we can use (in reverse) to compute P(*X*=*k*), if only we knew P(*X*=*m*) to get started. If we just pick something arbitrary, though, it turns out that all the results are just multiples of that choice. We can then divide by the sum of them all to normalize the probabilities to sum to 1.

Here I can write some code (in Haskell):

`import Probability.Distribution (Distribution, categorical, probabilities)`

nashEquilibriumTo :: Integer -> Distribution Double Integer

nashEquilibriumTo m = categorical (zip allPs [1 ..])

where

allPs = go m 1 0 []

go 1 pEqual pGreater ps = (/ (pEqual + pGreater)) <$> (pEqual : ps)

go k pEqual pGreater ps =

let pGreaterEqual = pEqual + pGreater

in go

(k - 1)

(sqrt (pGreaterEqual * pGreaterEqual - pGreater * pGreater))

pGreaterEqual

(pEqual : ps)

main :: IO ()

main = print (probabilities (nashEquilibriumTo 100))

I’ve used a probability library from https://github.com/cdsmith/prob that I wrote with Shae Erisson during a fun hacking session a few years ago. It doesn’t help yet, but we’ll play around with some of its further features below.

Trying a few large values for *m* confirms my suspicion that any reasonably large choice of *m* gives effectively the same result.

`1 -> 0.4563109873079237`

2 -> 0.24809127016999155

3 -> 0.1348844977362459

4 -> 7.333521940168612e-2

5 -> 3.987155303205954e-2

6 -> 2.1677725302500214e-2

7 -> 1.1785941067126387e-2

By inspection, this appears to be a geometric distribution, parameterized by the probability 0.4563109873079237. We can check that the distribution is geometric, which just means that for all *k* < *m* - 1, the ratio P(*X > k*) / P(*X *≥ *k*) is the same as P(*X > k *+ 1) / P(*X* ≥ *k* + 1). This is the defining property of a geometric distribution, and some simple algebra confirms that it holds in this case.

But what is this bizarre number? A few Google queries gets us to an answer of sorts. A 2002 Ph.D. dissertation by Joseph Myers seems to arrive at the same number in the solution to a question about graph theory, where it’s identified as the real root of the polynomial *x*³ - 4*x*² + 6*x *- 2. We can check that this is right for a geometric distribution. Starting with P(*X*=*k*) = √(P(*X≥k*+1)² -P(*X>k*+1)²) where *k *= 1, we get P(*X*=1) = √(P(*X ≥ *2)² -P(*X > *2)²). If P(*X*=1) = *p*, then P(*X ≥ *2) = 1 - *p*, and P(*X > *2) = (1 - *p*)², so we have *p* = √((1-*p*)² - ((1 - *p)*²)²), which indeed expands to *p*⁴ - 4*p*³ + 6*p*² - 2*p* = 0, so either *p* = 0 (which is impossible for a geometric distribution), or *p*³ - 4*p*² + 6*p* - 2 = 0, giving the probability seen above. (How and if this is connected to the graph theory question investigated in that dissertation, though, is certainly beyond my comprehension.)

You may wonder, in these large limiting cases, how often it turns out that no one wins, or that we see wins with each number. Answering questions like this is why I chose to use my probability library. We can first define a function to implement the game’s basic rule:

`leastUnique :: (Ord a) => [a] -> Maybe a`

leastUnique xs = listToMaybe [x | [x] <- group (sort xs)]

And then we can define the whole game using the strategy above for each player:

`gameTo :: Integer -> Distribution Double (Maybe Integer)`

gameTo m = do

ns <- replicateM 3 (nashEquilibriumTo m)

return (leastUnique ns)

Then we can update `main`

to tell us the distribution of game outcomes, rather than plays:

`main :: IO ()`

main = print (probabilities (gameTo 100))

And get these probabilities:

`Nothing -> 0.11320677243374572`

Just 1 -> 0.40465349320873445

Just 2 -> 0.22000565820506113

Just 3 -> 0.11961465909617276

Just 4 -> 6.503317590749513e-2

Just 5 -> 3.535782320137907e-2

Just 6 -> 1.9223659987298684e-2

Just 7 -> 1.0451692718822408e-2

An 11% probability of no winner for large *m* is an improvement over the 25% we computed for *m* = 2. Once again, a least unique number greater than 7 has less than 1% probability, and the probabilities drop even more rapidly from there.

## More than three players?

With an arbitrary number of players, the expressions for the probability of winning grow rather more involved, since you must consider the possibility that *some* other players have chosen numbers greater than yours, while *others *have chosen smaller numbers that are duplicated, possibly in twos or in threes.

For the four-player case, this isn’t too bad. The three winning possibilities are:

- All three other players choose the same smaller number. This has probability P(
*X*=1)³ + … + P(*X*=*k*-1)³ - All three other players choose larger numbers, though not necessarily the same one. This has probability P(
*X*>*k*)³ - Two of the three other players choose the same smaller number, and the third chooses a larger number. This has probability 3 P(
*X*>*k*) (P(*X*=1)² + … + P(*X*=*k*-1)²)

You could possibly work out how to compute this one without too much difficulty. The algebra gets harder, though, and I dug deep enough to determine that the Nash equilibrium is no longer a geometric distribution. If you assume the Nash equilibrium is geometric, then numerically, the probability of choosing 1 that gives 1 and 2 equal rewards would need to be about 0.350788, but this choice gives too small a reward for choosing 3 or more, implying they ought to be chosen less often.

For larger *n*, even stating the equations turns into a nontrivial problem of accurately counting the possible ways to win. I’d certainly be interested if there’s a nice-looking result here, but I do not yet know what it is.

## Numerical solutions

We can solve this numerically, though. Using the probability library mentioned above, one can easily compute, for any finite game and any strategy (as a probability distribution of moves) the expected benefit for each choice.

`expectedOutcomesTo :: Int -> Int -> Distribution Double Int -> [Double]`

expectedOutcomesTo n m dist =

[ probability (== Just i) $ leastUnique . (i :) <$> replicateM (n - 1) dist

| i <- [1 .. m]

]

We can then then iteratively adjust the probability of each choice slightly based on how its expected outcome compares to other expected outcomes in the distribution. It turns out to be good enough to compare with an immediate neighbor. Just so that all of our distributions remain valid, instead of working with the global probabilities P(*X*=*k*), we’ll do the computation with conditional probabilities P(*X *= *k *| *X *≥ *k*), so that any sequence of probabilities is valid, without worrying about whether they sum to 1. Given this list of conditional probabilities, we can produce a probability distribution like this.

`distFromConditionalStrategy :: [Double] -> Distribution Double Int`

distFromConditionalStrategy = go 1

where

go i [] = pure i

go i (q : qs) = do

choice <- bernoulli q

if choice then pure i else go (i + 1) qs

Then we can optimize numerically, using the difference of each choice’s win probability from its neighbor as a diff to add to the conditional probability of that choice.

`refine :: Int -> Int -> [Double] -> Distribution Double Int`

refine n iters strategy

| iters == 0 = equilibrium

| otherwise =

let ps = expectedOutcomesTo n m equilibrium

delta = zipWith subtract (drop 1 ps) ps

adjs = zipWith (+) strategy delta

in refine n (iters - 1) adjs

where

m = length strategy + 1

equilibrium = distFromConditionalStrategy strategy

It works well enough to run this for 10,000 iterations at *n* = 4, *m* = 10.

`main :: IO ()`

main = do

let n = 4

m = 10

d = refine n 10000 (replicate (m - 1) 0.3)

print $ probabilities d

print $ expectedOutcomesTo n m d

The resulting probability distribution is, to me, at least, quite surprising! I would have expected that more players would incentivize you to choose a higher number, since the additional players make collisions on low numbers more likely. But it seems the opposite is true. While three players at least occasionally (with 1% or more probability) should choose numbers up to 7, four players should apparently stop at 3.

Huh. I’m not sure why this is true, but I’ve checked the computation in a few ways, and it seems to be a real phenomenon. Please leave a comment if you have a better intuition for why it ought to be so!

With five players, at least, we see some larger numbers again in the Nash equilibrium, lending support to the idea that there was something unusual going on with the four player case. Here’s the strategy for five players:

The six player variant retracts the distribution a little, reducing the probabilities of choosing 5 or 6, but then 7 players expands the choices a bit, and it’s starting to become a pattern that even numbers of players lend themselves to a tighter style of play, while odd numbers open up the strategy.

In general, it looks like this is converging to something. The computations are also getting progressively slower, so let’s stop there.

## Game variants

There is plenty of room for variation in the game, which would change the analysis. If you’re looking for a variant to explore on your own, in addition to expanding the game to more players, you might try these:

- What if a tie awards each player an equal fraction of the reward for a full win, instead of nothing at all? (This actually simplifies the analysis a bit!)
- What if, instead of all wins being equal, we found the least unique number, and paid that player an amount equal to the number itself? Now there’s somewhat less of an incentive for players to choose small numbers, since a larger number gives a large payoff! This gives the problem something like a prisoner’s dilemma flavor, where players could coordinate to make more money, but leave themselves open to being undercut by someone willing to make a small profit by betraying the coordinated strategy.

What other variants might be interesting?

## Addendum (Sep 26): Making it faster

As is often the case, the naive code I originally wrote can be significantly improved. In this case, the code was evaluating probabilities by enumerating all the ways players might choose numbers, and then computing the winner for each one. For large values of *m* and *n* this is a lot, and it grows exponentially.

There’s a better way. We don’t need to remember each individual choice to determine the outcome of the game in the presence of further choices. Instead, we need only determine which numbers have been chosen once, and which have been chosen more than once.

`data GameState = GameState`

{ dups :: Set Int,

uniqs :: Set Int

}

deriving (Eq, Ord)

To add a new choice to a `GameState`

requires checking whether it’s one of the existing unique or duplicate choices:

`addToState :: Int -> GameState -> GameState`

addToState n gs@(GameState dups uniqs)

| Set.member n dups = gs

| Set.member n uniqs = GameState (Set.insert n dups) (Set.delete n uniqs)

| otherwise = GameState dups (Set.insert n uniqs)

We can now directly compute the distribution of `GameState`

corresponding to a set of *n* players playing moves with a given distribution. The use of `simplify`

from the probability library here is crucial: it combines all the different paths that lead to the same outcome into a single case, avoiding the exponential explosion.

`stateDist :: Int -> Distribution Double Int -> Distribution Double GameState`

stateDist n moves = go n (pure (GameState mempty mempty))

where

go 0 states = states

go i states = go (i - 1) (simplify $ addToState <$> moves <*> states)

Now it remains to determine whether a certain move can win, given the game state resulting from the remaining moves.

`win :: Int -> GameState -> Bool`

win n (GameState dups uniqs) =

not (Set.member n dups) && maybe True (> n) (Set.lookupMin uniqs)

Finally, we update the function that computes win probabilities to use this new code.

`expectedOutcomesTo :: Int -> Int -> Distribution Double Int -> [Double]`

expectedOutcomesTo n m dist = [probability (win i) states | i <- [1 .. m]]

where

states = stateDist (n - 1) dist

The result is that while I previously had to leave the code running overnight to compute the *n *= 8 case, I can now easily compute cases up to 15 players with enough patience. This would involve computing the winner for about a quadrillion games in the naive code, making it hopeless , but the simplification reduces that to something feasible.

It seems that once you leave behind small numbers of players where odd combinatorial things happen, the equilibrium eventually follows a smooth pattern. I suppose with enough players, the probability for every number would peak and then decline, just as we see for 4 and 5 here, as it becomes worthwhile to spread your choices even further to avoid duplicates. That’s a nice confirmation of my intuition.