ipynb/Jotto.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div align=\"right\" style=\"text-align: right;\"><i>Peter Norvig<br>Jotto: April 2020<br>Wordle: Jan 2022<br>Evil/Anti: Nov 2022</i></div>\n",
    "\n",
    "# Wordle, Evil Wordle, Antiwordle, and Jotto\n",
    "\n",
    "[**Wordle**](https://www.nytimes.com/games/wordle/index.html) is Josh Wardle's [tremendously popular](https://www.nytimes.com/2022/01/03/technology/wordle-word-game-creator.html) word game in which a **guesser** tries to guess a secret **target** word (chosen from a **word list** of allowable words) in as few guesses as possible. Each guess must be one of the words on the list, and the **reply** to each guess consists of 5 bits (actually [trits](https://en.wiktionary.org/wiki/trit#English)) of information, one for each of the 5 word spots:\n",
    "  - *Green* if the guess letter is in the word and in the correct spot.\n",
    "  - *Yellow* if the guess letter is in the word but in the wrong spot.\n",
    "  - *Miss* if the letter is not in the word in any spot.\n",
    "\n",
    "Wordle uses a list of 12,971 allowable guess words, but only 2,309 of them can be target words. (I think the idea is to follow [Postel's law](https://en.wikipedia.org/wiki/Robustness_principle): \"be conservative in what you send, be liberal in what you accept\".) In this notebook, we'll assume we're only dealing with the 2,309 target words. Historically, Wordle is a refinement of **Jotto**, and has in turn inspired variants inclusding **Evil Wordle** and **Antiwordle**, all of which we will cover in this notebook.\n",
    "\n",
    "First off, import some modules and define the basic types `Word`, `Score`, and `Reply`, and the colors that make up the reply:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing      import List, Tuple, Dict, Union, Counter, Callable, Iterable\n",
    "from dataclasses import dataclass\n",
    "from statistics  import mean, median, stdev\n",
    "from collections import defaultdict\n",
    "from functools   import lru_cache\n",
    "from pathlib     import Path\n",
    "from math        import log2\n",
    "import random \n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "Word  = str # A word is a string of five different letters\n",
    "Score = int # A score is the number of guesses it took to get the target word\n",
    "Reply = str # A reply is a str of 5 characters, e.g. 'G...Y'\n",
    "\n",
    "Green, Yellow, Miss = 'GY.'\n",
    "Correct = 5 * Green # The reply for the correct guess\n",
    "\n",
    "random.seed('for reproducibility')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now read in the word list:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "! [ -e wordle-small.txt ] || curl -O https://norvig.com/ngrams/wordle-small.txt\n",
    "\n",
    "wordlist = Path('wordle-small.txt').read_text().split()\n",
    "\n",
    "assert len(wordlist) == 2309"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Replies\n",
    "\n",
    "The rules for Wordle replies, outlined above, contain an ambiguity. Let's clear things up.\n",
    "\n",
    "Assume the guess is `'NINNY'` and the target is `'ANNEX'`. A strict reading of the rules would say that the reply should be `'Y.GY.'`–one of the three `'N'`s is in the right spot and thus is green, and the other two should be yellow  because they are  \"in the word but in the wrong spot.\" But the actual (unstated) rules are that Wordle matches the greens first, and then goes left-to-right with the yellows, and only gives you as many non-misses as there are letters in the target to support them. In this example, there are two `'N'`s in the target, so after the one green, there will only be one more yellow `'N'`, and it will be in the leftmost available spot. The actual reply is `'Y.G..'`.\n",
    "\n",
    "In general, how many possible replies are there? There are 3 responses at each of five positions, and  3<sup>5</sup> = 243, but five of those replies are impossible: you can't have four Greens and one Yellow, because if four letters of the guess are in the right place then the fifth must be either in the right place or a miss. \n",
    "\n",
    "Below is the definition of `reply_for` and some tests. Note that `reply_for` is not symmetric; `reply_for(A, B)` is always a permutation of `reply_for(B, A)`, but they are usually not equal. Since the computation of a reply is somewhat complex, we cache the results.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "@lru_cache(None)\n",
    "def reply_for(guess: Word, target: Word) -> Reply: \n",
    "    \"The five-character reply for this guess on this target.\"\n",
    "    # We'll start by having each element of the reply be either Green or Miss ...\n",
    "    reply = [Green if guess[i] == target[i] else Miss for i in range(5)]\n",
    "    # ... then we'll change the elements that should be yellow\n",
    "    counts = Counter(target[i] for i in range(5) if guess[i] != target[i])\n",
    "    for i in range(5):\n",
    "        if reply[i] == Miss and counts[guess[i]] > 0:\n",
    "            counts[guess[i]] -= 1\n",
    "            reply[i] = Yellow\n",
    "    return ''.join(reply)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "assert reply_for('NINNY', 'ANNEX') == 'Y.G..'; assert  reply_for('ANNEX', 'NINNY') == '.YG..'\n",
    "assert reply_for('HELLO', 'WORLD') == '...GY'; assert  reply_for('WORLD', 'HELLO') == '.Y.G.'\n",
    "assert reply_for('HELLO', 'ABYSS') == '.....'; assert  reply_for('ABYSS', 'HELLO') == '.....'\n",
    "assert reply_for('EPEES', 'GEESE') == 'Y.GYY'; assert  reply_for('GEESE', 'EPEES') == '.YGYY'\n",
    "assert reply_for('WHEEE', 'PEEVE') == '..GYG'; assert  reply_for('PEEVE', 'WHEEE') == '.YG.G'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Consistent Target Words\n",
    "\n",
    "A key concept in Wordle is the idea of **consistent target words**. If I guess `'NINNY'` and the reply is `'Y.G..'`, then the target word could be `'ANNEX'`, but it could also be `'ANNUL'` or `'CANON'`. We say these three words are **consistent** with the guess/reply pair.  If we next guess `'ENNUI'` and get the reply `'YGG..'`, then `'ANNEX'` is the only consistent target. When there is a single consistent target left, the guesser can always get it on the next guess. In general, given a word list, I can always determine the list of consistent targets from a sequence of guess/reply pairs. Once I know the consistent words, the guess/reply pairs themselves provide no additional useful information.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def consistent_targets(targets, guess, reply) -> List[Word]: \n",
    "    \"\"\"All the words in `targets` that give this `reply` to this `guess`.\"\"\"\n",
    "    return [target for target in targets if reply_for(guess, target) == reply]\n",
    "\n",
    "assert consistent_targets(wordlist, 'NINNY', 'Y.G..') == ['ANNEX', 'ANNUL', 'CANON']\n",
    "assert consistent_targets(consistent_targets(wordlist, 'NINNY', 'Y.G..'), 'ENNUI', 'YGG..') == ['ANNEX']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Playing Wordle\n",
    "\n",
    "The function `play` will play a game of Wordle and return the score (the number of guesses). The  arguments are:\n",
    "- `guesser`: a `callable` (e.g., a function) that should return the guess to make. The guesser is passed two arguments: \n",
    "  - The **reply** to the previous guess.\n",
    "  - A list of **consistent target words**.<br>(A word is **consistent** if it\n",
    "  gives the same replies to all the guesses made so far as the replies that were actually received.)\n",
    "- `wordlist`: The list of allowable words.\n",
    "- `target`: The target word. If none is given, the target word is chosen at random from the wordlist.\n",
    "- `verbose`: Unless false, print a message for each guess.\n",
    "\n",
    "Two corner cases: \n",
    "1. If the guesser improperly guesses a non-word, the reply is `'unknown'`. \n",
    "2. To prevent an infinite loop with a bad guesser, the worst score you can get is the number of words in the wordlist plus 1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def play(guesser, wordlist=wordlist, target=None, verbose=True) -> Score:\n",
    "    \"\"\"The number of guesses it take for `guesser` to guess the Jotto word,\n",
    "    which is given by `target` or selected from the words in `wordlist`?\"\"\"\n",
    "    target  = target or random.choice(wordlist) # Choose a random target if none was given\n",
    "    targets = wordlist      # The targets that are consistent with all guess/reply pairs\n",
    "    reply   = None          # For the first guess, there is no previous reply\n",
    "    N       = len(wordlist)\n",
    "    for turn in range(1, N + 1):\n",
    "        guess   = guesser(reply, targets)\n",
    "        reply   = reply_for(guess, target) if guess in wordlist else 'unknown'\n",
    "        targets = consistent_targets(targets, guess, reply)\n",
    "        if verbose: \n",
    "            print(f'Guess {turn}: {guess}, Reply: {reply}; Remaining targets: {len(targets)}')\n",
    "        if reply == Correct:  \n",
    "            return turn\n",
    "    return N + 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To play a game, we will need a guesser. Here are two simple ones:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def human_guesser(reply, targets) -> Word: \n",
    "    \"\"\"Ask a human to make a guess.\"\"\"\n",
    "    return input(f'Reply was {reply}. Your guess? ')\n",
    "\n",
    "def random_guesser(reply, targets) -> Word: \n",
    "    \"\"\"Choose a guess at random from the consistent targets.\"\"\"\n",
    "    return random.choice(targets)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Sample Wordle Games\n",
    "\n",
    "Here is the `random_guesser` in action:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Guess 1: VALUE, Reply: .....; Remaining targets: 313\n",
      "Guess 2: NOTCH, Reply: .Y...; Remaining targets: 21\n",
      "Guess 3: PROXY, Reply: YGG..; Remaining targets: 1\n",
      "Guess 4: DROOP, Reply: GGGGG; Remaining targets: 1\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "play(random_guesser)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Guess 1: SLAIN, Reply: ....G; Remaining targets: 25\n",
      "Guess 2: TOKEN, Reply: ....G; Remaining targets: 1\n",
      "Guess 3: CHURN, Reply: GGGGG; Remaining targets: 1\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "play(random_guesser)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Guess 1: SMOKE, Reply: ..Y.Y; Remaining targets: 64\n",
      "Guess 2: VOWEL, Reply: .Y.YY; Remaining targets: 3\n",
      "Guess 3: FELON, Reply: .GGY.; Remaining targets: 2\n",
      "Guess 4: CELLO, Reply: .GGGG; Remaining targets: 1\n",
      "Guess 5: HELLO, Reply: GGGGG; Remaining targets: 1\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "play(random_guesser, target='HELLO')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#  Partitioning Target Words\n",
    "\n",
    "We can think of a guess as **partitioning** the consistent targets into different **branches** of a tree, each branch corresponding to a different reply:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "Partition = Dict[Reply, List[str]]\n",
    "\n",
    "def partition(guess, targets) ->  Partition:\n",
    "    \"\"\"A guess partition targets by the possible replies to guess: {reply: [word, ...]}.\"\"\"\n",
    "    branches = defaultdict(list)\n",
    "    for target in targets:\n",
    "        branches[reply_for(guess, target)].append(target)\n",
    "    return branches"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A partition for the full wordlist would be too big to look at, so let's pick out a few words (every 100th one, so that's 24 words), and partition them by two different guesses. First, the few words partitioned by `'ROAST'`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "defaultdict(list,\n",
       "            {'..G..': ['ABACK', 'QUACK'],\n",
       "             'YYY..': ['ARBOR'],\n",
       "             'Y...Y': ['BIRTH', 'TREND'],\n",
       "             '.....': ['BULLY', 'CUMIN'],\n",
       "             '..GG.': ['CLASP', 'PHASE'],\n",
       "             'YY...': ['DROOL', 'HUMOR'],\n",
       "             '..Y..': ['FANCY', 'NINJA'],\n",
       "             'Y.G..': ['FRANK'],\n",
       "             'Y.G.Y': ['GRATE'],\n",
       "             'Y.Y.Y': ['LATER'],\n",
       "             '.YYY.': ['MASON'],\n",
       "             'GGGGG': ['ROAST'],\n",
       "             '..GY.': ['SHALE'],\n",
       "             '...Y.': ['SMELL'],\n",
       "             '..GYY': ['STAMP'],\n",
       "             '..Y.Y': ['TAKEN'],\n",
       "             'Y.Y..': ['VIRAL'],\n",
       "             '..Y.G': ['YACHT']})"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "few = wordlist[::100]\n",
    "\n",
    "partition('ROAST', few)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "No matter what the reply to `'ROAST'` is,  we will be left with no more than 2 remaining possible targets, so we will always be able to win in no more than 3 total guesses. Now, partition by  `'NINJA'`:\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "defaultdict(list,\n",
       "            {'....Y': ['ABACK',\n",
       "              'ARBOR',\n",
       "              'CLASP',\n",
       "              'GRATE',\n",
       "              'LATER',\n",
       "              'PHASE',\n",
       "              'QUACK',\n",
       "              'ROAST',\n",
       "              'SHALE',\n",
       "              'STAMP',\n",
       "              'YACHT'],\n",
       "             '.G...': ['BIRTH'],\n",
       "             '.....': ['BULLY', 'DROOL', 'HUMOR', 'SMELL'],\n",
       "             'YY...': ['CUMIN'],\n",
       "             '..G.Y': ['FANCY'],\n",
       "             'Y...Y': ['FRANK', 'MASON', 'TAKEN'],\n",
       "             'GGGGG': ['NINJA'],\n",
       "             'Y....': ['TREND'],\n",
       "             '.G..Y': ['VIRAL']})"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "partition('NINJA', few)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Almost half the time we get a reply of `'....Y'`, and there are 11 possible target words remaining. That  suggests that `'ROAST'` is a better guess and that a good strategy is: **guess a word that partitions the possible remaining targets into small branches.**\n",
    "\n",
    "To do this we only need to know the *size* of each branch, not the list of words therein, so we could use `partition_counts`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def partition_counts(guess, targets) -> List[int]: \n",
    "    \"The sizes of the branches of a partition of targets by guess.\"\n",
    "    counter = Counter(reply_for(guess, target) for target in targets)\n",
    "    return sorted(counter.values())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "assert partition_counts('ROAST', few) == [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2]\n",
    "assert partition_counts('NINJA', few) == [1, 1, 1, 1, 1, 1, 3, 4, 11]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Metrics for Minimizing Partitions\n",
    "\n",
    "We want partitions with **small branches**, but what exactly does that mean? Ideally, we want the partition that minimizes the average number of additional guesses it will take to finish the game (and possibly also that minimizes the number of times that we more than 6 guesses). However, just looking at a single partition (without looking ahead further) can't tell us what we want to know, so instead we can minimize one of the following proxy metrics:\n",
    "\n",
    "- **Maximum**: choose the partition that minimizes the size of the largest branch.\n",
    "\n",
    "- **Expectation**: In probability theory, the expectation (also known as expected value) is the weighted average of a random variable. Here it means the sum, over all branches, of the probability of ending up in the branch multiplied by the size of the branch. We are assuming that every target is equally likely, so the probability of a branch is proportional to the number of targets in it.\n",
    "\n",
    "- **Negative Entropy**: In information theory, entropy is the weighted average amount of \"information\" measured in bits. The calculation is the same as expectation except that we count the base 2 logarithm of the branch sizes, not the branches sizes themselves. You can think of the base 2 logarithm as the number of times that you need to cut a branch in half to get it down to one word. We want to maximize entropy, or minimize *negative* entropy.\n",
    "\n",
    "The maximum is just the builtin `max` function; here are the other two metrics:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def expectation(counts: List[int]) -> float:\n",
    "    \"The expected value of the counts.\"\n",
    "    N = sum(counts)\n",
    "    def P(x): return x / N\n",
    "    return sum(P(x) * x for x in counts)\n",
    "\n",
    "def neg_entropy(counts: List[int]) -> float: \n",
    "    \"\"\"The negation of the entropy of the counts.\"\"\"\n",
    "    N = sum(counts)\n",
    "    def P(x): return x / N\n",
    "    return sum(P(x) * log2(P(x)) for x in counts)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#  Caching Best Guesses: Guess Trees\n",
    "\n",
    "Going through every word in the wordlist to decide which one makes the best partition takes some time. I would prefer to do that computation just once and cache it, rather than have to repeat the computation in every new game. I will cache the best guesses in a structure called a **guess tree**: a tree that has branches for every possible path the game might take, with the best guess for each situation precomputed. Some people call this a **policy**: a guideline that tells you what to do in any situation. A guess tree is either:\n",
    "- An **interior node**, which has a guess and a dict of branches, `Node(guess, {reply: subtree, ...})`, where  each subtree covers all the target words that are consistent with the corresponding reply.\n",
    "- A **leaf word**,  indicating the sole remaining consistent target word. Every word in the word list appears as a leaf in exactly one place in the tree."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "@dataclass \n",
    "class Node:\n",
    "    \"\"\"A node in a guess tree stores the best guess, the number of targets covered, and a branch for every reply.\"\"\"\n",
    "    guess: Word\n",
    "    size: int\n",
    "    branches: Dict[Reply, 'Tree']\n",
    "\n",
    "Tree = Union[Node, Word] # A Tree is either an interior Node or a leaf Word"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The function `minimizing_tree(metric, targets)` builds a guess tree that covers all the targets and that, at every node, guesses a word that  minimizes the `metric` applied to the `partition_counts` of the guess."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "def minimizing_tree(metric, targets) -> Tree:\n",
    "    \"\"\"Make a tree that picks guesses that minimize metric(partition_counts(guess, targets)).\"\"\"\n",
    "    if len(targets) == 1:\n",
    "        return targets[0]\n",
    "    else:\n",
    "        guess = min(targets, key=lambda guess: metric(partition_counts(guess, targets))) \n",
    "        branches = partition(guess, targets)\n",
    "        return Node(guess, len(targets), \n",
    "                    {reply: minimizing_tree(metric, branches[reply]) \n",
    "                     for reply in branches})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here is a minimizing tree that covers the 24 `few` words. The tree says that the first guess, `\"ROAST\"`, covers 24 target words, and for 12 replies there is only one word left, but for the first 6 replies a second guess is required. Either that second guess will be right, or we will need a third guess.\n",
    "\n",
    "if the reply is `0` the next guess is `\"would\"`. If, say, the reply to `\"would\"` is 4, then there is only one other word left, the leaf word `'cloud'`. If the reply is 5, that means `\"would\"` was correct. I won't go through the other branches of the tree."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "assert (minimizing_tree(max, few) == \n",
    "    Node(\"ROAST\", 24,\n",
    "         {'..G..': Node(\"ABACK\", 2, {'GGGGG': 'ABACK', '..GGG': 'QUACK'}), \n",
    "          'Y...Y': Node(\"BIRTH\", 2, {'GGGGG': 'BIRTH', '..YY.': 'TREND'}), \n",
    "          '.....': Node(\"BULLY\", 2, {'GGGGG': 'BULLY', '.G...': 'CUMIN'}), \n",
    "          '..GG.': Node(\"CLASP\", 2, {'GGGGG': 'CLASP', '..GGY': 'PHASE'}), \n",
    "          'YY...': Node(\"DROOL\", 2, {'GGGGG': 'DROOL', '.Y.G.': 'HUMOR'}), \n",
    "          '..Y..': Node(\"FANCY\", 2, {'GGGGG': 'FANCY', '.YG..': 'NINJA'}), \n",
    "          'YYY..': 'ARBOR', \n",
    "          'Y.G..': 'FRANK', \n",
    "          'Y.G.Y': 'GRATE', \n",
    "          'Y.Y.Y': 'LATER', \n",
    "          '.YYY.': 'MASON', \n",
    "          'GGGGG': 'ROAST', \n",
    "          '..GY.': 'SHALE', \n",
    "          '...Y.': 'SMELL', \n",
    "          '..GYY': 'STAMP', \n",
    "          '..Y.Y': 'TAKEN', \n",
    "          'Y.Y..': 'VIRAL', \n",
    "          '..Y.G': 'YACHT'}))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Turning a Tree into a Guesser\n",
    "\n",
    "A tree is not a guesser, but we can easily make a guesser from a tree. A `TreeGuesser` works as follows:\n",
    "- When *initialized*, it takes a tree as input, and stores the tree under the `.root` attribute.\n",
    "- When *called*, it sets the `.tree` attribute as follows:\n",
    "  - For the first turn in a game (when the reply is `None`), it resets `.tree`  to `.root`.\n",
    "  - On subsequent turns, it updates `.tree` to be the branch corresponding to the reply.\n",
    "- When *called*, it then returns the guess for the current tree: either the `.guess` attribute  or the leaf word. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "class TreeGuesser:\n",
    "    \"\"\"Given a guess tree, use it to create a callable Guesser that can play Wordle.\"\"\"\n",
    "    def __init__(self, tree): self.root = tree\n",
    "        \n",
    "    def __call__(self, reply, targets) -> Word:\n",
    "        \"\"\"If reply is `None`, start a new game; otherwise follow the branch for the `reply`.\n",
    "        Then return the current leaf or interior node guess. (Ignore `targets`.)\"\"\"\n",
    "        self.tree = self.root if reply is None else self.tree.branches[reply]\n",
    "        return self.tree.guess if isinstance(self.tree, Node) else self.tree"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here we build a tree that minimizes the maximum branch size (over the full wordlist) and make a guesser out of it:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 24.3 s, sys: 596 ms, total: 24.9 s\n",
      "Wall time: 26.2 s\n"
     ]
    }
   ],
   "source": [
    "%time guesser = TreeGuesser(minimizing_tree(max, wordlist))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Sample Games with the Minimizing Guesser\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Guess 1: ARISE, Reply: ..Y..; Remaining targets: 107\n",
      "Guess 2: UNTIL, Reply: ..GY.; Remaining targets: 10\n",
      "Guess 3: DITCH, Reply: .GG.Y; Remaining targets: 1\n",
      "Guess 4: PITHY, Reply: GGGGG; Remaining targets: 1\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "play(guesser)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Guess 1: ARISE, Reply: ....Y; Remaining targets: 120\n",
      "Guess 2: TOWEL, Reply: .GYG.; Remaining targets: 3\n",
      "Guess 3: WOKEN, Reply: GGGGG; Remaining targets: 1\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "play(guesser)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Guess 1: ARISE, Reply: ....Y; Remaining targets: 120\n",
      "Guess 2: TOWEL, Reply: .Y.YY; Remaining targets: 5\n",
      "Guess 3: CELLO, Reply: .GGGG; Remaining targets: 1\n",
      "Guess 4: HELLO, Reply: GGGGG; Remaining targets: 1\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "play(guesser, target='HELLO')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#  Inconsistent Guesses and \"Hard Mode\"\n",
    "\n",
    "So far,  we have always guessed a **consistent** word. That seems reasonable; why waste a guess on a word that could not possibly be the target? But it turns out that in some cases it ***is*** a good strategy to guess such a word.\n",
    "\n",
    "Suppose the entire word list consisted of these nine words:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "ails = ['BAILS', 'FAILS', 'HAILS', 'NAILS', 'PAILS', 'RAILS', 'SAILS', 'TAILS', 'WAILS']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we guessed any one of the nine words, there would be a 1/9 chance of being correct, and a 8/9 chance of getting the reply `'.GGGG'`, which adds no new information, and leaves us with 8 similar words to choose from. Overall, we'd expect to take 5 guesses on average, with 9 in the worst case. Not a good performance. \n",
    "\n",
    "On the other hand, we could make an inconsistent guess. This sacrifices the 1/9 chance of being correct on the first guess, but gives us more new information for subsequent guesses. For example, `'BERTH'` is a good first guess:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "defaultdict(list,\n",
       "            {'G....': ['BAILS'],\n",
       "             '.....': ['FAILS', 'NAILS', 'PAILS', 'SAILS', 'WAILS'],\n",
       "             '....Y': ['HAILS'],\n",
       "             '..Y..': ['RAILS'],\n",
       "             '...Y.': ['TAILS']})"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "partition('BERTH', ails)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "After `'BERTH'`, we have a 4/9 chance of being correct on the second guess, and a 5/9 chance of having just 5 remaining words. The 5 can be handled with another inconsistent guess:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "defaultdict(list,\n",
       "            {'Y.Y..': ['FAILS'],\n",
       "             'Y.Y.Y': ['NAILS'],\n",
       "             'YYY..': ['PAILS'],\n",
       "             'G.Y..': ['SAILS'],\n",
       "             'Y.YY.': ['WAILS']})"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "partition('SPAWN', ['FAILS', 'NAILS', 'PAILS', 'SAILS', 'WAILS'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Wordle has an option to play in **hard mode**, where only consistent guesses are allowed. Why is that called \"hard mode\"? One reason is that it can be a little bit hard for a human without access to a computer to verify that a guess is consistent. But more importantly, it is hard to win the game in hard mode if you get stuck in a situation like the `ails` list, where there are many targets remaining, but you are forced to make guesses that give no new information.\n",
    "\n",
    "To allow for inconsistent guesses, I will redefine `minimizing_tree` so that it is passed both the list of remaining consistent target words and the complete word list. It also takes a flag, `inconsistent`. When this flag is true, any word in the wordlist can be considered as a guess; when false, only consistent targets are considered, as before. (Note: when there are 3 or fewer target words left there is no use considering inconsistent guesses, since they cannot improve the average score over a consistent guess. Also, when there are many targets, the odds are one of them will be as good as any inconsistent guess. The value of *many* was empirically chosen as `inconsistent_max = 125`.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "def minimizing_tree(metric, targets, wordlist=wordlist, inconsistent=False) -> Tree:\n",
    "    \"\"\"Make a tree that picks guesses that minimize metric(partition_counts(guess, targets)).\"\"\"\n",
    "    if len(targets) == 1:\n",
    "        return targets[0]\n",
    "    else:\n",
    "        guesses  = wordlist if (inconsistent and (3 < len(targets) <= inconsistent_max)) else targets\n",
    "        guess    = min(guesses, key=lambda guess: metric(partition_counts(guess, targets))) \n",
    "        branches = partition(guess, targets)\n",
    "        return Node(guess, len(targets), \n",
    "                    {reply: minimizing_tree(metric, branches[reply], wordlist, inconsistent) \n",
    "                     for reply in branches})\n",
    "    \n",
    "inconsistent_max = 125"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "assert (minimizing_tree(max, ails, inconsistent=True) == \n",
    "        Node(\"BERTH\", 9,\n",
    "             {'.....': Node(\"SPAWN\", 5,\n",
    "                            {'G.Y..': 'SAILS', \n",
    "                             'Y.Y..': 'FAILS', \n",
    "                             'Y.Y.Y': 'NAILS', \n",
    "                             'Y.YY.': 'WAILS', \n",
    "                             'YYY..': 'PAILS'}), \n",
    "              '....Y': 'HAILS', \n",
    "              '...Y.': 'TAILS', \n",
    "              '..Y..': 'RAILS', \n",
    "              'G....': 'BAILS'}))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Evaluating and Reporting on Guessers\n",
    "\n",
    "I'll introduce three functions that together will evaluate a guesser and produce a report:\n",
    "\n",
    "- `report_minimizing_tree` builds a minimizing tree, gets its tree scores, and calls `report`.\n",
    "- `report` takes a list of scores and reports the following statistics:\n",
    "  - The median, mean, standard deviation, and worst case number of guesses, and total number of scores.\n",
    "  - The cumulative percentages guessed correctly (e.g., `\"≤5:11%\"` means 11% of the targets took 5 or fewer guesses).\n",
    "  - A histogram of scores.\n",
    "- `tree_scores` takes a guesser and returns a list of *all* the scores it would make for *all* its targets. For each subtree branch in the tree there are three cases:\n",
    "  - If the subtree is a leaf word that is the same as the node's guess, we're done; it took one guess.\n",
    "  - If the subtree is a leaf word that is not the guess, it took two guesses: one for the incorrect guess and one for the leaf word.\n",
    "  - If the subtree is a Node, add one to each of the scores from the subtree and yield those scores."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "def report_minimizing_tree(metric, targets=wordlist, wordlist=wordlist, inconsistent=False):\n",
    "    \"\"\"Build a minimizing tree and report on its scores.\"\"\"\n",
    "    print(f\"minimizing the {metric.__name__} of partition sizes over {len(targets):,d}\",\n",
    "          f\"targets; inconsistent guesses\", (\"allowed\" if inconsistent else \"prohibited\"))\n",
    "    tree = minimizing_tree(metric, targets, wordlist, inconsistent)\n",
    "    print(f'first guess: \"{tree.guess}\"')\n",
    "    report(tree_scores(tree))\n",
    "\n",
    "def report(scores: Iterable[Score]) -> None:\n",
    "    \"\"\"Report statistics and a histogram for these scores.\"\"\"\n",
    "    scores  = list(scores)\n",
    "    ctr     = Counter(scores)\n",
    "    bins    = range(1, histogram_bins + 2)\n",
    "    scale   = 100 / len(scores)\n",
    "    weights = [scale * ctr[score] for score in ctr]\n",
    "    plt.hist(list(ctr), weights=weights, align='left', rwidth=0.9, bins=bins)\n",
    "    plt.xticks(bins[:-1])\n",
    "    plt.xlabel('Number of guesses'); plt.ylabel('% of scores')\n",
    "    def cumulative_pct(g) -> str: \n",
    "        \"\"\"What percent of games requires no more than g guesses?\"\"\"\n",
    "        percent = scale * sum(ctr[i] for i in range(1, g + 1))\n",
    "        return f'≤{g}:{percent:.{1 if 99 < percent < 100 else 0}f}%'\n",
    "    print(f'median: {median(scores):.0f} guesses, mean: {mean(scores):.2f}',\n",
    "          f'± {stdev(scores):.2f}, worst: {max(scores)}, best: {min(scores)}\\n'\n",
    "          'cumulative:', ', '.join(map(cumulative_pct, range(2, 11))))\n",
    "    \n",
    "def tree_scores(node: Node) -> Iterable[Score]:\n",
    "    \"\"\"All the scores for playing all the target words in the tree under `node`.\"\"\"\n",
    "    for subtree in node.branches.values():\n",
    "        if isinstance(subtree, Word):\n",
    "            yield 1 if subtree == node.guess else 2\n",
    "        else:\n",
    "            yield from (score + 1 for score in tree_scores(subtree))\n",
    "            \n",
    "histogram_bins = 10 # The number of bins in the histogram created by `report` "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here are two reports for the 9-word `ails` list, with consistent guesses prohibited and allowed:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "minimizing the max of partition sizes over 9 targets; inconsistent guesses prohibited\n",
      "first guess: \"BAILS\"\n",
      "median: 5 guesses, mean: 5.00 ± 2.74, worst: 9, best: 1\n",
      "cumulative: ≤2:22%, ≤3:33%, ≤4:44%, ≤5:56%, ≤6:67%, ≤7:78%, ≤8:89%, ≤9:100%, ≤10:100%\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "report_minimizing_tree(max, ails)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "minimizing the max of partition sizes over 9 targets; inconsistent guesses allowed\n",
      "first guess: \"BERTH\"\n",
      "median: 3 guesses, mean: 2.56 ± 0.53, worst: 3, best: 2\n",
      "cumulative: ≤2:44%, ≤3:100%, ≤4:100%, ≤5:100%, ≤6:100%, ≤7:100%, ≤8:100%, ≤9:100%, ≤10:100%\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "report_minimizing_tree(max, ails, inconsistent=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We see that allowing inconsistent guesses improves the mean number of guesses (across all possible targets) from 5.00 to 2.56.\n",
    "\n",
    "# Reports on Consistent Wordle Guessers\n",
    "\n",
    "Here are reports on trees made from minimizing each of the three metrics (max, expectation, and entropy), with only consistent guesses allowed: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "minimizing the max of partition sizes over 2,309 targets; inconsistent guesses prohibited\n",
      "first guess: \"ARISE\"\n",
      "median: 4 guesses, mean: 3.68 ± 0.86, worst: 8, best: 1\n",
      "cumulative: ≤2:5%, ≤3:43%, ≤4:87%, ≤5:97%, ≤6:99.4%, ≤7:99.9%, ≤8:100%, ≤9:100%, ≤10:100%\n",
      "CPU times: user 2.08 s, sys: 171 ms, total: 2.25 s\n",
      "Wall time: 2.42 s\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "%time report_minimizing_tree(max, inconsistent=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "minimizing the expectation of partition sizes over 2,309 targets; inconsistent guesses prohibited\n",
      "first guess: \"RAISE\"\n",
      "median: 4 guesses, mean: 3.62 ± 0.86, worst: 8, best: 1\n",
      "cumulative: ≤2:6%, ≤3:47%, ≤4:88%, ≤5:98%, ≤6:99.4%, ≤7:99.9%, ≤8:100%, ≤9:100%, ≤10:100%\n",
      "CPU times: user 1.99 s, sys: 17.6 ms, total: 2.01 s\n",
      "Wall time: 2.03 s\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "%time report_minimizing_tree(expectation, inconsistent=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "minimizing the neg_entropy of partition sizes over 2,309 targets; inconsistent guesses prohibited\n",
      "first guess: \"RAISE\"\n",
      "median: 4 guesses, mean: 3.60 ± 0.85, worst: 8, best: 1\n",
      "cumulative: ≤2:6%, ≤3:49%, ≤4:89%, ≤5:97%, ≤6:99.5%, ≤7:99.9%, ≤8:100%, ≤9:100%, ≤10:100%\n",
      "CPU times: user 2.08 s, sys: 31.5 ms, total: 2.11 s\n",
      "Wall time: 2.12 s\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "%time report_minimizing_tree(neg_entropy, inconsistent=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The random guesser is also a consistent guesser. Here is a report on it (each run will give slightly different results):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "median: 4 guesses, mean: 4.09 ± 1.04, worst: 9, best: 2\n",
      "cumulative: ≤2:4%, ≤3:29%, ≤4:69%, ≤5:92%, ≤6:98%, ≤7:99.7%, ≤8:99.9%, ≤9:100%, ≤10:100%\n",
      "CPU times: user 1.92 s, sys: 34.5 ms, total: 1.96 s\n",
      "Wall time: 1.96 s\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "%time report(play(random_guesser, target=target, verbose=False) for target in wordlist)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The random guesser strategy might have seemed hopelessly naive, but it is actually a pretty decent strategy, with mean number of guesses only about 15% worse than the best minimizing tree, and the same median number of guesses, 4. However, it does lose the game (by scoring more than 6) about 2% of the time."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Reports on Inconsistent Wordle Guessers\n",
    "Now we'll report on trees with inconsistent guesses allowed. This will take double or triple as much time for each run."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "minimizing the max of partition sizes over 2,309 targets; inconsistent guesses allowed\n",
      "first guess: \"ARISE\"\n",
      "median: 4 guesses, mean: 3.64 ± 0.66, worst: 6, best: 1\n",
      "cumulative: ≤2:2%, ≤3:42%, ≤4:93%, ≤5:99.5%, ≤6:100%, ≤7:100%, ≤8:100%, ≤9:100%, ≤10:100%\n",
      "CPU times: user 6.48 s, sys: 141 ms, total: 6.62 s\n",
      "Wall time: 6.78 s\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "%time report_minimizing_tree(max, inconsistent=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "minimizing the expectation of partition sizes over 2,309 targets; inconsistent guesses allowed\n",
      "first guess: \"RAISE\"\n",
      "median: 4 guesses, mean: 3.55 ± 0.64, worst: 6, best: 1\n",
      "cumulative: ≤2:2%, ≤3:48%, ≤4:95%, ≤5:99.6%, ≤6:100%, ≤7:100%, ≤8:100%, ≤9:100%, ≤10:100%\n",
      "CPU times: user 6.62 s, sys: 94.8 ms, total: 6.71 s\n",
      "Wall time: 6.78 s\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "%time report_minimizing_tree(expectation, inconsistent=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "minimizing the neg_entropy of partition sizes over 2,309 targets; inconsistent guesses allowed\n",
      "first guess: \"RAISE\"\n",
      "median: 3 guesses, mean: 3.52 ± 0.64, worst: 6, best: 1\n",
      "cumulative: ≤2:2%, ≤3:50%, ≤4:95%, ≤5:99.6%, ≤6:100%, ≤7:100%, ≤8:100%, ≤9:100%, ≤10:100%\n",
      "CPU times: user 6.96 s, sys: 93 ms, total: 7.06 s\n",
      "Wall time: 7.21 s\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAX4AAAEICAYAAABYoZ8gAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAAU5UlEQVR4nO3de9RddX3n8fdHwBvaAhIYFGmsQ1HrFC8RsThWuSgKA6jF4gw2q9JSW4vYq9HpzXa6BnXqWF2tLRUxs1AsVSmILDGN0I4dCwZEhEaalkaLBBJFxUtFIt/5Y/9SHx6SPIeYvZ/A7/1a61n78pxzvt/D5XP289tn/3aqCklSPx602A1IkqZl8EtSZwx+SeqMwS9JnTH4JakzBr8kdWb3MV88yXrg68B3gc1VtSzJPsBfAEuB9cDLquorY/YhSfqejPk9/hb8y6rqS3P2vRm4varOSrIC2LuqXre919l3331r6dKlo/UpSQ9EV1999Zeqasn8/aMe8W/DicBz2/pK4Apgu8G/dOlS1qxZM25XkvQAk+TzW9s/9hh/AR9LcnWS09u+/atqA0Bb7jdyD5KkOcY+4j+iqm5Jsh+wKsnnZn1i+6A4HeCggw4aqz9J6s6oR/xVdUtbbgQuBA4DbktyAEBbbtzGc8+uqmVVtWzJknsNUUmSdtBowZ9kzySP3LIOPB+4HrgYWN4ethy4aKweJEn3NuZQz/7AhUm21HlfVX00yaeAC5KcBnwBOHnEHiRJ84wW/FV1E3DoVvZ/GThqrLqSpO3zyl1J6ozBL0mdMfglqTOLceWuJrB0xUcmq7X+rOMmqyXp++cRvyR1xuCXpM4Y/JLUGYNfkjpj8EtSZwx+SeqMwS9JnTH4JakzBr8kdcbgl6TOGPyS1BmDX5I6Y/BLUmcMfknqjNMya6eacjpocEpoaUd4xC9JnTH4JakzBr8kdcbgl6TOGPyS1BmDX5I6Y/BLUmcMfknqjMEvSZ0x+CWpMwa/JHXG4Jekzhj8ktQZg1+SOmPwS1JnRg/+JLsl+XSSS9r2PklWJVnXlnuP3YMk6XumOOI/E1g7Z3sFsLqqDgZWt21J0kRGDf4kBwLHAe+as/tEYGVbXwmcNGYPkqR7GvuI/23AbwB3z9m3f1VtAGjL/UbuQZI0x2jBn+R4YGNVXb2Dzz89yZokazZt2rSTu5Okfo15xH8EcEKS9cD7gSOTnAfcluQAgLbcuLUnV9XZVbWsqpYtWbJkxDYlqS+jBX9Vvb6qDqyqpcApwMer6lTgYmB5e9hy4KKxepAk3dtifI//LOCYJOuAY9q2JGkiu09RpKquAK5o618GjpqiriTp3rxyV5I6Y/BLUmcMfknqjMEvSZ0x+CWpMwa/JHXG4Jekzhj8ktQZg1+SOmPwS1JnDH5J6ozBL0mdMfglqTMGvyR1xuCXpM4Y/JLUGYNfkjpj8EtSZwx+SeqMwS9JnTH4JakzBr8kdcbgl6TOGPyS1BmDX5I6Y/BLUmcMfknqjMEvSZ0x+CWpMwa/JHXG4JekziwY/ElOTvLItv6bST6U5GnjtyZJGsMsR/y/VVVfT/Js4AXASuCd47YlSRrLLMH/3bY8DnhnVV0EPHi8liRJY5ol+L+Y5M+AlwGXJnnILM9L8tAkVyX5TJIbkryx7d8nyaok69py7+/vLUiS7otZgv9lwGXAsVX1VWAf4NdneN6dwJFVdSjwFODYJIcDK4DVVXUwsLptS5ImsmDwV9W3gI3As9uuzcC6GZ5XVfWNtrlH+yngRIbzBLTlSfetZUnS92OWIZvfAV4HvL7t2gM4b5YXT7JbkmsZPjhWVdWVwP5VtQGgLffbgb4lSTtolqGeFwMnAN8EqKpbgEfO8uJV9d2qegpwIHBYkifP2liS05OsSbJm06ZNsz5NkrSAWYL/O1VVDMM0JNnzvhZp5wauAI4FbktyQHutAxj+Gtjac86uqmVVtWzJkiX3taQkaRtmCf4L2rd69kryc8BfA3++0JOSLEmyV1t/GHA08DngYmB5e9hy4KId6FuStIN2394vkwT4C+AJwB3AIcBvV9WqGV77AGBlkt0YPmAuqKpLknyS4cPkNOALwMnfzxuQJN032w3+qqokf1VVTwdmCfu5z70OeOpW9n8ZOOo+dSlJ2mlmGer5+yTPGL0TSdIktnvE3zwPeFWS9Qzf7AnDHwM/NmZjkqRxzBL8Lxy9C0nSZGa5cvfzwF7Af2k/e7V9kqT7oVmu3D0TeC/DFbb7AeclOWPsxiRJ45hlqOc04JlV9U2AJG8CPgm8Y8zGJEnjmOVbPeF7c/LT1jNOO5Kksc1yxH8ucGWSC9v2ScA5o3UkSRrVgsFfVW9NcgXDtMwBfqaqPj12Y5KkcSwY/O3mKTdU1TVt+5FJntmmWJYk3c/MMsb/TuAbc7a/iTdbl6T7rZlO7rZpmQGoqruZ7dyAJGkXNEvw35TkNUn2aD9nAjeN3ZgkaRyzBP+rgB8HvgjcDDwTOH3MpiRJ45nlWz0bgVMm6EWSNIFZpmx4c5IfaMM8q5N8KcmpUzQnSdr5ZhnqeX5V3QEczzDU8yPAr4/alSRpNLME/x5t+SLg/Kq6fcR+JEkjm+VrmR9O8jng34BfTLIE+Pa4bUmSxjLLfPwrgGcBy6rqLuBbwIljNyZJGsdMF2JV1VfmrH+T4epdSdL90Cxj/JKkB5BtBn+SI9ryIdO1I0ka2/aO+N/elp+cohFJ0jS2N8Z/V5Jzgcckefv8X1bVa8ZrS5I0lu0F//HA0cCRwNXTtCNJGts2g7+qvgS8P8naqvrMhD1JkkY0y7d6vpzkwiQbk9yW5INJDhy9M0nSKGYJ/nOBi4FHA48BPtz2SZLuh2YJ/v2q6tyq2tx+3gMsGbkvSdJIZgn+TUlOTbJb+zkV+PLYjUmSxjFL8L8SeBlwK7AB+Mm2T5J0PzTLHbi+AJwwQS+SpAk4V48kdWa04E/y2CSXJ1mb5IYkZ7b9+yRZlWRdW+49Vg+SpHsb84h/M/CrVfVE4HDg1UmeBKwAVlfVwcDqti1JmsjMwZ/k8CQfT/J3SU5a6PFVtaGqrmnrXwfWMlwHcCKwsj1sJbDga0mSdp5tntxN8h+q6tY5u36F4SRvgP8H/NWsRZIsBZ4KXAnsX1UbYPhwSLLffW9bkrSjtvetnj9NcjXwlqr6NvBV4L8CdwN3zFogySOADwKvrao7ksz6vNOB0wEOOuigWctJkhawzaGeqjoJuBa4JMkrgNcyhP7DmXF4JskeDKH/3qr6UNt9W5ID2u8PADZuo/7ZVbWsqpYtWeKFwpK0s2x3jL+qPgy8ANgL+BBwY1W9vao2LfTCGQ7tzwHWVtVb5/zqYmB5W18OXLQDfUuSdtD2br14QpJPAB8HrgdOAV6c5Pwkj5/htY8AXgEcmeTa9vMi4CzgmCTrgGPatiRpItsb4/8fwLOAhwGXVtVhwK8kORj4A4YPgm2qqk8wnAjemqN2oFdJ0k6wveD/GkO4P4w54/BVtY4FQl+StOva3hj/ixlO5G5m+DaPJOkBYKFbL75jwl4kSRNwkjZJ6ozBL0mdMfglqTMGvyR1xuCXpM4Y/JLUGYNfkjpj8EtSZwx+SeqMwS9JnTH4JakzBr8kdcbgl6TOGPyS1BmDX5I6Y/BLUmcMfknqjMEvSZ0x+CWpMwa/JHXG4Jekzhj8ktQZg1+SOmPwS1JnDH5J6ozBL0mdMfglqTMGvyR1xuCXpM4Y/JLUGYNfkjozWvAneXeSjUmun7NvnySrkqxry73Hqi9J2roxj/jfAxw7b98KYHVVHQysbtuSpAmNFvxV9bfA7fN2nwisbOsrgZPGqi9J2rqpx/j3r6oNAG2538T1Jal7u+zJ3SSnJ1mTZM2mTZsWux1JesCYOvhvS3IAQFtu3NYDq+rsqlpWVcuWLFkyWYOS9EA3dfBfDCxv68uBiyauL0ndG/PrnOcDnwQOSXJzktOAs4BjkqwDjmnbkqQJ7T7WC1fVy7fxq6PGqilJWtgue3JXkjQOg1+SOmPwS1JnDH5J6ozBL0mdMfglqTMGvyR1xuCXpM4Y/JLUGYNfkjpj8EtSZwx+SeqMwS9JnTH4JakzBr8kdcbgl6TOGPyS1BmDX5I6Y/BLUmdGu+euNLWlKz4yab31Zx03aT1pZ/GIX5I6Y/BLUmcMfknqjMEvSZ0x+CWpMwa/JHXG4Jekzhj8ktQZL+AakRcUSdoVecQvSZ0x+CWpMwa/JHXG4Jekzhj8ktSZRQn+JMcmuTHJPyVZsRg9SFKvJg/+JLsBfwy8EHgS8PIkT5q6D0nq1WJ8j/8w4J+q6iaAJO8HTgT+YRF6kXYKr9nQ/cliDPU8BvjXOds3t32SpAmkqqYtmJwMvKCqfrZtvwI4rKrOmPe404HT2+YhwI2TNgr7Al+auOZi1+7xPfdau8f33GPtH6qqJfN3LsZQz83AY+dsHwjcMv9BVXU2cPZUTc2XZE1VLeupdo/vudfaPb7nnmvPtxhDPZ8CDk7yuCQPBk4BLl6EPiSpS5Mf8VfV5iS/BFwG7Aa8u6pumLoPSerVoszOWVWXApcuRu37YNGGmRaxdo/vudfaPb7nnmvfw+QndyVJi8spGySpMwb/PEnenWRjkusnrvvYJJcnWZvkhiRnTlj7oUmuSvKZVvuNU9Vu9XdL8ukkl0xZt9Ven+SzSa5NsmbCunsl+UCSz7V/58+aqO4h7b1u+bkjyWunqN3q/3L7b+z6JOcneehEdc9sNW8Y+/1uLUOS7JNkVZJ1bbn3mD0sxOC/t/cAxy5C3c3Ar1bVE4HDgVdPOJXFncCRVXUo8BTg2CSHT1Qb4Exg7YT15nteVT1l4q/a/RHw0ap6AnAoE73/qrqxvdenAE8HvgVcOEXtJI8BXgMsq6onM3y545QJ6j4Z+DmGWQMOBY5PcvCIJd/DvTNkBbC6qg4GVrftRWPwz1NVfwvcvgh1N1TVNW396wxBMMkVzTX4Rtvco/1McvInyYHAccC7pqi3K0jyA8BzgHMAquo7VfXVRWjlKOCfq+rzE9bcHXhYkt2Bh7OVa3hG8ETg76vqW1W1Gfgb4MVjFdtGhpwIrGzrK4GTxqo/C4N/F5RkKfBU4MoJa+6W5FpgI7Cqqqaq/TbgN4C7J6o3XwEfS3J1u1p8Cj8MbALObUNc70qy50S15zoFOH+qYlX1ReB/AV8ANgBfq6qPTVD6euA5SR6V5OHAi7jnRaRT2L+qNsBwkAfsN3H9ezD4dzFJHgF8EHhtVd0xVd2q+m778/9A4LD25/GokhwPbKyqq8eutR1HVNXTGGaLfXWS50xQc3fgacA7q+qpwDeZ+E//dvHkCcBfTlhzb4Yj38cBjwb2THLq2HWrai3wJmAV8FHgMwxDq90y+HchSfZgCP33VtWHFqOHNuRwBdOc5zgCOCHJeuD9wJFJzpug7r+rqlvaciPDWPdhE5S9Gbh5zl9VH2D4IJjSC4Frquq2CWseDfxLVW2qqruADwE/PkXhqjqnqp5WVc9hGIZZN0XdOW5LcgBAW26cuP49GPy7iCRhGPNdW1Vvnbj2kiR7tfWHMfwP+rmx61bV66vqwKpayjDs8PGqGv0IcIskeyZ55JZ14PkMwwKjqqpbgX9NckjbdRTTT0v+ciYc5mm+ABye5OHtv/ejmOikdpL92vIg4CVM/94vBpa39eXARRPXv4dFuXJ3V5bkfOC5wL5JbgZ+p6rOmaD0EcArgM+2sXaAN7SrnMd2ALCy3STnQcAFVTX5VysXwf7AhUMGsTvwvqr66ES1zwDe24ZcbgJ+ZqK6tHHuY4Cfn6omQFVdmeQDwDUMQy2fZrqrWT+Y5FHAXcCrq+orYxXaWoYAZwEXJDmN4QPw5LHqz8IrdyWpMw71SFJnDH5J6ozBL0mdMfglqTMGvyR1xuDXoktSSf5wzvavJfndnfTa70nykzvjtRaoc3KbZfPysWtJ3y+DX7uCO4GXJNl3sRuZq13XMKvTgF+squeN1Y+0sxj82hVsZriQ55fn/2L+EXuSb7Tlc5P8TZILkvxjkrOS/Ld2X4HPJnn8nJc5Osn/bY87vj1/tyRvSfKpJNcl+fk5r3t5kvcBn91KPy9vr399kje1fb8NPBv40yRvmff4ByX5kzYP/CVJLt3yfjLcC2Dftr4syRVtfc82p/un2iRuJ7b9P9re37Wt54PbYz+S4V4K1yf5qfbYp7d/PlcnuWzOdAGvSfIP7fnv34F/V3oA8Mpd7Sr+GLguyZvvw3MOZZhy93aGq1/fVVWHZbiJzRnAa9vjlgI/ATweuDzJfwR+mmF2yGckeQjwd0m2zBR5GPDkqvqXucWSPJphsq+nA19hmNXzpKr6vSRHAr9WVfNv5vKSVv8/MczIuBZ49wLv678zTF/xyjaVxlVJ/hp4FfBHVbXlit/dGGaavKWqjms9/mCb8+kdwIlVtal9GPwB8EqGyeAeV1V3bpmmQ/3xiF+7hDYT6f9huFHHrD7V7mNwJ/DPwJbg/ixD2G5xQVXdXVXrGD4gnsAwL89Pt+kxrgQeBWy5OcdV80O/eQZwRZtkbDPwXoZ59bfn2cBftvq3ArOcA3g+sKL1dgXwUOAg4JPAG5K8Dvihqvq39l6PTvKmJP+5qr4GHAI8GVjVXuM3GWZdBbiOYaqIU+l8hsqeecSvXcnbGOZxOXfOvs20A5Q2sdeD5/zuzjnrd8/Zvpt7/rc9f16SAgKcUVWXzf1FkucyTJO8NVmg//v6nH9/bwzhPvc5L62qG+c9fm2SKxluXHNZkp+tqo8neTrDkf//bH+1XAjcUFVbu53jcQwfVicAv5XkR9uHmDriEb92GVV1O3ABw4nSLdYzDK3AMJf7Hjvw0ie3sfbHM9wE5UbgMuAX2rAISX4kC98M5UrgJ5Ls2078vpzhbk7b8wngpa3+/gyTd22xnu+9t5fO2X8ZcEb7oCPJU9vyh4GbqurtDLM9/lgbfvpWVZ3HcJOTp7X3tyTtPr5J9mjnBx4EPLaqLme4+c1ewCMW6F8PQB7xa1fzh8Avzdn+c+CiJFcx3Kt0W0fj23MjQ0DvD7yqqr6d5F0Mw0HXtIDdxAK3w6uqDUlezzBcE+DSqlpoet0PMkw/fD3wjwwfHl9rv3sjcE6SN3DPu639PsNfP9e13tYDxwM/BZya5C7gVuD3GIaf3pLkboaZJ3+hqr7TTiC/PckPMvx//rZW/7y2L8D/XqRbPmqROTunNLIkj6iqb2SYFvgqhrt+3brYfalfHvFL47ukfYPmwcDvG/pabB7xS1JnPLkrSZ0x+CWpMwa/JHXG4Jekzhj8ktQZg1+SOvP/AYfpzOWsEP3lAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "%time report_minimizing_tree(neg_entropy, inconsistent=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Mission accomplished!** With inconsistent guesses allowed, all three metrics  solve every target word in 6 guesses or less. \n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Best and Worst First Guesses\n",
    "\n",
    "Below we create a table of the best and worst first guesses (that is, the guesses that score the highest and lowest  according to each of the three metrics):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "\n",
    "def first_guesses(targets) -> pd.DataFrame: \n",
    "    \"\"\"A data frame of words and scores on the 3 metrics, sorted best to worst on each metric.\"\"\"\n",
    "    metrics = (max, expectation, neg_entropy)\n",
    "    data = [sorted((metric(partition_counts(g, targets)), g) for g in wordlist)\n",
    "            for metric in metrics]\n",
    "    def reformat(row):\n",
    "        (val1, word1), (val2, word2), (val3, word3) = row\n",
    "        return [word1, val1, word2, round(val2, 2), word3, round(val3, 3)]\n",
    "    return pd.DataFrame(map(reformat, zip(*data)), \n",
    "                        columns='max_word max_score exp_word exp_score ent_word ent_score'.split())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The best and worst first guesses for Wordle:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>max_word</th>\n",
       "      <th>max_score</th>\n",
       "      <th>exp_word</th>\n",
       "      <th>exp_score</th>\n",
       "      <th>ent_word</th>\n",
       "      <th>ent_score</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>ARISE</td>\n",
       "      <td>167</td>\n",
       "      <td>RAISE</td>\n",
       "      <td>60.74</td>\n",
       "      <td>RAISE</td>\n",
       "      <td>-5.878</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>RAISE</td>\n",
       "      <td>167</td>\n",
       "      <td>ARISE</td>\n",
       "      <td>63.47</td>\n",
       "      <td>SLATE</td>\n",
       "      <td>-5.856</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>ALONE</td>\n",
       "      <td>182</td>\n",
       "      <td>IRATE</td>\n",
       "      <td>63.49</td>\n",
       "      <td>CRATE</td>\n",
       "      <td>-5.835</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>AROSE</td>\n",
       "      <td>182</td>\n",
       "      <td>AROSE</td>\n",
       "      <td>65.76</td>\n",
       "      <td>IRATE</td>\n",
       "      <td>-5.833</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>RATIO</td>\n",
       "      <td>190</td>\n",
       "      <td>ALTER</td>\n",
       "      <td>69.83</td>\n",
       "      <td>TRACE</td>\n",
       "      <td>-5.830</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2304</th>\n",
       "      <td>CIVIC</td>\n",
       "      <td>1247</td>\n",
       "      <td>PUPPY</td>\n",
       "      <td>775.34</td>\n",
       "      <td>FIZZY</td>\n",
       "      <td>-2.506</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2305</th>\n",
       "      <td>PUPPY</td>\n",
       "      <td>1283</td>\n",
       "      <td>MAMMA</td>\n",
       "      <td>776.30</td>\n",
       "      <td>MUMMY</td>\n",
       "      <td>-2.480</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2306</th>\n",
       "      <td>MUMMY</td>\n",
       "      <td>1321</td>\n",
       "      <td>VIVID</td>\n",
       "      <td>812.76</td>\n",
       "      <td>MAMMA</td>\n",
       "      <td>-2.398</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2307</th>\n",
       "      <td>VIVID</td>\n",
       "      <td>1324</td>\n",
       "      <td>MUMMY</td>\n",
       "      <td>817.96</td>\n",
       "      <td>JAZZY</td>\n",
       "      <td>-2.309</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2308</th>\n",
       "      <td>FUZZY</td>\n",
       "      <td>1349</td>\n",
       "      <td>FUZZY</td>\n",
       "      <td>854.18</td>\n",
       "      <td>FUZZY</td>\n",
       "      <td>-2.304</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>2309 rows × 6 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "     max_word  max_score exp_word  exp_score ent_word  ent_score\n",
       "0       ARISE        167    RAISE      60.74    RAISE     -5.878\n",
       "1       RAISE        167    ARISE      63.47    SLATE     -5.856\n",
       "2       ALONE        182    IRATE      63.49    CRATE     -5.835\n",
       "3       AROSE        182    AROSE      65.76    IRATE     -5.833\n",
       "4       RATIO        190    ALTER      69.83    TRACE     -5.830\n",
       "...       ...        ...      ...        ...      ...        ...\n",
       "2304    CIVIC       1247    PUPPY     775.34    FIZZY     -2.506\n",
       "2305    PUPPY       1283    MAMMA     776.30    MUMMY     -2.480\n",
       "2306    MUMMY       1321    VIVID     812.76    MAMMA     -2.398\n",
       "2307    VIVID       1324    MUMMY     817.96    JAZZY     -2.309\n",
       "2308    FUZZY       1349    FUZZY     854.18    FUZZY     -2.304\n",
       "\n",
       "[2309 rows x 6 columns]"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df = first_guesses(wordlist)\n",
    "df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The top guesses are `\"RAISE\"` and its anagram `\"ARISE\"`. The letters `'A'`, `'R'`, and `'E'` are the most common in the top guesses. The three metrics agree that `'FUZZY'` is the worst first guess.\n",
    "\n",
    "Here are the top 20 words for each metric:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>max_word</th>\n",
       "      <th>max_score</th>\n",
       "      <th>exp_word</th>\n",
       "      <th>exp_score</th>\n",
       "      <th>ent_word</th>\n",
       "      <th>ent_score</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>ARISE</td>\n",
       "      <td>167</td>\n",
       "      <td>RAISE</td>\n",
       "      <td>60.74</td>\n",
       "      <td>RAISE</td>\n",
       "      <td>-5.878</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>RAISE</td>\n",
       "      <td>167</td>\n",
       "      <td>ARISE</td>\n",
       "      <td>63.47</td>\n",
       "      <td>SLATE</td>\n",
       "      <td>-5.856</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>ALONE</td>\n",
       "      <td>182</td>\n",
       "      <td>IRATE</td>\n",
       "      <td>63.49</td>\n",
       "      <td>CRATE</td>\n",
       "      <td>-5.835</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>AROSE</td>\n",
       "      <td>182</td>\n",
       "      <td>AROSE</td>\n",
       "      <td>65.76</td>\n",
       "      <td>IRATE</td>\n",
       "      <td>-5.833</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>RATIO</td>\n",
       "      <td>190</td>\n",
       "      <td>ALTER</td>\n",
       "      <td>69.83</td>\n",
       "      <td>TRACE</td>\n",
       "      <td>-5.830</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>ATONE</td>\n",
       "      <td>191</td>\n",
       "      <td>SANER</td>\n",
       "      <td>70.02</td>\n",
       "      <td>ARISE</td>\n",
       "      <td>-5.821</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>IRATE</td>\n",
       "      <td>193</td>\n",
       "      <td>LATER</td>\n",
       "      <td>70.03</td>\n",
       "      <td>STARE</td>\n",
       "      <td>-5.807</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>AISLE</td>\n",
       "      <td>196</td>\n",
       "      <td>SNARE</td>\n",
       "      <td>71.02</td>\n",
       "      <td>SNARE</td>\n",
       "      <td>-5.769</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>ALERT</td>\n",
       "      <td>196</td>\n",
       "      <td>STARE</td>\n",
       "      <td>71.05</td>\n",
       "      <td>AROSE</td>\n",
       "      <td>-5.768</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>ALTER</td>\n",
       "      <td>196</td>\n",
       "      <td>SLATE</td>\n",
       "      <td>71.28</td>\n",
       "      <td>LEAST</td>\n",
       "      <td>-5.752</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>10</th>\n",
       "      <td>LATER</td>\n",
       "      <td>196</td>\n",
       "      <td>ALERT</td>\n",
       "      <td>71.51</td>\n",
       "      <td>ALERT</td>\n",
       "      <td>-5.744</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>11</th>\n",
       "      <td>TEARY</td>\n",
       "      <td>198</td>\n",
       "      <td>CRATE</td>\n",
       "      <td>72.81</td>\n",
       "      <td>CRANE</td>\n",
       "      <td>-5.741</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>12</th>\n",
       "      <td>LEANT</td>\n",
       "      <td>207</td>\n",
       "      <td>TRACE</td>\n",
       "      <td>73.95</td>\n",
       "      <td>STALE</td>\n",
       "      <td>-5.738</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>13</th>\n",
       "      <td>LEARN</td>\n",
       "      <td>212</td>\n",
       "      <td>STALE</td>\n",
       "      <td>75.33</td>\n",
       "      <td>SANER</td>\n",
       "      <td>-5.734</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>14</th>\n",
       "      <td>RENAL</td>\n",
       "      <td>212</td>\n",
       "      <td>AISLE</td>\n",
       "      <td>76.09</td>\n",
       "      <td>ALTER</td>\n",
       "      <td>-5.713</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>15</th>\n",
       "      <td>EARLY</td>\n",
       "      <td>215</td>\n",
       "      <td>LEARN</td>\n",
       "      <td>76.72</td>\n",
       "      <td>LATER</td>\n",
       "      <td>-5.707</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>16</th>\n",
       "      <td>LAYER</td>\n",
       "      <td>215</td>\n",
       "      <td>LEANT</td>\n",
       "      <td>77.09</td>\n",
       "      <td>REACT</td>\n",
       "      <td>-5.697</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>17</th>\n",
       "      <td>LOSER</td>\n",
       "      <td>215</td>\n",
       "      <td>ALONE</td>\n",
       "      <td>77.16</td>\n",
       "      <td>TRADE</td>\n",
       "      <td>-5.684</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>18</th>\n",
       "      <td>RELAY</td>\n",
       "      <td>215</td>\n",
       "      <td>LEAST</td>\n",
       "      <td>77.97</td>\n",
       "      <td>LEANT</td>\n",
       "      <td>-5.684</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>19</th>\n",
       "      <td>CANOE</td>\n",
       "      <td>216</td>\n",
       "      <td>CRANE</td>\n",
       "      <td>78.69</td>\n",
       "      <td>LEARN</td>\n",
       "      <td>-5.652</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   max_word  max_score exp_word  exp_score ent_word  ent_score\n",
       "0     ARISE        167    RAISE      60.74    RAISE     -5.878\n",
       "1     RAISE        167    ARISE      63.47    SLATE     -5.856\n",
       "2     ALONE        182    IRATE      63.49    CRATE     -5.835\n",
       "3     AROSE        182    AROSE      65.76    IRATE     -5.833\n",
       "4     RATIO        190    ALTER      69.83    TRACE     -5.830\n",
       "5     ATONE        191    SANER      70.02    ARISE     -5.821\n",
       "6     IRATE        193    LATER      70.03    STARE     -5.807\n",
       "7     AISLE        196    SNARE      71.02    SNARE     -5.769\n",
       "8     ALERT        196    STARE      71.05    AROSE     -5.768\n",
       "9     ALTER        196    SLATE      71.28    LEAST     -5.752\n",
       "10    LATER        196    ALERT      71.51    ALERT     -5.744\n",
       "11    TEARY        198    CRATE      72.81    CRANE     -5.741\n",
       "12    LEANT        207    TRACE      73.95    STALE     -5.738\n",
       "13    LEARN        212    STALE      75.33    SANER     -5.734\n",
       "14    RENAL        212    AISLE      76.09    ALTER     -5.713\n",
       "15    EARLY        215    LEARN      76.72    LATER     -5.707\n",
       "16    LAYER        215    LEANT      77.09    REACT     -5.697\n",
       "17    LOSER        215    ALONE      77.16    TRADE     -5.684\n",
       "18    RELAY        215    LEAST      77.97    LEANT     -5.684\n",
       "19    CANOE        216    CRANE      78.69    LEARN     -5.652"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df[:20]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We see below that partitioning with the guess`'RAISE'` will leave us with no more than 167 words in any branch, while `'FUZZY'` is likely to leave us with a branch of 1349 words, and about 80% of the time will leave us with a branch of 228 words or more."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Counter({1: 28,\n",
       "         2: 13,\n",
       "         3: 5,\n",
       "         4: 10,\n",
       "         5: 8,\n",
       "         6: 4,\n",
       "         7: 3,\n",
       "         8: 4,\n",
       "         9: 4,\n",
       "         10: 2,\n",
       "         12: 3,\n",
       "         13: 2,\n",
       "         14: 1,\n",
       "         15: 2,\n",
       "         17: 3,\n",
       "         18: 2,\n",
       "         19: 1,\n",
       "         20: 4,\n",
       "         21: 2,\n",
       "         22: 1,\n",
       "         23: 2,\n",
       "         24: 1,\n",
       "         25: 1,\n",
       "         26: 4,\n",
       "         28: 2,\n",
       "         29: 1,\n",
       "         34: 2,\n",
       "         35: 1,\n",
       "         40: 1,\n",
       "         41: 2,\n",
       "         43: 1,\n",
       "         51: 1,\n",
       "         61: 1,\n",
       "         69: 1,\n",
       "         77: 1,\n",
       "         80: 1,\n",
       "         91: 2,\n",
       "         102: 1,\n",
       "         103: 1,\n",
       "         107: 1,\n",
       "         120: 1,\n",
       "         167: 1})"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Counter(partition_counts('RAISE', wordlist))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Counter({1: 12,\n",
       "         2: 2,\n",
       "         3: 1,\n",
       "         4: 2,\n",
       "         5: 2,\n",
       "         6: 1,\n",
       "         7: 1,\n",
       "         8: 1,\n",
       "         10: 2,\n",
       "         16: 1,\n",
       "         20: 1,\n",
       "         45: 1,\n",
       "         51: 2,\n",
       "         84: 1,\n",
       "         122: 1,\n",
       "         228: 1,\n",
       "         265: 1,\n",
       "         1349: 1})"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Counter(partition_counts('FUZZY', wordlist))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Evil Wordle\n",
    "\n",
    "The [**Evil Wordle**](https://swag.github.io/evil-wordle/) variant says it works like this: *\"There's no [target] word set by default. Every time you guess, I look at all possible 5-letter words that would fit all your guesses, and choose the match pattern [reply] that results in the most possible words. My goal is to maximize the amount of guesses it takes to find the word.\"*\n",
    "\n",
    "To play against Evil Wordle, minimizing the max branch size is a good strategy. We know the guess tree that minimizes max has a few branches that require 6 guesses. If the Evil Replier did look-ahead, perhaps they could get to one of those branches. But we know that the Evil Replier greedily picks the branch with the \"most possible words.\" So I will define `evil` to follow branches through a guess tree and produce the (guess, reply) pairs along the way. For a given tree, there is only one possible game (assuming the Evil Replier breaks ties the same way each time)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "def evil(tree) -> List[Tuple[Word, Reply]]:\n",
    "    \"\"\"Given a guess tree, determine what happens when the Evil Replier always picks a maximum-sized branch.\n",
    "    The result is a list of (guess, reply) tuples.\"\"\"\n",
    "    if isinstance(tree, Word):\n",
    "        return [(tree, Correct)]\n",
    "    else:\n",
    "        def size(reply): \n",
    "            branch = tree.branches[reply]\n",
    "            return 0 if reply == Correct else 1 if isinstance(branch, Word) else branch.size\n",
    "        reply = max(tree.branches, key=size)\n",
    "        return [(tree.guess, reply)] + evil(tree.branches[reply])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('ARISE', '.....'),\n",
       " ('BLOND', '.....'),\n",
       " ('DUMPY', '.YYY.'),\n",
       " ('CHUMP', '.GGGG'),\n",
       " ('THUMP', 'GGGGG')]"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "evil(minimizing_tree(max, wordlist, inconsistent=True))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We see that the one possible game consists of 5 guesses. That raises two questions:\n",
    "- Would it be possible for a smarter Guesser to create a different tree (perhaps minimizing something other than max) that only requires 4 guesses? **No.** I know that because (a) when there are two words left in a branch, it will always take two guesses to defeat the Evil Replier, and (b) I previously tried all two-word guess pairs to see which resulted in the smallest branches, and every pair had branches with multiple words.\n",
    "- Would it be possible for a smarter Evil Replier to force a game with 6 guesses? **Maybe.** We know the minimizing-max guess tree has 11 out of 2,309 leaves that require 6 guesses. If the Evil Replier did look-ahead instead of acting greedily, could it get to one of those? I think it is unlikely, but I would need to do a minimax search to prove it one way or the other.\n",
    "\n",
    "Alas, this is all moot, because a little experimenting shows that [**Evil Wordle**](https://swag.github.io/evil-wordle/) is using a word list that contains multiple words that are not in the 2,309 word list. I suspect it is using Wordle's 12,971–word list."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Antiwordle\n",
    "\n",
    "The Wordle variant [**Antiwordle**](https://www.antiwordle.com/) invites you to *\"Avoid guessing the hidden word in as many tries as possible. Sounds easy, but there's a catch!*\"  The catch is that only consistent guesses are allowed. We can solve Antiwordle by minimizing the entropy (not negative entropy!) of branch sizes. That is, we want big branches."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "minimizing the entropy of partition sizes over 2,309 targets; inconsistent guesses prohibited\n",
      "first guess: \"FUZZY\"\n",
      "median: 6 guesses, mean: 5.75 ± 1.61, worst: 11, best: 1\n",
      "cumulative: ≤2:1%, ≤3:8%, ≤4:23%, ≤5:44%, ≤6:68%, ≤7:87%, ≤8:96%, ≤9:99%, ≤10:99.7%\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "def entropy(counts: List[int]) -> float: return -neg_entropy(counts)\n",
    "\n",
    "report_minimizing_tree(entropy, inconsistent=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We see that, as expected, the \"worst\" word, `'FUZZY'` is the first guess. Overall, we do pretty well, surviving up to 11 guesses a few times, with a median of 6."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Jotto\n",
    "\n",
    "[Jotto](https://en.wikipedia.org/wiki/Jotto) is a venerable word game (invented in 1955) that is quite similar to Wordle. The difference is that the reply in Jotto is an integer from 0 to 5 giving the number of matching letters, with no indication of which letter(s) are correct nor whether they are in the right position or not. There are several variants of Jotto; here are four key questions and my answers:\n",
    "\n",
    "- How many letters can each word have? **Five**.\n",
    "- Does a guess have to be a word in the word list? **Yes.**\n",
    "- Can a word have repeated letters, like the \"E\" in \"ELECT\"? **No. Every word must have 5 distinct letters.**\n",
    "- What if the reply is \"5\", but the guess is not the target? **Not allowed.**<br>*(E.g., only one of the anagrams APERS/PARES/PARSE/PEARS/REAPS/SPARE/SPEAR  is allowed in the word list.)*\n",
    "\n",
    "We can make a Jotto word list by:\n",
    "- Starting with a list of words. (We'll use the Wordle word list.)\n",
    "- Discarding the ones that don't have 5 distinct letters.\n",
    "- Putting the rest into a dict of anagrams keyed by the set of letters.\n",
    "- Keeping only one word for each anagram."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "def jotto_allowable(wordlist) -> List[Word]:\n",
    "    \"\"\"Build a list of allowable Jotto words from an iterable of words.\"\"\"\n",
    "    anagrams = {frozenset(w): w for w in wordlist if len(set(w)) == 5 == len(w)}\n",
    "    return sorted(anagrams.values())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The right thing to do now would be to refactor the code to allow for the injection of a different `reply_for` function, and a different `wordlist`, so that either game could be played at any time.\n",
    "\n",
    "However, I'm going to take a shortcut: I'm going to require the programmer to call `setup_game` with the name of the game they want, `'jotto'` or `'wordle'`. This will set global variables accordingly. Notice we mutate `wordlist` rather than rebinding it, because it has already been assigned as a default parameter value in various functions, and we don't want to require the caller to explicitly override those defaults."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "wordle_reply_for = reply_for      # Save the original Wordle reply_for function\n",
    "wordle_wordlist  = list(wordlist) # Save a copy of the original Wordle wordlist, which will be mutated\n",
    "\n",
    "def jotto_reply_for(guess, target) -> Reply: \n",
    "    \"The number of letters in common between the target and guess\"\n",
    "    return len(set(target).intersection(guess))\n",
    "\n",
    "def setup_game(game: str) -> None:\n",
    "    \"Redefine global variables to allow play of either 'jotto' or 'wordle'.\"\n",
    "    global histogram_bins, reply_for, Correct\n",
    "    table = {'wordle': (10, wordle_reply_for, 5 * 'G', wordle_wordlist),\n",
    "             'jotto':  (16, jotto_reply_for,  5,       jotto_allowable(wordle_wordlist))}\n",
    "    histogram_bins, reply_for, Correct, wordlist[:] = table[game]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Guess 1: ZONAL, Reply: 1; Remaining targets: 612\n",
      "Guess 2: ZESTY, Reply: 1; Remaining targets: 288\n",
      "Guess 3: FREAK, Reply: 2; Remaining targets: 83\n",
      "Guess 4: HOMER, Reply: 2; Remaining targets: 35\n",
      "Guess 5: PLIER, Reply: 1; Remaining targets: 12\n",
      "Guess 6: BEACH, Reply: 2; Remaining targets: 6\n",
      "Guess 7: HARDY, Reply: 5; Remaining targets: 1\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "setup_game('jotto')\n",
    "play(random_guesser)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Guess 1: PROUD, Reply: 1; Remaining targets: 594\n",
      "Guess 2: QUASI, Reply: 1; Remaining targets: 307\n",
      "Guess 3: FIEND, Reply: 0; Remaining targets: 41\n",
      "Guess 4: CHART, Reply: 3; Remaining targets: 11\n",
      "Guess 5: CRAZY, Reply: 2; Remaining targets: 5\n",
      "Guess 6: MOCHA, Reply: 4; Remaining targets: 2\n",
      "Guess 7: CHAMP, Reply: 3; Remaining targets: 1\n",
      "Guess 8: HAVOC, Reply: 5; Remaining targets: 1\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "play(random_guesser)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Below we show that we can switch back to Wordle, and then back to Jotto again, and things still function properly:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Guess 1: ANGLE, Reply: .....; Remaining targets: 309\n",
      "Guess 2: WISPY, Reply: .GG.G; Remaining targets: 4\n",
      "Guess 3: RISKY, Reply: GGGGG; Remaining targets: 1\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "setup_game ('wordle')\n",
    "play(random_guesser)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Guess 1: SHARK, Reply: 1; Remaining targets: 577\n",
      "Guess 2: TWANG, Reply: 1; Remaining targets: 250\n",
      "Guess 3: BRINY, Reply: 2; Remaining targets: 69\n",
      "Guess 4: GIVER, Reply: 1; Remaining targets: 26\n",
      "Guess 5: HYMEN, Reply: 2; Remaining targets: 7\n",
      "Guess 6: MOURN, Reply: 0; Remaining targets: 3\n",
      "Guess 7: PITHY, Reply: 5; Remaining targets: 1\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "setup_game('jotto')\n",
    "play(random_guesser)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Reports on Consistent Jotto Guessers\n",
    "\n",
    "As with Wordle, we'll give reports on the Jotto guessers for various metrics, and for the random guesser:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "minimizing the max of partition sizes over 1,391 targets; inconsistent guesses prohibited\n",
      "first guess: \"DRAPE\"\n",
      "median: 6 guesses, mean: 6.31 ± 1.43, worst: 16, best: 1\n",
      "cumulative: ≤2:0%, ≤3:2%, ≤4:7%, ≤5:24%, ≤6:58%, ≤7:88%, ≤8:95%, ≤9:97%, ≤10:99%\n",
      "CPU times: user 1.4 s, sys: 13.2 ms, total: 1.41 s\n",
      "Wall time: 1.42 s\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "%time report_minimizing_tree(max, inconsistent=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "minimizing the expectation of partition sizes over 1,391 targets; inconsistent guesses prohibited\n",
      "first guess: \"SOUTH\"\n",
      "median: 6 guesses, mean: 6.11 ± 1.22, worst: 14, best: 1\n",
      "cumulative: ≤2:0%, ≤3:2%, ≤4:8%, ≤5:26%, ≤6:64%, ≤7:93%, ≤8:98%, ≤9:99%, ≤10:99.5%\n",
      "CPU times: user 1.39 s, sys: 10.9 ms, total: 1.4 s\n",
      "Wall time: 1.41 s\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "%time report_minimizing_tree(expectation, inconsistent=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "minimizing the neg_entropy of partition sizes over 1,391 targets; inconsistent guesses prohibited\n",
      "first guess: \"STARE\"\n",
      "median: 6 guesses, mean: 6.31 ± 1.46, worst: 15, best: 1\n",
      "cumulative: ≤2:0%, ≤3:2%, ≤4:8%, ≤5:25%, ≤6:58%, ≤7:87%, ≤8:95%, ≤9:97%, ≤10:98%\n",
      "CPU times: user 1.4 s, sys: 8.2 ms, total: 1.41 s\n",
      "Wall time: 1.41 s\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "%time report_minimizing_tree(neg_entropy, inconsistent=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "median: 7 guesses, mean: 6.65 ± 1.46, worst: 13, best: 2\n",
      "cumulative: ≤2:0%, ≤3:2%, ≤4:7%, ≤5:20%, ≤6:44%, ≤7:75%, ≤8:91%, ≤9:97%, ≤10:99.3%\n",
      "CPU times: user 1.49 s, sys: 7.59 ms, total: 1.5 s\n",
      "Wall time: 1.51 s\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "%time report([play(random_guesser, target=target, verbose=False) for target in wordlist])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Reports on Inconsistent Jotto Guessers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "minimizing the max of partition sizes over 1,391 targets; inconsistent guesses allowed\n",
      "first guess: \"DRAPE\"\n",
      "median: 6 guesses, mean: 6.38 ± 0.93, worst: 9, best: 1\n",
      "cumulative: ≤2:0%, ≤3:1%, ≤4:3%, ≤5:13%, ≤6:52%, ≤7:93%, ≤8:99.8%, ≤9:100%, ≤10:100%\n",
      "CPU times: user 4.54 s, sys: 27.1 ms, total: 4.56 s\n",
      "Wall time: 4.71 s\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "%time report_minimizing_tree(max, inconsistent=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "minimizing the expectation of partition sizes over 1,391 targets; inconsistent guesses allowed\n",
      "first guess: \"SOUTH\"\n",
      "median: 6 guesses, mean: 6.13 ± 0.89, worst: 9, best: 1\n",
      "cumulative: ≤2:0%, ≤3:1%, ≤4:4%, ≤5:19%, ≤6:66%, ≤7:97%, ≤8:99.9%, ≤9:100%, ≤10:100%\n",
      "CPU times: user 4.59 s, sys: 42.4 ms, total: 4.63 s\n",
      "Wall time: 4.85 s\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "%time report_minimizing_tree(expectation, inconsistent=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "minimizing the neg_entropy of partition sizes over 1,391 targets; inconsistent guesses allowed\n",
      "first guess: \"STARE\"\n",
      "median: 6 guesses, mean: 6.18 ± 0.93, worst: 9, best: 1\n",
      "cumulative: ≤2:0%, ≤3:1%, ≤4:3%, ≤5:20%, ≤6:63%, ≤7:95%, ≤8:99.7%, ≤9:100%, ≤10:100%\n",
      "CPU times: user 4.87 s, sys: 45.5 ms, total: 4.91 s\n",
      "Wall time: 4.94 s\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAX4AAAEGCAYAAABiq/5QAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAAWLklEQVR4nO3dfdhcdX3n8ffHAAqIAhIwCt1YF62taxUjYrVWQSwCy4NP1RWbXXFZbX2qqzWW1mpdrwVdrQ9XVxdBpAW1tKIguosYpa1dBQMChkabVqOCgUSpzxVBvvvH+WW9CcmduWfmTB7O+3Vdc8055575zneSuT9z7jNnfr9UFZKk4bjH9m5AkjRbBr8kDYzBL0kDY/BL0sAY/JI0MLtt7wZGccABB9TSpUu3dxuStFO5+uqrv11VizffvlME/9KlS1m1atX2bkOSdipJvr6l7R7qkaSBMfglaWAMfkkaGINfkgbG4JekgTH4JWlgDH5JGhiDX5IGxuCXpIHZKb65q53X0hUfn7jGujOOm0InkjZxj1+SBsbgl6SBMfglaWAMfkkaGINfkgbG4JekgTH4JWlgDH5JGhiDX5IGxuCXpIEx+CVpYHoP/iSLknwxyaVtff8klydZ267367sHSdLPzWKP/+XAmjnrK4CVVXUosLKtS5JmpNfgT3IwcBxw9pzNJwLnteXzgJP67EGSdFd97/G/Hfh94M452w6qqvUA7frALd0xyWlJViVZtXHjxp7blKTh6C34kxwPbKiqq8e5f1WdVVXLqmrZ4sWLp9ydJA1XnxOxPB44IcmxwL2A+yQ5H7glyZKqWp9kCbChxx4kSZvpbY+/ql5bVQdX1VLgOcCnq+oU4BJgebvZcuDivnqQJN3d9jiP/wzg6CRrgaPbuiRpRmYy525VXQFc0Za/Axw1i8eVJN2d39yVpIEx+CVpYAx+SRoYg1+SBsbgl6SBMfglaWAMfkkaGINfkgbG4JekgTH4JWlgDH5JGhiDX5IGxuCXpIEx+CVpYAx+SRoYg1+SBsbgl6SBMfglaWAMfkkaGINfkgbG4JekgTH4JWlgDH5JGhiDX5IGxuCXpIEx+CVpYAx+SRoYg1+SBsbgl6SBMfglaWAMfkkaGINfkgbG4JekgdltezcgjWrpio9PXGPdGcdNoRNp5+YevyQNjMEvSQNj8EvSwBj8kjQwBr8kDUxvwZ/kXkmuSnJdkhuSvKFt3z/J5UnWtuv9+upBknR3fe7x3wYcWVW/CjwSOCbJEcAKYGVVHQqsbOuSpBnpLfir88O2unu7FHAicF7bfh5wUl89SJLurtdj/EkWJbkW2ABcXlVXAgdV1XqAdn3gVu57WpJVSVZt3LixzzYlaVB6Df6q+llVPRI4GDg8ycMXcN+zqmpZVS1bvHhxbz1K0tDM5KyeqvoucAVwDHBLkiUA7XrDLHqQJHX6PKtncZJ92/KewFOALwOXAMvbzZYDF/fVgyTp7vocpG0JcF6SRXRvMBdW1aVJPgdcmORU4BvAs3rsQZK0md6Cv6quBx61he3fAY7q63ElSfPzm7uSNDAGvyQNjMEvSQOzzeBP8qwk+7TlP0xyUZLD+m9NktSHUfb4/6iqfpDkCcBv0g2z8O5+25Ik9WWU4P9Zuz4OeHdVXQzs0V9LkqQ+jRL8NyX5X8CzgU8kueeI95Mk7YBGCfBnA5cBx7ShF/YHXt1nU5Kk/mwz+Kvqx3Tj6TyhbboDWNtnU5Kk/oxyVs8fA68BXts27Q6c32dTkqT+jHKo52TgBOBHAFX1LWCfPpuSJPVnlOD/aVUV3exZJNm735YkSX0aJfgvbGf17JvkPwOfAt7bb1uSpL7MOzpnkgB/CfwS8H3gocDrquryGfQmSerBvMFfVZXko1X1aMCwl6RdwCiHej6f5DG9dyJJmolRJmJ5MvCiJOvozuwJ3R8Dj+izMUlSP0YJ/qf13oUkaWZG+ebu14F9gX/fLvu2bZKkndAo39x9OXABcGC7nJ/kpX03JknqxyiHek4FHltVPwJIcibwOeBdfTYmSerHKGf1hJ+PyU9bTj/tSJL6Nsoe/7nAlUk+0tZPAs7prSNJUq+2GfxV9bYkV9ANyxzgP1XVF/tuTJLUj20Gf5IjgBuq6pq2vk+Sx1bVlb13J0maulGO8b8b+OGc9R/hZOuStNMa6cPdNiwzAFV1J6N9NiBJ2gGNEvxfTfKyJLu3y8uBr/bdmCSpH6ME/4uAXwNuAm4EHguc1mdTkqT+jHJWzwbgOTPoRZI0A6MM2fDmJPdph3lWJvl2klNm0ZwkafpGOdTz1Kr6PnA83aGehwCv7rUrSVJvRgn+3dv1scAHq+rWHvuRJPVslNMyP5bky8C/Ar+TZDHwk37bkiT1ZZTx+FcAjwOWVdXtwI+BE/tuTJLUj5G+iFVV/zJn+Ud0396VJO2ERjnGL0nahWw1+JM8vl3fc3btSJL6Nt8e/zvb9edm0YgkaTbmO8Z/e5JzgQcmeefmP6yql81XOMkhwJ8D9wfuBM6qqnck2R/4S2ApsA549tzPECRJ/Zpvj/944DK6Uzev3sJlW+4A/mtVPQw4AvjdJL8MrABWVtWhwMq2Lkmaka3u8VfVt4EPJVlTVdcttHBVrQfWt+UfJFkDPJDuVNAntZudB1wBvGah9SVJ4xnlrJ7vJPlIkg1Jbkny4SQHL+RBkiwFHgVcCRzU3hQ2vTkcuJX7nJZkVZJVGzduXMjDSZLmMUrwnwtcAjyAbo/9Y23bSJLcG/gw8Io25s9IquqsqlpWVcsWL1486t0kSdswSvAfWFXnVtUd7fJ+YKQkTrI7XehfUFUXtc23JFnSfr4E2DBG35KkMY0S/BuTnJJkUbucAnxnW3dKEuAcYE1VvW3Ojy4Blrfl5cDFC21akjS+UYL/BcCzgZvpPqx9Ztu2LY8Hng8cmeTadjkWOAM4Osla4Oi2LkmakVFm4PoGcMJCC1fVZ4Fs5cdHLbSeJGk6HKtHkgbG4JekgTH4JWlgRg7+JEck+XSSv09yUo89SZJ6tNUPd5Pcv6punrPplXQf8gb4v8BH+21NktSH+c7qeU+Sq4G3VNVPgO8C/4FupM2Rv4ErSdqxbPVQT1WdBFwLXJrk+cAr6EJ/L+Ck/luTJPVh3mP8VfUx4DeBfYGLgK9U1TurylHTJGknNd/Uiyck+SzwaWA18Bzg5CQfTPLgWTUoSZqu+Y7x/zfgccCewCeq6nDglUkOBd5E90YgSdrJzBf836ML9z2ZM4JmVa3F0N+lLV3x8YlrrDvjuCl0IqkP8x3jP5nug9w76M7mkSTtArY19eK7ZtiLJGkGHLJBkgbG4JekgTH4JWlgDH5JGhiDX5IGxuCXpIEx+CVpYAx+SRoYg1+SBsbgl6SBMfglaWAMfkkaGINfkgbG4JekgTH4JWlgDH5JGhiDX5IGxuCXpIEx+CVpYAx+SRoYg1+SBsbgl6SBMfglaWAMfkkaGINfkgbG4Jekgekt+JO8L8mGJKvnbNs/yeVJ1rbr/fp6fEnSlvW5x/9+4JjNtq0AVlbVocDKti5JmqHegr+q/ha4dbPNJwLnteXzgJP6enxJ0pbN+hj/QVW1HqBdH7i1GyY5LcmqJKs2btw4swYlaVe3w364W1VnVdWyqlq2ePHi7d2OJO0yZh38tyRZAtCuN8z48SVp8GYd/JcAy9vycuDiGT++JA1en6dzfhD4HPDQJDcmORU4Azg6yVrg6LYuSZqh3foqXFXP3cqPjurrMSVJ27bDfrgrSeqHwS9JA2PwS9LAGPySNDAGvyQNjMEvSQNj8EvSwBj8kjQwBr8kDYzBL0kDY/BL0sAY/JI0MAa/JA2MwS9JA2PwS9LAGPySNDAGvyQNjMEvSQNj8EvSwPQ25660I1u64uMT11h3xnFT6ESaPff4JWlgDH5JGhiDX5IGxuCXpIEx+CVpYAx+SRoYg1+SBsbgl6SBMfglaWAMfkkaGINfkgbG4JekgXGQtl2Eg45JGpV7/JI0MAa/JA2MwS9JA2PwS9LAGPySNDAGvyQNzHY5nTPJMcA7gEXA2VV1xvboY3uaxumX4CmYkhZu5sGfZBHwZ8DRwI3AF5JcUlX/MOteFsqw1pb4utDOZnvs8R8O/FNVfRUgyYeAE4Fegt8vNknSXaWqZvuAyTOBY6rqhW39+cBjq+olm93uNOC0tvpQ4Cs9tnUA8G1r7fS1pl3PWrtGrWnX21Frbcm/qarFm2/cHnv82cK2u737VNVZwFn9twNJVlXVMmvt3LWmXc9au0atadfbUWstxPY4q+dG4JA56wcD39oOfUjSIG2P4P8CcGiSByXZA3gOcMl26EOSBmnmh3qq6o4kLwEuozud831VdcOs+9jMNA8pWWv71Zp2PWvtGrWmXW9HrTWymX+4K0navvzmriQNjMEvSQMz6OBP8r4kG5KsnrDOIUk+k2RNkhuSvHzCevdKclWS61q9N0xYb1GSLya5dJI6rda6JF9Kcm2SVRPW2jfJXyf5cvu3e9yYdR7a+tl0+X6SV0zQ1++1f/fVST6Y5F4T1Hp5q3PDOD1t6TWaZP8klydZ2673m6DWs1pvdyYZ+bTCrdR6S/u/vD7JR5LsO0GtN7Y61yb5ZJIHjFtrzs9elaSSHDBKrXl6e32Sm+a83o6dpLckL03ylfb/8OZRe5tIVQ32AjwROAxYPWGdJcBhbXkf4B+BX56gXoB7t+XdgSuBIyao90rgA8ClU/g3WwccMKV///OAF7blPYB9p1BzEXAz3RdXxrn/A4GvAXu29QuB/zhmrYcDq4G96E6k+BRw6AJr3O01CrwZWNGWVwBnTlDrYXRfkLwCWDZhX08FdmvLZ07Y133mLL8MeM+4tdr2Q+hOKPn6Ql6/W+nt9cCrxng9bKnWk9vr4p5t/cBxXmsLvQx6j7+q/ha4dQp11lfVNW35B8AaugAZt15V1Q/b6u7tMtan8EkOBo4Dzh63nz4kuQ/dL8I5AFX106r67hRKHwX8c1V9fYIauwF7JtmNLrTH/Z7Jw4DPV9WPq+oO4G+AkxdSYCuv0RPp3jRp1yeNW6uq1lTVgr8Vv5Van2zPE+DzdN/RGbfW9+es7s2Ir/95fqf/FPj9UeuMUG/BtlLrxcAZVXVbu82GaTzWtgw6+PuQZCnwKLq99EnqLEpyLbABuLyqxq33droX/J2T9DNHAZ9McnUbVmNcvwhsBM5th6HOTrL3FPp7DvDBce9cVTcB/wP4BrAe+F5VfXLMcquBJya5X5K9gGO565cXx3VQVa1v/a4HDpxCzWl7AfC/JymQ5E1Jvgk8D3jdBHVOAG6qqusm6WczL2mHot436qG2rXgI8OtJrkzyN0keM60G52PwT1GSewMfBl6x2R7LglXVz6rqkXR7TYcnefgY/RwPbKiqqyfpZTOPr6rDgKcBv5vkiWPW2Y3uz953V9WjgB/RHbYYW/tC4AnAX01QYz+6PeoHAQ8A9k5yyji1qmoN3SGPy4H/A1wH3DHvnXYBSU6ne54XTFKnqk6vqkNanZds6/Zb6WUv4HQmeOPYgncDDwYeSbdz8NYJau0G7AccAbwauDDJloa1mSqDf0qS7E4X+hdU1UXTqtsOf1wBHDPG3R8PnJBkHfAh4Mgk50/Yz7fa9QbgI3SjrY7jRuDGOX/J/DXdG8EkngZcU1W3TFDjKcDXqmpjVd0OXAT82rjFquqcqjqsqp5I92f+2gl62+SWJEsA2vVMDg+MIsly4HjgedUOWk/BB4BnjHnfB9O9iV/Xfg8OBq5Jcv9xm6mqW9qO2Z3Aexn/dwC634OL2uHdq+j+Mh/5w+dxGfxT0N6hzwHWVNXbplBv8aYzIpLsSRdGX15onap6bVUdXFVL6Q6BfLqqxtp7bb3snWSfTct0H+aNdUZUVd0MfDPJQ9umo5h8aO7nMsFhnuYbwBFJ9mr/r0fRfWYzliQHtutfAJ4+hf6gG+JkeVteDlw8hZoTSzfB0muAE6rqxxPWOnTO6gmM8foHqKovVdWBVbW0/R7cSHcixs0T9LZkzurJjPk70HwUOLLVfQjdSQ59jtbZmcUnyDvqhe6XcD1wO90L4tQx6zyB7tj39cC17XLsBH09Avhiq7caeN0UnuuTmPCsHrrj8te1yw3A6RPWeySwqj3PjwL7TVBrL+A7wH2n8G/1BrqgWQ38Be2MizFr/R3dG9p1wFFj3P9ur1HgfsBKur8eVgL7T1Dr5LZ8G3ALcNkEtf4J+Oac34FRz8TZUq0Pt3//64GPAQ8ct9ZmP1/Hws7q2VJvfwF8qfV2CbBkglp7AOe353oNcOSkr99RLg7ZIEkD46EeSRoYg1+SBsbgl6SBMfglaWAMfkkaGINf210bMfGtc9ZfleT1U6r9/iTPnEatbTzOs9KNMPqZvh9LmpTBrx3BbcDTFzJc7iwkWbSAm58K/E5VPbmvfqRpMfi1I7iDbu7R39v8B5vvsSf5Ybt+UhvU6sIk/5jkjCTPSzePwZeSPHhOmack+bt2u+Pb/Re18eO/0Abb+i9z6n4myQfovqSzeT/PbfVXJzmzbXsd3Zf43pPkLZvd/h5J/mcba/3SJJ/Y9HzSzW1wQFteluSKtrx3G/zrC20AuxPb9l9pz+/a1vOh7bYfTzd3w+okv9Vu++j273N1ksvmDPHwsiT/0O7/oTH+r7QLmPlk69JW/BlwfRY2EcWv0g19fCvwVeDsqjo83UQ4LwVe0W63FPgNunFbPpPk3wK/TTfy5mOS3BP4+ySbRuE8HHh4VX1t7oOlmwzkTODRwL/QjVJ6UlX9SZIj6cZo33xymqe3x/93dKNorgHet43ndTrd8BovaEN3XJXkU8CLgHdU1QVtQLpFdCN+fquqjms93reNG/Uu4MSq2tjeDN5EN2LmCuBBVXVbRpwoRbse9/i1Q6huNNM/p5t0Y1RfqG4uhNuAfwY2BfeX6MJ2kwur6s6qWkv3BvFLdOMM/Xa6oa+vpBsGYdP4MFdtHvrNY4ArqhvAbdPok9sanfQJwF+1x78ZGOUzgKcCK1pvVwD3An4B+BzwB0leQzfRzL+25/qUJGcm+fWq+h7dxCoPBy5vNf6Qn4+Nfz1wQboRR3f5kUK1Ze7xa0fydrrxSs6ds+0O2g5KGzRtjzk/u23O8p1z1u/krq/tzcclKbpZzl5aVZfN/UGSJ9ENEb0l4wyXO999/v9zowv3ufd5Rt19gpQ1Sa6km1jnsiQvrKpPJ3k03Z7/f29/tXwEuKGqtjSV5XF0b1YnAH+U5Ffq55OnaCDc49cOo6pupZvq8NQ5m9fRHVqBbpz83cco/ax2rP3BdAPNfYVuGr4Xt8MiJHlItj0RzJXAbyQ5oH3w+1y6WbXm81ngGe3xD6IbLG+Tdfz8uc0ddvgy4KXtjY4kj2rXvwh8tareSTc42CPa4acfV9X5dBPIHNae3+K0OYyT7N4+H7gHcEhVfYZucp59gXtvo3/tgtzj147mrdx10o33AhcnuYpuJMqt7Y3P5yt0AX0Q8KKq+kmSs+kOB13TAnYj25jCsKrWJ3kt3eGaAJ+oqm0NifxhuqGdV9PNxXwl8L32szcA5yT5A+46Y9sb6f76ub71to5ujPvfAk5JcjvdvMJ/Qnf46S1J7qQb9fHFVfXT9gHyO5Pcl+73/O3t8c9v2wL8aU1nukvtZBydU+pZkntX1Q+T3A+4im4Ws7HHg5cm5R6/1L9L2xk0ewBvNPS1vbnHL0kD44e7kjQwBr8kDYzBL0kDY/BL0sAY/JI0MP8PpWEgyMc0XpsAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "%time report_minimizing_tree(neg_entropy, inconsistent=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Jotto and Wordle Evaluation Summary\n",
    "\n",
    "Here is a summary of the reports on both games:\n",
    "\n",
    "|<br><br><br>Algorithm|JOTTO<br>Inonsistent<br><u>Prohibited</u><br>Mean (Max)|JOTTO<br>Inconsistent<br><u>Allowed</u><br>Mean (Max)|WORDLE<br>Inconsistent<br><u>Prohibited</u><br>Mean (Max)|WORDLE<br>Inconsistent<br><u>Allowed</u><br>Mean (Max)||\n",
    "|--|--|--|--|--|--|\n",
    "|minimize max        |6.31 (16)|6.38  (9)| 3.68 (8) | 3.64 (6) | \n",
    "|minimize expectation|6.11 (14)|6.13  (9)| 3.62 (8) | 3.55 (6) | \n",
    "|minimize neg_entropy|6.31 (15)|6.18  (9)| 3.60 (8) | 3.52 (6) |\n",
    "|random guesser      |6.59 (13)|         | 4.09 (9) |          |\n",
    "\n",
    "\n",
    "One surprising thing: allowing inconsistent guesses in Jotto does *not* improve the mean score with eiither the max or expectation metric. However, it does uniformly improve the worst score.\n",
    "\n",
    "\n",
    "# Jotto Best and Worst First Guesses\n",
    "\n",
    "Here are the best and worst first guesses for Jotto:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>max_word</th>\n",
       "      <th>max_score</th>\n",
       "      <th>exp_word</th>\n",
       "      <th>exp_score</th>\n",
       "      <th>ent_word</th>\n",
       "      <th>ent_score</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>DRAPE</td>\n",
       "      <td>497</td>\n",
       "      <td>SOUTH</td>\n",
       "      <td>400.50</td>\n",
       "      <td>STARE</td>\n",
       "      <td>-1.971</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>DREAM</td>\n",
       "      <td>497</td>\n",
       "      <td>DEBAR</td>\n",
       "      <td>401.43</td>\n",
       "      <td>CEDAR</td>\n",
       "      <td>-1.964</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>TRASH</td>\n",
       "      <td>497</td>\n",
       "      <td>CRAVE</td>\n",
       "      <td>401.94</td>\n",
       "      <td>DEBAR</td>\n",
       "      <td>-1.961</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>DEBAR</td>\n",
       "      <td>499</td>\n",
       "      <td>STARE</td>\n",
       "      <td>402.56</td>\n",
       "      <td>SPEAR</td>\n",
       "      <td>-1.958</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>DECAL</td>\n",
       "      <td>499</td>\n",
       "      <td>CEDAR</td>\n",
       "      <td>402.94</td>\n",
       "      <td>REACH</td>\n",
       "      <td>-1.958</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1386</th>\n",
       "      <td>QUAIL</td>\n",
       "      <td>740</td>\n",
       "      <td>AVOID</td>\n",
       "      <td>534.45</td>\n",
       "      <td>QUASI</td>\n",
       "      <td>-1.600</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1387</th>\n",
       "      <td>QUAKE</td>\n",
       "      <td>740</td>\n",
       "      <td>QUAKE</td>\n",
       "      <td>534.54</td>\n",
       "      <td>JUICY</td>\n",
       "      <td>-1.587</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1388</th>\n",
       "      <td>AVOID</td>\n",
       "      <td>745</td>\n",
       "      <td>QUASI</td>\n",
       "      <td>538.90</td>\n",
       "      <td>JUMPY</td>\n",
       "      <td>-1.564</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1389</th>\n",
       "      <td>AUDIO</td>\n",
       "      <td>761</td>\n",
       "      <td>AUDIO</td>\n",
       "      <td>595.22</td>\n",
       "      <td>AXIOM</td>\n",
       "      <td>-1.500</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1390</th>\n",
       "      <td>AXIOM</td>\n",
       "      <td>827</td>\n",
       "      <td>AXIOM</td>\n",
       "      <td>599.56</td>\n",
       "      <td>AUDIO</td>\n",
       "      <td>-1.460</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>1391 rows × 6 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "     max_word  max_score exp_word  exp_score ent_word  ent_score\n",
       "0       DRAPE        497    SOUTH     400.50    STARE     -1.971\n",
       "1       DREAM        497    DEBAR     401.43    CEDAR     -1.964\n",
       "2       TRASH        497    CRAVE     401.94    DEBAR     -1.961\n",
       "3       DEBAR        499    STARE     402.56    SPEAR     -1.958\n",
       "4       DECAL        499    CEDAR     402.94    REACH     -1.958\n",
       "...       ...        ...      ...        ...      ...        ...\n",
       "1386    QUAIL        740    AVOID     534.45    QUASI     -1.600\n",
       "1387    QUAKE        740    QUAKE     534.54    JUICY     -1.587\n",
       "1388    AVOID        745    QUASI     538.90    JUMPY     -1.564\n",
       "1389    AUDIO        761    AUDIO     595.22    AXIOM     -1.500\n",
       "1390    AXIOM        827    AXIOM     599.56    AUDIO     -1.460\n",
       "\n",
       "[1391 rows x 6 columns]"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "first_guesses(wordlist)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One difference is that in Jotto, most of the best guesses have two vowels, in Wordle three.\n",
    "\n",
    "`'OUIJA'` is not in our word list, but it was in another list, and it is uniquely bad as a Jotto guess, worse than `'AXIOM'` or `'AUDIO'`. \n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Next Steps\n",
    "\n",
    "There are many directions you could take this if you are interested:\n",
    "- **Other games:**\n",
    "  - Implement [Mastermind](https://en.wikipedia.org/wiki/Mastermind_%28board_game%29). The default version has 6 colors and 4 pegs. Can you go beyond that?\n",
    "  - Consider a Jotto game variant where each reply consists of two numbers: the number of letters in common with the target, and the number of letters that are in the exact correct position, as in Mastermind.\n",
    "  - Research what other computer scientists have done with [Jotto](https://arxiv.org/abs/1107.3342) or [Mastermind](http://serkangur.freeservers.com/).\n",
    "  - There are many variants of Wordle: Evil Wordle, Anti-Wordle, Quordle, Octordle, ...\n",
    "  - Refactor the code so it can more smoothly handle multiple different games.\n",
    "- **Better strategy**:\n",
    "  - Our `minimizing_tree` function is **greedy** in that it guesses the word that minimizes some metric of the current situation without looking ahead to future branches in the tree. Can you get better performance by doing some **look-ahead**? Perhaps with a beam search?\n",
    "  - As an alternative to look-ahead, can you improve a tree by editing it? Given a tree, look for interior nodes that end up with a worse-than-expected average score, and see if the node can be replaced with something better (covering the same target words). Correcting a few bad nodes might be faster than carefully searching for good nodes in the first place.\n",
    "  - The three metrics (max, expectation, and negative entropy) are all designed as proxies to what we really want to minimize: the average number of guesses. Can we estimate that directly? For example, we know a branch of size 1 will always take 1 guess; a branch of size 2 an average of 3/2 guesses; and a branch of size 3 an average of 5/3 guesses if one of the words partitions the other two, otherwise an average of 2. Can we learn a function that takes a set of words as input and estimates the average number of guesses for the set? Would a deep neural net be a good way to learn this function?\n",
    "  - Is it feasible to do a complete search and find the guaranteed optimal strategy? What optimizations to the code would be necessary? Is it worthwhile to port to a different language? How long would the search take?\n",
    "  - We assume that the list of taregt words is known to the guesser. The [New York Times WordleBot](https://www.nytimes.com/interactive/2022/upshot/wordle-bot.html) initally took this approach too, but then switched to a more nuanced approach where the guesser (the Bot) does not know for sure the list of target words, but instead assigns words a probability of being a target word that is correlated with the word's frequency in English usage. Can you develop a guesser that works along these lines?\n",
    "- **Chooser strategy**:\n",
    "  - Analyze the game where the chooser is not random, but rather is an adversary to the guesser–the chooser tries to choose a word that will maximize the guesser's score. What's a good strategy for the chooser? Is there a strategy equilibrium?\n",
    "  - Refactor `play` to accomodate three roles:\n",
    "    - A chooser, who decides what the target word is.\n",
    "    - A guesser, who guesses the target word.\n",
    "    - A replier, who says what the reply to the guess is."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.9.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}