From e61f2070a3fe4f760bee374c07b168171ff97cdf Mon Sep 17 00:00:00 2001 From: Peter Norvig Date: Thu, 11 Mar 2021 21:31:52 -0800 Subject: [PATCH] Add files via upload --- ipynb/risk.ipynb | 831 ++++++++++++++++++++++++++++++++++------------- 1 file changed, 601 insertions(+), 230 deletions(-) diff --git a/ipynb/risk.ipynb b/ipynb/risk.ipynb index 7315e20..98f8871 100644 --- a/ipynb/risk.ipynb +++ b/ipynb/risk.ipynb @@ -10,21 +10,25 @@ "\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", - "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", + "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** was poised to make a sweeping attack on player **D**, 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 **D**'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", + "![](https://www.ultraboardgames.com/risk/gfx/board.jpg)\n", "\n", "______\n", "\n", "# Terminology\n", "\n", - "Let's explain some *Risk* rules and terminology:\n", + "Let's explain some *Risk* [rules](https://www.ultraboardgames.com/risk/game-rules.php) 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 defender will roll 2 dice if possible (or only one die if they have only one army defending). \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", + "- A **campaign** consists of a sequence of battles and occupations. In this notebook 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 outcome 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", + "\n", "\n", "With that out of the way, we're ready for some Python implementation." ] @@ -35,8 +39,10 @@ "metadata": {}, "outputs": [], "source": [ + "from typing import List, Iterable\n", "from collections import Counter\n", "from functools import lru_cache\n", + "import random\n", "import itertools\n", "import matplotlib.pyplot as plt" ] @@ -66,10 +72,10 @@ "metadata": {}, "source": [ "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." + "- `A(state)`: the number of attackers in a state.\n", + "- `D(state)`: the number of defenders in the defender's first territory (or `0` if there are no defenders at all).\n", + "- `allD(state)`: the tuple of numbers of defenders in each territory.\n", + "- `update(state, dead)`: a new state reflecting the aftermath of a battle that leads to `dead` armies, where `dead` is a two-element tuple of (attackers-who-died, defenders-who-died). The attackers will occupy the first territory if all the defenders in the first territory died. Note that `dead` is a slightly different usage of `State`, counting the number of deaths rather than the number of living armies." ] }, { @@ -82,87 +88,84 @@ "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" + "Deaths = State # A kind of state where (A, D) means that A attackers and D defenders died\n", + "\n", + "def update(state, dead: Deaths) -> State:\n", + " \"\"\"Update the `state` of a campaign to reflect the`dead` in a battle.\"\"\"\n", + " a, d, ds = A(state) - A(dead), D(state) - D(dead), allD(state)[1:]\n", + " if d: # Can't occupy first territory if there are defenders there \n", + " return State((a, d, *ds))\n", + " else: # Occupy territory, leaving 1 behind\n", + " return State((a - 1, *ds))" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "72" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ - "# 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": [ - "# Rolling the Dice: Death Counts\n", - "\n", - "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:" + "A(start)" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "22" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ - "die = (1, 2, 3, 4, 5, 6)\n", - "Dice = list # a sorted list of die rolls\n", - "\n", - "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)" + "D(start)" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "(22, 8, 2, 2, 2, 7, 1, 1, 3, 1, 2, 3, 5, 1)" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ - "# 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)" + "allD(start)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "# Simulation versus Full Probability Distribution\n", + "# Rolling the Dice and the Outcome of a Single Battle\n", "\n", - "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`.)" + "We'll represent a roll of the dice with a list of integers; for example the attacker might roll `[2, 6, 1]` with three dice. The function `random_roll(n)` gives a random outcome for rolling `n` dice. The function `battle_deaths`, when given the specific sets of dice rolled by attacker and defender in a battle, returns a two-element `State` tuple that gives the number of attackers and defenders who perish in the battle." ] }, { @@ -171,46 +174,50 @@ "metadata": {}, "outputs": [], "source": [ - "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. " + "die = (1, 2, 3, 4, 5, 6)\n", + "Dice = List[int] # a list of die rolls, like [2, 6, 1]\n", + "\n", + "def random_roll(n) -> Dice:\n", + " \"\"\"Roll n dice randomly.\"\"\"\n", + " return [random.choice(die) for _ in range(n)]\n", + "\n", + "def battle_deaths(A_dice: Dice, D_dice: Dice) -> Deaths:\n", + " \"\"\"How many (attacker, defender) armies perish as the result of these dice?\"\"\"\n", + " dead = Counter('D' if a > d else 'A'\n", + " for a, d in zip(sorted(A_dice, reverse=True), \n", + " sorted(D_dice, reverse=True)))\n", + " return Deaths((dead['A'], dead['D']))" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "[3, 3, 6]" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ - "@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", - "def rolls(n) -> Dice: \n", - " \"\"\"All possible rolls of `n` dice.\"\"\"\n", - " return itertools.product(die, repeat=n)" + "random_roll(3) # Example roll" ] }, { "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/):" + "# Monte Carlo Simulation of a Campaign\n", + "\n", + "A [**Monte Carlo simulation**](https://en.wikipedia.org/wiki/Monte_Carlo_method) makes random choices at every choice point (here, every dice roll), and reports on the outcome. \n", + "\n", + "The function `simulate_campaign` rolls random dice for a battle until we've reached a terminal state where there can be no more battles (either because the defenders have all been defeated, or because the attackers do not have the two armies necessary to launch an attack)." ] }, { @@ -219,87 +226,72 @@ "metadata": {}, "outputs": [], "source": [ - "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})" + "def simulate_campaign(state) -> State:\n", + " \"\"\"Simulate a campaign with random rolls, returning the final state.\"\"\"\n", + " while not terminal(state):\n", + " dead = battle_deaths(random_roll(min(3, A(state))), \n", + " random_roll(min(2, D(state))))\n", + " state = update(state, dead)\n", + " return state\n", + "\n", + "def terminal(state) -> bool: \n", + " \"\"\"Is the game over?\"\"\"\n", + " return A(state) < 2 or not D(state)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "# Outcomes of a Campaign\n", + "# Finishing the Unfinished Game (Randomly)\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." + "**Let's see who wins!**" ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "(9,)" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], "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))" + "simulate_campaign(start)" ] }, { "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)." + "That final state says that the attackers won—there are 9 attackers and no defenders left. \n", + "\n", + "# Predicting the Unfinished Game: Estimating Probabilities\n", + "\n", + "But what if we want to know not just who won that one game, but what is the **probability** that the attackers win? Monte Carlo simulation answers that question by repeating a simulation many times and **summarizing** all the final outcomes. The summary is in the form of a **probability distribution**, a mapping of `{outcome_state: probability}` pairs, which I have implemented as `ProbDist`. I implemented `ProbDist` as a subclass of `Counter`, with the restriction that the values are normalized to sum to 1. (I realize that the name `Counter` suggests integer counts, but that's not a requirement, and `Counter` has a nicer API than `dict`, including a default value of 0 and the `most_common` method.)" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "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, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ - "campaign((4, 2, 1))" + "class ProbDist(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 " ] }, { @@ -310,7 +302,13 @@ { "data": { "text/plain": [ - "0.3612842161541686" + "ProbDist({'H': 0.1,\n", + " 'E': 0.1,\n", + " 'L': 0.3,\n", + " 'O': 0.2,\n", + " 'W': 0.1,\n", + " 'R': 0.1,\n", + " 'D': 0.1})" ] }, "execution_count": 12, @@ -319,47 +317,33 @@ } ], "source": [ - "attacker_wins(_)" + "ProbDist('HELLOWORLD') # example probability distribution over 10 letters" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "# Finishing the Unfinished Game\n", - "\n", - "What is the probability of winning the unfinished game?" + "The higher-order function `monte_carlo` works with any random simulation function, calling it `k` times, each time passing in a `start` state, and collecting the `k` outcome states in a `ProbDist`:" ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "0.8105485936352178" - ] - }, - "execution_count": 13, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ - "attacker_wins(campaign(start))" + "def monte_carlo(simulation, start, k=1000) -> ProbDist:\n", + " \"Call simulation(start) repeatedly (k times) and return a ProbDist of outcomes.\"\n", + " return ProbDist(simulation(start) for _ in range(k))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "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:" + "Here we run the campaign \n", + "simulation 10 times and see the summary of outcomes:" ] }, { @@ -369,67 +353,43 @@ "outputs": [ { "data": { - "image/png": "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\n", "text/plain": [ - "
" + "ProbDist({(4,): 0.1,\n", + " (15,): 0.1,\n", + " (20,): 0.1,\n", + " (1, 1, 5, 1): 0.1,\n", + " (16,): 0.2,\n", + " (11,): 0.1,\n", + " (6,): 0.1,\n", + " (12,): 0.1,\n", + " (8,): 0.1})" ] }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "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": [ - { - "data": { - "text/plain": [ - "0.02662110993767859" - ] - }, - "execution_count": 15, + "execution_count": 14, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "S = campaign(start)\n", - "Q = Pdist({score(s): S[s] for s in S})\n", - "Q[-7]" + "monte_carlo(simulate_campaign, start, 10)" ] }, { "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." + "And here we run it 1,000 times and report the probability that the attackers win:" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "def attacker_win_probability(dist: ProbDist) -> float: \n", + " \"\"\"The probability that the attackers win the campaign.\"\"\"\n", + " return sum(dist[s] for s in dist if not allD(s))" ] }, { @@ -439,26 +399,24 @@ "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAm0AAAFNCAYAAABST1gVAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAAgAElEQVR4nO3de7gkVXn3/e+P4XwQAoxGOTggoKLGAyOo8YAaFEWERJAxKGg0RJ+gUWMM5g1qCEnwjaeoBEVQEKKgqMkoGAQRT0FgEBQ5+YyIYQAVgiIaUdH7+aPWdopmH3rG6b13z3w/11VXV61atWpVV/fue6+1qipVhSRJkua39ea6ApIkSZqZQZskSdIYMGiTJEkaAwZtkiRJY8CgTZIkaQwYtEmSJI0BgzZpjCRZlKSSrD/H9fhJkp3nsg6StK4xaJNWU5ILk/wwyUYD6ackOXYg7YYkfzC7NRydqtq8qq5fk2Um2S7JfyS5PcmKJC8fWL9/km+2gPG/kuz+W5T1tCRfS/LjJNcnOaK37pFJrkpyW5LX9NI3SHJxkh1W49j2bsH261d1W62e9v28q31efpLkuoH1r0zynfYZWJbkidOU9dAkFyS5I8nyJH84+iOQ7s2gTVoNSRYBTwIKeO6cVmY1pDPfvv+nA98B7gfsB/xjkqcCJNkV+Dfg5cBWwKeApdO0OE5X1gbAJ4H3AVsChwBvT/LItu0/Aa8DHgn8bZLfbemvBT5eVTeuxrEdDtzeXkciyYJRlT3b1mBL8pHtH4zNq+rBvfL3Ao4DDqL7DJwMfHKy97DV5T+ATwNbA0cApyfZbQ3VURpeVTk5Oa3iBLwR+ArwduDTvfQjgF8CvwB+QhdcnAb8GvhZS3t9y/sx4HvAHcAXgYf1ytkEeBvw3bb+yy1tEV2guH7L9zzgBuDhbflxwH8BPwK+DuzdK/NC4B9avX8G7DJwTC8BPtVbXg58tLd8I/CoNl8T2wOnAMcDZwN3AhcDD2rrArwD+EE7jm9M1HVg35u3Mhf20k4ETmvzRwJn99at147h6atR1v3a+k176y8FXtDmrwE2avNfBfYEdgQuATZYjc/Kpu19WdI+F4t76/6TLrDo5/868Edt/iHAeXQB33XA83v5TgFOAM4Bfgr8AV2Aejnw43a+3jxQ9mHtM/U/wNHts/MHvff0KODbbf1Hga2nOKZt6YKYH7W6fQlYr63bAfgEcGsr5z298v+27f8HwIeALdu6Re2cvBT4b+CLM32eh3jfLwReNsW6Q4BLesubtf3ff5K8D6f73qaX9lng7+f675DTujfNeQWcnMZxogto/g+wB12Qdr/eulOAYwfy/+bHsZf2J8AWwEbAO4EreuuObz862wELgCe0fBM/buvTBVnLWRk8bdd+JJ/dfiD3acsL2/oL2w/iw9r2GwzUZ+f247gecP/243pTb90Pez/Mg0Hb7XTBzfp0LWJntHXPBC6jax0L8NApfhi3aGXet5f2fuDyNv9K4JzeugXAXcBfrGpZbfnDwJ+3ch5PF0Ts0NZ9DNgf2J4uqN4G+HdWIWAYqM+LgFvavj4FvKu37jDgK73l3ds52IgukLixnef1gccAt9GC+/a+3wH8fjtnGwN7A49oy78HfB84sFf2T4AnAhsCb6X77E4Eba+mC1K3b/t/H/CRKY7pn4D3Ahu06Unt/C6gC67e0eq/MfDE3ud9efssbU4X2E0E0ovaOftQ224TZv48H0XvH6ZJ6nghXeB4G90/Knv31t2H7nO5V6vzK+mC3UxSziO4d9B2HvDJuf475LTuTXNeASencZvaj94vgW3b8rXAa3rrT2GIoG1g/VbtR2tLVrYiPXKSfBM/bq8Drga2763764kfwV7aucDhbf5C4JgZju1GuuBgCV3r1CV0rT0vAZb28g0GbSf11j0buLbNPw34Fl2LyXoz7PvLwLvbD/1jaK1Lbd1D6FqT9qYLOI6ma718w6qW1dbvTxfQ3N2mP+2teyBd69XXgBfQdX+fRtfa9h/AF4CDV+Hzcj7wzjb/ghZIbNCWt2jH9cC2/A/AB9r8IcCXBsp6H/Cm3vv+oRn2/U7gHW3+jfSCMLoWwF+wMmi7hl7LJV3g/ktaq+5Auce092Kwtfbx7fgm2+ZzwP/pLT94onxWfq53HvbzPMT7vhcr/yk6nK61s98C/Ddt/3fTBXaPnaKcDYDrgde3+We09+3cYT8DTk5rappvY1qkcXA48Nmquq0tf5hVHKuUZEGS45J8O8mP6YI66LqdtqULNr49TRF/BRxfVSt6aQ8EDk7yo4mJLsC8fy/PTOOxvkAXGD25zV8IPKVNX5hmu+/15v+XriWFqroAeA9dy+H3k5yY5D5TlHEosFOr4wl0LXYrWjnX0r3H76FrtdqWLmhdMWlJ05SV5CHAmXStXBvStTy+Psl+bV/frapnV9Vj6AKTY+iC5Le27Z5LNwZu62neD9q+dgCe2vZPK29jum5MqupOum7lJW39kl7eBwJ7DZzPQ4GJMXYwcD6T7JXk80luTXIH3RjAbdvqB/TzV9X/0rVcTXgg3biuiX1dA/yKrjt50D/TtZp9tl3IcVRL3wH4blXdPck2D6BrvZ3wXbqArV9+/3iG+TxPqaourqo7q+rnVXUqXWvbs9vql9G1/D2M7jPwQuDTSR4wSTm/BA6kO2ffA/6Srut4qs+eNDIGbdIqSLIJ8HzgKUm+l+R7wGuAR/YGstckmw6m/TFwAN04pC3pWhqgawG4ja7r70HTVOUZdIPkn9dLu5GuZWKr3rRZVR03TT0GTQRtT2rzX2C4oG1KVfWuqtqD7gdyN7qAc7J8362q51TVwqrai65b8pLe+rOq6uFVtQ3wJrof9UtXo6yH07W6nVtVv66q6+gCp2dNUtQb6VoRv0/XTbasqu6g+8HeZYjDfxHd39lPtc/K9XRB22G9PB8BXpDk8XTdgp9v6TcCXxg4n5tX1Sv6hzqwvw8DS+m6erek68JMW3cLXdcn8JvP8ja9bW8EnjWwv42r6qbBg2rB0F9W1c50rZavTfL0VsaOU1xIcDPdOZuwI10r1/enOJ5hPs+rolj5XjySbvzmt9pn4D/p3p8nTLph1Teq6ilVtU1VPZOui/eSyfJKo2TQJq2aA+laH3YHHtWmh9INxJ74If4+3R/1vsG0LYCf07V0bAr848SKqvo18AG61pwHtFa5xw/cWuQqYF/g+CQTV6+eDuyf5Jltm43brSa2Z3hfoGsZ2qS14n2p7WcbujE/qyTJY1vrzwZ03YB30b1/k+V9aJItkmyY5IV0genbe+v3aMe1kK6b8FOtBW5Vy7oc2LXd9iNJHgQ8h24sVr+M3ekC2BNa0neApyW5H7Ar3fjAmRwG/B0rPyuPort4ZL8kEwHTOXTBzDHAme38QzfQf7ckL2q3G9mgvZ8PnWZ/WwC3V9VdSfak++dgwll0n48nJNmw1Su99e8F/iHJA9vxL0xywGQ7SfKcJLskCd1FD79q0yV0wc9xSTZrn8Hfb5t9BHhNkp2SbE73mT9zilY5+C0+z0m2atttnGT9JIfStR6f27JcSncOdm6fgX3o/qH45hTl/V4ra9Mkr6Nr7TtlpnpIa9xc9886OY3TRHe139smSX8+XdfJ+nQ/6FfQDSj/97b+ALof+R/RdbVtTtdVdiddN9Fh3HOc2CZ045FuYuXVpZNdPbqYLiB8Vlveiy7wup1ubNHZwI5t3YVMcTXdwLHcAnywt7wM+MxAnsExbcf21u0NrGjzT6e7YvQndC2I/wZsPsV+X93q/FO6MWmLB9Z/ub1ft9MFbZv11h0KXLUKZT2f7gf6TrpWs7cwMOaOrsVrr97yI+m6ZG8DXttLvwo4dJLjeRxdkLpwknVX0btqlO6WE8XAuCq6cV9ns/JKzAtYeQXvPd73lnZQ+zzdSRf0vQc4vbf+xXSfw4mrR28CntTWrUd3W5Pr2vbfBv5xinP1Grou/Z+29+/o3rod6S7c+J/2Xr2rV/4b6VrQbqULyn6nrVtE73PdK2u6z/PfMPC57G23kC4wu5PuO/dVYJ/e+tAFyf/d8lwDvKi3/h5l03UH/5Duc/wZemP52vH+ZKJeTk6jnFI1U2+JJGlt01q7fgTsWlXfmev6SJqZ3aOStI5I91SJTZNsRndhxZWsvAhG0jxn0CZJ644D6C4IuJmuG39J2d0ijQ27RyVJksaALW2SJEljwKBNkiRpDEx2A8S1zrbbbluLFi2a62pIkiTN6LLLLrutqhYOpq8TQduiRYtYtmzZXFdDkiRpRkm+O1m63aOSJEljwKBNkiRpDBi0SZIkjQGDNkmSpDFg0CZJkjQGDNokSZLGgEGbJEnSGDBokyRJGgMGbZIkSWPAoE2SJGkMGLRJkiSNgXXi2aOStLZYdNTZ91i+4bj95qgmkmabQZskraUM8KS1i92jkiRJY8CgTZIkaQzYPSpJ84BdmZJmYkubJEnSGDBokyRJGgN2j0rSOs6uWWk82NImSZI0BgzaJEmSxoBBmyRJ0hhwTJskjTnHpEnrBoM2SRqR3zaYMhiT1Gf3qCRJ0hiwpU2S1iG23knjy5Y2SZKkMWDQJkmSNAYM2iRJksaAY9okSUNzTJw0dwzaJGkWGfRIWl12j0qSJI0BgzZJkqQxYPeoJOle7MaV5h9b2iRJksaAQZskSdIYsHtUklaRXYeS5oItbZIkSWNgpEFbkn2TXJdkeZKjJlm/UZIz2/qLkyxq6fskuSzJle31ab1tLmxlXtGm+47yGCRJkuaDkXWPJlkAHA/sA6wALk2ytKqu7mV7KfDDqtolyRLgLcAhwG3A/lV1c5KHA+cC2/W2O7Sqlo2q7pIkSfPNKMe07Qksr6rrAZKcARwA9IO2A4A3t/mzgPckSVVd3stzFbBxko2q6ucjrK8krTbHuUkatVF2j24H3NhbXsE9W8vukaeq7gbuALYZyPM84PKBgO2DrWv06CRZs9WWJEmaf0YZtE0WTNWq5EnyMLou0z/rrT+0qh4BPKlNL5p058kRSZYlWXbrrbeuUsUlSZLmm1EGbSuAHXrL2wM3T5UnyfrAlsDtbXl74JPAYVX17YkNquqm9non8GG6bth7qaoTq2pxVS1euHDhGjkgSZKkuTLKMW2XArsm2Qm4CVgC/PFAnqXA4cBFwEHABVVVSbYCzgbeUFVfmcjcArutquq2JBsAzwHOH+ExSJJWg2P8pDVvZEFbVd2d5Ei6Kz8XAB+oqquSHAMsq6qlwMnAaUmW07WwLWmbHwnsAhyd5OiW9gzgp8C5LWBbQBewvX9UxyBJmpkBmjQ7RvpEhKo6BzhnIO2Nvfm7gIMn2e5Y4Ngpit1jTdZRkiRpHPhEBEmSpDFg0CZJkjQGDNokSZLGgEGbJEnSGDBokyRJGgMjvXpUksaFt62QNN/Z0iZJkjQGbGmTpCnY+iZpPrGlTZIkaQwYtEmSJI0BgzZJkqQxYNAmSZI0BgzaJEmSxoBBmyRJ0hjwlh+SpFnhLVSk344tbZIkSWPAljZJ0pyyBU4aji1tkiRJY8CgTZIkaQwYtEmSJI0BgzZJkqQxYNAmSZI0BgzaJEmSxoC3/JC0VpvsdhLeYkLSOLKlTZIkaQwYtEmSJI0BgzZJkqQxYNAmSZI0BgzaJEmSxoBBmyRJ0hgwaJMkSRoDBm2SJEljwKBNkiRpDBi0SZIkjQEfYyVJmnd81Jh0b7a0SZIkjYGRBm1J9k1yXZLlSY6aZP1GSc5s6y9Osqil75PksiRXtten9bbZo6UvT/KuJBnlMUiSJM0HIwvakiwAjgeeBewOvCDJ7gPZXgr8sKp2Ad4BvKWl3wbsX1WPAA4HTuttcwJwBLBrm/Yd1TFIkiTNF6Mc07YnsLyqrgdIcgZwAHB1L88BwJvb/FnAe5Kkqi7v5bkK2DjJRsDWwH2q6qJW5oeAA4HPjPA4JEnzgOPctK4bZffodsCNveUVLW3SPFV1N3AHsM1AnucBl1fVz1v+FTOUKUmStNYZKmhL8sQkL2nzC5PsNMxmk6TVquRJ8jC6LtM/W4UyJ7Y9IsmyJMtuvfXWIaorSZI0f80YtCV5E/DXwBta0gbA6UOUvQLYobe8PXDzVHmSrA9sCdzelrcHPgkcVlXf7uXffoYyAaiqE6tqcVUtXrhw4RDVlSRJmr+GGdP2h8Cjga8BVNXNSbYYYrtLgV1bq9xNwBLgjwfyLKW70OAi4CDggqqqJFsBZwNvqKqvTGSuqluS3JnkccDFwGHAu4eoi6S1yFRjm/rpjneStLYZpnv0F1VVtG7IJJsNU3Abo3YkcC5wDfDRqroqyTFJntuynQxsk2Q58Fpg4rYgRwK7AEcnuaJN923rXgGcBCwHvo0XIUiSpHXAMC1tH03yPmCrJH8K/Anw/mEKr6pzgHMG0t7Ym78LOHiS7Y4Fjp2izGXAw4fZvyRJ0tpixqCtqt6aZB/gx8CDgTdW1Xkjr5kkSZJ+Y9qgrd0g99yq+gPAQE2SJGmOTDumrap+Bfxvki1nqT6SJEmaxDBj2u4CrkxyHvDTicSqetXIaiVJkqR7GCZoO7tNkiRJmiPDXIhwapINgd1a0nVV9cvRVkuSJEl9MwZtSfYGTgVuoHuM1A5JDq+qL462apIkSZowTPfo24BnVNV1AEl2Az4C7DHKikmSJGmlYZ6IsMFEwAZQVd+ie/6oJEmSZskwLW3LkpwMnNaWDwUuG12VJEmSNGiYoO0VwJ8Dr6Ib0/ZF4F9HWSlJkoax6Kh73tzghuP2m6OaSKM3TNC2PvAvVfV2+M1TEjYaaa0kSZJ0D8OMafscsElveRPg/NFUR5IkSZMZJmjbuKp+MrHQ5jcdXZUkSZI0aJig7adJHjOxkGQP4Gejq5IkSZIGDTOm7dXAx5Lc3JbvDxwyuipJkiRp0DCPsbo0yUOAB9NdPXqtj7GSNFu8OlCrw8+N1kbDPMbqYOA/q+qbSf4W+Lskx1bV10ZfPUnrEn9oJWlqw4xpO7qq7kzyROCZdM8hPWG01ZIkSVLfMEHbr9rrfsAJVfUfwIajq5IkSZIGDRO03ZTkfcDzgXOSbDTkdpIkSVpDhgm+ng+cC+xbVT8Ctgb+aqS1kiRJ0j0Mc/Xo/wKf6C3fAtwyykpJkiTpnuzmlCRJGgNTBm1t7JokSZLmgela2i4CSHLaLNVFkiRJU5huTNuGSQ4HnpDkjwZXVtUnJtlGkiRJIzBd0PZy4FBgK2D/gXVF7+IESZIkjdaUQVtVfRn4cpJlVXXyLNZJkiRJA2a85QdwWpJXAU9uy18A3utD4yVJkmbPMEHbvwIbtFeAF9E9e/Rlo6qUJEmS7mmYoO2xVfXI3vIFSb4+qgpJkiTp3oZ6YHySB00sJNmZlQ+RlyRJ0iwYpqXtr4DPJ7keCPBA4CUjrZUkSWvYoqPOvsfyDcftN0c1kVbPMM8e/VySXYEH0wVt11bVz0deM0mSJP3GMC1ttCDtGyOui6R1SL/VwxYPSZqZD4yXJEkaA0O1tK2uJPsC/wIsAE6qquMG1m8EfAjYA/gf4JCquiHJNsBZwGOBU6rqyN42FwL3B37Wkp5RVT8Y5XFIWn2OI5KkNWPGlrYkH0+yX5JVapVLsgA4HngWsDvwgiS7D2R7KfDDqtoFeAfwlpZ+F3A08Lopij+0qh7VJgM2SZK01hsmEDsB+GPg/yY5LslDhix7T2B5VV1fVb8AzgAOGMhzAHBqmz8LeHqSVNVP22O07hpyX5IkSWu1Ya4ePR84P8mWwAuA85LcCLwfOH2ax1ltB9zYW14B7DVVnqq6O8kdwDbAbTNU64NJfgV8HDi2qmqm45AkaZDd9xonQ3V5tjFmL6Z7dNXldOPUHgOcN91mk6QNBlfD5Bl0aFU9AnhSm1406c6TI5IsS7Ls1ltvnaFISZKk+W2YMW2fAL4EbArsX1XPraozq+qVwObTbLoC2KG3vD1w81R5kqwPbAncPl19quqm9non8GG6btjJ8p1YVYuravHChQunK1KSJGneG6al7aSq2r2q/qmqboHfXPVJVS2eZrtLgV2T7JRkQ2AJsHQgz1Lg8DZ/EHDBdF2dSdZPsm2b3wB4DvDNIY5BkiRprA1zy49jgXMG0i6i6x6dUhujdiRwLt0tPz5QVVclOQZYVlVLgZOB05Isp2thWzKxfZIbgPsAGyY5EHgG8F3g3BawLQDOpxtbJ0mStFabMmhL8rt0FwpskuTRrBx/dh+6rtIZVdU5DAR8VfXG3vxdwMFTbLtoimL3GGbfkiRJa5PpWtqeSXfxwfbA23vpdwJ/M8I6SZIkacCUQVtVnQqcmuR5VfXxWayTJEmSBkzXPfrCqjodWJTktYPrq+rtk2wmSZKkEZiue3Sz9jrdbT0kSZI0C6brHn1fe/272auOJEmSJjNd9+i7ptuwql615qsjSZKkyUzXPXrZrNVCkiRJ05rp6lFJkiTNA9N1j76zql6d5FNM8hD3qnruSGsmaewsOurseyzfcNx+c1QTSVr7TNc9elp7fetsVESSJElTm6579LL2+oX2wPeH0LW4XVdVv5il+kmSNKtsMdZ8NeMD45PsB7wX+Dbd80d3SvJnVfWZUVdO0vzlD5skza4ZgzbgbcBTq2o5QJIHAWcDBm2SJEmzZL0h8vxgImBrrgd+MKL6SJIkaRLTXT36R232qiTnAB+lG9N2MHDpLNRNkiRJzXTdo/v35r8PPKXN3wr8zshqJEmSpHuZ7urRl8xmRSRJkjS1Ya4e3Rh4KfAwYOOJ9Kr6kxHWS5IkST3DXD16GnAt8EzgGOBQ4JpRVkqSpPnG29xorg1z9eguVXU08NP2PNL9gEeMtlqSJEnqGyZo+2V7/VGShwNbAotGViNJkiTdyzDdoycm+R3gaGApsHmblyRJ0iyZMWirqpPa7BeAnUdbHUmSJE1mxu7RJNskeXeSryW5LMk7k2wzG5WTJElSZ5gxbWfQPbbqecBBwG3AmaOslCRJku5pmDFtW1fV3/eWj01y4KgqJEmSpHsbJmj7fJIldM8eha617exp8ktay3h/Kkmae9M9MP5OugfEB3gtcHpbtR7wE+BNI6+dJEmSgOmfPbrFbFZEkiRJUxume5QkzwWe3BYvrKpPj65KkuaK3aCSNH8Nc8uP44C/AK5u01+0NEmSJM2SYVrang08qqp+DZDkVOBy4KhRVkySJEkrDdU9CmwF3N7mtxxRXSRJGisOKdBsGiZo+yfg8iSfp7uS9MnAG0ZaK0mSJN3DtEFbkgBfBh4HPJYuaPvrqvreLNRNkiRJzbRBW1VVkn+vqj2ApbNUJ0mSJA0Y5tmjX03y2JHXRJIkSVMaJmh7Kl3g9u0k30hyZZJvDFN4kn2TXJdkeZJ7XW2aZKMkZ7b1FydZ1NK3SfL5JD9J8p6BbfZodVie5F2tC1eSJGmtNsyFCM9anYKTLACOB/YBVgCXJllaVVf3sr0U+GFV7dKeb/oW4BDgLuBo4OFt6jsBOAL4KnAOsC/wmdWpoyRJ0riY7tmjGwMvB3YBrgROrqq7V6HsPYHlVXV9K+8M4AC6G/ROOAB4c5s/C3hPklTVT4EvJ9lloE73B+5TVRe15Q8BB2LQJkmaJ7wNiEZluu7RU4HFdAHbs4C3rWLZ2wE39pZXtLRJ87SA8A5gmxnKXDFDmZIkSWud6bpHd6+qRwAkORm4ZBXLnmysWa1GntXKn+QIum5Udtxxx2mKlCRJmv+ma2n75cTMKnaLTlgB7NBb3h64eao8Sdane9rC7UxtRStnujIBqKoTq2pxVS1euHDhKlZdkiRpfpmupe2RSX7c5gNs0pZDdwu3+8xQ9qXArkl2Am4ClgB/PJBnKXA4cBFwEHBBVU3Z0lZVtyS5M8njgIuBw4B3z1APSZNw3I0kjZcpg7aqWvDbFFxVdyc5EjgXWAB8oKquSnIMsKyqlgInA6clWU7XwrZkYvskNwD3ATZMciDwjHbl6SuAU4BN6C5A8CIESZK01hv2gfGrparOobstRz/tjb35u4CDp9h20RTpy7j3bUAkSZLWaiMN2iTND3aFStL4G+aJCJIkSZpjBm2SJEljwKBNkiRpDBi0SZIkjQGDNkmSpDHg1aOSJI2YV3BrTbClTZIkaQwYtEmSJI0BgzZJkqQxYNAmSZI0BgzaJEmSxoBXj0prGa9Sk6S1k0GbJElzpP9Plv9gaSZ2j0qSJI0BW9qkMWU3qCStW2xpkyRJGgMGbZIkSWPAoE2SJGkMGLRJkiSNAYM2SZKkMWDQJkmSNAYM2iRJksaAQZskSdIY8Oa6kiTNI944W1MxaJPGgH/EJUl2j0qSJI0BgzZJkqQxYPeoNM/YFSpJmowtbZIkSWPAoE2SJGkM2D0qSdI857AJgS1tkiRJY8GgTZIkaQwYtEmSJI0BgzZJkqQxMNKgLcm+Sa5LsjzJUZOs3yjJmW39xUkW9da9oaVfl+SZvfQbklyZ5Ioky0ZZf0mSpPliZFePJlkAHA/sA6wALk2ytKqu7mV7KfDDqtolyRLgLcAhSXYHlgAPAx4AnJ9kt6r6VdvuqVV126jqLs0WrwiTJA1rlC1tewLLq+r6qvoFcAZwwECeA4BT2/xZwNOTpKWfUVU/r6rvAMtbeZIkSeukUd6nbTvgxt7yCmCvqfJU1d1J7gC2aelfHdh2uzZfwGeTFPC+qjpxBHWX1ihb1CStaf5dWfeMMmjLJGk1ZJ7ptv39qro5yX2B85JcW1VfvNfOkyOAIwB23HHH4WstSZI0D42ye3QFsENveXvg5qnyJFkf2BK4fbptq2ri9QfAJ5mi27SqTqyqxVW1eOHChb/1wUiSJM2lUQZtlwK7JtkpyYZ0FxYsHcizFDi8zR8EXFBV1dKXtKtLdwJ2BS5JslmSLQCSbAY8A/jmCI9BkiRpXhhZ92gbo3YkcC6wAPhAVV2V5BhgWVUtBU4GTkuynK6FbUnb9qokHwWuBu4G/ryqfpXkfsAnu2sVWB/4cFX956iOQZIkab4Y6QPjq+oc4JyBtDf25u8CDp5i238A/mEg7XrgkWu+ppIkSfPbSIM2SZI0u/pXlXpF6drFoE1aw7wMX5I0Cj57VJIkaQwYtEmSJI0Bu0el34JdoZKk2WJLmyRJ0hgwaJMkSRoDdo9Kkkwk6DoAAA3gSURBVLSWcyjH2sGWNkmSpDFg0CZJkjQG7B6VhmT3giRpLtnSJkmSNAZsaZMG2KImaV3g37rxY0ubJEnSGDBokyRJGgMGbZIkSWPAoE2SJGkMeCGC1mkOxJWklfybOL8ZtGmd4R8jSdI4s3tUkiRpDBi0SZIkjQG7RyVJ0pQcWjJ/GLRpreQfGUnS2sagTWPN4EyStK5wTJskSdIYsKVNkiStMns6Zp8tbZIkSWPAljaNDf+rk6T5zb/To2XQpnnJL74kSfdk96gkSdIYsKVNc85WNUlae/k3fs0xaNOs8YsrSdLqM2iTJEmzyn/iV49Bm35rk335/EJKkrRmGbRJkqR5wX/4p2fQpklN9cXxCyVJmk3+7qxk0Ca/EJIkjYGRBm1J9gX+BVgAnFRVxw2s3wj4ELAH8D/AIVV1Q1v3BuClwK+AV1XVucOUqekZoEmSxt26+ls2sqAtyQLgeGAfYAVwaZKlVXV1L9tLgR9W1S5JlgBvAQ5JsjuwBHgY8ADg/CS7tW1mKnOd1P8A25UpSVrXrAvDekbZ0rYnsLyqrgdIcgZwANAPsA4A3tzmzwLekyQt/Yyq+jnwnSTLW3kMUea8N2yA5VWZkiSteeP6+zrKoG074Mbe8gpgr6nyVNXdSe4AtmnpXx3Ydrs2P1OZc2JcPwCSJGly8+13PFU1moKTg4FnVtXL2vKLgD2r6pW9PFe1PCva8rfpWtSOAS6qqtNb+snAOXTPSp22zF7ZRwBHtMUHA9eN5EC1OrYFbpvrSmhanqP5z3M0/3mO5r/5eo4eWFULBxNH2dK2Atiht7w9cPMUeVYkWR/YErh9hm1nKhOAqjoROHF1K6/RSbKsqhbPdT00Nc/R/Oc5mv88R/PfuJ2j9UZY9qXArkl2SrIh3YUFSwfyLAUOb/MHARdU1/S3FFiSZKMkOwG7ApcMWaYkSdJaZ2QtbW2M2pHAuXS35/hAVV2V5BhgWVUtBU4GTmsXGtxOF4TR8n2U7gKDu4E/r6pfAUxW5qiOQZIkab4Y2Zg2aSpJjmjd15qnPEfzn+do/vMczX/jdo4M2iRJksbAKMe0SZIkaQ0xaNNIJdkhyeeTXJPkqiR/0dK3TnJekv/bXn9nruu6LkuyIMnlST7dlndKcnE7P2e2C380h5JsleSsJNe279Pj/R7NH0le0/7GfTPJR5Js7Pdo7iX5QJIfJPlmL23S700670qyPMk3kjxm7mo+OYM2jdrdwF9W1UOBxwF/3h5TdhTwuaraFfhcW9bc+Qvgmt7yW4B3tPPzQ7pHzmlu/Qvwn1X1EOCRdOfL79E8kGQ74FXA4qp6ON2FchOPZvR7NLdOAfYdSJvqe/MsurtV7Ep3n9cTZqmOQzNo00hV1S1V9bU2fyfdD812dI8fO7VlOxU4cG5qqCTbA/sBJ7XlAE+je7QceH7mXJL7AE+mu+KeqvpFVf0Iv0fzyfrAJu2eo5sCt+D3aM5V1Rfp7k7RN9X35gDgQ9X5KrBVkvvPTk2HY9CmWZNkEfBo4GLgflV1C3SBHXDfuavZOu+dwOuBX7flbYAfVdXdbbn/GDnNjZ2BW4EPtm7sk5Jsht+jeaGqbgLeCvw3XbB2B3AZfo/mq6m+N5M9fnNenTODNs2KJJsDHwdeXVU/nuv6qJPkOcAPquqyfvIkWb3MfG6tDzwGOKGqHg38FLtC5402JuoAYCfgAcBmdF1tg/wezW/z/m+fQZtGLskGdAHbv1XVJ1ry9yeandvrD+aqfuu43weem+QG4Ay67px30nULTNx8e8rHxWnWrABWVNXFbfksuiDO79H88AfAd6rq1qr6JfAJ4An4PZqvpvreDPP4zTll0KaRauOjTgauqaq391b1H2F2OPAfs103QVW9oaq2r6pFdAOnL6iqQ4HP0z1aDjw/c66qvgfcmOTBLenpdE+M8Xs0P/w38Lgkm7a/eRPnx+/R/DTV92YpcFi7ivRxwB0T3ajzhTfX1UgleSLwJeBKVo6Z+hu6cW0fBXak+4N3cFUNDhbVLEqyN/C6qnpOkp3pWt62Bi4HXlhVP5/L+q3rkjyK7mKRDYHrgZfQ/ePt92geSPJ3wCF0V8xfDryMbjyU36M5lOQjwN7AtsD3gTcB/84k35sWcL+H7mrT/wVeUlXL5qLeUzFokyRJGgN2j0qSJI0BgzZJkqQxYNAmSZI0BgzaJEmSxoBBmyRJ0hgwaJPWUkn+vyRXJflGkiuS7DWL+06SC9ozM9dUmS9Pclibf3GSB/TWnZRk9zW1r2nqcGGSxaPeT29/B/aPa/C4V7GsvZN8es3Vbsb9nZNkq9XY7jnt9hmSBhi0SWuhJI8HngM8pqp+j+6O7TdOv9WMZa4/c67feDbw9TX5yLKqem9VfagtvpjucUET615WVVevqX3NIwcC/WD0xfSOe7as4rkHoKqe3R5qv6rOpntKx6arsa20VjNok9ZO9wdum7iRZ1XdVlU3AyR5bJL/SvL1JJck2SLJxkk+mOTK9kDyp7a8L07ysSSfAj7b0v4qyaWtBW+qFpFDaXcZT7IoybVJTm3bnDXxg5zk6W1/Vyb5QJKNWvpxSa5u+d/a0t6c5HVJDgIWA//WWhA3mWgBS/KKJP//RCVa/d/d5l/YjveKJO9LsqBf4SR7JvlEmz8gyc+SbNjem+t7WQ9u5XwryZNa/gVJ/rn3vvxZS9+71e2s9h78W7uBJwP7/tO27deTfLzdWf8JwHOBf251/utJjvuNbbtvJjlxouwkuyQ5v5X3tSQPGtjfY9v7vnOSzdp7f2lLO2Cqc9/b/vVJXtXm35Hkgt75PL3N35Bk23b+r0ny/nQtv59NsknL86reeT6jfVYLuJDunw5JfVXl5OS0lk3A5sAVwLeAfwWe0tIn7qb/2LZ8H7qHkf8l8MGW9hC6u4RvTNeyswLYuq17BnAi3YOV1wM+DTx5kv1/F9iizS+ie+jy77flDwCva+XfCOzW0j8EvJru7vHXsfLm31u11zfTPbEBuh/1xb39XUgX0CwElvfSPwM8EXgo8Clgg5b+r8BhA3Ven+75kQBvBS6lezbrU4CP9Pbztjb/bOD8Nn8E8LdtfiNgGd3Dw/cG7qB7huF6wEXAEyd5v7bpzR8LvLLNnwIcNHicveWte/OnAfu3+YuBP2zzGwObtrp8mu6ZmJcBO7b1/0h3p36Areg+M5sNnvuB+j4O+Fib/xJwCbAB3d3m/6yl30B3F/pFdE8JeFRL/2hvfzcDG/XPc5s/FHj3XH+PnJzm22RLm7QWqqqfAHvQBRO3AmcmeTHwYOCWqrq05ftxVd1NF9ic1tKupQu6dmvFnVcrH430jDZdDnyNLsDbdZIqbF1Vd/aWb6yqr7T509v+HkwXJH2rpZ8KPBn4MXAXcFKSP6J7nMywx30rcH2SxyXZpu3jK3TPgtwDuDTJFW1554Ft7waWJ3kosCfw9lafJ9EFJhM+0V4vowtIoHtPDmtlXwxsw8r35ZKqWlFVv6YLpBdxbw9P8qUkV9IFLA8b8pCfmuTitt3TgIcl2QLYrqo+2Y7rrqqaeA8fShd0719V/92r+1Gt7hfSBXk7tnX9c993GbBH29fP6YLRxdz7vZrwnaq6orftojb/DbqWwxfSBXYTfsAcdANL890qj1OQNB6q6ld0P8IXth/1w+kCrcmeXXevLruenw7k+6eqet8Mu787yXotUGGSfdZU+6yqu5PsSRdYLQGOpAtIhnUm8HzgWuCTVVWt2/DUqnrDDNt+CXgW8EvgfLqWrgV0LYMTJp4d+StW/g0NXevYuf3C0j3Ptf+syf42facAB1bV11twvfcM9STJxnQthour6sYkb6YLuKY7l7e0PI+ma+WaqPvzquq6gfL34p7n/jeq6pdJbqB7/ul/0QVfTwUeBFwzySaD78EmbX4/usD4ucDRSR7WgueNgZ9NcxzSOsmWNmktlOTBSfotYI+iaz27FnhAkse2fFukG2T+RboWHpLsRtfSch33di7wJ0k2b3m3S3LfSfJdxz1bsnZMd3EEwAuAL7e6LEqyS0t/EfCFVvaWVXUOXXfpoyYp/05giykO/xN0A/hfQBfAAXwOOGiirkm2TvLASbb9YtvnRa3Vbhu61sSrptjXhHOBVyTZoJW/W5LNZtimbwvglrb9ob30wePsL2/cXm9r79lB0LWeAiuSHNjqslFWDur/EV2g9I8toJyo+yt74+EePWSdv0gXzH6RLth9OXBFVQ31QOsk6wE7VNXngdfTdc1u3lbvBnxzyHpI6wyDNmnttDlw6sQgb7orEN9cVb8ADgHeneTrwHl0P/7/CixoLXJnAi+udhFDX1V9FvgwcFHLexaTB09nc8/WomuAw1tdtgZOqKq76FpqPtbK+jXw3lbep1veLwCvmaT8U4D3TgzIH6jjD4GrgQdW1SUt7Wrgb4HPtnLPo7tYY9DFwP3oAhHoWpC+MUQgclLb59eSfBN4H6vWk3F02/d5dMHshDOAv2oXCDyI3nHTtV69H7gS+He6MXgTXgS8qh3rfwG/O7Giqr4P7A8c31rT/p5uPNo3Wt3/fsg6f4nuPbyolXkXk3eNTmUBcHo795cD76iVV5s+le4zJKknQ/5TJElDS3J/4ENVtU+SRcCnq+rhc1srjYMk9wM+XFVPn+u6SPONLW2S1riqugV4f9bgzXW1ztiR7mpmSQNsaZMkSRoDtrRJkiSNAYM2SZKkMWDQJkmSNAYM2iRJksaAQZskSdIYMGiTJEkaA/8Pflvwqc8cvjkAAAAASUVORK5CYII=\n", "text/plain": [ - "
" + "0.7960000000000003" ] }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" } ], "source": [ - "show(campaign((145, 100)))" + "attacker_win_probability(monte_carlo(simulate_campaign, start, 1000))" ] }, { "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." + "How accurate is that result? We can run it again and compare:" ] }, { @@ -468,7 +426,275 @@ "outputs": [ { "data": { - "image/png": "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\n", + "text/plain": [ + "0.8300000000000003" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "attacker_win_probability(monte_carlo(simulate_campaign, start))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Alernatively, we could do some math: the standard deviation of the expected value of a [binomial variable](https://www.mathsisfun.com/data/binomial-distribution.html) is $\\sqrt{p(1-p)/n}$, where $p$ is the true probability of one of the two outcomes and $n$ is the number of samples. In our case $\\sqrt{0.8(1-0.8)/1000}$ gives a standard deviation of about 1%. So we can be pretty confident (but not certain) \n", + "that the true percentage is somewhere between 77% and 86%.\n", + "\n", + "We could get better accuracy at the cost of increased computing time. It took about half a second to do 1,000 simulations; to get the standard deviation down by a factor of 10 to 0.1% would require 100 times more computing time (because of the square root in the formula), about a minute. To get to 0.01% would require 100 minutes. \n", + "\n", + "# Monte Carlo Simulation versus Exact Probability Calculation\n", + "\n", + "An alternative to the Monte Carlo approach is an approach that explicitly calculates the exact probability distribution of the final state of ther campaign. The differences between the two approaches are:\n", + "\n", + "- The **Monte Carlo approach** deals with a **single current state**, using random dice rolls to decide how that state changes. At the end of a simulated campaign we get a single final state, and we repeat the simulation to get an **estimated** probability distribution over final states.\n", + "\n", + "- The **exact probability calculation approach** deals with a **probability distribution over states**, right from the start. At each dice roll, every possible outcome is considered, and the probability distribution is updated to reflect all the outcomes and their probabilities. At the end of the campaign we have an **exact** probability distribution over all possible final states (well, exact at least to the limits of floating point precision; if you need even more precision, use `fractions.Fraction`).\n", + "\n", + "In deciding whether to use the exact calculation approach, there are three considerations:\n", + "\n", + "- **Is it worth the effort?** If I only wanted to know whether the attackers chance of winning is more or less than 50%, then the Monte Carlo approach is the simplest way to answer the question. The code will be simple and straightforward. If I need 0.0001% precision on the win probability, then exact calculation is called for.\n", + "- **Is it possible?** The exact calculation approach only works for **finite games**. \n", + "- **Is it feasible?** Computation may take too long if there are too many possible states of the game.\n", + "\n", + "**Worth the effort?** In general, the code for an exact calculation is more complex than for a Monte Carlo simulation, and thus it will take more time to write the code, and there will be more opportunity for bugs to sneak in. Monte Carlo code deals with the single current state of the simulation, for example: \n", + "\n", + " while not terminal(state):\n", + " \n", + "But in the exact calculation we need to consider every possible states (referenced in a loop):\n", + "\n", + " while any(not terminal(state) for state in probdist):\n", + " \n", + "Adding all these loops to the code makes it more complex.\n", + "\n", + "**Possible?** Imagine a *Risk* rule change where if the attackers roll three 6s and the defneders roll two 6s, then both sides *gain* an army. For the Monte Carlo simulation it would be trivial to add a single `if` statement to handle this rule, and the expected run time of the program would hardly change. But with the exact calculation everything has changed, because we now have an **infinite** game, where there will always be some possible state that has not terminated. (To deal with these we would have to make some compromises, such as stopping the calculation when there are still some nonterminal states, as long as they have very low probability.)\n", + "\n", + "**Feasible?** Imagine that before each battle, every army independently has the option to take one of ten possible actions (e.g. to move to a safe neighboring territory). Then with 100 armies, the very first move has $10^{100}$ outcomes, meaning that the probability distribution requires more states than the number of atoms in the universe. (To deal with this we would either stick with the Monte Carlo simulation, or a varioant of it such as [particle filtering](https://en.wikipedia.org/wiki/Particle_filter) in which we maintain a **sample** of several possible states–more than a single state, but less than the complete state distribution.)\n", + "\n", + " The *Risk* campaign problem as it stands leads to a very efficient exact probability calculation (possible, feasible, and worth it, IMHO). If there are $n$ total armies to start, then there are fewer than $n^2$ possible states, and the game can last no more than $n$ moves. With $n$ in the range of a few hundred, computation takes less than a second; much faster and more accurate than doing 100,000 simulations." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Exact Probability Distribution over a Battle\n", + "\n", + "The function `battle_deaths` was defined above to return the specific death counts for a specific dice roll. \n", + "\n", + "Now we'll define `battle_deaths_probdist` to give a probability distribution over all possible battle outcomes, corresponding to all possible dice rolls. The input to `battle_deaths_probdist` is a state giving the number of attacking and defending armies for just this one battle (not the total number of attacking and defending armies). 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, for efficiency." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [], + "source": [ + "@lru_cache()\n", + "def battle_deaths_probdist(state) -> ProbDist:\n", + " \"\"\"A probability distribution of deaths in a battle.\"\"\"\n", + " return ProbDist(battle_deaths(A_dice, D_dice)\n", + " for A_dice in rolls(A(state))\n", + " for D_dice in rolls(D(state)))\n", + "\n", + "def rolls(n) -> Iterable[Dice]: \n", + " \"\"\"All possible rolls of `n` dice.\"\"\"\n", + " return itertools.product(die, repeat=n)" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "ProbDist({(2, 0): 0.2925668724279835,\n", + " (1, 1): 0.3357767489711934,\n", + " (0, 2): 0.37165637860082307})" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "battle_deaths_probdist((3, 2)) # Three attacker dice against two defender dice" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Exact Probability Distribution over a Campaign\n", + "\n", + "The function `campaign_probdist` mimics `campaign`, except that the former updates a `ProbDist` whereas the later updates a `State`. We start with certainty: there is a 100% chance that we are initially in the `start` state. But the [fog of war](https://en.wikipedia.org/wiki/Fog_of_war) means that uncertainty arises: we don't know how the dice will land, so we don't know the outcome of the very first battle. Subsequent battles add more uncertainty. \n", + "\n", + "The function `campaign_probdist` calls the function `battle_update_probdist` to update the probability distribution to account for one battle, in all the possible ways it can turn out. The key line in `battle_update_probdist` is\n", + "\n", + " outcomes[update(state, dead)] += probdist[state] * dead_probdist[dead]\n", + " \n", + "which tells us to consider the outcome in which `dead` is the number of attackers and defenders that die in a battle, and to update `state` with those death counts, and increment the probability of that updated outcome by the product of the probability of `state` and the probability of `dead` given `state`." + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [], + "source": [ + "def campaign_probdist(start: State) -> ProbDist:\n", + " \"\"\"Probability distribution for all outcomes of a campaign.\"\"\"\n", + " probdist = ProbDist({start: 1.0})\n", + " while any(not terminal(state) for state in probdist):\n", + " probdist = battle_update_probdist(probdist)\n", + " return probdist\n", + "\n", + "def battle_update_probdist(probdist) -> ProbDist:\n", + " \"\"\"For every possible campaign state in the `probdist`, consider the outcomes of a battle. \n", + " Combine these all into one updated `outcomes` ProbDist.\"\"\"\n", + " outcomes = ProbDist()\n", + " for state in probdist:\n", + " if terminal(state): # `state` carries through unchanged to `outcomes`\n", + " outcomes[state] += probdist[state] \n", + " else: # Replace `state` with all possible outcomes from a battle\n", + " dead_probdist = battle_deaths_probdist((min(3, A(state) - 1), min(2, D(state))))\n", + " for dead in dead_probdist:\n", + " outcomes[update(state, dead)] += probdist[state] * dead_probdist[dead]\n", + " return outcomes" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Finishing the Unfinished Game (Exactly)\n", + "\n", + "What is the exact probability of winning the unfinished game?" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.8105485936352178" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "attacker_win_probability(campaign_probdist(start))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The attackers defeat all the defenders 81.05% of the time. \n", + "\n", + "What are the 20 most common outcomes? " + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[((12,), 0.03824220182706657),\n", + " ((11,), 0.0380992150215239),\n", + " ((13,), 0.038032667992797725),\n", + " ((10,), 0.037618411457469664),\n", + " ((14,), 0.03746512036620402),\n", + " ((9,), 0.036822601595588304),\n", + " ((15,), 0.036544033638847624),\n", + " ((8,), 0.035741340182918115),\n", + " ((16,), 0.035284184613703425),\n", + " ((7,), 0.03440940023374102),\n", + " ((17,), 0.03371050842173721),\n", + " ((6,), 0.03286517629527088),\n", + " ((18,), 0.031857448871758426),\n", + " ((5,), 0.031149102741286083),\n", + " ((19,), 0.029767807751056283),\n", + " ((4,), 0.029302161098148583),\n", + " ((20,), 0.027491133463900305),\n", + " ((3,), 0.0273645356924103),\n", + " ((1, 5, 1), 0.026621109937678585),\n", + " ((1, 1), 0.025661022694069335)]" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "campaign_probdist(start).most_common(20)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The most probable outcome is that the attackers win with 12 remaining armies. The top 10 outcomes have anywhere from 7 to 16 attackers remaining. You have to go down to the 19th most common outcome to find one where the defenders win." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Analyzing and Visualizing Campaigns\n", + "\n", + "Let's try to visualize all the possible outcomes. 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 probabilities:" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [], + "source": [ + "def show(probdist, epsilon=0.0002):\n", + " \"\"\"Plot and annotate a probability distribution over states.\"\"\"\n", + " states = [s for s in probdist if probdist[s] > epsilon] # Ignore low-probability states\n", + " X = [score(s) for s in states]\n", + " Y = [probdist[s] for s in states]\n", + " μ = sum(score(s) * probdist[s] for s in probdist)\n", + " p = attacker_win_probability(probdist)\n", + " plt.figure(figsize=(10, 5))\n", + " plt.title(f'Attacker wins {p:.2%}. Average score: {μ:.2f}.')\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))" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", "text/plain": [ "
" ] @@ -480,7 +706,71 @@ } ], "source": [ - "show(campaign((150, 100, 1, 1, 1, 1, 1)))" + "show(campaign_probdist(start))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Interesting!** To the right of 0, we see a nice bell-shaped curve. But there is 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 campaign score can never be 0. And in this campaign, no score can be -2, because a -2 can only be achieved with the final state `(1, 2)`: one attacker and two defenders in a single territory; this campaign has only one defender in the final territory, so `(1, 2)` could never occur. 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. These are exactly the number of defenders in the final 8 territories, so the gaps are indicating the impossible scores.\n", + "\n", + "What's causing the spikes? To some extent they represent probability mass that has shifted over a place from the impossible states to the neighboring possible states. But the spikes are not quite tall enough to fill in the gaps. I admit I don't understand the exact shape of each spike–do you?\n", + "\n", + "In the plot below all the defenders are in a single territory, and there is no visible gap–the normalish shape is restored. However, there is something going on with odd-versus-even scores. I believe that part of 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 is broken only in the final battles. But I don't think that's the full story—what do you think?" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAm0AAAFNCAYAAABST1gVAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAAgAElEQVR4nO3debglVXnv8e+PZhQQArRGGWyQQVGvKA1qnHBGEeFGEJQIGg3RhBg1ajA3oBKS4I1TVIIiqIBRUNSkFRIEEUWDQCMoMnlbxNCACkERB1TwvX/UOnaxOcNu6N3n7NPfz/PUc6pWVa1atav2qXevtaoqVYUkSZLmtrVmuwCSJEmamUGbJEnSGDBokyRJGgMGbZIkSWPAoE2SJGkMGLRJkiSNAYM2aQ5LsihJJVl7lsvxsyTbzWYZJGlNZ9AmDSnJeUl+nGS9gfSPJjl6IO26JM9cvSUcnaraqKquXZV5Jtkyyb8nuTXJ8iSvGpi/d5Jvt4Dxv5LsfB/yenqSbyT5aZJrkxzam/foJFckuSXJ63rp6yS5MMnW92Lf9mjB9ptWdl3dO+37eUc7X36W5JrevCT5P0n+u50Dpya5/zR57ZLk/CS3tfPpyIH5L0pyVZLbk1yZZN9R7ps0waBNGkKSRcCTgQJeMKuFuRfaRWuufd8/BnwPeCCwF/APSZ4GkGQH4F+BVwGbAp8DlkxT4zhdXusAnwU+CGwCHAC8K8mj27r/CLwBeDTwt0l+v6W/Hvh0VV1/L/btEODW9nckkiwYVd6r2yqsST6s/cDYqKp26qUfDLwUeCLwYGAD4H3T5PNx4CvAZsBTgVcneUEr65Z059vrgfsDbwQ+nuQBq2gfpKlVlYODwwwDcCTwNeBdwOd76YcCvwF+DfyMLrg4Bfgt8MuW9qa27KeAHwC30V0QHtHLZwPgncD32/yvtrRFdIHi2m25FwLXAY9s048H/gv4CfBNYI9enucBf9/K/Utg+4F9ejnwud70MuCTvenrgV3aeE2sD3wUOBY4A7gduBB4aJsX4N3Aj9p+fGuirAPb3qjlubCXdjxwShs/DDijN2+ttg/PuBd5PbDNv19v/sXAi9v4VcB6bfzrwO7ANsBFwDr34ly5X/tcDmznxeLevP+kCyz6y38T+MM2/jDgbLqA7xrgRb3lPgocB5wJ/Bx4Jl2Aeinw03a83jqQ98HtnPof4Ih27jyz95keDny3zf8ksNkU+7QF8Pl2nt0KnA+s1eZtDXwGuLnl8/5e/n/btv8j4GRgkzZvUTsmrwD+G/jKTOfzEJ/7ecArp5h3OvDG3vQfAHf0z4mB5X8B7Nyb/hTw5jb+OOBHA8vfDDxhdf9fcljzhlkvgIPDOAx0Ac2fAbvSBWkP7M37KHD0wPK/uzj20v4Y2BhYD3gPcFlv3rHtorMlsKBdVNbrXdzWpguylrEieNqyXSSf1y6Qz2rTC9v889oF8RFt/XUGyrNduziuBTyoXVxv6M37ce/CPBi03UoX3KxNVyN2apv3HOASutqxAA8HHjTJ57lxy/MBvbQPAZe28b8AzuzNW9Ausn+5snm16Y8Df97yeQJdELF1m/cpYG9gK7qgenPg31iJgGGgPC8Fbmrb+hzw3t68g4Gv9aZ3bsdgPWBDusDr5e1zfSxwCy24b5/7bXS1RWsB6wN7AI9q0/8L+CGwby/vnwFPAtYF3kF37k4Eba+lC1K3atv/IPCJKfbpH4EPAOu04cnt+C6gC67e3cq/PvCk3vm+rJ1LG9EFdhOB9KJ2zE5u623AzOfz4fR+ME1SxvPogqdb6H6o7NGb92naj6c2/cS2/UdPkdc/AMe0fd0JWA7s1jsXv0xX474A2LfN33C2/085zP9h1gvg4DDXh3bR+w2wRZu+Gnhdb/5HGSJoG5i/abtobMKKWqR7XEB6F7c3AFcCW/Xm/fXERbCXdhZwSBs/Dzhqhn27ni44OJCuduoiutqelwNLessNBm0n9OY9D7i6jT8d+A5djclaM2z7q3RNVOu3MtwKXNPmPYyuNmkPuoDjCLrayzevbF5t/t50Ac2dbfiT3ryH0NVefQN4cbsYn0JX2/bv7QK9/0qcL+cA72njL6YLJNZp0xu3/XpIm/574MNt/ADg/IG8Pgi8pfe5nzzDtt8DvLuNH0kvCKOrAfw1K4K2q+jVXNIF7r+h1eoO5HtU+ywGa2uf0PZvsnW+CPxZb3qnifxZcV5vN+z5PMTn/jhW/Cg6hK62c6IG+JXtvFxE951b0rY/ae0Y3Y+mZe1cKeBtA/NfQRcQ30lXK7fXsOeHg8N9GeZaHxdpLjoE+EJV3dKmP85K9lVKsiDJMUm+m+SndEEddM1OW9AFG9+dJos3AsdW1fJe2kOA/ZP8ZGKgCzAf1Ftmpv5YX6YLjJ7Sxs+j68Pz1DY9lR/0xn9BV5NCVZ0LvJ+u5vCHSY6fpsP3QcC2rYzH0dXYLW/5XE33Gb+frtZqC7qgdfmkOU2TV5KHAafR1XKtS1fz+KYke7Vtfb+qnldVj6ULTI6iC5Lf0dZ7AV0fuM2m+Txo29oaeFrbPi2/9emaMamq2+malQ9s8w/sLfsQ4HEDx/MgYKKPHQwczySPS/KlJDcnuY2uD+AWbfaD+8tX1S/oaq4mPAT4bG9bVwF30TUnD/onuiDmC+1GjsNb+tbA96vqzknWeTBd7e2E79MFbP38+/szzPk8paq6sKpur6pfVdVJdLVtz2uzPwx8gu78vgL4Uku/x/nUjvN/0p0H67d9fE6SP2vznwn8X1b8oHgqcEKSXYYpp3RfGLRJ00iyAfAi4KlJfpDkB8DrgEf3OrLXJKsOpr0E2IeuH9ImdL/4oWtiuoWu6e+h0xTl2XSd5F/YS7uermZi096wYVUdM005Bk0EbU9u419muKBtSlX13qralS442pEu4Jxsue9X1fOramFVPY6uWfKi3vzTq+qRVbU58Ba6i/rF9yKvR9LVup1VVb+tqmvoAqfnTpLVkXS1iD+ka3ZcWlW30V3ctx9i919K93/1c+1cuZbuwn9wb5lPAC9O8gS6ZsGJAOJ64MsDx3Ojqnp1f1cHtvdxulqjratqE7omzLR5N9E1fQK/O5c37617PfDcge2tX1U3DO5UC4b+qqq2o6u1fH2SZ7Q8tpniRoIb6Y7ZhG3oaqZ+OMX+DHM+r4yifRbtuL+lqhZV1VZ0gdsNbRi0HXBXVZ1cVXe2H0qnsiIA3IWuD97Slu/FdP06583d4pq7DNqk6e1LV/uwM90/613o+mmdz4oL8Q/p/tH3DaZtDPyKrqbjfnR9ZoDugkJXE/CuJA9utXJPGHi0yBXAnsCxE3ex0d3BtneS57R11m+PmtiK4X2ZrmZog3ZxOr9tZ3O6Du4rJclurfZnHbpmwDvoPr/Jln14ko2TrJvkj+gC03f15u/a9mshXTPh51oN3MrmdSmwQ3vsR5I8FHg+XV+sfh470wWwx7Wk7wFPT/JAYAe6/oEzORh4GyvOlV3obh7ZK8lEwHQmXTBzFHBaO/7QdfTfMclL2+NG1mmf58On2d7GwK1VdUeS3el+HEw4ne78+IMk67ZypTf/A8DfJ3lI2/+FSfaZbCNJnp9k+yShu+nhrjZcRBccHpNkw3YOPrGt9gngdUm2TbIR3Tl/2hS1cnAfzuckm7b11k+ydpKD6GqPz2rzN0vy0Hb8d6Y7N47qffZ93+lWyUuSrNXuJj6AFefLxcCTJ2rWkjyG7kfPt2Yqp3SfzXb7rIPDXB7omkneOUn6i+iaCNemu6BfRteh/N/a/H3oLvI/oWtq24iuqex2umaig7l7P7EN6Poj3cCKu0snu3t0MV1A+Nw2/Ti6wOtWur5FZwDbtHnnMcXddAP7chPwkd70UuA/BpYZ7NN2dG/eHsDyNv4MuovXz+hqEP8V2GiK7b62lfnndH3SFg/M/2r7vG6lC9o27M07CLhiJfJ6EfDtlt9y4O0M9Lmjq/F6XG/60XRNsrcAr++lXwEcNMn+PJ4uSF04ybwr6N01CpzYPtPdBpbbqR3DiTsxz2XFHbx3+9xb2n7tfLqdLuh7P/Cx3vyX0Z2HE3eP3gA8uc1bi+6xFde09b8L/MMUx+p1dE36P2+f3xG9edvQ3bjxP+2zem8v/yPpatBupgvKfq/NW0TvvO7lNd35/DcMnJe99RbSBVO3033nvg48qzd/x7afv2if1+sH1v8A8IHe9NNbfrfRfc8/xN3vPj6Mrrn4drra1L+a6tx0cFiVQ6pmaj2RJI27Vtv1E2CHqvrebJdH0sqzeVSS5ql0b5W4X5IN6W6suJwVN8FIGjMGbZI0f+1Dd0PAjXTN+AeWzSvS2LJ5VJIkaQxY0yZJkjQGDNokSZLGwGQPRJx3tthii1q0aNFsF0OSJGlGl1xyyS1VtXAwfY0I2hYtWsTSpUtnuxiSJEkzSvL9ydJtHpUkSRoDBm2SJEljwKBNkiRpDBi0SZIkjQGDNkmSpDFg0CZJkjQGDNokSZLGgEGbJEnSGDBokyRJGgMGbZIkSWPAoE2SJGkMrBHvHpWk+WLR4Wfcbfq6Y/aapZJIWt0M2iRpnjLAk+YXm0clSZLGgEGbJEnSGLB5VJJm0WATJtiMKWly1rRJkiSNAYM2SZKkMWDzqCTJZlppDFjTJkmSNAYM2iRJksaAQZskSdIYsE+bJI05+6NJawaDNklaxVbF66N8BZWkQTaPSpIkjQFr2iRpDWMtnjSerGmTJEkaAwZtkiRJY8CgTZIkaQzYp02StNLsFyetfgZtkrSaGOhIui9sHpUkSRoDBm2SJEljwOZRSdKUbNKV5g5r2iRJksaAQZskSdIYsHlUkoZgM6Gk2WZNmyRJ0hgYadCWZM8k1yRZluTwSeavl+S0Nv/CJIta+rOSXJLk8vb36b11zmt5XtaGB4xyHyRJkuaCkTWPJlkAHAs8C1gOXJxkSVVd2VvsFcCPq2r7JAcCbwcOAG4B9q6qG5M8EjgL2LK33kFVtXRUZZckSZprRtmnbXdgWVVdC5DkVGAfoB+07QO8tY2fDrw/Sarq0t4yVwDrJ1mvqn41wvJK0koZ7OcG9nWTNDqjbB7dEri+N72cu9eW3W2ZqroTuA3YfGCZFwKXDgRsH2lNo0ckyaottiRJ0twzyqBtsmCqVmaZJI+gazL90978g6rqUcCT2/DSSTeeHJpkaZKlN99880oVXJIkaa4ZZdC2HNi6N70VcONUyyRZG9gEuLVNbwV8Fji4qr47sUJV3dD+3g58nK4Z9h6q6viqWlxVixcuXLhKdkiSJGm2jLJP28XADkm2BW4ADgReMrDMEuAQ4AJgP+DcqqokmwJnAG+uqq9NLNwCu02r6pYk6wDPB84Z4T5Iku4jn3EnrRojC9qq6s4kh9Hd+bkA+HBVXZHkKGBpVS0BTgROSbKMrobtwLb6YcD2wBFJjmhpzwZ+DpzVArYFdAHbh0a1D5Kk4RmcSaM10jciVNWZwJkDaUf2xu8A9p9kvaOBo6fIdtdVWUZJkqRx4BsRJEmSxoBBmyRJ0hgwaJMkSRoDBm2SJEljwKBNkiRpDIz07lFJmqt8b6ikcWNNmyRJ0hiwpk2SenxArKS5ypo2SZKkMWDQJkmSNAYM2iRJksaAQZskSdIYMGiTJEkaAwZtkiRJY8BHfkiSZoWPV5FWjjVtkiRJY8CaNknSnGHtmzQ1a9okSZLGgEGbJEnSGDBokyRJGgMGbZIkSWPAoE2SJGkMGLRJkiSNAR/5IWnemOpxET5GQtJ8YE2bJEnSGDBokyRJGgMGbZIkSWPAoE2SJGkMGLRJkiSNAYM2SZKkMWDQJkmSNAYM2iRJksaAQZskSdIYMGiTJEkaA77GSpI05/kqMsmaNkmSpLEw0qAtyZ5JrkmyLMnhk8xfL8lpbf6FSRa19GcluSTJ5e3v03vr7NrSlyV5b5KMch8kSZLmgpEFbUkWAMcCzwV2Bl6cZOeBxV4B/LiqtgfeDby9pd8C7F1VjwIOAU7prXMccCiwQxv2HNU+SJIkzRWj7NO2O7Csqq4FSHIqsA9wZW+ZfYC3tvHTgfcnSVVd2lvmCmD9JOsBmwH3r6oLWp4nA/sC/zHC/ZAkzUGD/dzAvm6a30bZPLolcH1venlLm3SZqroTuA3YfGCZFwKXVtWv2vLLZ8hTkiRp3hkqaEvypCQvb+MLk2w7zGqTpNXKLJPkEXRNpn+6EnlOrHtokqVJlt58881DFFeSJGnumjFoS/IW4K+BN7ekdYCPDZH3cmDr3vRWwI1TLZNkbWAT4NY2vRXwWeDgqvpub/mtZsgTgKo6vqoWV9XihQsXDlFcSZKkuWuYPm3/G3gM8A2AqroxycZDrHcxsEOrlbsBOBB4ycAyS+huNLgA2A84t6oqyabAGcCbq+prEwtX1U1Jbk/yeOBC4GDgfUOURdKYmuz5XPZlkrQmGqZ59NdVVbRmyCQbDpNx66N2GHAWcBXwyaq6IslRSV7QFjsR2DzJMuD1wMRjQQ4DtgeOSHJZGx7Q5r0aOAFYBnwXb0KQJElrgGFq2j6Z5IPApkn+BPhj4EPDZF5VZwJnDqQd2Ru/A9h/kvWOBo6eIs+lwCOH2b4kSdJ8MWPQVlXvSPIs4KfATsCRVXX2yEsmSZKk35k2aGsPyD2rqp4JGKhJkiTNkmn7tFXVXcAvkmyymsojSZKkSQzTp+0O4PIkZwM/n0isqteMrFSSJEm6m2GCtjPaIEmSpFkyzI0IJyVZF9ixJV1TVb8ZbbEkSZLUN2PQlmQP4CTgOrrXSG2d5JCq+spoiyZJkqQJwzSPvhN4dlVdA5BkR+ATwK6jLJgkSZJWGOaNCOtMBGwAVfUduvePSpIkaTUZpqZtaZITgVPa9EHAJaMrkiRJkgYNE7S9Gvhz4DV0fdq+AvzLKAslSdK9tejwuz/w4Lpj9pqlkkir1jBB29rAP1fVu+B3b0lYb6SlkiRJ0t0M06fti8AGvekNgHNGUxxJkiRNZpigbf2q+tnERBu/3+iKJEmSpEHDBG0/T/LYiYkkuwK/HF2RJEmSNGiYPm2vBT6V5MY2/SDggNEVSZIkSYOGeY3VxUkeBuxEd/fo1b7GStKq5h1/GjXPMY27YV5jtT/wn1X17SR/C7wtydFV9Y3RF0/SfOTFU5JW3jB92o6oqtuTPAl4Dt17SI8bbbEkSZLUN0zQdlf7uxdwXFX9O7Du6IokSZKkQcMEbTck+SDwIuDMJOsNuZ4kSZJWkWGCrxcBZwF7VtVPgM2AN460VJIkSbqbYe4e/QXwmd70TcBNoyyUJEmS7s5mTkmSpDEwZdDW+q5JkiRpDpiupu0CgCSnrKaySJIkaQrT9WlbN8khwB8k+cPBmVX1mUnWkSRJ0ghMF7S9CjgI2BTYe2Be0bs5QZIkSaM1ZdBWVV8FvppkaVWduBrLJEmSpAEzPvIDOCXJa4CntOkvAx/wpfGSJEmrzzBB278A67S/AC+le/foK0dVKEmSJN3dMEHbblX16N70uUm+OaoCSZIk6Z6GemF8kodOTCTZjhUvkZckSdJqMExN2xuBLyW5FgjwEODlIy2VJEmrwaLDz7hH2nXH7DULJZFmNsy7R7+YZAdgJ7qg7eqq+tXISyZJkqTfGaamjRakfWvEZZE0zwzWYliDIUn3ni+MlyRJGgND1bTdW0n2BP4ZWACcUFXHDMxfDzgZ2BX4H+CAqrouyebA6cBuwEer6rDeOucBDwJ+2ZKeXVU/GuV+SJqeNWqSNHoz1rQl+XSSvZKsVK1ckgXAscBzgZ2BFyfZeWCxVwA/rqrtgXcDb2/pdwBHAG+YIvuDqmqXNhiwSZKkeW+YQOw44CXA/0tyTJKHDZn37sCyqrq2qn4NnArsM7DMPsBJbfx04BlJUlU/b6/RumPIbUmSJM1rw9w9eg5wTpJNgBcDZye5HvgQ8LFpXme1JXB9b3o58LiplqmqO5PcBmwO3DJDsT6S5C7g08DRVVUz7YckScOyyV9z0VBNnq2P2cvoXl11KV0/tccCZ0+32iRpg8HVMMsMOqiqHgU8uQ0vnXTjyaFJliZZevPNN8+QpSRJ0tw2TJ+2zwDnA/cD9q6qF1TVaVX1F8BG06y6HNi6N70VcONUyyRZG9gEuHW68lTVDe3v7cDH6ZphJ1vu+KpaXFWLFy5cOF2WkiRJc94wNW0nVNXOVfWPVXUT/O6uT6pq8TTrXQzskGTbJOsCBwJLBpZZAhzSxvcDzp2uqTPJ2km2aOPrAM8Hvj3EPkiSJI21YR75cTRw5kDaBXTNo1NqfdQOA86ie+THh6vqiiRHAUuraglwInBKkmV0NWwHTqyf5Drg/sC6SfYFng18HzirBWwLgHPo+tZJkiTNa1MGbUl+n+5GgQ2SPIYV/c/uT9dUOqOqOpOBgK+qjuyN3wHsP8W6i6bIdtdhti1JkjSfTFfT9hy6mw+2At7VS78d+JsRlkmSJEkDpgzaquok4KQkL6yqT6/GMkmSJGnAdM2jf1RVHwMWJXn94Pyqetckq0mSJGkEpmse3bD9ne6xHpIkSVoNpmse/WD7+7bVVxxJkiRNZrrm0fdOt2JVvWbVF0eSJEmTma559JLVVgpJkiRNa6a7RyVJkjQHTNc8+p6qem2SzzHJS9yr6gUjLZmkOWnR4Wfcbfq6Y/aapZJI0ppluubRU9rfd6yOgkiSJGlq0zWPXtL+frm98P1hdDVu11TVr1dT+SRJmjOsadZsmvGF8Un2Aj4AfJfu/aPbJvnTqvqPURdO0uzx4iRJc8uMQRvwTuBpVbUMIMlDgTMAgzZJkqTVZK0hlvnRRMDWXAv8aETlkSRJ0iSmu3v0D9voFUnOBD5J16dtf+Di1VA2SZIkNdM1j+7dG/8h8NQ2fjPweyMrkSRJku5hurtHX746CyJJkqSpDXP36PrAK4BHAOtPpFfVH4+wXJIkSeoZ5u7RU4CrgecARwEHAVeNslCSJI2LwcfjgI/I0WgMc/fo9lV1BPDz9j7SvYBHjbZYkiRJ6hsmaPtN+/uTJI8ENgEWjaxEkiRJuodhmkePT/J7wBHAEmCjNi5JkqTVZMagrapOaKNfBrYbbXEkSZI0mRmbR5NsnuR9Sb6R5JIk70my+eoonCRJkjrD9Gk7le61VS8E9gNuAU4bZaEkSZJ0d8P0adusqv6uN310kn1HVSBJkiTd0zBB25eSHEj37lHoatvu+VAaSWPJZ0xJ0niY7oXxt9O9ID7A64GPtVlrAT8D3jLy0kmSJAmY/t2jG6/OgkiSJGlqwzSPkuQFwFPa5HlV9fnRFUnSqAw2hdoMKknjY5hHfhwD/CVwZRv+sqVJkiRpNRmmpu15wC5V9VuAJCcBlwKHj7JgkiRJWmGo5lFgU+DWNr7JiMoiSdK8YXcErWrDBG3/CFya5Et0d5I+BXjzSEslSZKku5k2aEsS4KvA44Hd6IK2v66qH6yGskmSJKmZNmirqkryb1W1K7BkNZVJkiRJA4Z59+jXk+w28pJIkiRpSsMEbU+jC9y+m+RbSS5P8q1hMk+yZ5JrkixLco+7TZOsl+S0Nv/CJIta+uZJvpTkZ0neP7DOrq0My5K8tzXhSpIkzWvD3Ijw3HuTcZIFwLHAs4DlwMVJllTVlb3FXgH8uKq2b+83fTtwAHAHcATwyDb0HQccCnwdOBPYE/iPe1NGSZKkcTHdu0fXB14FbA9cDpxYVXeuRN67A8uq6tqW36nAPnQP6J2wD/DWNn468P4kqaqfA19Nsv1AmR4E3L+qLmjTJwP7YtAmSRoTPgpE99Z0zaMnAYvpArbnAu9cyby3BK7vTS9vaZMu0wLC24DNZ8hz+Qx5SpIkzTvTNY/uXFWPAkhyInDRSuY9WV+zuhfL3KvlkxxK14zKNttsM02WkiRJc990NW2/mRhZyWbRCcuBrXvTWwE3TrVMkrXp3rZwK1Nb3vKZLk8Aqur4qlpcVYsXLly4kkWXJEmaW6araXt0kp+28QAbtOnQPcLt/jPkfTGwQ5JtgRuAA4GXDCyzBDgEuADYDzi3qqasaauqm5LcnuTxwIXAwcD7ZiiHtMaxz4wkzT9TBm1VteC+ZFxVdyY5DDgLWAB8uKquSHIUsLSqlgAnAqckWUZXw3bgxPpJrgPuD6ybZF/g2e3O01cDHwU2oLsBwZsQJEnSvDfsC+Pvlao6k+6xHP20I3vjdwD7T7HuoinSl3LPx4BIkiTNayMN2iSN1mAzKNgUKknz1TBvRJAkSdIsM2iTJEkaAwZtkiRJY8CgTZIkaQwYtEmSJI0B7x6VJGmWeSe4hmFNmyRJ0hgwaJMkSRoDBm2SJEljwKBNkiRpDBi0SZIkjQHvHpXGxODdZd5ZJklrFoM2SZLmKH+sqc/mUUmSpDFgTZs0x/jLWpI0GWvaJEmSxoBBmyRJ0hgwaJMkSRoDBm2SJEljwKBNkiRpDBi0SZIkjQGDNkmSpDFg0CZJkjQGfLiuJEljxodwr5kM2qRZMvhPF/zHK0mams2jkiRJY8CgTZIkaQzYPCqtBvY/kSTdV9a0SZIkjQGDNkmSpDFg86gkSfOAd6TPf9a0SZIkjQGDNkmSpDFg0CZJkjQGDNokSZLGwEiDtiR7JrkmybIkh08yf70kp7X5FyZZ1Jv35pZ+TZLn9NKvS3J5ksuSLB1l+SVJkuaKkd09mmQBcCzwLGA5cHGSJVV1ZW+xVwA/rqrtkxwIvB04IMnOwIHAI4AHA+ck2bGq7mrrPa2qbhlV2aV7y4foSpJGZZQ1bbsDy6rq2qr6NXAqsM/AMvsAJ7Xx04FnJElLP7WqflVV3wOWtfwkSZLWSKN8TtuWwPW96eXA46ZapqruTHIbsHlL//rAulu28QK+kKSAD1bV8SMouzQtn4ckaVzYAjB/jDJoyyRpNeQy0637xKq6MckDgLOTXF1VX7nHxpNDgUMBttlmm+FLLUmSNAeNsnl0ObB1b3or4MaplkmyNrAJcOt061bVxN8fAZ9limbTqjq+qhZX1eKFCxfe552RJEmaTaMM2i4GdkiybZJ16W4sWDKwzBLgkDa+H3BuVVVLP7DdXbotsANwUZINk2wMkGRD4NnAt0e4D5IkSXPCyJpHWx+1w4CzgAXAh6vqiiRHAUuraglwInBKkmV0NWwHtvLxP2gAAA5NSURBVHWvSPJJ4ErgTuDPq+quJA8EPtvdq8DawMer6j9HtQ+SJElzxUhfGF9VZwJnDqQd2Ru/A9h/inX/Hvj7gbRrgUev+pJKkiTNbSMN2iRJ0tzkXaXjx6BNmoH/2CRJc4HvHpUkSRoDBm2SJEljwOZRqbEZVJI0l1nTJkmSNAYM2iRJksaAzaOSJAm4ZzcRsKvIXGJNmyRJ0hgwaJMkSRoDNo9qjWP1vyRpHFnTJkmSNAasadO85rPXJOm+83/p3GBNmyRJ0hgwaJMkSRoDBm2SJEljwKBNkiRpDHgjguYFO8lK0urn/97Vy6BNY8VnrEmS1lQ2j0qSJI0BgzZJkqQxYPOoJElaZeznNjoGbZqz/OJLkrSCQZtmncGZJEkzs0+bJEnSGLCmTZIkjZytKvedNW2SJEljwJo2rVb+0pIk9XldGJ5Bm0bCL6EkSauWzaOSJEljwJo23SfWqEmSVjWvLZMzaNPQ/BJJkjR7DNokSdJYWNMrDwza1mCDJz90X4A1/UshSdJcZNAmSZLG1lQVEPORQds8M1UtmbVnkqQ1yXy87hm0jak16ZeFJEkacdCWZE/gn4EFwAlVdczA/PWAk4Fdgf8BDqiq69q8NwOvAO4CXlNVZw2T53w0H38tSJI0G8b5mjqyoC3JAuBY4FnAcuDiJEuq6sreYq8AflxV2yc5EHg7cECSnYEDgUcADwbOSbJjW2emPOc8bwCQJGnuGJfr8ihr2nYHllXVtQBJTgX2AfoB1j7AW9v46cD7k6Sln1pVvwK+l2RZy48h8pwV9iWTJEmjNMrXWG0JXN+bXt7SJl2mqu4EbgM2n2bdYfKUJEmad1JVo8k42R94TlW9sk2/FNi9qv6it8wVbZnlbfq7dDVqRwEXVNXHWvqJwJl0Qea0efbyPhQ4tE3uBFwzkh2d37YAbpntQug+8RiOP4/h+PMYjr/VfQwfUlULBxNH2Ty6HNi6N70VcOMUyyxPsjawCXDrDOvOlCcAVXU8cPy9LbwgydKqWjzb5dC95zEcfx7D8ecxHH9z5RiOsnn0YmCHJNsmWZfuxoIlA8ssAQ5p4/sB51ZX9bcEODDJekm2BXYALhoyT0mSpHlnZDVtVXVnksOAs+gez/HhqroiyVHA0qpaApwInNJuNLiVLgijLfdJuhsM7gT+vKruApgsz1HtgyRJ0lwxsj5tGn9JDm3NzBpTHsPx5zEcfx7D8TdXjqFBmyRJ0hgYZZ82SZIkrSIGbSLJ1km+lOSqJFck+cuWvlmSs5P8v/b392a7rJpekgVJLk3y+Ta9bZIL2zE8rd3AozksyaZJTk9ydftOPsHv4nhJ8rr2v/TbST6RZH2/i3Nbkg8n+VGSb/fSJv3epfPeJMuSfCvJY1dXOQ3aBN3NHn9VVQ8HHg/8eXuV2OHAF6tqB+CLbVpz218CV/Wm3w68ux3DH9O9Ok5z2z8D/1lVDwMeTXc8/S6OiSRbAq8BFlfVI+lumpt4TaPfxbnro8CeA2lTfe+eS/dUix3ongd73Goqo0GboKpuqqpvtPHb6S4SW9K9IuyktthJwL6zU0INI8lWwF7ACW06wNPpXhEHHsM5L8n9gafQ3VlPVf26qn6C38VxszawQXv+6P2Am/C7OKdV1VfonmLRN9X3bh/g5Op8Hdg0yYNWRzkN2nQ3SRYBjwEuBB5YVTdBF9gBD5i9kmkI7wHeBPy2TW8O/KS9Ig587ds42A64GfhIa+Y+IcmG+F0cG1V1A/AO4L/pgrXbgEvwuziOpvrezdorNQ3a9DtJNgI+Dby2qn462+XR8JI8H/hRVV3ST55kUW8Xn9vWBh4LHFdVjwF+jk2hY6X1e9oH2BZ4MLAhXXPaIL+L42vW/rcatAmAJOvQBWz/WlWfack/nKjybX9/NFvl04yeCLwgyXXAqXRNMe+hq7afeIj2lK9905yxHFheVRe26dPpgji/i+PjmcD3qurmqvoN8BngD/C7OI6m+t4N85rOkTBo00TfpxOBq6rqXb1Z/deMHQL8++oum4ZTVW+uqq2qahFdp+dzq+og4Et0r4gDj+GcV1U/AK5PslNLegbdm2H8Lo6P/wYen+R+7X/rxDH0uzh+pvreLQEObneRPh64baIZddR8uK5I8iTgfOByVvSH+hu6fm2fBLah+0e0f1UNdtTUHJNkD+ANVfX8JNvR1bxtBlwK/FFV/Wo2y6fpJdmF7maSdYFrgZfT/cD2uzgmkrwNOIDuzvxLgVfS9XnyuzhHJfkEsAewBfBD4C3AvzHJ964F4++nu9v0F8DLq2rpaimnQZskSdLcZ/OoJEnSGDBokyRJGgMGbZIkSWPAoE2SJGkMGLRJkiSNAYM2aZ5K8n+SXJHkW0kuS/K41bjtJDm3vUtzVeX5qiQHt/GXJXlwb94JSXZeVduapgznJVk86u30trdvf78G93sl89ojyedXXelm3N6ZSTa9F+s9vz0yQ9IAgzZpHkryBOD5wGOr6n/RPaX9+unXmjHPtWde6neeB3xzVb4Orao+UFUnt8mX0b0iaGLeK6vqylW1rTlkX6AfjL6M3n6vLit57AGoque1l92vrDPo3u5xv3uxrjSvGbRJ89ODgFsmHt5ZVbdU1Y0ASXZL8l9JvpnkoiQbJ1k/yUeSXN5eVP60tuzLknwqyeeAL7S0Nya5uNXgTVUjchDt6eFJFiW5OslJbZ3TJy7ISZ7Rtnd5kg8nWa+lH5Pkyrb8O1raW5O8Icl+wGLgX1sN4gYTNWBJXp3k/04UopX/fW38j9r+Xpbkg0kW9AucZPckn2nj+yT5ZZJ122dzbW/R/Vs+30ny5Lb8giT/1Ptc/rSl79HKdnr7DP61PZiTgW3/SVv3m0k+3Z6m/wfAC4B/amX+60n2+8i23reTHD+Rd5Ltk5zT8vtGkocObG+39rlvl2TD9tlf3NL2merY99Z/U5LXtPF3Jzm3dzw/1savS7JFO/5XJflQuprfLyTZoC3zmt5xPrWdqwWcR/ejQ1JfVTk4OMyzAdgIuAz4DvAvwFNb+sRT9ndr0/ene0n5XwEfaWkPo3v69/p0NTvLgc3avGcDx9O9MHkt4PPAUybZ/veBjdv4IrqXKT+xTX8YeEPL/3pgx5Z+MvBauifGX8OKh39v2v6+le5ND9Bd1Bf3tnceXUCzEFjWS/8P4EnAw4HPAeu09H8BDh4o89p074wEeAdwMd07XZ8KfKK3nXe28ecB57TxQ4G/bePrAUvpXhi+B3Ab3bsJ1wIuAJ40yee1eW/8aOAv2vhHgf0G97M3vVlv/BRg7zZ+IfC/2/j6wP1aWT5P9x7MS4Bt2vx/oHs6P8CmdOfMhoPHfqC8jwc+1cbPBy4C1qF7ivyftvTr6J4uv4juzQC7tPRP9rZ3I7Be/zi38YOA983298jBYa4N1rRJ81BV/QzYlS6YuBk4LcnLgJ2Am6rq4rbcT6vqTrrA5pSWdjVd0LVjy+7sWvHKpGe34VLgG3QB3g6TFGGzqrq9N319VX2tjX+sbW8nuiDpOy39JOApwE+BO4ATkvwh3Wtiht3vm4Frkzw+yeZtG1+je//jrsDFSS5r09sNrHsnsCzJw4HdgXe18jyZLjCZ8Jn29xK6gAS6z+TglveFwOas+FwuqqrlVfVbukB6Eff0yCTnJ7mcLmB5xJC7/LQkF7b1ng48IsnGwJZV9dm2X3dU1cRn+HC6oHvvqvrvXtkPb2U/jy7I26bN6x/7vkuAXdu2fkUXjC7mnp/VhO9V1WW9dRe18W/R1Rz+EV1gN+FHzEIzsDTXrXQ/BUnjoaruorsIn9cu6ofQBVqTvbvuHk12PT8fWO4fq+qDM2z+ziRrtUCFSbZZU22zqu5MsjtdYHUgcBhdQDKs04AXAVcDn62qas2GJ1XVm2dY93zgucBvgHPoaroW0NUMTph4X+RdrPgfGrrasbP6maV7D2z//ZL9dfo+CuxbVd9swfUeM5STJOvT1Rgurqrrk7yVLuCa7lje1JZ5DF0t10TZX1hV1wzk/zjufux/p6p+k+Q6uvei/hdd8PU04KHAVZOsMvgZbNDG96ILjF8AHJHkES14Xh/45TT7Ia2RrGmT5qEkOyXp14DtQld7djXw4CS7teU2TtfJ/Ct0NTwk2ZGupuUa7uks4I+TbNSW3TLJAyZZ7hruXpO1TbqbIwBeDHy1lWVRku1b+kuBL7e8N6mqM+maS3eZJP/bgY2n2P3P0HXgfzFdAAfwRWC/ibIm2SzJQyZZ9yttmxe0WrvN6WoTr5hiWxPOAl6dZJ2W/45JNpxhnb6NgZva+gf10gf3sz+9fvt7S/vM9oOu9hRYnmTfVpb1sqJT/0/oAqV/aAHlRNn/otcf7jFDlvkrdMHsV+iC3VcBl1XVUC+0TrIWsHVVfQl4E13T7EZt9o7At4csh7TGMGiT5qeNgJMmOnnT3YH41qr6NXAA8L4k3wTOprv4/wuwoNXInQa8rNpNDH1V9QXg48AFbdnTmTx4OoO71xZdBRzSyrIZcFxV3UFXU/OpltdvgQ+0/D7flv0y8LpJ8v8o8IGJDvkDZfwxcCXwkKq6qKVdCfwt8IWW79l0N2sMuhB4IF0gAl0N0reGCEROaNv8RpJvAx9k5VoyjmjbPpsumJ1wKvDGdoPAQ+ntN13t1YeAy4F/o+uDN+GlwGvavv4X8PsTM6rqh8DewLGtNu3v6PqjfauV/e+GLPP5dJ/hBS3PO5i8aXQqC4CPtWN/KfDuWnG36dPoziFJPRnyR5EkDS3Jg4CTq+pZSRYBn6+qR85uqTQOkjwQ+HhVPWO2yyLNNda0SVrlquom4ENZhQ/X1RpjG7q7mSUNsKZNkiRpDFjTJkmSNAYM2iRJksaAQZskSdIYMGiTJEkaAwZtkiRJY8CgTZIkaQz8f40PzoHrF0bJAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "show(campaign_probdist((146, 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 quite normal—it is clearly a bit fatter on the left than the right (the mean is 60 and the probability of 20 is greater than the probability of 100." + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "show(campaign_probdist((146, 93, 1, 1, 1, 1)))" ] }, { @@ -491,34 +781,35 @@ "\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:" + "I will make a chart with the number of defenders varying from 1 to 60, and with 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, + "execution_count": 27, "metadata": {}, "outputs": [], "source": [ - "def chart(defenders=range(1, 61), deltas=(10, 5, 2, 1, 0, -1, -2, -5)):\n", + "def chart(defenders=range(1, 61), deltas=(9, 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()" + " winprobs = [attacker_win_probability(campaign_probdist((max(0, d + delta), d))) \n", + " for d in defenders]\n", + " plt.plot(defenders, winprobs, 'o-', label=f'Δ = {delta:2}')\n", + " plt.legend(shadow=True)" ] }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 28, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -539,6 +830,86 @@ "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; with 55 against 60 the win percentage is about 57%." ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Tests\n", + "\n", + "Here are regression unit tests that also serve as examples of usage." + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 29, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Tests for States\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", + "# Tests for update\n", + "small = State((10, 2, 5)) # Small example where 10 attackers battle 2, then 5 dfenders\n", + "assert update(small, (0, 2)) == (9, 5) # 2 defenders dead; occupy the first territory\n", + "assert update(small, (1, 1)) == (9, 1, 5) # continue to battle\n", + "assert update(small, (2, 0)) == (8, 2, 5) # continue to battle\n", + "assert update(start, (1, 1)) == (71, 21, 8, 2, 2, 2, 7, 1, 1, 3, 1, 2, 3, 5, 1)\n", + "assert update((9, 2), (0, 2)) == (8,) # Attackers occupied the final territory\n", + "\n", + "# The 4 sample dice rolls from www.ultraboardgames.com/risk/game-rules.php\n", + "assert battle_deaths([1, 1, 6], [3,]) == (0, 1) # Defender loses one\n", + "assert battle_deaths([2, 6, 1], [2, 3]) == (1, 1) # Both lose one\n", + "assert battle_deaths([3, 3], [3, 4]) == (2, 0) # Attacker loses two\n", + "assert battle_deaths([6,], [5, 4]) == (0, 1) # Defender loses one\n", + "\n", + "# All six possible battle dice combinations. The answers match those given at\n", + "# a Risk data analysis blog: http://datagenetics.com/blog/november22011/\n", + "assert battle_deaths_probdist((1, 1)) == ProbDist({(1, 0): 21, (0, 1): 15})\n", + "assert battle_deaths_probdist((2, 1)) == ProbDist({(1, 0): 91, (0, 1): 125})\n", + "assert battle_deaths_probdist((3, 1)) == ProbDist({(1, 0): 441, (0, 1): 855})\n", + "assert battle_deaths_probdist((1, 2)) == ProbDist({(1, 0): 161, (0, 1): 55})\n", + "assert battle_deaths_probdist((2, 2)) == ProbDist({(2, 0): 581, (1, 1): 420, (0, 2): 295})\n", + "assert battle_deaths_probdist((3, 2)) == ProbDist({(2, 0): 2275, (1, 1): 2611, (0, 2): 2890})\n", + "\n", + "assert set(rolls(2)) == {(1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), \n", + " (2, 1), (2, 2), (2, 3), (2, 4), (2, 5), (2, 6), \n", + " (3, 1), (3, 2), (3, 3), (3, 4), (3, 5), (3, 6), \n", + " (4, 1), (4, 2), (4, 3), (4, 4), (4, 5), (4, 6), \n", + " (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (5, 6), \n", + " (6, 1), (6, 2), (6, 3), (6, 4), (6, 5), (6, 6)}\n", + "\n", + "assert attacker_win_probability(campaign_probdist((2, 1))) == 15/36\n", + "assert campaign_probdist((2, 1)) == ProbDist({(1, 1): 21/36, (1,): 15/36})\n", + "assert campaign_probdist((4, 2, 1)) == ProbDist(\n", + " {(1, 2, 1): 0.21807067805974698,\n", + " (1, 1, 1): 0.12597532213712342,\n", + " (1, 1): 0.294669783648961,\n", + " (1,): 0.14620529335276633,\n", + " (2,): 0.21507892280140226})\n", + "\n", + "assert battle_update_probdist(ProbDist({start: 1})) == ProbDist(\n", + " {(70, 22, 8, 2, 2, 2, 7, 1, 1, 3, 1, 2, 3, 5, 1): 0.2925668724279835,\n", + " (71, 21, 8, 2, 2, 2, 7, 1, 1, 3, 1, 2, 3, 5, 1): 0.3357767489711934,\n", + " (72, 20, 8, 2, 2, 2, 7, 1, 1, 3, 1, 2, 3, 5, 1): 0.37165637860082307})\n", + "\n", + "True" + ] } ], "metadata": {