ipynb/risk.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div align=\"right\" style=\"text-align: right\"><i>Peter Norvig<br>2012, 2020, 2021</i></div>\n",
    "\n",
    "# The Unfinished Game ... of Risk\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 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). 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](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 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. 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."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing      import List, Iterable, Tuple\n",
    "from collections import Counter\n",
    "from functools   import lru_cache\n",
    "from dataclasses import dataclass\n",
    "import random\n",
    "import itertools\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Representing the State of a Campaign\n",
    "\n",
    "I will represent the **state of a campaign** with the class `State`, and the state of the unfinished game as `start`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "@dataclass(frozen=True)\n",
    "class State:\n",
    "    A: int # Number of attackers\n",
    "    D: int # Number of defenders in first territory\n",
    "    rest: Tuple[int] = () # Tuple of numbers of defenders in subsequent territories  \n",
    "        \n",
    "start = State(A=72, D=22, rest=(8, 2, 2, 2, 7, 1, 1, 3, 1, 2, 3, 5, 1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The function `update` will update a state to reflect the `Deaths` that happened in a battle. We declare `game_over` when there are no defenders or only a single attacker (who can't leave their territory) remaining."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "@dataclass(frozen=True)\n",
    "class Deaths:\n",
    "    \"The number of attackers and defenders who die in a battle.\"\n",
    "    A: int\n",
    "    D: int\n",
    "        \n",
    "def update(state: State, dead: Deaths) -> State:\n",
    "    \"\"\"Update the `state` of a campaign to reflect the`dead` in a battle.\"\"\"\n",
    "    a = state.A - dead.A  # Attackers remaining\n",
    "    d = state.D - dead.D  # First territory defenders remaining\n",
    "    r = state.rest        # Other territories defenders remaining\n",
    "    return (State(a, d, r) if d            # Defenders still in first territory\n",
    "       else State(a - 1, r[0], r[1:]) if r # First territory captured\n",
    "       else State(a - 1, 0))               # All territories captured\n",
    "\n",
    "def game_over(state) -> bool: \n",
    "    \"\"\"Is the game over?\"\"\"\n",
    "    return state.D == 0 or state.A <= 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Rolling the Dice and the Outcome of a Single Battle\n",
    "\n",
    "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 two lists of dice rolled by attacker and defender, returns  the number of attackers and defenders who perish in the battle."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "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": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "([6, 1, 6], [6, 4], Deaths(A=1, D=1))"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Example battle\n",
    "A_dice = random_roll(3)\n",
    "D_dice = random_roll(2)\n",
    "A_dice, D_dice, battle_deaths(A_dice, D_dice)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Monte Carlo Simulation of a Campaign\n",
    "\n",
    "A **simulation** makes random choices at every choice point (here, every dice roll), and reports on the outcome. The function `simulate_campaign` rolls random dice for a battle until the game is over:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def simulate_campaign(state) -> State:\n",
    "    \"\"\"Simulate a campaign with random rolls, returning the final state.\"\"\"\n",
    "    while not game_over(state):\n",
    "        dead  = battle_deaths(random_roll(min(3, state.A - 1)), \n",
    "                              random_roll(min(2, state.D)))\n",
    "        state = update(state, dead)\n",
    "    return state"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's see who wins:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "State(A=5, D=0, rest=())"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "simulate_campaign(start)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "That final state says that the attackers won—there are 5 attackers and no defenders left. \n",
    "\n",
    "But what if we want to know the **probability** that the attackers win? [Monte Carlo simulation](https://en.wikipedia.org/wiki/Monte_Carlo_method) 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`. \n",
    "\n",
    "*Note*: I have `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`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ProbDist(Counter): \n",
    "    \"A Probability Distribution.\"\n",
    "    def __init__(self, *args):\n",
    "        \"Normalize total to 1.\"\n",
    "        Counter.__init__(self, *args)\n",
    "        total = sum(self.values())\n",
    "        for x in self:\n",
    "            self[x] /= total "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "ProbDist({4: 0.176, 3: 0.168, 2: 0.163, 1: 0.175, 5: 0.16, 6: 0.158})"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ProbDist(random_roll(1000)) # Probability distribution over 1,000 die rolls"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "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": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "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": [
    "Here we simulate the campaign \n",
    " 10 times and see the summary of outcomes:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "ProbDist({State(A=16, D=0, rest=()): 0.1,\n",
       "          State(A=1, D=5, rest=(1,)): 0.1,\n",
       "          State(A=11, D=0, rest=()): 0.2,\n",
       "          State(A=1, D=2, rest=(5, 1)): 0.1,\n",
       "          State(A=17, D=0, rest=()): 0.1,\n",
       "          State(A=6, D=0, rest=()): 0.2,\n",
       "          State(A=1, D=0, rest=()): 0.1,\n",
       "          State(A=28, D=0, rest=()): 0.1})"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "monte_carlo(simulate_campaign, start, 10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And here we run 1,000 simulations and report how often the attackers win:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.8190000000000004"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "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 s.D)\n",
    "\n",
    "attacker_win_probability(monte_carlo(simulate_campaign, start, 1000))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The Monte Carlo simulation says the attackers win about 82% of the time. How accurate is that result?  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 that the true percentage is within 3 standard deviations; that is, between 79% and 85%.\n",
    "\n",
    "We could get better accuracy at the cost of increased computing time.  To get the standard deviation down by a factor of 10 from 1% to 0.1% would require 100 times more computation (because of the square root in the formula). \n",
    "\n",
    "# Monte Carlo versus Exact Probability Calculation\n",
    "\n",
    "An alternative to the Monte Carlo approach is to explicitly calculate the exact probability distribution of the final state of the 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 possible 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 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?** Code for an exact calculation is more complex, and will take more time to write and debug.\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",
    "Let's examine the three considerations:\n",
    "\n",
    "**Worth the effort?** If I only wanted to know whether the attackers chance of winning is above or below 50%, then the Monte Carlo approach is the quickest way to answer the question. The code will be simple and straightforward.   Monte Carlo code deals with the single current state of the simulation, for example: \n",
    "\n",
    "     while not game_over(state):\n",
    " \n",
    "But in the exact calculation we need to consider every possible states (referenced in a loop):\n",
    "\n",
    "    while any(not game_over(state) for state in probdist):\n",
    "\n",
    "Putting all these loops into the code makes it more complex. (Less added complexity in Python, which has comprehensions, than in other languages where loops must be statements, not expressions.) After the shared basics of representing states and battle outcomes, we need just 10 non-comment lines of code to implement the Monte Carlo method (in `simulate_campaign`, `monte_carlo`, and `random_roll` above), but twice as much code (22 lines) to implement exact calculation (in `battle_deaths_probdist`,  `all_rolls`, `campaign_probdist`, and `battle_update_probdist` below).\n",
    "\n",
    "**Possible?** Imagine a *Risk* rule change where if the attackers roll three 6s and the defenders 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  exact calculation everything has changed, because we now have an  **infinite** game: no matter how many moves ahead we look, there will always be some possible states that have 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 sufficiently low total probability. Sometimes a mathematical formula can determine the value of an infinite game.)\n",
    "\n",
    "**Feasible?** Imagine a rule change where 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 just 80 armies, the very first move has $10^{80}$ possible outcomes, meaning that the probability distribution requires as many states as there are [atoms in the universe](http://norvig.com/atoms.html). (To deal with this we would either stick with the Monte Carlo simulation, or a variant 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, or we would find a way to abstract over the possible moves.)\n",
    "\n",
    " The *Risk* campaign problem as it stands leads to a very efficient exact probability calculation (possible, feasible, and, IMHO, worth it). 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   the number of attacking and defending armies for just this one battle (*not* the total number of attacking and defending armies in the current state). Thus, the attackers will always be 3, 2, or 1, and the defenders will always be 2 or 1. I define it this way so that I can **cache** the results and reuse them in subsequent battles, for efficiency."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "@lru_cache()\n",
    "def battle_deaths_probdist(battlers: State) -> ProbDist:\n",
    "    \"\"\"A probability distribution of deaths in a single battle.\n",
    "    Requires 1 <= battlers.A <= 3 and 1 <= battlers.D <= 2.\"\"\"\n",
    "    return ProbDist(battle_deaths(A_dice, D_dice)\n",
    "                    for A_dice in all_rolls(battlers.A)\n",
    "                    for D_dice in all_rolls(battlers.D))\n",
    "\n",
    "def all_rolls(n) -> Iterable[Dice]: \n",
    "    \"\"\"All possible rolls of `n` dice.\"\"\"\n",
    "    return tuple(itertools.product(die, repeat=n))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "ProbDist({Deaths(A=2, D=0): 0.2925668724279835,\n",
       "          Deaths(A=1, D=1): 0.3357767489711934,\n",
       "          Deaths(A=0, D=2): 0.37165637860082307})"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "battle_deaths_probdist(State(3, 2)) # Three attacker dice against two defender dice"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exact Probability Distribution over a Campaign\n",
    "\n",
    "Our old function `campaign` is mimiced by `campaign_probdist`, except that the former updates a `State` whereas the later updates a `ProbDist`. 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 soon 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",
    "`campaign_probdist` calls  `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": 15,
   "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 game_over(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 game_over(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(Deaths(min(3, state.A - 1), min(2, state.D)))\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": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.8105485936352178"
      ]
     },
     "execution_count": 16,
     "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": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(State(A=12, D=0, rest=()), 0.03824220182706657),\n",
       " (State(A=11, D=0, rest=()), 0.0380992150215239),\n",
       " (State(A=13, D=0, rest=()), 0.038032667992797725),\n",
       " (State(A=10, D=0, rest=()), 0.037618411457469664),\n",
       " (State(A=14, D=0, rest=()), 0.03746512036620402),\n",
       " (State(A=9, D=0, rest=()), 0.036822601595588304),\n",
       " (State(A=15, D=0, rest=()), 0.036544033638847624),\n",
       " (State(A=8, D=0, rest=()), 0.035741340182918115),\n",
       " (State(A=16, D=0, rest=()), 0.035284184613703425),\n",
       " (State(A=7, D=0, rest=()), 0.03440940023374102),\n",
       " (State(A=17, D=0, rest=()), 0.03371050842173721),\n",
       " (State(A=6, D=0, rest=()), 0.03286517629527088),\n",
       " (State(A=18, D=0, rest=()), 0.031857448871758426),\n",
       " (State(A=5, D=0, rest=()), 0.031149102741286083),\n",
       " (State(A=19, D=0, rest=()), 0.029767807751056283),\n",
       " (State(A=4, D=0, rest=()), 0.029302161098148583),\n",
       " (State(A=20, D=0, rest=()), 0.027491133463900305),\n",
       " (State(A=3, D=0, rest=()), 0.0273645356924103),\n",
       " (State(A=1, D=5, rest=(1,)), 0.026621109937678585),\n",
       " (State(A=1, D=1, rest=()), 0.025661022694069335)]"
      ]
     },
     "execution_count": 17,
     "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 function `show` plots score probabilities, with the attacker's wins in green and the defender's wins in blue:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "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=0.7, color=['g' if x > 0 else 'b' for x in X])\n",
    "    \n",
    "def score(state): \n",
    "    return (state.A if not state.D else \n",
    "            state.A - (state.D + sum(state.rest)) - (len(state.rest) + 1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "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 `State(1, 2)`:  one attacker and two defenders in a single territory; this campaign has only one defender in the final territory, so `State(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",
    "To help your intuition, here's a campaign where 100 attackers take on 100 defenders, 50 in the first territory and  5  in each of 10 more territories:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAm0AAAFNCAYAAABST1gVAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAAgAElEQVR4nO3de7wdVX338c+XBAICgoZoFQhBwQvQeiGirXdRxGuwgoZSAcWitlTbPrZCWxURW3lapbWigoIg6gOKt6hYRBHxgkiQm9xsRCwRqlAuAgoY/D1/zDqyszmXnZCdc3byeb9e8zoza9asWTOzz9m/s9bMrFQVkiRJmtk2mO4KSJIkaWoGbZIkSSPAoE2SJGkEGLRJkiSNAIM2SZKkEWDQJkmSNAIM2qQRkmRBkkoye5rrcXuSR0xnHSRpfWPQJq2mJGcnuTnJnL70E5Mc2Zd2TZLnrt0aDk9VbVZVV6/pcpM8N8kPktyR5NokrxgnzwEtcH3tJOV8PMn1SX6Z5Ef9eZM8IMkHktyY5NYk5/Ss+5O27U+SPKsn/ZFJvptk1moc1+Gtzrut6rZaPe1839H+wbg9yUcmyXtIkqVJ7kpy4iT53t7KXWd+lzVapvW/dWlUJVkAPB24FXgp8OnprM+qShIgVfXb6a7LmCQ7AZ8EDgDOBLYAtuzL8yDgMOCyKYr7Z+CgqroryWOAs5NcWFUXtPXH0f39eyxwE/D4Vv5s4N3AE4FdgfcDu7Rt3gf8TVXds4rHFeBVbT8HAN9fle0H3MfsqlqxpsudLmvweB5XVcsGyHcdcCTwfGCTCer0SGBv4Po1UC9ptdjSJq2e/YHvASfSfREDkORgYD/g79p/919McjIwH/hiS/u7lvfTSf5nrKUnyc495WyS5D1JftrWfzvJfb5Mkry8teLt0paf0lqDbklycV9L0dlJ3pXkO8CvgEf0lfXqJF/sWV6W5FM9y9cmGQtuKskObf7EJMck+XKS25Kc177gSOfoJL9ox3HJWF3H8Y/AsVX1lapaUVX/W1U/7svzz3TB040TlAFAVV1WVXeNLbZprE6Ppgu0D66qG6rqnp5gbi7ws6q6Hvja2DlKsndL/95k+53A04GHA28CFifZqJU5p12n352PJPOS/DrJQ9ryi5Nc1PJ9N8kf9OS9JslbklwC3JFkdpJDk/y4XYfLk7ysJ/+s9pm6sbUiHpKervYkWyQ5vrUy/izJkRO1KibZrbVM/TLJz5O8t2fd03o+g9cmObCn/I8luaF9rv8xyQZt3YFJvtM+KzcBh7f01yS5Il2L9hlJtluN8z+lqvpsVX0e+N9Jsr0feAtw9zDqIA2kqpycnFZxApYBf07XGvMb4KE9604EjuzLfw3w3L601wCbA3OAfwMu6ll3DHA2sDUwC/ijlm8BXQAyG3h1q8cObZut6b50Xkj3D9nz2vK8tv5s4L+Bndv2G/bV5xHALW3bhwE/pQtUxtbdDGzQlqtnvyfStSLt1sr9BHBKW/d84AK6FrPQtWw9bIJzejXwTuBSutaMjwMP7lm/G7C01e9s4LVTXKMP0AWnBfwA2Kyl79/2cTRd8Hcp8PK2bgPgR8A2wEuA84HNgIuAuav5WTke+BSwYbsef9yz7gTgXT3LfwH8Z5t/IvAL4MntM3BA+xzN6flMXQRsC2zS0vahCxA3AF4J3DF2voHXA5e3Y3sQXVBawOy2/vPAscCmwEPoWgRfN8ExnQu8qs1vBjylzc8HbgP2bcc7F3h8W/cx4At0n/kF7Twf1NYdCKwA/rJ9hjYB9qL7fD+2pf0j8N2eOnwJOHSS8150LWj/A3wWWDDAtToSOHGc9H2AL0z0u+zktLamaa+Ak9OoTcDT6AK1rdrylcBf96w/kQGCtr71W7YvmS3aF+6v6bp2+vMtaPnePPYF3LPuLcDJffnPAA5o82cDR0xxbNfSBQuL6boQvw88hi5AXNKTrz9o+0jPuhcCV7b557Qv56fQAr5J9n13O0+PaoHAZ4BPtHWz6AK2P+w5lkmDtp7tnta+8DdsaX/f6n84sBHwTOB24LFt/e50rajfpOs2fS9wEPAs4BvtnO4y4GflAcAvgb3a8rFjX/5t+bnA1T3L3wH2b/MfBN7ZV95VwDN7PlOvmWL/FwGL2vxZ9ARhbd9j/wA8FLiLFvy19fsC35ig3HOAd9B+B3rSDwM+N8F1uAvYqSftdcDZbf5A4L/7tvkKLahryxvQBeHbDXjun9Gu75Z0rWQ/pAWok2xzn6CtfRb/C9h+kN9lJ6dhTnaPSqvuAOCrVTXWRTd2H9bAWlfVu1tX1i/pvggAtmrTxkB/12CvvwWOqarlPWnbAfu0bqlbktxCF7A8rCfPtVNU7Zt0wckz2vzZdEHNM9vyRP6nZ/5XdF90VNVZdF+YxwA/T3JckgdOUMavgY9W1Y+q6nbgn+gCQOhaNS+pqnOnqP9Kquv6/DZd69IbevbzG7rA+u6q+iZdMLZH2+brVfWUqnom8FtgIV1gejJdcPFOYMKb2vu8jK4F6fS2/AngBUnmteWzgE2SPLl1/T0e+Fxbtx3wf/qu57Z0LWljVrqeSfbv6U69he5+vK3a6of35e+d346uZez6nm2PpWtxG89BdMH1lUnOT/Lilr4t439ut6ILoH7ak/ZTutbhcY+l1enfe+pzE11r7dYMoKrOadf3Frqu6e3pWu1W1Tvo/hn6yWpsK61RPoggrYJ2X9krgFlJxgKVOcCWSR5XVRfTtV7060/7E2ARXWvHNXQtbDfTfSndCNxJdw/WxRNUZQ/gP5P8T1V9pqVdS/fl8meTHMJ4dev1Tbpuwe3pgqZb6O7R+0O64GuVVdX7gPe1+7Q+RRdwvnWcrJdMUr/dgWcmGQviHgw8Icnjq+qQAaoxm3ZPW9vPlJKE7pjfSBd0zKqqn7br/geTbnyvA+gC2P/uiiN0wdG+wPuq6rftvsF9gZ8DX6qq29q219J1nb5rkvJ/d75a0PdhunN1blXdk+Sitk/oupy36dl22575a+lawraqAR4AqKr/AvZt96T9MXBakrmtnPGekL2RLlDejq6FGLqu1J+Ndyw9dXpXVX1iqvoMqLj3XKyK3YFtkvx5W54HfCrJUVV11BqqmzQQW9qkVbMXcA+wE12ryOPp/nv/Ft29UtB9+fa/w6w/bXO6L8n/petC+6exFdU90XkC8N4kD2+tcn+YlV8tchmwJ3BMkpe2tI8DL0ny/LbNxkmelaT3i3oq3wSeTddNtrwd15509yZduArlAJDkSa0VaUO6+6vupDt/4/ko8Ookj0jyALru3i+1dQfSneexc76UrgXkH8bZ50OSLE6yWTsPz6cLis5qWc6hu7fvsHbz/lPpWhfP6CvqtcCFVXUR3XXaJN0Trs+mu/9uqmPfmu4L/8U99X4ccBQrt8x+ku7+s/3a/JgPA69v5y9JNk3yoiSbT7DLTekCkxva/l/NvU++QhcwvynJ1km2pDu/AFT34MVXgfckeWCSDdK94uSZExzbnyaZ1z6rt7Tke+haEp+b5BXt3M5tgfU9bf/vSrJ5CzD/hu4zO5EP0V2jnds+t0iyzyT5e+u3c5LHt+u/GfAeugDxignyz06yMV037tjvzlijxu5053HsGl5H17V7zCB1kdao6e6fdXIapQn4T+A946S/gq6LcDawI929RLcAn2/rF9EFCrfQ3Y+2Gd1N2bfRdRPtz8r3iW1C93DCz+heK3JOS1vAyjePL6QLCF/Qlp9MF3jdRPfl/WVgflt3NoPdB3Y9XTfl2PJS4Ct9efrvaTuyZ92zgOVtfne6lq3b6VpbPkF7IGCCfb+j1fsGuu7IB02Qb6VjobtP7Sttfl47B7fQ3U92KfBnfdvvTHcz/R10LT8v61u/Fd09UA/sSduvXeNrgGe3tPnt2OaPU8dDgQvGSX84XavTLj1py9o126gv7550D0Pc0q7Lp4HN27pruO/DLe9q5dxIdy/eN8fOE91n82i6APQnwF+3eqSt34LuPrrl7TN3IbB4gvP/cbqHJG6n+wdir551TwfOa+f+Wu69p/JBbbsbWvrbuPfBlgOBb4+zn1e16zdW1gk9674C/P0E9XsO3f1/d7R6fh7YcbzPS1s+nHufMh6bDp+g7JXOO11w+aG1+XfIaf2dxn5ZJUnrkSQvoAs2tpvuukgajN2jkrQeSPfuvxe2rsCtgbdz70MPkkaALW2StB5o9wl+k+4VLr+m6zp/U1X9clorJmlgBm2SJEkjwO5RSZKkEWDQJkmSNALWi5frbrXVVrVgwYLproYkSdKULrjgghural5/+noRtC1YsIClS5dOdzUkSZKmlOSn46XbPSpJkjQCDNokSZJGgEGbJEnSCDBokyRJGgEGbZIkSSPAoE2SJGkEGLRJkiSNAIM2SZKkEWDQJkmSNAKGGrQl2TPJVUmWJTl0nPVzkpza1p+XZEHf+vlJbk/y5kHLlCRJWhcNLWhLMgs4BngBsBOwb5Kd+rIdBNxcVTsARwNH9a0/GvjKKpYpSZK0zhlmS9tuwLKqurqq7gZOARb15VkEnNTmTwN2TxKAJHsBVwOXrWKZktZRycqTJK1Phhm0bQ1c27O8vKWNm6eqVgC3AnOTbAq8BXjHapQpSZK0zhlm0Dbe/8E1YJ53AEdX1e2rUWaXMTk4ydIkS2+44YYpKytJkjSTzR5i2cuBbXuWtwGumyDP8iSzgS2Am4AnA3sn+b/AlsBvk9wJXDBAmQBU1XHAcQALFy4cN7CTJEkaFcMM2s4HdkyyPfAzYDHwJ315lgAHAOcCewNnVVUBTx/LkORw4Paqen8L7KYqU5IkaZ0ztKCtqlYkOQQ4A5gFnFBVlyU5AlhaVUuA44GTkyyja2FbvDplDusYJEmSZop0DVvrtoULF9bSpUunuxqS7qf+J0bXgz9fktZDSS6oqoX96Y6IIEmSNAIM2iRJkkaAQZskSdIIMGiTJEkaAQZtkiRJI8CgTZIkaQQYtEmSJI0AgzZJkqQRYNAmSZI0AgzaJEmSRoBBmyRJ0ggwaJMkSRoBBm2SJEkjwKBNkiRpBBi0SZIkjQCDNkmSpBFg0CZJkjQCDNokSZJGgEGbJEnSCDBokyRJGgEGbZIkSSPAoE2SJGkEGLRJkiSNgKEGbUn2THJVkmVJDh1n/Zwkp7b15yVZ0NJ3S3JRmy5O8rKeba5Jcmlbt3SY9ZckSZopZg+r4CSzgGOA5wHLgfOTLKmqy3uyHQTcXFU7JFkMHAW8EvghsLCqViR5GHBxki9W1Yq23bOr6sZh1V2SJGmmGWZL227Asqq6uqruBk4BFvXlWQSc1OZPA3ZPkqr6VU+AtjFQQ6ynJEnSjDfMoG1r4Nqe5eUtbdw8LUi7FZgLkOTJSS4DLgVe3xPEFfDVJBckOXiI9ZckSZoxhtY9CmSctP4WswnzVNV5wM5JHguclOQrVXUn8NSqui7JQ4Azk1xZVefcZ+ddQHcwwPz58+/PcUiSJE27Yba0LQe27VneBrhuojxJZgNbADf1ZqiqK4A7gF3a8nXt5y+Az9F1w95HVR1XVQurauG8efPu98FIkiRNp2EGbecDOybZPslGwGJgSV+eJcABbX5v4KyqqrbNbIAk2wGPBq5JsmmSzVv6psAedA8tSJIkrdOG1j3anvw8BDgDmAWcUFWXJTkCWFpVS4DjgZOTLKNrYVvcNn8acGiS3wC/Bf68qm5M8gjgc0nG6v7JqvrPYR2DJEnSTJGqdf/BzIULF9bSpb7STRp16bsLdj348yVpPZTkgqpa2J/uiAiSJEkjwKBNkiRpBBi0SZIkjQCDNkmSpBFg0CZJkjQCDNokSZJGgEGbJEnSCDBokyRJGgEGbZIkSSPAoE2SJGkEGLRJkiSNAIM2SZKkEWDQJkmSNAIM2iRJkkaAQZskSdIIMGiTJEkaAQZtkiRJI8CgTZIkaQQYtEmSJI0AgzZJkqQRYNAmSZI0AgzaJEmSRoBBmyRJ0ggYatCWZM8kVyVZluTQcdbPSXJqW39ekgUtfbckF7Xp4iQvG7RMSZKkddHQgrYks4BjgBcAOwH7JtmpL9tBwM1VtQNwNHBUS/8hsLCqHg/sCRybZPaAZUqSJK1zhtnSthuwrKqurqq7gVOARX15FgEntfnTgN2TpKp+VVUrWvrGQK1CmZIkSeucYQZtWwPX9iwvb2nj5mlB2q3AXIAkT05yGXAp8Pq2fpAyJQ1BsvIkSVq7hhm0jfdnvQbNU1XnVdXOwJOAw5JsPGCZXcHJwUmWJll6ww03rEK1JUmSZp5hBm3LgW17lrcBrpsoT5LZwBbATb0ZquoK4A5glwHLHNvuuKpaWFUL582bdz8OQ5IkafoNM2g7H9gxyfZJNgIWA0v68iwBDmjzewNnVVW1bWYDJNkOeDRwzYBlSpIkrXNmD6vgqlqR5BDgDGAWcEJVXZbkCGBpVS0BjgdOTrKMroVtcdv8acChSX4D/Bb486q6EWC8Mod1DJIkSTNFqsa9JWydsnDhwlq6dOl0V0Maaf0PH0zHn46ZUAdJGrYkF1TVwv50R0SQJEkaAQZtkiRJI8CgTZIkaQQYtEmSJI0AgzZJkqQRMNArP5I8Ddixqj6aZB6wWVX9ZLhVkyRNJO9Y+VHaentNmD5RXkmjZcqWtiRvB94CHNaSNgQ+PsxKSZIkaWWDtLS9DHgC8AOAqrouyeZDrZUk6XeG1VJmC5w0Wga5p+3u6t7AWwBJNh1ulSRJktRvkJa2TyU5FtgyyZ8BrwE+PNxqSdL6Z6a0fM2Uekha2ZRBW1X9a5LnAb+kG7j9bVV15tBrJkmSpN+ZNGhLMgs4o6qeCxioSZIkTZNJg7aquifJr5JsUVW3rq1KSdK6rrcL0u5HSYMY5J62O4FLk5wJ3DGWWFVvHFqtJEkzive5SdNvkKDty22SJEnSNBnkQYSTkmwEPKolXVVVvxlutSRJktRryqAtybOAk4BrgADbJjmgqs4ZbtUkafTZrShpTRmke/Q9wB5VdRVAkkcB/w/YdZgVkyTNfAal0tozyIgIG44FbABV9SO68UclSZK0lgzS0rY0yfHAyW15P+CC4VVJkiRJ/QYJ2t4A/AXwRrp72s4BPjDMSkmSJGllgwRts4F/r6r3wu9GSZgz1FpJkiRpJYMEbV8Hngvc3pY3Ab4K/NGwKiVJGl0+nCANxyAPImxcVWMBG23+AYMUnmTPJFclWZbk0HHWz0lyalt/XpIFLf15SS5Icmn7+Zyebc5uZV7UpocMUhdJkqRRNkjQdkeSJ44tJNkV+PVUG7Vu1GOAFwA7Afsm2akv20HAzVW1A3A0cFRLvxF4SVX9PnAA9z4EMWa/qnp8m34xwDFIkiSNtEG6R/8K+HSS69ryw4BXDrDdbsCyqroaIMkpwCLg8p48i4DD2/xpwPuTpKou7MlzGbBxkjlVddcA+5UkSVrnDDKM1flJHgM8mu7p0SsHHMZqa+DanuXlwJMnylNVK5LcCsyla2kb83Lgwr6A7aNJ7gE+AxxZVd4wIUmS1mlTdo8m2YfuvrYf0rWMndrbXTrZpuOk9QdXk+ZJsjNdl+nretbv17pNn96mV01Q74OTLE2y9IYbbhigupIkSTPXIPe0vbWqbkvyNOD5dOOQfnCA7ZYD2/YsbwNcN1GeJLOBLYCb2vI2wOeA/avqx2MbVNXP2s/bgE/SdcPeR1UdV1ULq2rhvHnzBqiuJGmY8o6sNElaNYMEbfe0ny8CPlhVXwA2GmC784Edk2yfZCNgMbCkL88SugcNAPYGzqqqSrIl8GXgsKr6zljmJLOTbNXmNwReDPxwgLpIkiSNtEGCtp8lORZ4BXB6kjmDbFdVK4BDgDOAK4BPVdVlSY5I8tKW7XhgbpJlwN8AY68FOQTYAXhr36s95gBnJLkEuAj4GfDhQQ9WkiRpVA3y9OgrgD2Bf62qW5I8DPjbQQqvqtOB0/vS3tYzfyewzzjbHQkcOUGxuw6yb0mSpHXJIE+P/gr4bM/y9cD1w6yUJEmSVjZIS5skzWjpu6fdlwBJWhdNGLT5MltJo8xAbnQ4Vqk0mMkeKDgXIEn/EFKSJElayybrHt0oyQHAHyX54/6VVfXZcbaRJEnSEEwWtL0e2A/YEnhJ37qi5+EESZIkDdeEQVtVfRv4dpKlVXX8WqyTJEmS+gzy9OjJSd4IPKMtfxP40ICDxkuSJGkNGCRo+wCwYfsJ3QDtHwReO6xKSZIkaWWDBG1PqqrH9SyfleTiYVVIkobJV4GMBl8DIt3XQAPGJ3nk2EKSR3DvIPKSJElaCwZpaftb4BtJrgYCbAe8eqi1kiRJ0koGGXv060l2BB5NF7Rd6UgJkiRJa9dAY4+2IO2SIddFkiRJExjknjZJkiRNM4M2SZKkETBl0JbkM0lelMQAT5IkaZoMck/bB+meFn1fkk8DJ1bVlcOtliRJ9+X727Q+m7L1rKq+VlX7AU8ErgHOTPLdJK9OsuGwKyhJkqQB72lLMhc4kG7oqguBf6cL4s4cWs0kSZL0O1N2jyb5LPAY4GTgJVV1fVt1apKlw6ycJEmSOoPc0/aRqjq9NyHJnKq6q6oWDqlekiRJ6jFI9+iR46Sdu6YrIkmSpIlNGLQl+b0kuwKbJHlCkie26VnAAwYpPMmeSa5KsizJoeOsn5Pk1Lb+vCQLWvrzklyQ5NL28zk92+za0pcleV+S9JcrSZK0rpmse/T5dA8fbAO8tyf9NuDvpyo4ySzgGOB5wHLg/CRLqurynmwHATdX1Q5JFgNHAa8EbqS7f+66JLsAZwBbt20+CBwMfA84HdgT+MpU9ZEkSRplEwZtVXUScFKSl1fVZ1aj7N2AZVV1NUCSU4BFQG/Qtgg4vM2fBrw/Sarqwp48lwEbJ5kDPBh4YFWd28r8GLAXBm2StN7y3W1aX0wYtCX506r6OLAgyd/0r6+q946zWa+tgWt7lpcDT54oT1WtSHIrMJeupW3My4ELq+quJFu3cnrL3BpJkqR13GTdo5u2n5utZtnj3WvW/+/PpHmS7EzXZbrHKpQ5tu3BdN2ozJ8/f6q6SpIkzWiTdY8e236+YzXLXg5s27O8DXDdBHmWJ5kNbAHcBJBkG+BzwP5V9eOe/NtMUeZY/Y8DjgNYuHChbeWSJGmkTdY9+r7JNqyqN05R9vnAjkm2B34GLAb+pC/PEuAAuleI7A2cVVWVZEvgy8BhVfWdnn1en+S2JE8BzgP2B/5jinpIkiSNvMm6Ry+4PwW3e9QOoXvycxZwQlVdluQIYGlVLQGOB05OsoyuhW1x2/wQYAfgrUne2tL2qKpfAG8ATgQ2oXsAwYcQJEnSOm+qp0fvlzaSwul9aW/rmb8T2Gec7Y5k/Jf6UlVLgV3ub92kUdH/JsKys1+S1kuTdY/+W1X9VZIvMs7N/lX10qHWTJIkSb8zWffoye3nv66Nikhad9g6qJnA97dpXTNZ9+gF7ec3k2wEPIauxe2qqrp7LdVPkiRJTN7SBkCSFwEfAn5M95607ZO8rqp8AECSJGktmTJoA94DPLuqlgEkeSTd6zgM2qT13Kp0g9plKkn3zwYD5PnFWMDWXA38Ykj1kSRJ0jgme3r0j9vsZUlOBz5Fd0/bPnQvzpUkSdJaMln36Et65n8OPLPN3wA8aGg1kiRJ0n1M9vToq9dmRSRJkjSxQZ4e3Rg4CNgZ2HgsvapeM8R6SZIkqccgT4+eDFwJPB84AtgPuGKYlZIkaVh86a5G1SBPj+5QVW8F7mjjkb4I+P3hVkuSJEm9BgnaftN+3pJkF2ALYMHQaiRJkqT7GKR79LgkDwLeCiwBNmvzkqTGLjdJwzZl0FZVH2mz3wQeMdzqSJIkaTxTdo8mmZvkP5L8IMkFSf4tydy1UTlJkiR1Brmn7RS6YateDuwN3AicOsxKSZIkaWWD3NP24Kp6Z8/ykUn2GlaFJEmSdF+DBG3fSLKYbuxR6Frbvjy8KkmStHb5IIlGwWQDxt9GN0B8gL8BPt5WbQDcDrx96LWTJEkSMPnYo5uvzYpIkiRpYoN0j5LkpcAz2uLZVfWl4VVJkiRJ/QZ55ce7gTcBl7fpTS1NkiRJa8kgLW0vBB5fVb8FSHIScCFw6DArJkmSpHsN8p42gC175rcYtPAkeya5KsmyJPcJ8pLMSXJqW39ekgUtfW6SbyS5Pcn7+7Y5u5V5UZseMmh9JEmSRtUgLW3/DFyY5Bt0T5I+Azhsqo2SzAKOAZ4HLAfOT7Kkqi7vyXYQcHNV7dBeK3IU8ErgTrrxTXdpU7/9qmrpAHWXJElaJ0za0pYkwLeBpwCfbdMfVtUpA5S9G7Csqq6uqrvpRlZY1JdnEXBSmz8N2D1JquqOqvo2XfAmSZK03pu0pa2qKsnnq2pXYMkqlr01cG3P8nLgyRPlqaoVSW4F5tINlTWZjya5B/gMcGRV3ectiEkOBg4GmD9//ipWXZIkX7qrmWWQe9q+l+RJq1F2xknr/7QPkqffflX1+8DT2/Sq8TJV1XFVtbCqFs6bN2/KykqSJM1kgwRtz6YL3H6c5JIklya5ZIDtlgPb9ixvA1w3UZ4ks+kecrhpskKr6mft523AJ+m6YSVJktZpgzyI8ILVLPt8YMck2wM/AxYDf9KXZwlwAHAu3ZimZ43X1TmmBXZbVtWNSTYEXgx8bTXrJ0mSNDImG3t0Y+D1wA7ApcDxVbVi0ILbPWqHAGcAs4ATquqyJEcAS6tqCXA8cHKSZXQtbIt79n8N8EBgoyR7AXsAPwXOaAHbLLqA7cOrcLySJEkjabKWtpOA3wDfomtt24luZISBVdXpwOl9aW/rmb8T2GeCbRdMUOyuq1IHSZKkdcFkQdtO7YZ/khwPfH/tVEmSJEn9JnsQ4TdjM6vSLSpJkqQ1b7KWtscl+WWbD7BJWw7dK9weOPTaSZI0w/juNk2XCYO2qpq1NisiSZKkiQ06YLwkSZKm0SDvaZM0ItI3xsjYWw8nSpckjQ5b2iRJkkaAQZskSdIIMGiTJEkaAQZtkiRJI8AHEaQR5cMFkrR+MWiTJGkN8KW7Gja7RyVJkkaAQZskSdIIsHtUklj5HkHvD5Q0E9nSJkmSNAIM2iRJkkaAQZskSdIIMGiTJEkaAT6IIEnSEPW+v813t+n+sKpmbAMAABHcSURBVKVNkiRpBNjSJk3C10BIkmYKW9okSZJGwFCDtiR7JrkqybIkh46zfk6SU9v685IsaOlzk3wjye1J3t+3za5JLm3bvC/pHzZbkiRp3TO0oC3JLOAY4AXATsC+SXbqy3YQcHNV7QAcDRzV0u8E3gq8eZyiPwgcDOzYpj3XfO0lSZJmlmG2tO0GLKuqq6vqbuAUYFFfnkXASW3+NGD3JKmqO6rq23TB2+8keRjwwKo6t6oK+Biw1xCPQZIkaUYYZtC2NXBtz/LyljZunqpaAdwKzJ2izOVTlClJkrTOGebTo+Pda9b//N0geVYrf5KD6bpRmT9//iRFSppO/Xel+pSu1ge9724D39+mwQyzpW05sG3P8jbAdRPlSTIb2AK4aYoyt5miTACq6riqWlhVC+fNm7eKVZckSZpZhhm0nQ/smGT7JBsBi4ElfXmWAAe0+b2Bs9q9auOqquuB25I8pT01uj/whTVfdUmSpJllaN2jVbUiySHAGcAs4ISquizJEcDSqloCHA+cnGQZXQvb4rHtk1wDPBDYKMlewB5VdTnwBuBEYBPgK22SJElapw11RISqOh04vS/tbT3zdwL7TLDtggnSlwK7rLlaSpIkzXyOiCBJkjQCDNokSZJGgAPGS5I0Q/gqEE3GljZJkqQRYEubJK0iW0MkTQdb2iRJkkaALW3SEDlEkyRpTbGlTZIkaQTY0iatIbaqSZKGyaBNkqQZzAdfNMbuUUmSpBFg0CZJkjQC7B6VVpH3rkmSpoNBm7SeMviUpNFi96gkSdIIsKVNkqQR5FOl6x9b2iRJkkaAQZskSdIIMGiTJEkaAQZtkiRJI8CgTZIkaQT49KgkSeuQ3qdKfaJ03WJLmyRJ0ggYatCWZM8kVyVZluTQcdbPSXJqW39ekgU96w5r6VcleX5P+jVJLk1yUZKlw6y/JEnSTDG07tEks4BjgOcBy4Hzkyypqst7sh0E3FxVOyRZDBwFvDLJTsBiYGfg4cDXkjyqqu5p2z27qm4cVt0lSZJmmmG2tO0GLKuqq6vqbuAUYFFfnkXASW3+NGD3JGnpp1TVXVX1E2BZK0+SJGm9NMwHEbYGru1ZXg48eaI8VbUiya3A3Jb+vb5tt27zBXw1SQHHVtVxQ6i7ppmDmUvSmuOQV+uGYQZtGSet/1MyUZ7Jtn1qVV2X5CHAmUmurKpz7rPz5GDgYID58+cPXmtJkqQZaJjdo8uBbXuWtwGumyhPktnAFsBNk21bVWM/fwF8jgm6TavquKpaWFUL582bd78PRpIkaToNM2g7H9gxyfZJNqJ7sGBJX54lwAFtfm/grKqqlr64PV26PbAj8P0kmybZHCDJpsAewA+HeAySJEkzwtC6R9s9aocAZwCzgBOq6rIkRwBLq2oJcDxwcpJldC1si9u2lyX5FHA5sAL4i6q6J8lDgc91zyowG/hkVf3nsI5BGhbv2ZMkraqhjohQVacDp/elva1n/k5gnwm2fRfwrr60q4HHrfmaal1kYCRJk/MBhdHiiAiSJEkjwLFHNfJsUZMkrQ9saZMkSRoBtrRppPS2qtmiJklrnve5zVy2tEmSJI0AgzZJkqQRYNAmSZI0ArynTZIkTcl73aafLW2SJEkjwKBNkiRpBBi0SZIkjQDvadN6xdETJGnN8T63tcuWNkmSpBFg0CZJkjQC7B7VStZE96FdkJK0frPbdDgM2nS/GKBJkrR2GLRJkqS1wha4+8egTQOxRU2SpOll0CZJkqaNrW+D8+lRSZKkEWBLm9Yau1glSYOyBe6+DNokSdJIWN8DOYO2GcR3pEmSpIkMNWhLsifw78As4CNV9e6+9XOAjwG7Av8LvLKqrmnrDgMOAu4B3lhVZwxS5rpmoiDM4EySpM5ELXDrWsvc0IK2JLOAY4DnAcuB85MsqarLe7IdBNxcVTskWQwcBbwyyU7AYmBn4OHA15I8qm0zVZnqY4AnSVJnlAO5Yba07QYsq6qrAZKcAiwCegOsRcDhbf404P1J0tJPqaq7gJ8kWdbKY4Ayp4WBkSRJo2u8YG6mBXjDfOXH1sC1PcvLW9q4eapqBXArMHeSbQcpU5IkaZ2TGlKTUJJ9gOdX1Wvb8quA3arqL3vyXNbyLG/LP6ZrUTsCOLeqPt7SjwdOpwsyJy2zp+yDgYPb4qOBq4ZyoGvPVsCN010JrTav32jz+o02r99oWx+v33ZVNa8/cZjdo8uBbXuWtwGumyDP8iSzgS2Am6bYdqoyAaiq44DjVrfyM02SpVW1cLrrodXj9RttXr/R5vUbbV6/ew2ze/R8YMck2yfZiO7BgiV9eZYAB7T5vYGzqmv6WwIsTjInyfbAjsD3ByxTkiRpnTO0lraqWpHkEOAMutdznFBVlyU5AlhaVUuA44GT24MGN9EFYbR8n6J7wGAF8BdVdQ/AeGUO6xgkSZJmiqHd06Y1K8nBrctXI8jrN9q8fqPN6zfavH73MmiTJEkaAcO8p02SJElriEHbiEjy5iSVZKu2nCTvS7IsySVJnjjdddR9JfmXJFe2a/S5JFv2rDusXb+rkjx/OuupiSXZs12jZUkOne76aGJJtk3yjSRXJLksyZta+oOTnJnkv9rPB013XTWxJLOSXJjkS215+yTntet3ansQcb1k0DYCkmxLN3TXf/ckv4Duqdod6d5H98FpqJqmdiawS1X9AfAj4DCAvqHa9gQ+0IZ+0wzSMxzfC4CdgH3btdPMtAL4P1X1WOApwF+063Uo8PWq2hH4elvWzPUm4Iqe5aOAo9v1u5luCMz1kkHbaDga+Dug9wbERcDHqvM9YMskD5uW2mlCVfXVNtoHwPfo3i0IPUO1VdVPgN6h2jRz/G44vqq6GxgbOk8zUFVdX1U/aPO30X3xb013zU5q2U4C9pqeGmoqSbYBXgR8pC0HeA7dUJewnl8/g7YZLslLgZ9V1cV9qxzSa/S8BvhKm/f6jQav04hKsgB4AnAe8NCquh66wA54yPTVTFP4N7pGit+25bnALT3//K7Xv4PDHBFBA0ryNeD3xln1D8DfA3uMt9k4aT4KPA0mu35V9YWW5x/oum4+MbbZOPm9fjOP12kEJdkM+AzwV1X1y66xRjNdkhcDv6iqC5I8ayx5nKzr7e+gQdsMUFXPHS89ye8D2wMXtz862wA/SLIbgw0TprVgous3JskBwIuB3eved+x4/UaD12nEJNmQLmD7RFV9tiX/PMnDqur6dhvJL6avhprEU4GXJnkhsDHwQLqWty2TzG6tbev176DdozNYVV1aVQ+pqgVVtYDuC+SJVfU/dMN37d+eIn0KcOtY879mjiR7Am8BXlpVv+pZNdFQbZpZHDpvhLT7n44Hrqiq9/as6h0y8QDgC2u7bppaVR1WVdu077vFdENb7gd8g26oS1jPr58tbaPrdOCFdDew/wp49fRWRxN4PzAHOLO1ln6vql4/2VBtmjkmGo5vmquliT0VeBVwaZKLWtrfA+8GPpXkILqn8PeZpvpp9bwFOCXJkcCFdIH5eskRESRJkkaA3aOSJEkjwKBNkiRpBBi0SZIkjQCDNkmSpBFg0CZJkjQCDNqkdVSSf0hyWZJLklyU5Mlrcd9JclaSB67BMl+fZP82f2CSh/es+8jaGMg9ydlJFg57Pz3726v3uPqPexXLelaSL6252k25v9OTbLka2704yTuGUSdp1Bm0SeugJH9INwrDE6vqD4DnsvIYmqtT5qq81/GFwMVV9cv7s89eVfWhqvpYWzwQeHjPutdW1eVral8zyF5AbzB6ID3Hvbas4rUHoKpeWFW3rMbuvkz3VvwHrMa20jrNoE1aNz0MuLGq7gKoqhur6jqAJE9K8t0kFyf5fpLNk2yc5KNJLk1yYZJnt7wHJvl0ki8CX21pf5vk/NaCN1GLyH60t5YnWZDkyiQntW1OG/tCTrJ729+lSU5IMqelvzvJ5S3/v7a0w5O8OcnewELgE60FcZOxFrAkb0jyf8cq0er/H23+T9vxXpTk2CSzeiucZLckn23zi5L8OslG7dxc3ZN1n1bOj5I8veWfleRfes7L61r6s1rdTmvn4BPtrf307fvP2rYXJ/lMkgck+SPgpcC/tDq/ZZzjflvb7odJjhsrO8kOSb7WyvtBkkf27e9J7bw/Ismm7dyf39IWTXTte7b/uyRvbPNHJzmr53p+vM1fk2Srdv2vSPLhdC2/X02yScvzxp7rfEr7rBZwNt0/HZJ6VZWTk9M6NgGbARcBPwI+ADyzpW8EXA08qS0/kG5klP8DfLSlPYburfEb07XsLAce3NbtARxHN4jzBsCXgGeMs/+fApu3+QV0Azw/tS2fALy5lX8t8KiW/jHgr4AHA1dx78u/t2w/Dwfe3ObPBhb27O9suoBmHrCsJ/0rwNOAxwJfBDZs6R8A9u+r82zgJ23+X+mGsHoq8Ezg//Xs5z1t/oXA19r8wcA/tvk5wFK6cYOfBdxKN17iBsC5wNPGOV9ze+aPBP6yzZ8I7N1/nD3LD+6ZPxl4SZs/D3hZm98YeECry5eAPwIuAOa39f8E/OnYuab7zGzaf+376vsU4NNt/lt0Q7BtCLwdeF1LvwbYql3/FcDjW/qnevZ3HTCn9zq3+f2A/5ju3yMnp5k22dImrYOq6nZgV7pg4gbg1CQHAo8Grq+q81u+X1Y3CPPT6L70qaor6YKuR7Xizqyqm9r8Hm26EPgBXYC34zhVeHBV3dazfG1VfafNf7zt79F0QdKPWvpJwDOAXwJ3Ah9J8sd0w7QNetw3AFcneUqSuW0f3wF2b+fj/HTDG+0OPKJv2xXAsiSPBXYD3tvq83S6wGTM2CDkF9AFJNCdk/1b2ecBc7n3vHy/qpZX1W/pAukF3NcuSb6V5FK6gGXnAQ/52UnOa9s9B9g5yebA1lX1uXZcd9a9494+li7ofklV/XdP3Q9tdT+bLsib39b1XvteFwC7tn3dRReMLuS+52rMT6rqop5tF7T5S+haDv+ULrAb8wumoRtYmukce1RaR1U3lunZwNntS/0AukBrvLHr7tNl1+OOvnz/XFXHTrH7FUk2aIEK4+yzJtpndeN97kYXWC0GDqELSAZ1KvAK4Ergc1VVrdvwpKo6bIptvwW8APgN8DW6lq5ZdC2DY+5qP+/h3r+hoWsdO6O3sCTP6snfv02vE4G9quriFlw/a4p6kmRjuhbDhVV1bZLD6QKuya7l9S3PE+haucbq/vKquqqv/Cez8rX/nar6TZJr6MY8/i5d8PVs4JHAFeNs0n8ONmnzL6ILjF8KvDXJzi143hj49STHIa2XbGmT1kFJHp2ktwXs8XStZ1cCD0/ypJZv83Q3mZ9D18JDkkfRtbRcxX2dAbwmyWYt79ZJHjJOvqtYuSVrfrqHIwD2Bb7d6rIgyQ4t/VXAN1vZW1TV6XTdpY8fp/zbgM0nOPzP0t3Avy9dAAfwdWDvsbomeXCS7cbZ9py2z3Nbq91cutbEqQaJPwN4Q5INW/mPSrLpFNv02hy4vm2/X096/3H2Lm/cft7Yztne0LWeAsuT7NXqMif33tR/C12g9E8toByr+1/23A/3hAHrfA5dMHsOXbD7euCiqhpoQOskGwDbVtU3gL+j65rdrK1+FPDDAeshrTcM2qR102bASWM3edM9gXh4Vd0NvBL4jyQXA2fSffl/AJjVWuROBQ6s9hBDr6r6KvBJ4NyW9zTGD56+zMqtRVcAB7S6PBj4YFXdSddS8+lW1m+BD7XyvtTyfhP463HKPxH40NgN+X11vBm4HNiuqr7f0i4H/hH4aiv3TLqHNfqdBzyULhCBrgXpkgECkY+0ff4gyQ+BY1m1noy3tn2fSRfMjjkF+Nv2gMAj6TluutarDwOXAp+nuwdvzKuAN7Zj/S7we2MrqurnwEuAY1pr2jvp7ke7pNX9nQPW+Vt05/DcVuadjN81OpFZwMfbtb8QOLrufdr02XSfIUk9MuA/RZI0sCQPAz5WVc9LsgD4UlXtMr210ihI8lDgk1W1+3TXRZppbGmTtMZV1fXAh7MGX66r9cZ8uqeZJfWxpU2SJGkE2NImSZI0AgzaJEmSRoBBmyRJ0ggwaJMkSRoBBm2SJEkjwKBNkiRpBPx/j4QM9HGGTeQAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 720x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "show(campaign_probdist(State(100, 50, 10 * (5,))))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the plot below  all the defenders are in a single territory, and there is no visible gap–the bell 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": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "show(campaign_probdist(State(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": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "show(campaign_probdist(State(146, 93, (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 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": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "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",
    "    plt.yticks([i / 10 for i in range(11)]); plt.xticks(range(0, 61, 5))\n",
    "    for delta in deltas:\n",
    "        winprobs = [attacker_win_probability(campaign_probdist(State(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": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "chart()"
   ]
  },
  {
   "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 still has better than 50/50 odds with 45 attackers or more.\n",
    "\n",
    "# Tests\n",
    "\n",
    "Here are regression unit tests that also serve as examples of usage."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Tests for States\n",
    "assert start.A  == 72\n",
    "assert start.D  == 22 \n",
    "assert start.rest == (8, 2, 2, 2, 7, 1, 1, 3, 1, 2, 3, 5, 1)\n",
    "assert sum(start.rest) + start.D == 60 \n",
    "assert len(start.rest) == 13\n",
    "\n",
    "# Tests for update\n",
    "small = State(10, 2, (3, 4)) # Small example where 10 attackers battle 2 + 3 + 4 defenders\n",
    "assert update(small, Deaths(0, 2)) == State(9, 3, (4,))    \n",
    "assert update(small, Deaths(1, 1)) == State(9, 1, (3, 4)) \n",
    "assert update(small, Deaths(2, 0)) == State(8, 2, (3, 4)) # continue to battle\n",
    "assert update(State(10, 2, ()), Deaths(0, 2)) == State(9, 0, ())\n",
    "\n",
    "# The 4 sample dice rolls from www.ultraboardgames.com/risk/game-rules.php\n",
    "assert battle_deaths([1, 1, 6], [3,])   == Deaths(0, 1) # Defender loses one\n",
    "assert battle_deaths([2, 6, 1], [2, 3]) == Deaths(1, 1) # Both lose one\n",
    "assert battle_deaths([3, 3],    [3, 4]) == Deaths(2, 0) # Attacker loses two\n",
    "assert battle_deaths([6,],      [5, 4]) == Deaths(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(State(1, 1)) == ProbDist(\n",
    "    {Deaths(1, 0):   21, Deaths(0, 1):   15})\n",
    "assert battle_deaths_probdist(State(2, 1)) == ProbDist(\n",
    "    {Deaths(1, 0):   91, Deaths(0, 1):  125})\n",
    "assert battle_deaths_probdist(State(3, 1)) == ProbDist(\n",
    "    {Deaths(1, 0):  441, Deaths(0, 1):  855})\n",
    "assert battle_deaths_probdist(State(1, 2)) == ProbDist(\n",
    "    {Deaths(1, 0):  161, Deaths(0, 1):   55})\n",
    "assert battle_deaths_probdist(State(2, 2)) == ProbDist(\n",
    "    {Deaths(2, 0):  581, Deaths(1, 1):  420, Deaths(0, 2):  295})\n",
    "assert battle_deaths_probdist(State(3, 2)) == ProbDist(\n",
    "    {Deaths(2, 0): 2275, Deaths(1, 1): 2611, Deaths(0, 2): 2890})\n",
    "\n",
    "assert set(all_rolls(2)) == {\n",
    "    (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(State(2, 1))) == 15/36\n",
    "assert campaign_probdist(State(2, 1)) == ProbDist({State(1, 1): 21/36, State(1, 0): 15/36})\n",
    "assert campaign_probdist(State(4, 2, (1,))) == ProbDist(\n",
    "    {State(1, 2, (1,)): 0.21807067805974698,\n",
    "     State(1, 1, (1,)): 0.12597532213712342,\n",
    "     State(1, 1): 0.294669783648961,\n",
    "     State(1, 0): 0.14620529335276633,\n",
    "     State(2, 0): 0.21507892280140226})\n",
    "\n",
    "assert battle_update_probdist(ProbDist({start: 1})) == ProbDist(\n",
    "    {State(70, 22, (8, 2, 2, 2, 7, 1, 1, 3, 1, 2, 3, 5, 1)): 0.2925668724279835,\n",
    "     State(71, 21, (8, 2, 2, 2, 7, 1, 1, 3, 1, 2, 3, 5, 1)): 0.3357767489711934,\n",
    "     State(72, 20, (8, 2, 2, 2, 7, 1, 1, 3, 1, 2, 3, 5, 1)): 0.37165637860082307})\n",
    "\n",
    "True"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}