From c61c76364deecae8de36737d02d2ce26b64c4ebb Mon Sep 17 00:00:00 2001 From: Peter Norvig Date: Wed, 24 Feb 2021 23:24:47 -0800 Subject: [PATCH] Add files via upload --- ipynb/risk.ipynb | 665 +++++++++++++++++++++++------------------------ 1 file changed, 323 insertions(+), 342 deletions(-) diff --git a/ipynb/risk.ipynb b/ipynb/risk.ipynb index 8bf3a08..7315e20 100644 --- a/ipynb/risk.ipynb +++ b/ipynb/risk.ipynb @@ -4,21 +4,29 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "
Peter Norvig
2012, 2020
\n", + "
Peter Norvig
2012, 2020, 2021
\n", "\n", "# The Unfinished Game ... of Risk\n", "\n", - "![](components_.jpg)\n", + "[Keith Devlin](https://web.stanford.edu/~kdevlin/)'s [book](https://www.amazon.com/Unfinished-Game-Pascal-Fermat-Seventeenth-Century/dp/0465018963) [*The Unfinished Game*](https://wordplay.blogs.nytimes.com/2015/12/14/devlin-unfinished-game/) describes how Fermat and Pascal discovered the rules of probability that guide gambling in games. The question they confronted was: what if a gambling game is interrupted, but one player is in the lead by a certain score. How much of the pot should the leader get?\n", "\n", - "[Keith Devlin](https://web.stanford.edu/~kdevlin/)'s [book](https://www.amazon.com/Unfinished-Game-Pascal-Fermat-Seventeenth-Century/dp/0465018963) [*The Unfinished Game*](https://wordplay.blogs.nytimes.com/2015/12/14/devlin-unfinished-game/) describes how Fermat and Pascal discovered the rules of probability that guide gambling in games. The question they confront is: what if a gambling game is interrupted, but one player is in the lead by a certain score. How much of the pot should the leader get?\n", - "\n", - "My friends and I faced a similar question when a game of [Risk](https://www.ultraboardgames.com/risk/game-rules.php) ran on too long (as they often do) and we were unable to finish. Player **A** had just cashed in cards and added troops to a single large force in Brazil that was poised to make a sweeping attack on player **B**, whose territories were situated in Africa and Asia in such a way that **A** could attack North Africa first and then go from one territory to the next without ever having to branch off. We wrote down the number of **A**'s armies in Brazil, **72**, and the number of armies in **B**'s successive territories: **22, 8, 2, 2, 2, 7, 1, 1, 3, 1, 2, 3, 5, 1.** What is the probability that **A** can capture all these territories?\n", + "My friends and I faced a similar question when a game of [*Risk*](https://www.ultraboardgames.com/risk/game-rules.php) ran on too long (as they often do) and we were unable to finish. Player **A** had just cashed in cards and added troops to a single large force that was poised to make a sweeping attack on player **B**, whose territories were arranged in such a way that **A** could attack from one territory to the next without ever having to branch off. We wrote down the number of **A**'s massed armies, **72**, and the number of armies in **B**'s successive territories: **22, 8, 2, 2, 2, 7, 1, 1, 3, 1, 2, 3, 5, 1.** What is the probability that **A** can capture all these territories?\n", "\n", "______\n", "\n", - "# Monte Carlo Simulation\n", + "# Terminology\n", "\n", - "We can answer the question with a [**Monte Carlo simulation**](https://en.wikipedia.org/wiki/Monte_Carlo_method) that follows the rules of Risk and uses random numbers to roll the dice. First some preliminaries:" + "Let's explain some *Risk* rules and terminology:\n", + "\n", + "- A **battle** is when armies from one territory attack an enemy neighboring territory. A roll of dice determines which armies perish:\n", + " - The attacker will roll 3 dice if possible (but no more than the number of armies in the attacking territory minus one).\n", + " - The defender will roll 2 dice if possible (or only one if they have only one army remaining). \n", + " - The **outcome** of the battle is determined by comparing the highest die from each of the two players, with the defender losing an army if the attacker's die is higher, and the attacker losing an army if tied or lower. Then if both sides rolled at least two dice, we do the same comparison with the second highest die on each side. \n", + " - When a battle kills off the last defender in a territory, the attackers **occupy** the territory. They must leave behind one army, but can move the rest in. \n", + "\n", + "- A **campaign** consists of a sequence of battles and occupations. We will consider only a **chain** campaign, in which attackers invade successive enemy territories in order, always moving all their remaining armies into each captured territory, never branching, and never changing strategy based on the result of a battle. The attackers **win** the campaign if they occupy all the territories. The attackers **lose** if there are any remaining defenders and only one remaining attacker, who by rule cannot attack.\n", + "\n", + "With that out of the way, we're ready for some Python implementation." ] }, { @@ -27,56 +35,41 @@ "metadata": {}, "outputs": [], "source": [ - "from typing import List, Tuple\n", - "import matplotlib.pyplot as plt\n", - "import numpy as np\n", - "import random\n", - "\n", - "attackers = 72\n", - "territories = (22, 8, 2, 2, 2, 7, 1, 1, 3, 1, 2, 3, 5, 1)\n", - "\n", - "die = (1, 2, 3, 4, 5, 6)\n", - "Die = int # a type alias\n", - "\n", - "random.seed(42) # For reproducability" + "from collections import Counter\n", + "from functools import lru_cache\n", + "import itertools\n", + "import matplotlib.pyplot as plt" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "How many territories and how many total defenders?" + "# Representing the State of a Campaign\n", + "\n", + "I will represent the **state of a campaign** as a tuple where the first element is the number of attacking armies, and subsequent elements are the number of defenders in each successive territory. Thus we can represent the start state of our unfinished campaign as follows:" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(14, 60)" - ] - }, - "execution_count": 2, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ - "len(territories), sum(territories)" + "State = tuple\n", + "\n", + "start = State((72, 22, 8, 2, 2, 2, 7, 1, 1, 3, 1, 2, 3, 5, 1))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "It looks fairly even: the attackers have 12 more armies, 72 to 60, but they will have to leave an army in each of the 14 territories along the way. \n", - "\n", - "# Battless, Invasions, and Campaigns\n", - "\n", - "In Risk a **battle** consists of a one-time roll of some dice and the resulting loss of armies. The attacker will roll three dice if possible (but can roll a maximum of the number of armies in the attacking territory minus one) and the defender will roll two dice if possible (or only one if they have only one army remaining). We compare the highest die on each side, with the defender losing an army if the attacker's die is higher, and the attacker losing an army if tied or lower. Then if both sides rolled at least two dice, we do the same comparison with the second highest die on each side. The function `deaths` returns a tuple of (number of attacking armies that die, number of defending armies that die). " + "I'll define the following functions on states: \n", + "- `A(state)` gives the number of attackers in a state.\n", + "- `D(state)` gives the number of defenders in the first territory (or `0` if there are no defenders at all).\n", + "- `allD(state)` gives the tuple of numbers of defenders in each territory.\n", + "- `update(state, dead)` gives a new state reflecting the number of dead attacking and defending armies spewcified by the two-element tuple `dead`. If `D(state) == D(dead)` then the attackers have killed off all the defenders in the first territory, and the new state will reflect the fact that the attackers now occupy the territory." ] }, { @@ -85,51 +78,44 @@ "metadata": {}, "outputs": [], "source": [ - "def deaths(attack_dice: List[Die], defend_dice: List[Die]) -> Tuple[int, int]:\n", - " \"\"\"The number of (attackers, defenders) who die due to this roll.\"\"\"\n", - " dead = [0, 0]\n", - " for a, d in zip(sorted(attack_dice, reverse=True), \n", - " sorted(defend_dice, reverse=True)):\n", - " dead[a > d] += 1\n", - " return tuple(dead)" + "def A(state) -> int: \"Attackers\"; return state[0]\n", + "def D(state) -> int: \"First defenders\"; return state[1] if allD(state) else 0\n", + "def allD(state) -> tuple: \"All defenders\"; return state[1:]\n", + "\n", + "def update(state, dead) -> State:\n", + " \"\"\"Update the state of a campaign to reflect battle deaths.\"\"\"\n", + " if D(state) == D(dead):\n", + " return State((A(state) - A(dead) - 1, *allD(state)[1:])) # Occupy territory, leaving 1 behind\n", + " else:\n", + " return State((A(state) - A(dead), allD(state)[0] - D(dead), *allD(state)[1:])) # Can't occupy yet" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "True" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ - "def test1() -> bool:\n", - " # Four examples from www.ultraboardgames.com/risk/game-rules.php\n", - " assert deaths([6, 1, 1], [3]) == (0, 1) # 6 beats 3, so defender loses 1\n", - " assert deaths([6, 2, 1], [3, 2]) == (1, 1) # 6 beats 3, but 2 ties 2, so 1 loss each\n", - " assert deaths([3, 3], [4, 3]) == (2, 0) # 3 loses to 4, and attacker 3 loses to 3\n", - " assert deaths([6], [5, 4]) == (0, 1) # 6 beats 5, so defender loses 1\n", - " return True\n", - " \n", - "test1()" + "# Tests\n", + "\n", + "assert A(start) == 72\n", + "assert D(start) == 22 \n", + "assert allD(start) == (22, 8, 2, 2, 2, 7, 1, 1, 3, 1, 2, 3, 5, 1)\n", + "assert sum(allD(start)) == 60 \n", + "assert len(allD(start)) == 14\n", + "\n", + "assert update((10, 2, 5), (0, 2)) == (9, 5) # 2 defenders dead; occupy the first territory\n", + "assert update((10, 2, 5), (1, 1)) == (9, 1, 5) # continue to battle\n", + "assert update((10, 2, 5), (2, 0)) == (8, 2, 5) # continue to battle" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "An **invasion** consists of a series of battles until either the defenders are all defeated (in which case the attacker can move armies into the captured territory, but must leave one army behind), or the attackers have fewer than two armies left, and can no longer attack. \n", + "# Rolling the Dice: Death Counts\n", "\n", - "A **campaign** consists of a sequence of invasions, designed to capture all the defender's territories.\n", - "In the function `campaign`, the variable `attackers` tracks the number of attackers invading the current territory. (The total number of armies for the attacking side will in general be more than `attackers`, because there will be one army left behind in each captured territory.) If `verbose` is true, we'll `say` what is happening along the way. In the end, return the number of `attackers` in the final territory minus the total number of defenders still alive. This will be positive if all the defenders have been defeated, and nonpositive if not." + "First we'll define the function `deaths`, which, given the specific sets of dice rolled by attacker and defender in a battle, returns a `State` tuple that gives the number of attackers and defenders who perish in the battle:" ] }, { @@ -138,153 +124,93 @@ "metadata": {}, "outputs": [], "source": [ - "def campaign(attackers: int, territories: List[int], verbose=True) -> int:\n", - " \"\"\"Given a number of armies for attacker and a list of territory army sizes for defender,\n", - " randomly play to the end, and return remaining attackers minus remaining defenders.\"\"\"\n", - " for t, defenders in enumerate(territories, 1):\n", - " if verbose: say(attackers, 'attack', defenders, t)\n", - " while attackers > 1 and defenders > 0:\n", - " A, D = deaths(roll(min(3, attackers - 1)), \n", - " roll(min(2, defenders)))\n", - " attackers -= A\n", - " defenders -= D\n", - " if attackers == 1:\n", - " if verbose: say(attackers, \"can't beat\", defenders, t)\n", - " break\n", - " attackers -= 1 # Capture a new territory, leave one behind\n", - " return attackers - (defenders + sum(territories[t:]))\n", + "die = (1, 2, 3, 4, 5, 6)\n", + "Dice = list # a sorted list of die rolls\n", "\n", - "def say(attackers, action, defenders, t):\n", - " \"\"\"Say what is happening.\"\"\"\n", - " print(f'{attackers:3} armies {action} {defenders:2} defenders in territory {t}')\n", - " \n", - "def roll(n) -> List[Die]: \n", - " \"\"\"A random roll of `n` dice, sorted largest first.\"\"\"\n", - " return sorted((random.choice(die) for _ in range(n)), reverse=True)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# The Answer\n", - "\n", - "Let's answer the question of who wins the unfinished game:" + "def deaths(A_dice: Dice, D_dice: Dice) -> State:\n", + " \"\"\"How many (attacker, defender) armies perish as the result of these dice?\"\"\"\n", + " dead = [0, 0]\n", + " for a, d in zip(sorted(A_dice, reverse=True), \n", + " sorted(D_dice, reverse=True)):\n", + " dead[a > d] += 1\n", + " return State(dead)" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - " 72 armies attack 22 defenders in territory 1\n", - " 48 armies attack 8 defenders in territory 2\n", - " 44 armies attack 2 defenders in territory 3\n", - " 40 armies attack 2 defenders in territory 4\n", - " 35 armies attack 2 defenders in territory 5\n", - " 33 armies attack 7 defenders in territory 6\n", - " 23 armies attack 1 defenders in territory 7\n", - " 22 armies attack 1 defenders in territory 8\n", - " 20 armies attack 3 defenders in territory 9\n", - " 19 armies attack 1 defenders in territory 10\n", - " 17 armies attack 2 defenders in territory 11\n", - " 16 armies attack 3 defenders in territory 12\n", - " 15 armies attack 5 defenders in territory 13\n", - " 13 armies attack 1 defenders in territory 14\n" - ] - }, - { - "data": { - "text/plain": [ - "12" - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ - "campaign(attackers, territories)" + "# Tests: the 4 sample dice rolls from www.ultraboardgames.com/risk/game-rules.php\n", + "\n", + "assert deaths((6, 1, 1), (3,)) == (0, 1) # Defender loses one\n", + "assert deaths((6, 2, 1), (3, 2)) == (1, 1) # Both lose one\n", + "assert deaths((3, 3), (4, 3)) == (2, 0) # Attacker loses two\n", + "assert deaths((6,), (5, 4)) == (0, 1) # Defender loses one\n", + "\n", + "assert update((10, 2, 5), deaths((6, 2, 1), (3, 2))) == (9, 1, 5)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "The attackers won, capturing all the territories and moving 12 remaining armies into the final territory.\n", + "# Simulation versus Full Probability Distribution\n", "\n", - "But that was just one simulation; other simulations could have different results. Let's summarize, say, 100,000 simulations, see how long it takes, and plot a histogram of the resulting scores:" + "My first approach to the problem was a [**Monte Carlo simulation**](https://en.wikipedia.org/wiki/Monte_Carlo_method), in which I used random dice rolls to determine the outcome of each battle, and thus the campaign. That was good enough to estimate the probability of winning to within 1%, but it was not good enough to get a completely accurate breakdown of all possible outcomes. \n", + "\n", + "Therefore I decided to compute the full probability distribution for a campaign. The code becomes a bit more complex, because we have to deal with a collection of possible results for each dice roll, not just a single result. However, I think the precision gained is worth the slight code complexity. \n", + "\n", + "`Pdist` will be used to represent a probability distribution of the form `{state: probability, ...}`, where the probabilities are normalized so that they are all between 0 and 1, and sum to 1. (I realize that it is suggested that a `Counter`has integer counts, but that is not required, and `Counter` has a nicer API than `dict`, including the fact that it has a default value of 0. So I am not ashamed to inherit from `Counter`.)" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "CPU times: user 33.1 s, sys: 70.9 ms, total: 33.1 s\n", - "Wall time: 33.2 s\n" - ] - } - ], + "outputs": [], "source": [ - "%time scores = [campaign(attackers, territories, False) for _ in range(100000)]" + "class Pdist(Counter): \n", + " \"A Probability distribution.\"\n", + " def __init__(self, *args):\n", + " Counter.__init__(self, *args)\n", + " total = sum(self.values())\n", + " for x in self:\n", + " self[x] /= total # Normalize\n", + " assert 0.0 <= self[x] <= 1.0" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now for the full probability distribution (over all dice rolls) of deaths in a battle. The input to the function `deaths_pdist` will be a state giving the number of attacking and defending armies for just this one battle. (Thus, the attackers will always be 3, 2, or 1, and the defenders will always be 2 or 1. I define it this way, rather than passing in the full state of the campaign, so that I can **cache** the results and reuse them in subsequent battles.) The return value will be a probability distribution over the number of deaths for attacker and defender. " ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ - "def summary(scores):\n", - " \"\"\"Summarize the scores from simulations.\"\"\"\n", - " P = np.average([s > 0 for s in scores]) \n", - " N, avg = len(scores), np.average(scores)\n", - " title = f'Attacker wins {P:.0%}. Average armies left: {avg:.1f}'\n", - " plt.ylabel(f'Frequency (out of {N:,d} runs)'); \n", - " plt.xlabel('Armies left (positive for attacker)')\n", - " plt.hist(scores, bins=max(scores) - min(scores) + 1)\n", - " plt.plot([0, 0], [0, N/25], 'r:'); plt.title(title)\n", - " \n", - "summary(scores)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "We see that the attackers win 81% of the time, and the scores look roughly like a bell-shaped curve, but with a non-normal pattern on the left side. What's causing the non-normal pattern? Note that the number of defenders in the final four territories are `(2, 3, 5, 1)`, and the width of the four spikes on the left are `(1, 2, 4, 1)`, one less than the number of defenders (except for the last spike). I think there are spikes rather than a smooth curve because it is doubly-difficult to capture a territory: you need to have two armies left, not just one, so that you can leave one behind. " - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Exact Probabilities\n", + "@lru_cache()\n", + "def deaths_pdist(state) -> Pdist:\n", + " \"\"\"A probability distribution of deaths in a battle.\"\"\"\n", + " return Pdist(deaths(A_dice, D_dice)\n", + " for A_dice in rolls(A(state))\n", + " for D_dice in rolls(D(state)))\n", "\n", - "By repeatedly running a simulation, we can get approximate probabilities. But what if we wanted **exact probabilities** (at least exact under the assumption that the dice are exactly fair and that floating point roundoff is not an issue)? I'll start by defining the function `outcomes`, so that, for example, `outcomes(3, 2)` returns a Counter of all possible outcomes of rolling 3 attacker dice versus 2 defender dice; each outcome is a pair of `(attacker_deaths, defender_deaths)` and has a count of how often it occurred." + "def rolls(n) -> Dice: \n", + " \"\"\"All possible rolls of `n` dice.\"\"\"\n", + " return itertools.product(die, repeat=n)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Below we test all six possible battle dice combinations to make sure they match the odds stated at a [*Risk* data analysis blog](http://datagenetics.com/blog/november22011/):" ] }, { @@ -293,43 +219,63 @@ "metadata": {}, "outputs": [], "source": [ - "from functools import lru_cache\n", - "from collections import Counter\n", - "import itertools\n", - "\n", - "@lru_cache()\n", - "def outcomes(num_A: int, num_D: int) -> List[Tuple[int, int]]:\n", - " \"\"\"All (equiprobable) outcomes of (attacker_deaths, defender_deaths)\n", - " from rolling num_A dice versus num_D dice.\"\"\"\n", - " return Counter(deaths(dice[:num_A], dice[num_A:])\n", - " for dice in itertools.product(die, repeat=num_A + num_D))" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Counter({(2, 0): 2275, (1, 1): 2611, (0, 2): 2890})" - ] - }, - "execution_count": 10, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "outcomes(3, 2)" + "assert deaths_pdist((1, 1)) == Pdist({(1, 0): 21, (0, 1): 15})\n", + "assert deaths_pdist((2, 1)) == Pdist({(1, 0): 91, (0, 1): 125})\n", + "assert deaths_pdist((3, 1)) == Pdist({(1, 0): 441, (0, 1): 855})\n", + "assert deaths_pdist((1, 2)) == Pdist({(1, 0): 161, (0, 1): 55})\n", + "assert deaths_pdist((2, 2)) == Pdist({(2, 0): 581, (1, 1): 420, (0, 2): 295})\n", + "assert deaths_pdist((3, 2)) == Pdist({(2, 0): 2275, (1, 1): 2611, (0, 2): 2890})" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "The result for `outcomes(3, 2)` says that the attackers lose two armies in 2,275 out of the $6^5 = 7,776$ different outcomes; the defenders lose two in 2,890 outcomes; and they each lose one in the remaining 2,611 outcomes. I found a [web page](http://datagenetics.com/blog/november22011/) that lists the results for all six possible battles (attackers roll 1, 2, or 3 dice; defenders roll 1 or 2); let's verify that our `outcomes` agree with theirs:" + "# Outcomes of a Campaign\n", + "\n", + "A `campaign` is a series of battles. We keep battling until either the attackers no longer have the two armies necessary to enter into a battle, or until there are no defenders left. The function `battle` updates a probability distribution to reflect all possible results of a single battle." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "def campaign(start: State) -> Pdist:\n", + " \"\"\"Probability distribution for all outcomes of a campaign.\"\"\"\n", + " pdist = Pdist({start: 1})\n", + " while any(map(can_battle, pdist)):\n", + " pdist = battle(pdist)\n", + " return pdist\n", + "\n", + "def battle(pdist) -> Pdist:\n", + " \"\"\"For every possible campaign state in the Pdist, do one battle, \n", + " and return an updated `result` Pdist over the outcomes.\"\"\"\n", + " result = Pdist()\n", + " for state in pdist:\n", + " if not can_battle(state): # State carries through unchanged\n", + " result[state] += pdist[state] \n", + " else: # Replace state with all outcomes from a battle\n", + " pdead = deaths_pdist((min(3, A(state) - 1), min(2, D(state))))\n", + " for dead in pdead:\n", + " result[update(state, dead)] += pdist[state] * pdead[dead]\n", + " return result\n", + "\n", + "def can_battle(state) -> bool: \n", + " \"\"\"The attackers can battle if they have at least 2 armies, and there are defenders.\"\"\"\n", + " return A(state) >= 2 and allD(state)\n", + "\n", + "def attacker_wins(pdist) -> float: \n", + " \"\"\"The probability that the attackers win the campaign in this distribution.\"\"\"\n", + " return sum(pdist[s] for s in pdist if not allD(s))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Here's a small example campaign: when 4 attackers go against 2 defenders in the first territory and 1 defender in a second territory, the attackers win about 36% of the time (about 15% with 1 attacker remaining in the final territory, and 21% with 2 attackers in the final territory)." ] }, { @@ -340,7 +286,11 @@ { "data": { "text/plain": [ - "True" + "Pdist({(1, 2, 1): 0.21807067805974698,\n", + " (1, 1, 1): 0.12597532213712342,\n", + " (1, 1): 0.294669783648961,\n", + " (1,): 0.14620529335276633,\n", + " (2,): 0.21507892280140226})" ] }, "execution_count": 11, @@ -349,52 +299,36 @@ } ], "source": [ - "def test2() -> bool:\n", - " # See http://datagenetics.com/blog/november22011/\n", - " assert outcomes(1, 1) == {(1, 0): 21, (0, 1): 15}\n", - " assert outcomes(2, 1) == {(1, 0): 91, (0, 1): 125}\n", - " assert outcomes(3, 1) == {(1, 0): 441, (0, 1): 855}\n", - " assert outcomes(1, 2) == {(1, 0): 161, (0, 1): 55}\n", - " assert outcomes(2, 2) == {(2, 0): 581, (1, 1): 420, (0, 2): 295}\n", - " assert outcomes(3, 2) == {(2, 0): 2275, (1, 1): 2611, (0, 2): 2890}\n", - " return True\n", - " \n", - "test2()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Now we know exact outcomes for a single roll of the dice; what about an invasion where $A$ attackers keep attacking until they defeat $D$ defenders (or all but one attacker dies trying)? The function `winP(A, D)` gives the probability of the attackers winning. It works recursively. The two base cases are that the probability is zero if the attackers don't have at least two armies and the probability is one if the defenders have no armies. \n", - "\n", - "In the recursive case we observe the possible outcomes for the first battle, and then compute the win probability for the invasion as the average, over every possible outcome of the dice rolls, of the win probability for the number of remaining attackers and defenders after the battle, weighted by the number of times that the outcome occurs. (We use `np.average` because it accepts an optional `weights` argument.)" + "campaign((4, 2, 1))" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "0.3612842161541686" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ - "@lru_cache(None)\n", - "def winP(attackers: int, defenders: int) -> float:\n", - " \"\"\"The probability that `attackers` can invade and defeat all the `defenders`.\"\"\"\n", - " if attackers <= 1:\n", - " return 0\n", - " elif defenders == 0:\n", - " return 1\n", - " else:\n", - " battle = outcomes(min(3, attackers - 1), min(2, defenders))\n", - " return np.average([winP(attackers - A, defenders - D) for (A, D) in battle],\n", - " weights=list(battle.values()))" + "attacker_wins(_)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "Let's try a simple example: `winP(2, 1)` should be `15/36`, the same as the probability of the attacker prevailing in `outcomes(2, 1)`:" + "# Finishing the Unfinished Game\n", + "\n", + "What is the probability of winning the unfinished game?" ] }, { @@ -405,7 +339,7 @@ { "data": { "text/plain": [ - "True" + "0.8105485936352178" ] }, "execution_count": 13, @@ -414,14 +348,18 @@ } ], "source": [ - "winP(2, 1) == 15/36" + "attacker_wins(campaign(start))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "What's the probability that 12 attackers successfully invade 10 defenders?" + "The attackers defeat all the defenders 81% of the time. \n", + "\n", + "# Analyzing Campaigns\n", + "\n", + "Let's try to see the whole picture. I'll define the **score** of a campaign as the number of attacker armies in the final territory minus the total number of defenders, minus the number of territories that the defenders hold. This score will be positive when the attackers win and negative when they lose. A score cannot be zero (the closest is that there could be one attacker and one defender left, in which case there can be no more attacks, but the score would be -1, because the defenders have one army and one territory). The function `show` plots a histogram of scores:" ] }, { @@ -431,40 +369,67 @@ "outputs": [ { "data": { + "image/png": "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\n", "text/plain": [ - "0.6538260547697077" + "
" ] }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" } ], "source": [ - "winP(12, 10)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Let's make a chart, with the number of defenders varying from 1 to 60, and the number of attackers separated into eight cases (depicted as eight lines), where in each case there are Δ more attackers than defenders, for Δ = -5, -2, 0, 1, 2, 5, and 10:" + "def show(pdist, epsilon=1e-4):\n", + " \"\"\"Plot and annotate a probability distribution over states.\"\"\"\n", + " X = [score(s) for s in pdist if pdist[s] > epsilon]\n", + " Y = [pdist[s] for s in pdist if pdist[s] > epsilon]\n", + " avg = sum(score(s) * pdist[s] for s in pdist)\n", + " plt.figure(figsize=(10, 5))\n", + " plt.title(f'Attacker wins {attacker_wins(pdist):.2%}. Average score: {avg:.1f}.')\n", + " plt.xlabel('Score (positive when attacker wins)')\n", + " plt.ylabel('Probability of score')\n", + " plt.bar(X, Y, width=3/4)\n", + " \n", + "def score(state): return A(state) - sum(allD(state)) - len(allD(state))\n", + " \n", + "show(campaign(start))" ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "0.02662110993767859" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ - "def chart(Ds=range(1, 61), deltas=(-5, -2, -1, 0, 1, 2, 5, 10)):\n", - " plt.figure(figsize=(9, 6)); plt.grid()\n", - " plt.title('Each line: attackers with Δ more armies than defenders')\n", - " plt.xlabel('Number of Defenders'); plt.ylabel('Win Probability for Attackers')\n", - " for delta in reversed(deltas):\n", - " Ps = [winP(max(0, D + delta), D) for D in Ds]\n", - " plt.plot(Ds, Ps, '.-', label=f'Δ={delta}')\n", - " plt.legend()" + "S = campaign(start)\n", + "Q = Pdist({score(s): S[s] for s in S})\n", + "Q[-7]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Interesting! We see that the scores look roughly like a bell-shaped curve on the right side, but with a decidely non-normal pattern on the left side. There are gaps—scores for which the probability is zero—and there are spikes that rise above the normal curve. \n", + "\n", + "What's causing the gaps? We know that a score can never be 0. And in this campaign, no score can be -2. because a -2 can only be achieved with one attacker and two defenders in one territory; this campaign has only one defender in the final territory. Looking at the plot, we see gaps surrounding groups of bars, where the group sizes, reading left to right, are 1, 1, 3, 1, 2, 3, 5, and 1. Note that these are exactly the number of defenders in the final 8 territories.\n", + "\n", + "What's causing the spikes? To some extent they represent probability mass that has shifted over a place. But the spikes are not quite tall enough to fill in the gaps. And I don't understand the exact shape of each group.\n", + "\n", + "Below is an example where there is no visible gap. The normalish shape is restored, except that there is something going on with odd-versus-even scores. I believe what is happening is that all but the very last few battles will be 3-versus-2 battles, and thus will result in 2 casualties, preserving the parity of the total number of armies. The parity can only be broken in the final battles." ] }, { @@ -474,9 +439,88 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ - "
" + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "show(campaign((145, 100)))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The odd-even disparity can be lessened by adding a few territories where there will not be 3-versus-2 battles. The result is a very smooth curve, although not normal—it is clearer a bit fatter on the left than the right." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "show(campaign((150, 100, 1, 1, 1, 1, 1)))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Analyzing Single-Territory Attacks\n", + "\n", + "I want to analyze a simpler situation: With *A* attackers and *D* defenders in a single territory, what is the probability the attackers win? \n", + "\n", + "I will make a chart with the number of defenders varying from 1 to 60, and the number of attackers separated into eight cases (depicted as eight lines), where in each case there are Δ more attackers than defenders:" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [], + "source": [ + "def chart(defenders=range(1, 61), deltas=(10, 5, 2, 1, 0, -1, -2, -5)):\n", + " \"\"\"Plot win probability for various numbers of defenders and Δ more attackers.\"\"\"\n", + " plt.figure(figsize=(10, 5)); plt.grid()\n", + " plt.title('Each line: attackers with Δ more armies than defenders')\n", + " plt.xlabel('Number of Defenders'); plt.ylabel('Win Probability for Attackers')\n", + " for delta in deltas:\n", + " winprobs = [attacker_wins(campaign((max(0, d + delta), d))) for d in defenders]\n", + " plt.plot(defenders, winprobs, '.-', label=f'Δ = {delta}')\n", + " plt.legend()" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" ] }, "metadata": { @@ -493,70 +537,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Note that the purple line (fourth from bottom), where the number of attackers exactly equals the number of defenders, gives a low win probability for a small attacking force, but reaches 50% for 12-on-12, and 73% for 60-on-60. The red line, where the attackers have one more army than the defenders, dips from one to two defenders but is over 50% for a 6-on-5 attack. Similarly, the green line, where the attackers have a surplus of two armies, dips sharply from 75% to 66% as the number of defenders goes from 1 to 2, dips slightly more for 3 and 4 defenders, and then starts to rise. So overall, an attacker does not need a big advantage in armies as long as there are many armies on both sides. Even when the attacker is at a disadvantage in numbers (as in the bottom grey line where the attacker has five fewer armies), the attacker can still have an advantage in win probability; `winP(55, 60)` is about 57%." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Simulation versus Exact Computation\n", - "\n", - "Let's see how the exact computation compares with a simulation:" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(0.7194339370737594, 0.7178)" - ] - }, - "execution_count": 17, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "A, D = 32, 30\n", - "\n", - "exact = winP(A, D)\n", - "simul = np.average([campaign(A, [D], False) > 0 for _ in range(10000)])\n", - "\n", - "exact, simul" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "We see that they give similar results, differing by one or two parts per thousand. So when would you prefer a simulation, and when an exact computation?\n", - "\n", - "**Advantages of a simulation:**\n", - "- Usually simpler to code; can use an `if` statement to distinguish two branches; don't have to follow every branch.\n", - "- Can be more efficient to compute; don't have to spend a lot of computation time on extremely rare events.\n", - "- Can handle event sequences of potentially unbounded length.\n", - "\n", - "**Advantages of an exact calculation:**\n", - "- Don't need to rerun multiple times; don't need statistical inference to analyze the range of outcomes.\n", - "- If a very rare event can be extremely bad (or good), it is important to know exactly how likely the rare event is. \n", - "\n", - "I chose to use a **simulation** for `campaign` because:\n", - "- I thought it would be easier to code.\n", - "- I would be happy with only four bits of accuracy: enough to determine the win percentage within 6%. (I ended up running enough simulations to get within 1%.) \n", - "- I didn't care about the 1-in-a-billion chance of, say, the attackers losing 17 battles in a row; I just want to know the overall odds of the attackers losing the campaign. (Note that if I was doing a simulation of a nuclear reactor, I would certainly be very concerned with a 1-in-a-billion chance of a meltdown, and would need to code ways of exploring that possibility more carefully.)\n", - "- A simulation is more flexible. Consider a small change to the rules of Risk: if the dice show five 1s in a battle, both sides add one army. We can easily implement that in a simulation in two or three lines of code, and the effect on run time will be negligible, because it only happens one in 7,776 times. But in an exact calculation this new rule would change everything: it would become an infinite game, and we would have to make a wholesale rearrangement of the code to deal with that. \n", - "\n", - "I chose to use **exact calculation** for `winP` because:\n", - "- I knew the computational demands would be very small either way.\n", - "- I saw there was something going on with odd/even number of armies, and I wanted to distinguish slight variations that are real from slight variations that are random, so getting exact numbers was useful.\n", - "\n", - "\n", - "(*Note:* I call it an \"exact\" calculation, but it is actually limited to the precision of 64-bit floating point numbers. If you truly need an exact answer for a discrete combinatorics problem, do division with the `fraction.Fraction` class, not with `float`. And of course it is an exact computation in the model; if the model does not reflect the world, the results will be wrong.)" + "Note that the purple line (fourth from bottom), where the number of attackers exactly equals the number of defenders, gives a low win probability for a small attacking force, but reaches 50% for 12-on-12, and 73% for 60-on-60. The red line, where the attackers have one more army than the defenders, dips from one to two defenders but is over 50% for a 6-on-5 attack. Similarly, the green line, where the attackers have a surplus of two armies, dips sharply from 75% to 66% as the number of defenders goes from 1 to 2, dips slightly more for 3 and 4 defenders, and then starts to rise. So overall, an attacker does not need a big advantage in armies as long as there are many armies on both sides. Even when the attacker is at a disadvantage in numbers (as in the bottom grey line where the attacker has five fewer armies), the attacker can still have an advantage in win probability; with 55 against 60 the win percentage is about 57%." ] } ], @@ -576,7 +557,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.6" + "version": "3.7.7" } }, "nbformat": 4,