diff --git a/ipynb/jotto.ipynb b/ipynb/jotto.ipynb index 987e7a9..3cdcecd 100644 --- a/ipynb/jotto.ipynb +++ b/ipynb/jotto.ipynb @@ -8,31 +8,31 @@ "\n", "# Jotto\n", "\n", - "[Jotto](https://en.wikipedia.org/wiki/Jotto) is a game in which a **guesser** tries to guess a **target** word, which is chosen from a list of permissible words, in a minimum number of guesses. The **reply** to each guess is the number of letters in common between the guess word and the target word, regardless of the positions of the letters. \n", + "[Jotto](https://en.wikipedia.org/wiki/Jotto) is a word game in which a **guesser** tries to guess a secret **target** word, which is chosen from a list of permissible words, in as few guesses as possible. Each guess must be one of the permissible words, and the **reply** to each guess is the number of letters in common between the guess word and the target word, regardless of the positions of the letters. \n", "\n", - "Here is an example Jotto game, where I show the guesses, the replies, the number of possible targets that are consistent with all the guesses/replies seen so far, and finally the letters that matched (this is as an aid to you, the reader; these matching letters are not known to the guesser). In this game, the guesser gets to the target word, \"wonky\", in 7 guesses. \n", + "Here is an example Jotto game, where I show the guesses, the replies, the number of remaining targets that are **consistent** with all the replies seen so far, and finally the letters that matched (this is as an aid to you, the reader; these matching letters are not known to the guesser). In this game, the guesser gets to the target word, \"wonky\", in 7 guesses. \n", "\n", - " Guess 1: stoma, Reply: 1, Possible targets: 1118 (Matched: \"o\")\n", - " Guess 2: bairn, Reply: 1, Possible targets: 441 (Matched: \"n\")\n", - " Guess 3: swipe, Reply: 1, Possible targets: 197 (Matched: \"w\")\n", - " Guess 4: lurks, Reply: 1, Possible targets: 87 (Matched: \"k\")\n", - " Guess 5: rowdy, Reply: 3, Possible targets: 14 (Matched: \"owy\")\n", - " Guess 6: roved, Reply: 1, Possible targets: 2 (Matched: \"o\")\n", - " Guess 7: wonky, Reply: 5, Possible targets: 1 (Matched: \"wonky\")\n", + " Guess 1: stoma, Reply: 1, Consistent targets: 1118 (Matched: \"o\")\n", + " Guess 2: bairn, Reply: 1, Consistent targets: 441 (Matched: \"n\")\n", + " Guess 3: swipe, Reply: 1, Consistent targets: 197 (Matched: \"w\")\n", + " Guess 4: lurks, Reply: 1, Consistent targets: 87 (Matched: \"k\")\n", + " Guess 5: rowdy, Reply: 3, Consistent targets: 14 (Matched: \"owy\")\n", + " Guess 6: roved, Reply: 1, Consistent targets: 2 (Matched: \"o\")\n", + " Guess 7: wonky, Reply: 5, Consistent targets: 1 (Matched: \"wonky\")\n", "\n", "\n", + "There are several variants of the game; here are four key questions and my answers:\n", "\n", - "There are several variants of the game; here are my answers to four key questions:\n", + "- Q: How many letters can each word be?
A: **Only five-letter words are allowed in the word list**.\n", + "- Q: Can a guess be a word that is not in the word list?
A: **No. (If the guesser proposes a non-word, the reply is 0.)**\n", + "- Q: What is the reply for a word that has the same letter twice, like the `s` in `stars`?
A: **Only words with no repeated letters are allowed in the word list**.\n", + "- Q: What if the reply is `5`, but the guess is not the target?
A: **No two words in the word list are allowed to have the same set of five letters**.
**For example, only one of** `{'apers', 'pares', 'parse', 'pears', 'reaps', 'spare', 'spear'}` **is allowed.**\n", "\n", - "1. How many letters can each word be?
My answer is **only five-letter words**.\n", - "2. Can a guess be a word that is not in the word list?
My answer is **no**.\n", - "1. What is the reply for a word that has the same letter twice, like the `s` in `stars`?
My answer is to **disallow such words**.\n", - "2. What if the reply is `5`, but the guess is not the target? For example, if the guess is `parse` the\n", - "target might be `apres`, `asper`, `pares`, `parse`, `pears`, `reaps`, `spare`, or `spear`.
My answer is to **disallow two or more words that are anagrams** of each other; only one such word is allowed in the word list. \n", + "# Choosers and Guessers\n", "\n", - "Typically, the **guesser** plays against a **chooser**, who chooses the target word. This introduces a game-theoretic aspect: the chooser chooses a word that should be difficult for the guesser, but knowing that, the guesser modifies their strategy, and knowing that, the chooser further modifies their choice, etc. To avoid these complications, I will instead use a scenario that eliminates the chooser: the guesser plays against *every* possible target, and we measure the scores from all those games. (This is appropriate when the guesser is a program, but would be extremely tedious for a human guesser.)\n", + "Typically, the **guesser** plays against a **chooser**, who chooses the target word. This introduces a game-theoretic aspect: the chooser chooses a word that should be difficult for the guesser, but knowing that, the guesser modifies their strategy, and knowing that, the chooser further modifies their choice, etc. To avoid these complications, I will instead use a scenario where every target word is equally likely, and to evaluate a guesser we have it play one game with each target word, and aggregate the scores from all those games. (This is appropriate when the guesser is a program, but would be extremely tedious for a human guesser.)\n", "\n", - "We can make a Jotto word list by reading in a file of words, `sgb-words.txt`, and keeping only those words that have five distinct letters, and only one of the words that share a common anagram form. (But first some imports.)" + "First some imports and (if necessary) the download of a file of words, `sgb-words.txt`:" ] }, { @@ -43,18 +43,38 @@ "source": [ "import matplotlib.pyplot as plt\n", "import random\n", - "from typing import List\n", + "from typing import List, Tuple, Dict, Union\n", "from statistics import mean, stdev\n", - "from collections import namedtuple\n", + "from collections import defaultdict, Counter\n", "from math import log\n", "\n", "! [ -e sgb-words.txt ] || curl -O https://norvig.com/ngrams/sgb-words.txt" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can make a Jotto word list from `sgb-words.txt` by putting all the words that have five distinct letters into a dict keyed by the set of letters in each word, and then keeping only one word for each letter set:" + ] + }, { "cell_type": "code", "execution_count": 2, "metadata": {}, + "outputs": [], + "source": [ + "def jotto_words(words) -> List[str]:\n", + " \"\"\"Build a list of permissible Jotto words from an iterable of words.\"\"\"\n", + " lettersets = {frozenset(w): w \n", + " for w in words if len(w) == 5 == len(frozenset(w))}\n", + " return list(lettersets.values())" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, "outputs": [ { "data": { @@ -62,20 +82,12 @@ "2845" ] }, - "execution_count": 2, + "execution_count": 3, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "def jotto_words(words) -> List[str]:\n", - " \"\"\"Build a list of permissible Jotto words from an iterable of words.\"\"\"\n", - " anagram_table = {anagram_form(w): w \n", - " for w in words if len(w) == 5 == len(set(w))}\n", - " return list(anagram_table.values())\n", - "\n", - "def anagram_form(word) -> str: return ''.join(sorted(word))\n", - "\n", "wordlist = jotto_words(open('sgb-words.txt').read().split())\n", "len(wordlist)" ] @@ -84,7 +96,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "We see there are 2845 permissible words." + "We see there are 2,845 permissible target words." ] }, { @@ -93,34 +105,35 @@ "source": [ "# Playing a Game\n", "\n", - "We will define the function `play_jotto` to play a game and optionally produce the output shown above in the example game (without the \"(Matched: ...)\"), and finally return the number of guesses made. To avoid a possible infinite loop with a poor guesser, we impose an upper limit of 1000 guesses for a game.\n", + "We will define the function `play_jotto` to play a game and optionally produce the output shown above in the example game (without the \"(Matched: ...)\" part), and finally return as a score the number of guesses made. To avoid a possible infinite loop with a very poor guesser, we limit the number of guesses to the number of words in the word list.\n", "\n", - "The first argument to `play_jotto` is a `guesser`. I choose to implement a guesser as a `callable` (e.g., a function) that is passed the current state of the game and returns a guess word. So how do we represent the state of the game? `play_jotto` is keeping track of the `targets` that are still possible given previous guesses and replies, so we might as well pass that in. In addition, we pass in the reply from the previous guess. Note that a guess need not be one of the possible targets, but it must be one of the words in the word list. (If it is not, the guesser forfeits the game, and the score is recorded as the limit.) " + "The first argument to `play_jotto` is a `guesser`. I choose to implement a guesser as a `callable` (e.g., a function) that is passed the current state of the game and returns a guess word. So how do we represent the state of the game? `play_jotto` is keeping track of the `targets` that are still consistent given previous guesses and replies, so we might as well pass that in. In addition, we pass in the reply from the previous guess. Note that a guess need not be one of the consistent targets, but it must be one of the words in the word list. The second argument is a `chooser`: a function that selects a word from a wordlist. By default, it chooses randomly." ] }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ - "def play_jotto(guesser, target=None, wordlist=wordlist, limit=1000, verbose=False) -> int:\n", - " \"\"\"How many guesses does it take for the guesser to guess the Jotto target word?\"\"\"\n", - " target = target or random.choice(wordlist)\n", - " targets = wordlist\n", + "def play_jotto(guesser, chooser=random.choice, wordlist=wordlist, verbose=False) -> int:\n", + " \"\"\"How many guesses does it take for `guesser` to guess the Jotto target word,\n", + " which is selected by `chooser` from the words in `wordlist`?\"\"\"\n", + " targets = wordlist # The targets that are consistent with all replies\n", + " target = chooser(targets)\n", " reply = None\n", - " for guesses in range(1, limit + 1):\n", + " for i in range(1, len(wordlist) + 1):\n", " guess = guesser(reply, targets)\n", - " if guess not in wordlist:\n", - " return limit\n", - " reply = reply_for(target, guess)\n", + " reply = reply_for(target, guess) if guess in wordlist else -1\n", " targets = [w for w in targets if reply_for(guess, w) == reply]\n", " if verbose: \n", - " print(f'Guess {guesses}: {guess}, Reply: {reply}, Possible targets: {len(targets)}')\n", - " if guess == target or guesses == limit: \n", - " return guesses\n", + " print(f'Guess {i}: {guess}, Reply: {reply}, Consistent targets: {len(targets)}')\n", + " if guess == target or i == len(wordlist): \n", + " return i\n", + " \n", + "Reply = int # A reply to a guess is an integer (from 0 to 5)\n", " \n", - "def reply_for(target, guess) -> int: \n", + "def reply_for(target, guess) -> Reply: \n", " \"The number of letters in common between the target and guess\"\n", " return len(set(target).intersection(guess))" ] @@ -131,36 +144,33 @@ "source": [ "# Random Guesser\n", "\n", - "One simple guesser function is `random_guesser`: from the possible targets, pick one at random. That sounds naive, but it is actually a decent strategy:" + "One simple guesser function is `random_guesser`: from the remaining consistent targets, pick one at random. That sounds hopelessly naive, but it is actually a decent strategy:" ] }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 5, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Guess 1: blunt, Reply: 0, Possible targets: 683\n", - "Guess 2: exams, Reply: 2, Possible targets: 290\n", - "Guess 3: vised, Reply: 2, Possible targets: 120\n", - "Guess 4: heard, Reply: 3, Possible targets: 38\n", - "Guess 5: redox, Reply: 2, Possible targets: 30\n", - "Guess 6: pawed, Reply: 4, Possible targets: 8\n", - "Guess 7: waked, Reply: 3, Possible targets: 3\n", - "Guess 8: paged, Reply: 4, Possible targets: 2\n", - "Guess 9: caped, Reply: 5, Possible targets: 1\n" + "Guess 1: delis, Reply: 3, Consistent targets: 410\n", + "Guess 2: coeds, Reply: 2, Consistent targets: 210\n", + "Guess 3: dirts, Reply: 2, Consistent targets: 97\n", + "Guess 4: veldt, Reply: 2, Consistent targets: 44\n", + "Guess 5: adieu, Reply: 2, Consistent targets: 17\n", + "Guess 6: child, Reply: 5, Consistent targets: 1\n" ] }, { "data": { "text/plain": [ - "9" + "6" ] }, - "execution_count": 4, + "execution_count": 5, "metadata": {}, "output_type": "execute_result" } @@ -177,54 +187,45 @@ "source": [ "# Evaluating Guessers\n", "\n", - "That was just one sample game. How well will this guesser do averaged over all targets? The function `play_jottos` plays a game against every target and collects the scores. Then, `show` displays a histogram and the mean, standard deviation, and maximum values of the scores. " - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [], - "source": [ - "def play_jottos(guesser, targets=wordlist, wordlist=wordlist) -> List[int]:\n", - " \"\"\"Scores for this guesser on all targets.\"\"\"\n", - " return [play_jotto(guesser, target, wordlist, verbose=False)\n", - " for target in targets]\n", - " \n", - "def show(scores):\n", - " \"\"\"Show a histogram and statistics for these scores.\"\"\"\n", - " scores = list(scores)\n", - " bins = range(min(scores), max(scores) + 2) \n", - " weights = [1/len(scores)] * len(scores)\n", - " plt.hist(scores, align='left', rwidth=0.9, bins=bins, weights=weights)\n", - " plt.xticks(bins[:-1])\n", - " plt.xlabel('Number of guesses to find target'); \n", - " plt.ylabel('Proportion of targets')\n", - " print(f'mean = {mean(scores):.2f} ± {stdev(scores):.2f}, max = {max(scores)}')" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Since `random_guesser` has a random component, let's evaluate each target multiple times to reduce variance. Let's say 5 times:" + "That was just one sample game. How well will this guesser do averaged over all target words? The function `play_jottos` plays a game against every target and collects the scores. Then, `show` displays a histogram and the mean, standard deviation, and worst case number of guesses. " ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, + "outputs": [], + "source": [ + "def play_jottos(guesser, targets=wordlist) -> List[int]:\n", + " \"\"\"Scores for this guesser on all targets.\"\"\"\n", + " return [play_jotto(guesser, lambda _: target, wordlist, verbose=False)\n", + " for target in targets]\n", + " \n", + "def show(scores: List[int]):\n", + " \"\"\"Show a histogram and statistics for these scores.\"\"\"\n", + " bins = range(min(scores), max(scores) + 2)\n", + " plt.hist(scores, align='left', rwidth=0.9, bins=bins,\n", + " weights=[100 / len(scores) for _ in scores])\n", + " plt.xticks(bins[:-1])\n", + " plt.xlabel('Number of guesses to find target'); plt.ylabel('% of targets')\n", + " print(f'mean = {mean(scores):.2f} ± {stdev(scores):.2f} guesses; worst = {max(scores)}')" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "mean = 7.37 ± 1.71, max = 18\n" + "mean = 7.32 ± 1.66 guesses; worst = 16\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -236,89 +237,39 @@ } ], "source": [ - "show(play_jottos(random_guesser, targets=5*wordlist))" + "show(play_jottos(random_guesser))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "The average is 7.38 guesses, and most of the time it will take from 6 to 9 guesses. Can we do better than that?\n", + "The average is a bit more than 7 guesses; 2/3 of the time it will take from 6 to 9 guesses, and the worst case is 18 guesses. Can we improve the average and/or worst case?\n", "\n", - "# Strategies that Partition Targets\n", + "# Guessers that Partition Targets\n", "\n", - "It seems that a key idea in guessing is to reduce the number of possible targets. We can think of each guess as **partitioning** the possible targets into different **branches** of a tree, each branch corresponding to a different reply number. Once you get the reply, you can discard all the other branches. \n", - "\n", - "I will define `reply_branches(guess, targets)[i]` to give all the target words that yield a reply of `i`, for any `i` from 0 to 5. Similarly, `reply_counts(guess, targets)[i]` gives the number of targets that yield a reply of `i`. The reply counts for every guess (with the full wordlist as targets) are cached in `reply_counts_cache`." - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [], - "source": [ - "def reply_branches(guess, targets) -> List[str]:\n", - " \"\"\"A list of [[targets_with_reply_i], ...] for i from 0 to 5.\"\"\"\n", - " result = [[] for _ in range(6)]\n", - " for target in targets:\n", - " result[reply_for(target, guess)].append(target)\n", - " return result\n", - "\n", - "def reply_counts(guess, targets) -> List[int]: \n", - " \"A list of [number_of_targets_with_reply_i, ...] for i from 0 to 5.\"\n", - " counts = [0] * 6\n", - " for target in targets:\n", - " counts[reply_for(guess, target)] += 1\n", - " return counts\n", - "\n", - "reply_counts_cache = {guess: reply_counts(guess, wordlist) for guess in wordlist}" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "I don't want to show `reply_branches` with all 2,845 words, so here it is for the first 20 words of the word list, with the guess `'after'`:" + "A key idea in guessing is to reduce the number of consistent targets. 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": 8, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[['would', 'cloud', 'sound'],\n", - " ['sword', 'think', 'fondu', 'might'],\n", - " ['about', 'girth', 'place', 'ethos', 'nuder'],\n", - " ['their', 'throe', 'write', 'rifts', 'resay'],\n", - " ['water', 'grate'],\n", - " ['after']]" - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ - "reply_branches('after', wordlist[:20])" + "def partition(guess, targets) -> Dict[Reply, List[str]]:\n", + " \"\"\"A partition of targets by the possible replies to guess: {reply: [word, ...]}.\"\"\"\n", + " branches = defaultdict(list)\n", + " for target in targets:\n", + " branches[reply_for(target, guess)].append(target)\n", + " return branches" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "We see that `'after'` does a pretty good job of partitioning the words into roughly-equal branches." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Below are the reply counts over the full wordlist for two possible guesses, `ouija` and `coder`:" + "It would take too much space to show a partition of all 2,845 words, so here's a partition of just the first 22 words:" ] }, { @@ -329,7 +280,13 @@ { "data": { "text/plain": [ - "[175, 1848, 755, 65, 1, 1]" + "defaultdict(list,\n", + " {4: ['their', 'might'],\n", + " 1: ['about', 'sword', 'resay', 'nuder', 'house'],\n", + " 0: ['would', 'cloud', 'place', 'sound', 'fondu'],\n", + " 3: ['throe', 'write', 'rifts', 'think', 'grate'],\n", + " 2: ['water', 'after', 'ethos', 'while'],\n", + " 5: ['girth']})" ] }, "execution_count": 9, @@ -338,13 +295,70 @@ } ], "source": [ - "reply_counts_cache['ouija']" + "partition('girth', wordlist[:22])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We see that after guesssing `'girth'` we will be left with no more than five consistent targets, no matter what the reply.\n", + "\n", + "To decide which guess is best, we don't need to know the identity of all the words in each branch, just the *count* of how many there are. The function `partition_counts` computes that, returning a list of counts, one for each possible reply:" ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, + "outputs": [], + "source": [ + "def partition_counts(guess, targets) -> List[int]: \n", + " \"A partition: {reply: number_of_targets_with_reply, ...}.\"\n", + " counts = Counter(reply_for(guess, target) for target in targets)\n", + " return [counts[i] for i in all_possible_replies]\n", + "\n", + "all_possible_replies = range(6)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Below are the partition counts for two possible first guesses, `ouija` and `coder`:" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[175, 1848, 755, 65, 1, 1]" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "partition_counts('ouija', wordlist)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We see that for the guess `'ouija'`, 1848 consistent targets (about 2/3 of the word list) are bunched into one branch, meaning that 2/3 of the time you will be left with 1848 targets after guessing `'ouija'`. (*Note:* Why is this so? Because `'ouija'` has all the vowels except `'e'`, and about 2/3 of the words have exactly one of these vowels, so the reply for those words is 1. Only one other word, `'audio'`, has these four vowels. Only 56 words have a `'j'`, so that is not a major factor.)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, "outputs": [ { "data": { @@ -352,35 +366,33 @@ "[433, 1030, 1014, 327, 40, 1]" ] }, - "execution_count": 10, + "execution_count": 12, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "reply_counts_cache['coder']" + "partition_counts('coder', wordlist)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "We see that for the guess `'ouija'`, there are 1848 possible targets in the `1` branch (the second entry in the counts, because the first entry is for `0`). There are far fewer possible targets in the other branches, so that means that for the majority of targets, you will be left with 1848 possible targets.\n", + "For the guess `'coder'`, the targets are more spread out over multiple branches. After guessing `'coder'` you will never be left with more than 1030 consistent targets. That suggests that `'coder'` is a better first guess, and it suggests a general strategy: **guess the word that best partitions the consistent targets into small branches.**\n", "\n", - "For the guess `coder`, the reply will be `1` or `2` for (1030 + 1014) / 2845 = 72% of the targets, and in any case, there will never be more than 1030 possible targets to deal with. That suggests that `coder` is a better first guess, and it suggests a general strategy: **choose the guess that best partitions the possible targets into small branches.**\n", + "What's a good metric for measuring how **small** the branches are? What we really want to know is how many additional guesses it will take to handle each branch, but since we don't know that, we can use one of the following proxy metrics:\n", "\n", - "What's a proper metric for measuring how \"small\" the branches are? \n", + "- A simple metric is to **minimize the maximum number in the partition counts**. That is, we should deduce that `coder`, with its `max` partition count of 1030, is a better guess than `ouija`, with its `max` of 1848. \n", "\n", - "- The simplest metric is to **minimize the maximum number in the reply counts**. That is, we should deduce that `coder`, with its `max` reply count of 1030, is a better guess than `ouija`, with its `max` of 1848. \n", + "- A more sophisticated metric is to **minimize the expected value of the partition counts**: in probability theory the expected value or **expectation** is the weighted average of a random variable. Here it means the sum, over all branches, of the size of the branch multiplied by the probability of ending up in the branch.\n", "\n", - "- A slightly more sophisticated metric is to **minimize the expected number in the reply counts**: the expectation is the sum, over all branches, of the probability of ending up in the branch times the size of the branch.\n", - "\n", - "- Information theory provides a suggestion to **maximize the entropy in the reply counts**. Entropy is similar to expectation, except that it weights each branch size by its base 2 logarithm (whereas expectation weights it by its actual size). Note that we want to minimize *negative* entropy." + "- Information theory provides a suggestion to **maximize the entropy in the partition counts**. Entropy is similar to expectation, except that it weights each branch size by its base 2 logarithm (whereas expectation weights it by its actual size). Note that we want to minimize *negative* entropy." ] }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 13, "metadata": {}, "outputs": [], "source": [ @@ -394,144 +406,65 @@ " def P(x, scale=1/sum(counts)): return scale * x\n", " return - sum(P(x) * log(P(x), 2) for x in counts if x)\n", "\n", - "def negative_entropy(counts) -> float: return - entropy(counts)\n", - "\n", - "def top(words, metric, n=15) -> str: \n", - " \"\"\"The top n words according to metric(reply_counts_cache[w]).\"\"\"\n", - " return ' '.join(sorted(words, key=lambda w: metric(reply_counts_cache[w]))[:n])" + "def negative_entropy(counts) -> float: return - entropy(counts)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "Here are the top 15 words according to each of the three metrics:" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "'wader cadre armed diner coder padre rayed raved delta drone garde eland heard tired debar'" - ] - }, - "execution_count": 12, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# minimize the maximum number in the reply counts\n", - "top(wordlist, metric=max)" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "'raved debar roved orbed wader armed fader dater alder cadre garde padre deign gored laved'" - ] - }, - "execution_count": 13, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# minimize the expected number in the reply counts\n", - "top(wordlist, metric=expectation)" + "Here are the top 10 guesses according to each of the three metrics:" ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "'debar alder raved dater cadre armed garde wader lased padre fader dears drone diner rayed'" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ - "# maximize the entropy (by minimizing negative entropy) in the reply counts\n", - "top(wordlist, metric=negative_entropy)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The three metrics yield a lot of overlap; `wader`, `raved`, and `debar` appear near the top in all three. Which metric is best? We have the tools to answer that: we could use `play_jottos` to get scores for each metric. But that would take a long time, because many computations would be repeated for each target word. We were able to create the `reply_counts_cache` for the words in the complete wordlist, but we really could use a similar cache for all the cases where we have eliminated some of the possible targets." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Guesser Trees \n", - "\n", - "My approach to the cache problem will be to build a **guesser tree**: a tree that partitions target words into branches all the way to the end, where each partition holds a single word. Think of this as a universal strategy that we can precompute once, and then apply to every possible target word with no need for additional complex computation—just branch-following in the tree. I define a tree as either:\n", - "- A **leaf**, which is a string, such as `'oiuja'`, indicating that this is the sole remaining possible target. Every word in the word list should appear as a leaf in exactly one place in the guesser tree.\n", - "- An **interior node**, such as `Node(guess='wader', branches={1: 'oiuja', 5: 'wader'})`, consisting of a guess and branches which are `{reply: tree}` pairs. The node shown here means that we should guess `'wader'` first, and if the reply is `1`, then we're left with the single target `'oiuja'` to guess next, and if the reply is `5`, then we finished the game; `'wader'` was the target.\n" + "def top(metric, n=10, words=wordlist) -> str: \n", + " \"\"\"The top n words according to metric(partition_counts(w, words)).\"\"\"\n", + " return ' '.join(sorted(words, key=lambda w: metric(partition_counts(w, words)))[:n])" ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "'wader cadre armed diner coder padre rayed raved delta drone'" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ - "Leaf = str\n", - "Node = namedtuple('Node', 'guess, branches')\n", - "Tree = (Node, Leaf) # A Tree is a Node or a Leaf" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The function `make_tree` builds a tree that, at every node, chooses the guess that minimizes the value of a metric applied to the reply counts for the guess and the targets. It takes two arguments:\n", - "- `metric`, a function that takes a reply count list as input and returns a number;\n", - "- `targets`, the list of remaining possible target words. " + "top(max) # minimize the maximum number" ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "'raved debar roved orbed wader armed fader dater alder cadre'" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ - "def make_tree(metric, targets=wordlist) -> Tree:\n", - " \"\"\"Make a tree that guesses to minimize or maximize metric(reply_counts(guess, targets)).\"\"\"\n", - " if len(targets) == 1:\n", - " return targets[0]\n", - " else:\n", - " guess = min(targets, key=lambda guess: metric(reply_counts(guess, targets))) \n", - " branches = reply_branches(guess, targets)\n", - " return Node(guess, {i: make_tree(metric, branches[i]) \n", - " for i in range(6) if branches[i]})" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Consider the case where there are five possible targets: `purge`, `bites`, `sulky`, `patsy`, and `hayed`.\n", - "Here is a tree to cover those words by, at each node in the tree, making the guess that **minimizes** the **maximum** number in the reply counts list:" + "top(expectation) # minimize the expectation" ] }, { @@ -542,7 +475,7 @@ { "data": { "text/plain": [ - "Node(guess='bites', branches={1: Node(guess='purge', branches={1: Node(guess='sulky', branches={1: 'hayed', 5: 'sulky'}), 5: 'purge'}), 2: 'patsy', 5: 'bites'})" + "'debar alder raved dater cadre armed garde wader lased padre'" ] }, "execution_count": 17, @@ -551,37 +484,25 @@ } ], "source": [ - "words5 = 'purge bites sulky patsy hayed'.split()\n", - "tree5 = make_tree(max, words5)\n", - "tree5" + "top(negative_entropy) # maximize the entropy (by minimizing negative entropy)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "\n", - "That tree is easier to understand if we reformat it like this:\n", - "\n", - " Node(guess='bites', \n", - " branches={1: Node(guess='purge', \n", - " branches={1: Node(guess='sulky', \n", - " branches={1: 'hayed', \n", - " 5: 'sulky'}), \n", - " 5: 'purge'}), \n", - " 2: 'patsy', \n", - " 5: 'bites'})\n", - " \n", - "This says that the first guess is `'bites'`, and if the reply is `1` there is a complex subtree to consider (starting with the guess `'purge'`), but if the reply is `2` the target must be `'patsy'` and of course if the reply is `5` then `'bites'` was the target." + "The three metrics yield a lot of overlap; `wader`, `raved`, `armed` and `cadre` appear in the top 10 for all three. Every word has both a `'d'` and an `'e'`, and 28 out of 30 have an `'r'`. Which metric is best? We have the tools to answer that: we could use `play_jottos` to get scores for guessers that use each metric. But that would take a long time. It takes about 5 seconds to compute the `top` word for just the first guess; I don't want to repeat that computation 3 × 2,845 times (and that's just for choosing the first word)." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "# Turning a Tree into a Callable Guesser\n", + "# Guesser Trees \n", "\n", - "Now that we've made a tree, we need to use it as a component of a guesser that `play_jotto` can call upon. A `TreeGuesser` is an object that stores a tree in the `self.root` and `self.tree` attributes, and while the game is being played, it follows branches in the tree, choosing the guess indicated at each node. This is done within the `__call__` method, because `play_jotto` expects a callable. Note that whenever the reply is `None`, that indicates the first turn of a new game, in which case we reset `self.tree` to be the root tree. For subsequent turns, we follow the branch indicated by the reply. If the resulting `self.tree` is a `Node` object, then the `.guess` attribute is the guess; if it is a leaf, then the leaf itself is the guess." + "I can speed up computation by precomputing a **guesser tree**: a tree that keeps partitioning target words into branches until every branch holds a single word (we call that a leaf). Think of the tree as a universal strategy that we can apply to every target word with no need for additional computation—just branch-following in the tree. I define a guesser tree as either:\n", + "- A **leaf**, which is a string, such as `'coder'`, indicating that this is the sole remaining consistent target. Every word in the word list should appear as a leaf in exactly one place in the guesser tree.\n", + "- An **interior node**, which is a tuple of a guess and a dict of branches, `(guess, {reply: subtree, ...})`, where the reply is an integer, 0 to 5, and each subtree covers all the target words that are consistent with that reply." ] }, { @@ -589,16 +510,98 @@ "execution_count": 18, "metadata": {}, "outputs": [], + "source": [ + "Leaf = str\n", + "Node = Tuple[str, Dict[Reply, 'Tree']]\n", + "Tree = Union[Leaf, Node] # A Tree is a Node or a Leaf\n", + "GUESS, BRANCHES = 0, 1 # Indexes into a Node tuple" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The function `make_tree(metric, targets)` builds a 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": 19, + "metadata": {}, + "outputs": [], + "source": [ + "def make_tree(metric, targets=wordlist) -> Tree:\n", + " \"\"\"Make a tree that guesses to 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 (guess, {reply: make_tree(metric, branches[reply]) \n", + " for reply in sorted(branches)})" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Here is a tree that covers five words by always making the guess that minimizes the **maximum** number in the partition counts:" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "('bites',\n", + " {1: ('purge', {1: ('sulky', {1: 'hayed', 5: 'sulky'}), 5: 'purge'}),\n", + " 2: 'patsy',\n", + " 5: 'bites'})" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "words5 = ['purge', 'bites', 'sulky', 'patsy', 'hayed']\n", + "tree5 = make_tree(max, words5)\n", + "tree5" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The tree says that the first guess is `'bites'`, and if the reply is `1` there is a complex subtree to consider (starting with the guess `'purge'`), but if the reply is `2` the target can only be `'patsy'` and of course if the reply is `5` then `'bites'` was the target." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Turning a Tree into a Callable Guesser\n", + "\n", + "Now that we've made a tree, we need to use it as a component of a guesser that `play_jotto` can call upon. A `TreeGuesser` is an object that stores a tree in the `self.root` and `self.tree` attributes, and while the game is being played, it follows branches in the tree, choosing the guess indicated at each node. This is done within the `__call__` method, because `play_jotto` expects a callable. Note that on the first turn of a new game the reply will be `None`, in which case we reset `self.tree` to be the root tree. For subsequent turns, we follow the branch indicated by the reply. " + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [], "source": [ "class TreeGuesser:\n", " \"\"\"Given a guesser tree, use it to create a callable that can play_jotto.\"\"\"\n", " def __init__(self, tree): self.root = self.tree = tree\n", " \n", " def __call__(self, reply, _) -> str:\n", - " self.tree = self.root if reply is None else self.tree.branches[reply]\n", - " return guess(self.tree)\n", - " \n", - "def guess(tree) -> str: return tree.guess if isinstance(tree, Node) else tree " + " self.tree = self.root if reply is None else self.tree[BRANCHES][reply]\n", + " return self.tree if isinstance(self.tree, str) else self.tree[GUESS]" ] }, { @@ -610,31 +613,32 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 22, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Guess 1: bites, Reply: 1, Possible targets: 3\n", - "Guess 2: purge, Reply: 1, Possible targets: 2\n", - "Guess 3: sulky, Reply: 5, Possible targets: 1\n" + "Guess 1: bites, Reply: 1, Consistent targets: 3\n", + "Guess 2: purge, Reply: 1, Consistent targets: 2\n", + "Guess 3: sulky, Reply: 1, Consistent targets: 1\n", + "Guess 4: hayed, Reply: 5, Consistent targets: 1\n" ] }, { "data": { "text/plain": [ - "3" + "4" ] }, - "execution_count": 19, + "execution_count": 22, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "play_jotto(TreeGuesser(tree5), target='sulky', wordlist=words5, verbose=True)" + "play_jotto(TreeGuesser(tree5), wordlist=words5, verbose=True)" ] }, { @@ -646,63 +650,65 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 23, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Guess 1: wader, Reply: 0, Possible targets: 466\n", - "Guess 2: tings, Reply: 1, Possible targets: 142\n", - "Guess 3: hypos, Reply: 0, Possible targets: 8\n", - "Guess 4: climb, Reply: 5, Possible targets: 1\n" + "Guess 1: wader, Reply: 3, Consistent targets: 319\n", + "Guess 2: sword, Reply: 1, Consistent targets: 131\n", + "Guess 3: paled, Reply: 3, Consistent targets: 56\n", + "Guess 4: cadet, Reply: 4, Consistent targets: 15\n", + "Guess 5: hated, Reply: 5, Consistent targets: 1\n" ] }, { "data": { "text/plain": [ - "4" + "5" ] }, - "execution_count": 20, + "execution_count": 23, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "tree = make_tree(max)\n", - "play_jotto(TreeGuesser(tree), verbose=True)" + "tree = make_tree(max)\n", + "guesser = TreeGuesser(tree)\n", + "\n", + "play_jotto(guesser, verbose=True)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "# Guessing a Nontarget Word\n", + "# Making Inconsistent Guesses\n", "\n", - "So far, we have always guessed one of the possible targets. 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", + "So far, we have always guessed one of the consistent targets. 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", - "I will redefine `make_tree` so that it is passed both the list of possible target words and the complete word list. It also has a flag, `nontargets`. When this flag is true, any word in the wordlist can be considered as a guess; when false, only target words are considered, as before. (One hack: if there are only three targets or fewer remaining, then it makes no sense to consider a nontarget guess, because it can't possibly decrease the mean score.)" + "I will redefine `make_tree` so that it is passed both the list of consistent target words and the complete word list. It also has 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. " ] }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 24, "metadata": {}, "outputs": [], "source": [ - "def make_tree(metric, targets=wordlist, wordlist=wordlist, nontargets=False) -> Tree:\n", - " \"\"\"Make a tree that guesses to minimize or maximize metric(reply_counts(guess, targets)).\n", - " Allow nontarget guesses if `nontargets` is true.\"\"\"\n", + "def make_tree(metric, targets=wordlist, wordlist=wordlist, inconsistent=False) -> Tree:\n", + " \"\"\"Make a tree that guesses to minimize metric(partition_counts(guess, targets)).\"\"\"\n", " if len(targets) == 1:\n", " return targets[0]\n", " else:\n", - " candidates = wordlist if nontargets and len(targets) > 3 else targets\n", - " guess = min(candidates, key=lambda guess: metric(reply_counts(guess, targets))) \n", - " branches = reply_branches(guess, targets)\n", - " return Node(guess, {i: make_tree(metric, branches[i], wordlist, nontargets) \n", - " for i in range(6) if branches[i]})" + " words = wordlist if (inconsistent and len(targets) > 3) else targets\n", + " guess = min(words, key=lambda guess: metric(partition_counts(guess, targets))) \n", + " branches = partition(guess, targets)\n", + " return (guess, {reply: make_tree(metric, branches[reply], wordlist, inconsistent) \n", + " for reply in sorted(branches)})" ] }, { @@ -714,16 +720,19 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 25, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "Node(guess='bites', branches={1: Node(guess='purge', branches={1: Node(guess='sulky', branches={1: 'hayed', 5: 'sulky'}), 5: 'purge'}), 2: 'patsy', 5: 'bites'})" + "('bites',\n", + " {1: ('purge', {1: ('sulky', {1: 'hayed', 5: 'sulky'}), 5: 'purge'}),\n", + " 2: 'patsy',\n", + " 5: 'bites'})" ] }, - "execution_count": 22, + "execution_count": 25, "metadata": {}, "output_type": "execute_result" } @@ -736,82 +745,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "But when allowed to guess a nontarget word, it comes up with a different tree:" - ] - }, - { - "cell_type": "code", - "execution_count": 23, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Node(guess='dashy', branches={0: 'purge', 1: 'bites', 2: 'sulky', 3: 'patsy', 4: 'hayed'})" - ] - }, - "execution_count": 23, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "tree5b = make_tree(max, words5, nontargets=True)\n", - "tree5b" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "This tree guesses a nontarget word, `dashy` with the first guess. There is no chance that this is the target, but it sets us up so that we will always be able to get the target on the second guess (so the average score, and the maximum score, is 2):" - ] - }, - { - "cell_type": "code", - "execution_count": 24, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[2, 2, 2, 2, 2]" - ] - }, - "execution_count": 24, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "play_jottos(TreeGuesser(tree5b), words5)" - ] - }, - { - "cell_type": "code", - "execution_count": 25, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(2, 2)" - ] - }, - "execution_count": 25, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "mean(_), max(_)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "In contrast, the guesser that guesses only target words has an average score of 2.4, and can take up to four guesses:" + "But when allowed `make_tree` to guess an inconsistent word, it comes up with a different tree:" ] }, { @@ -822,7 +756,7 @@ { "data": { "text/plain": [ - "[2, 1, 3, 2, 4]" + "('dashy', {0: 'purge', 1: 'bites', 2: 'sulky', 3: 'patsy', 4: 'hayed'})" ] }, "execution_count": 26, @@ -831,7 +765,15 @@ } ], "source": [ - "play_jottos(TreeGuesser(tree5), words5)" + "tree5b = make_tree(max, words5, inconsistent=True)\n", + "tree5b" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This tree guesses an inconsistent word, `dashy`, with the first guess. There is no chance that this is the target, but it sets us up so that we will always be able to get the target on the second guess. That means that both the average and the worst case number of guesses is 2 for `tree5b`:" ] }, { @@ -842,7 +784,7 @@ { "data": { "text/plain": [ - "(2.4, 4)" + "[2, 2, 2, 2, 2]" ] }, "execution_count": 27, @@ -850,6 +792,26 @@ "output_type": "execute_result" } ], + "source": [ + "play_jottos(TreeGuesser(tree5b), words5)" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(2, 2)" + ] + }, + "execution_count": 28, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "mean(_), max(_)" ] @@ -858,64 +820,101 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "So the tree with a nontarget guess is better both in the mean (2.0 versus 2.4) and in the maximum (2 versus 4).\n", - "\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Comparing Metrics" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Now we will compare six guessers derived from `make_tree`:\n", - "- Minimizing either `max`, `expectation`, or `negative_entropy`.\n", - "- For each of the above, guessing either targets only or targets plus nontargets.\n", - "\n", - "The function `show_metric` makes the appropriate tree and calls `play_jottos` and `show` to display results:" - ] - }, - { - "cell_type": "code", - "execution_count": 28, - "metadata": {}, - "outputs": [], - "source": [ - "def show_metric(metric, nontargets=False):\n", - " \"\"\"Show statistics and histogram for a guesser that minimizes `metric` over reply counts.\"\"\"\n", - " guesser = TreeGuesser(make_tree(metric, nontargets=nontargets))\n", - " show(play_jottos(guesser))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Comparing Metrics for Target Guesses Only" + "In contrast, `tree5` has an average score of 2.4, and can take up to four guesses in the worst case:" ] }, { "cell_type": "code", "execution_count": 29, "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[2, 1, 3, 2, 4]" + ] + }, + "execution_count": 29, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "play_jottos(TreeGuesser(tree5), words5)" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(2.4, 4)" + ] + }, + "execution_count": 30, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "mean(_), max(_)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "So the tree with an inconsistent guess is better both in the average and in the worst case.\n", + "\n", + "# Comparing Metrics\n", + "\n", + "Now we will compare six guessers derived from `make_tree`:\n", + "- Minimizing either `max`, `expectation`, or `negative_entropy`.\n", + "- For each of the above, guessing either consistent targets only or allowing inconsistent targets.\n", + "\n", + "The function `show_metric` makes the appropriate `TreeGuesser` and calls `play_jottos` and `show` to display results:" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [], + "source": [ + "def show_metric(metric, inconsistent):\n", + " \"\"\"Show statistics and histogram for a guesser that minimizes `metric` over partition counts.\"\"\"\n", + " tree = make_tree(metric, inconsistent=inconsistent)\n", + " guesser = TreeGuesser(tree)\n", + " show(play_jottos(guesser))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Comparing Metrics with Consistent Guesses Only" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "mean = 7.15 ± 1.81, max = 18\n", - "CPU times: user 12.7 s, sys: 28.7 ms, total: 12.8 s\n", - "Wall time: 12.8 s\n" + "mean = 7.15 ± 1.81 guesses; worst = 18\n", + "CPU times: user 12.6 s, sys: 29.5 ms, total: 12.6 s\n", + "Wall time: 12.6 s\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -932,21 +931,21 @@ }, { "cell_type": "code", - "execution_count": 30, + "execution_count": 33, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "mean = 7.14 ± 1.82, max = 17\n", - "CPU times: user 14.2 s, sys: 69.5 ms, total: 14.2 s\n", - "Wall time: 14.5 s\n" + "mean = 7.14 ± 1.82 guesses; worst = 17\n", + "CPU times: user 13 s, sys: 59.7 ms, total: 13.1 s\n", + "Wall time: 13.2 s\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -963,21 +962,21 @@ }, { "cell_type": "code", - "execution_count": 31, + "execution_count": 34, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "mean = 7.09 ± 1.79, max = 19\n", - "CPU times: user 12.9 s, sys: 59.3 ms, total: 13 s\n", - "Wall time: 13 s\n" + "mean = 7.09 ± 1.79 guesses; worst = 19\n", + "CPU times: user 13.6 s, sys: 87.6 ms, total: 13.6 s\n", + "Wall time: 14.6 s\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -996,26 +995,26 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# Comparing Metrics with Nontarget Guesses Allowed" + "# Comparing Metrics with Inconsistent Guesses Allowed" ] }, { "cell_type": "code", - "execution_count": 32, + "execution_count": 35, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "mean = 7.05 ± 0.98, max = 10\n", - "CPU times: user 32.3 s, sys: 47.2 ms, total: 32.3 s\n", - "Wall time: 32.4 s\n" + "mean = 7.05 ± 0.98 guesses; worst = 10\n", + "CPU times: user 38.2 s, sys: 134 ms, total: 38.4 s\n", + "Wall time: 38.5 s\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAX4AAAEGCAYAAABiq/5QAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAAWsUlEQVR4nO3de7gkdX3n8fdHLoIgosygCMZBl/USo6izCMEYAphFcREjKkRcokTcFUVjfBJ0XSPRbOBxjYproigCWRFF8YJAQMJFQ1RwuINI8DIaIjCjcpFV0YHv/lF15HDmzJmeyVSdmfm9X8/TT1dVV/X3V90zn67zq+5fpaqQJLXjQfPdAEnSuAx+SWqMwS9JjTH4JakxBr8kNWbT+W7AJBYsWFCLFi2a72ZI0gbl8ssv/1FVLZy5fIMI/kWLFrFkyZL5boYkbVCSfH+25Xb1SFJjDH5JaozBL0mNMfglqTEGvyQ1xuCXpMYY/JLUGINfkhpj8EtSYzaIX+5KWrVFR589Wq2lx+4/Wi0NxyN+SWqMwS9JjTH4JakxBr8kNcbgl6TGGPyS1BiDX5IaY/BLUmMMfklqjMEvSY0x+CWpMQa/JDXG4Jekxhj8ktQYg1+SGmPwS1JjDH5JaszgwZ9kkyRXJjmrn985yaVJbkryqSSbD90GSdL9xjjifwNww7T544D3VtUuwO3A4SO0QZLUGzT4k+wE7A98tJ8PsDfwmX6VU4ADh2yDJOmBhj7ifx/wZ8B9/fx2wB1VtaKfvxnYcbYNkxyRZEmSJcuXLx+4mZLUjsGCP8kLgGVVdfn0xbOsWrNtX1UnVNXiqlq8cOHCQdooSS3adMDn3hM4IMnzgS2Abej+Atg2yab9Uf9OwA8HbIMkaYbBjvir6i1VtVNVLQIOBi6sqpcDFwEH9asdBnxhqDZIklY2H9/j/3PgTUm+Tdfnf+I8tEGSmjVkV8+vVdXFwMX99HeB3caoK0lamb/claTGGPyS1BiDX5IaY/BLUmMMfklqjMEvSY0x+CWpMQa/JDXG4Jekxhj8ktQYg1+SGmPwS1JjDH5JaozBL0mNMfglqTEGvyQ1xuCXpMYY/JLUGINfkhpj8EtSYwx+SWqMwS9JjTH4JakxBr8kNcbgl6TGGPyS1BiDX5IaY/BLUmMMfklqjMEvSY0x+CWpMQa/JDXG4Jekxhj8ktQYg1+SGmPwS1JjDH5JasxgwZ9kiySXJbk6yfVJjumX75zk0iQ3JflUks2HaoMkaWVDHvHfA+xdVU8DdgX2S7I7cBzw3qraBbgdOHzANkiSZhgs+Ktzdz+7WX8rYG/gM/3yU4ADh2qDJGllg/bxJ9kkyVXAMuB84DvAHVW1ol/lZmDHIdsgSXqgQYO/qu6tql2BnYDdgCfNttps2yY5IsmSJEuWL18+ZDMlqSmrDf4kj0/y4H56ryRHJdl2TYpU1R3AxcDuwLZJNu0f2gn44Sq2OaGqFlfV4oULF65JOUnSHCY54j8DuDfJfwBOBHYGPrG6jZIsnPqASLIlsC9wA3ARcFC/2mHAF9ai3ZKktbTp6lfhvqpakeRFwPuq6gNJrpxgux2AU5JsQvcBc3pVnZXkm8Ank7wLuJLuw0SSNJJJgv9XSQ6hOzr/L/2yzVa3UVVdAzx9luXfpevvlyTNg0m6el4J7AH8VVV9L8nOwMeHbZYkaSiTHPE/t6qOmprpw//nA7ZJkjSgSY74D5tl2R+t43ZIkkayyiP+vl//D4Gdk5w57aGHAj8eumGSpGHM1dXzVeAWYAHwnmnLfwpcM2SjJEnDWWXwV9X3ge8DeyR5LLBLVf1j/538Lek+ACRJG5hJfrn7arpB1T7cL9oJ+PyQjZIkDWeSk7tHAnsCdwFU1U3A9kM2SpI0nEmC/56q+uXUTD/OzqwDq0mS1n+TBP+Xk7wV2DLJc4FPA18ctlmSpKFMEvxHA8uBa4HXAOcAbxuyUZKk4az2l7tVdR/wkf4mSdrArTb4k1zLyn36dwJLgHdVlT/mkqQNyCRj9fwDcC/3j8F/cH9/F3Ay94/YKakhi44+e9R6S4/df9R6G7NJgn/Pqtpz2vy1Sf65qvZMcuhQDZMkDWOSk7tbJ3nW1EyS3YCt+9kVs28iSVpfTXLEfzhwUpKpsP8pcHiSrYC/HqxlkqRBzBn8SR4EPK6qfivJw4D0F06fcvqgrZMkrXNzdvX0X+V8XT9954zQlyRtgCbp4z8/yZuTPCbJI6Zug7dMkjSISfr4X9XfHzltWQGPW/fNkSQNbZJf7u48RkMkSeOY5IifJE8BngxsMbWsqv5+qEZJkoYzyZANfwHsRRf85wDPAy4BDH5J2gBNcnL3IGAf4NaqeiXwNODBg7ZKkjSYSYL/5/3XOlck2QZYhid2JWmDNUkf/5Ik29INy3w5cDdw2aCtkiQNZpJv9by2n/xQknOBbarqmmGbJUkaymq7epJcMDVdVUur6prpyyRJG5ZVHvEn2QJ4CLAgycOB9A9tAzx6hLZJkgYwV1fPa4A30oX85dwf/HcBHxy4XZKkgawy+Kvq/cD7k7y+qj4wYpskSQNabR+/oS9JG5dJvscvSdqIrDL4k+zZ3/srXUnaiMx1xH98f/+1MRoiSRrHXN/q+VWSk4Adkxw/88GqOmq4ZkmShjJX8L8A2BfYm+7rnJKkjcBcX+f8EfDJJDdU1dVr+sRJHkM3dPOjgPuAE6rq/f1lGz8FLAKWAi+tqtvXou2SpLUwybd6fpzkc0mWJbktyRlJdppguxXAn1bVk4DdgSOTPBk4GrigqnYBLujnJUkjmST4TwLOpPsF747AF/tlc6qqW6rqin76p8AN/fYvBE7pVzsFOHDNmy1JWluTBP/2VXVSVa3obycDC9ekSJJFwNOBS4FHVtUt0H04ANuvYpsjkixJsmT58uVrUk6SNIdJgn95kkOTbNLfDgV+PGmBJFsDZwBvrKq7Jt2uqk6oqsVVtXjhwjX6nJEkzWGS4H8V8FLgVuAWuksxvmqSJ0+yGV3on1pVn+0X35Zkh/7xHeiu6CVJGskkF2L5AXDAmj5xkgAnAjdU1d9Me+hM4DDg2P7+C2v63JKktTfJpRfX1p7AK4Brk1zVL3srXeCfnuRw4AfASwZsgyRphsGCv6ou4f4x/GfaZ6i6kqS5OTqnJDVm4uBPsnuSC5P8cxK/ey9JG6i5rrn7qKq6ddqiN9Gd5A3wVeDzA7dN2mAsOvrs0WotPXb/0Wpp4zRXH/+HklwOvLuqfgHcAfwh3bg7E38fX5K0flllV09VHQhcBZyV5BV0F16/D3gIDrMgSRusOfv4q+qLwH8GtgU+C9xYVcdXlWMoSNIGaq5LLx6Q5BLgQuA64GDgRUlOS/L4sRooSVq35urjfxewB7AlcE5V7Qa8KckuwF/RfRBIkjYwcwX/nXThviXTxtOpqpsw9CVpgzVXH/+L6E7krqD7No8kaSOwuksvfmDEtkiSRuCQDZLUGINfkhpj8EtSYwx+SWqMwS9JjTH4JakxBr8kNcbgl6TGGPyS1BiDX5IaY/BLUmMMfklqjMEvSY0x+CWpMQa/JDXG4Jekxhj8ktQYg1+SGmPwS1JjDH5JaozBL0mNMfglqTEGvyQ1xuCXpMYY/JLUGINfkhozWPAn+ViSZUmum7bsEUnOT3JTf//woepLkmY35BH/ycB+M5YdDVxQVbsAF/TzkqQRDRb8VfUV4CczFr8QOKWfPgU4cKj6kqTZjd3H/8iqugWgv99+VSsmOSLJkiRLli9fPloDJWljt96e3K2qE6pqcVUtXrhw4Xw3R5I2GmMH/21JdgDo75eNXF+Smjd28J8JHNZPHwZ8YeT6ktS8Ib/OeRrwNeAJSW5OcjhwLPDcJDcBz+3nJUkj2nSoJ66qQ1bx0D5D1ZQkrd56e3JXkjQMg1+SGmPwS1JjDH5JaozBL0mNMfglqTEGvyQ1xuCXpMYY/JLUGINfkhpj8EtSYwx+SWqMwS9JjTH4JakxBr8kNcbgl6TGGPyS1JjBrsAljW3R0WePWm/psfuPWk9aVwx+SRscP+T/fezqkaTGGPyS1BiDX5IaY/BLUmMMfklqjMEvSY0x+CWpMQa/JDXG4Jekxhj8ktQYg1+SGmPwS1JjDH5JaozBL0mNMfglqTEGvyQ1xuCXpMYY/JLUGC+9qHXKS+JJ6795OeJPsl+SG5N8O8nR89EGSWrV6MGfZBPgg8DzgCcDhyR58tjtkKRWzUdXz27At6vquwBJPgm8EPjmPLRlUGN2e9jlIY1jY/h/naoa5IlXWTA5CNivqv64n38F8Kyqet2M9Y4AjuhnnwDcOGpDYQHwo5FrznftFve51dot7nOLtR9bVQtnLpyPI/7MsmylT5+qOgE4YfjmzC7Jkqpa3FLtFve51dot7nPLtWeaj5O7NwOPmTa/E/DDeWiHJDVpPoL/G8AuSXZOsjlwMHDmPLRDkpo0eldPVa1I8jrgPGAT4GNVdf3Y7ZjAvHUzzWPtFve51dot7nPLtR9g9JO7kqT55ZANktQYg1+SGmPwz5DkY0mWJblu5LqPSXJRkhuSXJ/kDSPW3iLJZUmu7msfM1btvv4mSa5MctbIdZcmuTbJVUmWjFx72ySfSfKt/j3fY6S6T+j3d+p2V5I3jlG7r/8n/b+x65KclmSLkeq+oa95/dD7O1uGJHlEkvOT3NTfP3zINqyOwb+yk4H95qHuCuBPq+pJwO7AkSMOZXEPsHdVPQ3YFdgvye4j1QZ4A3DDiPWm+72q2nUevl/9fuDcqnoi8DRG2v+qurHf312BZwI/Az43Ru0kOwJHAYur6il0X+44eIS6TwFeTTdqwNOAFyTZZcCSJ7NyhhwNXFBVuwAX9PPzxuCfoaq+AvxkHureUlVX9NM/pQuCHUeqXVV1dz+7WX8b5ax/kp2A/YGPjlFvfZBkG+A5wIkAVfXLqrpjHpqyD/Cdqvr+iDU3BbZMsinwEMb5Dc+TgK9X1c+qagXwZeBFQxVbRYa8EDilnz4FOHCo+pMw+NdDSRYBTwcuHbHmJkmuApYB51fVWLXfB/wZcN9I9aYr4EtJLu+HCBnL44DlwEl9F9dHk2w1Yv0pBwOnjVWsqv4N+N/AD4BbgDur6ksjlL4OeE6S7ZI8BHg+D/wR6RgeWVW3QHeQB2w/cv0HMPjXM0m2Bs4A3lhVd41Vt6ru7f/83wnYrf/zeFBJXgAsq6rLh661CntW1TPoRoo9MslzRqq7KfAM4O+q6unA/2PkP/37H08eAHx6xJoPpzvy3Rl4NLBVkkOHrltVNwDHAecD5wJX03WtNsvgX48k2Ywu9E+tqs/ORxv6LoeLGec8x57AAUmWAp8E9k7y8RHqAlBVP+zvl9H1c+82UumbgZun/VX1GboPgjE9D7iiqm4bsea+wPeqanlV/Qr4LPDbYxSuqhOr6hlV9Ry6bpibxqg7zW1JdgDo75eNXP8BDP71RJLQ9fneUFV/M3LthUm27ae3pPsP+q2h61bVW6pqp6paRNftcGFVDX4ECJBkqyQPnZoGfp+uS2BwVXUr8K9JntAv2ofxhyU/hBG7eXo/AHZP8pD+3/s+jHRSO8n2/f1vAH/A+Pt+JnBYP30Y8IWR6z+Al16cIclpwF7AgiQ3A39RVSeOUHpP4BXAtX1fO8Bbq+qcEWrvAJzSXyTnQcDpVTXqVyvnwSOBz3X5w6bAJ6rq3BHrvx44te9y+S7wyrEK9/3czwVeM1ZNgKq6NMlngCvoulquZLxhDM5Ish3wK+DIqrp9qEKzZQhwLHB6ksPpPgBfMlT9SThkgyQ1xq4eSWqMwS9JjTH4JakxBr8kNcbgl6TGGPyNSlJJ3jNt/s1J3rGOnvvkJAeti+daTZ2X9CNbXjR0rSEl2TXJ89diu9OSXNOPePmXSfZdw+2XJlkwy/K3rmlb1sba7rf+/Qz+dt0D/MFs//HnU/9bgkkdDry2qn5vqPaMZFe68WMmluRRwG9X1VOr6r1V9faq+sd11J41Dv41fN+mrPF+a90w+Nu1gu7HM38y84GZR+xJ7u7v90ry5SSnJ/mXJMcmeXm6sfyvTfL4aU+zb5J/6td7Qb/9JkneneQb/ZHqa6Y970VJPgFcO0t7Dumf/7okx/XL3g48G/hQknfPWP9BSf62H3v9rCTnTO3P9KPcJIuTXNxPb5VuHPVv9AOnvbBf/pv9/l3Vt3mXft2z012/4LokL+vXfWb/+lye5LxpP9E/Ksk3++0/OaOtmwN/Cbysr/GydGO3f75f/+tJnjrL+/clYPt+m9+Z/p71+3hMkiv61+2J/fLtknyp378PA5nltT6WbvTMq5Kc2i/7fL9P12faYHZJ7u7/0rgU2CPJ89NdX+CSJMenv77CbK/tbPs9yz5qKFXlrcEbcDewDbAUeBjwZuAd/WMnAwdNX7e/3wu4g+6Xvg8G/g04pn/sDcD7pm1/Lt2BxS50Y9NsARwBvK1f58HAEroBu/aiG6hs51na+Wi6XzoupPuF7YXAgf1jF9ON7T5zm4OAc/r6jwJun9qffn8X9NOLgYv76f8FHNpPbwv8C7AV8AHg5f3yzYEtgRcDH5lW72F0Q1l/FVjYL3sZ8LF++ofAg6eee5b2/hHwf6bNf4DuF+MAewNXzbLNIuC6afO/fs/6fXx9P/1a4KP99PHA2/vp/elGJ10w27+NGfOP6O+3pBvWYrt+voCX9tNbAP869R7SDYlw1mpe2wfst7fxbh7xN6y60T//nu7iGJP6RnXXDrgH+A7dkSd0R+qLpq13elXdV1U30Q1J8ES68XD+a7ohKS4FtqP7YAC4rKq+N0u9/0QXzsurG0v9VLqx7OfybODTff1bgUnOAfw+cHTftovpguw3gK8Bb03y58Bjq+rn/b7um+S4JL9TVXcCTwCeApzfP8fb6EY6BbiGbniGQ5lsVMhnA/8XoKouBLZL8rAJtptuapC/y7n/fXkO8PH+ec+m+0CcxFFJrga+Tjec8dR7di/doILQvb/fnfYeTh8LZ1WvreaJY/XofXRjp5w0bdkK+m7AJKE70p1yz7Tp+6bN38cD/z3NHAuk6LoWXl9V501/IMledEf8s1mpO2ICc23z632jC6Dp27y4qm6csf4NfVfG/sB5Sf64qi5M8ky6/um/TvIlutE9r6+q2S6huD9d6B4A/M8kv9l/iK1J+9d0bJWp9+Ve5n5f5tS/N/sCe1TVz/qusanX7RdVde/UqnM9DbO8tkmetSZt0brjEX/jquonwOl0J0qnLKW7LB9046dvthZP/ZK+r/3xdBceuRE4D/jv6YafJsl/zOovQHIp8LtJFqQ7gXgI3RWU5nIJ8OK+/iPpupKmLOX+fXvxtOXnAa/vP+hI8vT+/nF0R7LH042w+NQkjwZ+VlUfp7uwyDP6/VuY/tq5STbrzw88CHhMVV1Ed8GZbYGtZ7T3p8BDp81/BXh5/zx7AT+qdXNthunP+zxgVdd9/dXUe0TXjXV7H/pPpLss6Gy+BTwu3UWEoOvqmjLra8vK+62RGPwCeA8w/ds9H6EL28uAZ7Hqo/G53EgX0P8A/Leq+gXd5RW/CVyR7kLUH2Y1f3VWd7Wit9B111xNN4b86oa0PYPuvMJUjUuBO/vHjgHen+Sf6I6Gp7yT7gPumr5t7+yXvwy4ru+meCJd19hvAZf1y/4H8K6q+iXduYXj+m6Rq+jGmt8E+HiSa+lGo3xvrXyZxYuAJ087yfkOYHGSa+hGdTyMdeMYuitRXUHX/fKDVax3At3rcCrduZpN+7a8k667ZyV9F9hrgXOTXALcxv2v+ape25n7rZE4Oqc2Skm2rqq70w3Fexnd1bZune92bcymveYBPgjcVFXvne92aWX28WtjdVa6i8tsDrzT0B/Fq5McRveaX0n315bWQx7xS1Jj7OOXpMYY/JLUGINfkhpj8EtSYwx+SWrM/wcjPEwbRHjHlAAAAABJRU5ErkJggg==\n", "text/plain": [ "
" ] @@ -1032,21 +1031,21 @@ }, { "cell_type": "code", - "execution_count": 33, + "execution_count": 36, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "mean = 6.84 ± 0.95, max = 10\n", - "CPU times: user 34 s, sys: 66.9 ms, total: 34.1 s\n", - "Wall time: 34.3 s\n" + "mean = 6.84 ± 0.95 guesses; worst = 10\n", + "CPU times: user 39.9 s, sys: 183 ms, total: 40.1 s\n", + "Wall time: 40.5 s\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAX4AAAEGCAYAAABiq/5QAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAAWsElEQVR4nO3de7gkdX3n8fdH7oKIMoMiGAfdWS8xijqLEIwhgFkUFzFihIg7USLuioIanwRd10g0CTyuUTFmFUUgK2JQvCAQkHDRsCo4IFeR4AUNkct4AWRVdOC7f1QdOZw5c6ZnnKozM7/363n66arqrv7+qnvm03V+1fWrVBWSpHY8aL4bIEkal8EvSY0x+CWpMQa/JDXG4Jekxmw63w2YxIIFC2rRokXz3QxJ2qBcfvnlP6iqhTOXbxDBv2jRIpYtWzbfzZCkDUqS78623K4eSWqMwS9JjTH4JakxBr8kNcbgl6TGGPyS1BiDX5IaY/BLUmMMfklqzAZx5q6kVVt09Nmj1brp2P1Hq6XhuMcvSY0x+CWpMQa/JDXG4Jekxhj8ktQYg1+SGmPwS1JjDH5JaozBL0mNMfglqTEGvyQ1xuCXpMYY/JLUGINfkhpj8EtSYwx+SWqMwS9JjTH4JakxBr8kNcbgl6TGGPyS1JjBgz/JJkm+luSsfn6XJJcmuTHJPybZfOg2SJLuN8Ye/1HA9dPmjwPeXVWLgR8Dh43QBklSb9DgT7IzsD/w4X4+wN7AJ/unnAIcOGQbJEkPNPQe/3uAPwPu6+e3B+6oqhX9/M3ATrOtmOTwJMuSLFu+fPnAzZSkdgwW/EmeD9xeVZdPXzzLU2u29avqhKpaUlVLFi5cOEgbJalFmw742nsCByR5HrAlsC3dXwDbJdm03+vfGfj+gG2QJM0w2B5/Vb2pqnauqkXAwcCFVfVS4CLgoP5pS4HPDtUGSdLK5uN3/H8OvCHJN+n6/E+chzZIUrOG7Or5laq6GLi4n/42sNsYdSVJK/PMXUlqjMEvSY0x+CWpMQa/JDXG4Jekxhj8ktQYg1+SGmPwS1JjDH5JaozBL0mNMfglqTEGvyQ1xuCXpMYY/JLUGINfkhpj8EtSYwx+SWqMwS9JjTH4JakxBr8kNcbgl6TGGPyS1BiDX5IaY/BLUmMMfklqjMEvSY0x+CWpMQa/JDXG4Jekxhj8ktQYg1+SGmPwS1JjDH5JaozBL0mNMfglqTEGvyQ1ZrDgT7JlksuSXJXkuiTH9Mt3SXJpkhuT/GOSzYdqgyRpZUPu8d8D7F1VTwV2BfZLsjtwHPDuqloM/Bg4bMA2SJJmWG3wJ3lcki366b2SHJlku9WtV527+9nN+lsBewOf7JefAhy4Vi2XJK2VSfb4zwDuTfIfgBOBXYCPTfLiSTZJciVwO3A+8C3gjqpa0T/lZmCnVax7eJJlSZYtX758knKSpAlMEvz39UH9QuA9VfV6YMdJXryq7q2qXYGdgd2AJ872tFWse0JVLamqJQsXLpyknCRpApME/y+THAIsBc7ql222JkWq6g7gYmB3YLskm/YP7Qx8f01eS5L065kk+F8O7AH8VVV9J8kuwEdXt1KShVPHApJsBewLXA9cBBzUP20p8Nm1abgkae1suvqn8JyqOnJqpg//n02w3o7AKUk2ofuCOb2qzkrydeDjSd4BfI3uuIEkaSSTBP9S4L0zlv3xLMseoKquBp42y/Jv0/X3S5LmwSqDv+/X/yNglyRnTnvoIcAPh26YJGkYc+3xfwm4BVgAvGva8p8AVw/ZKEnScFYZ/FX1XeC7wB5JHgMsrqp/7g/UbkX3BSBJ2sBMcubuK+nOtP1gv2hn4DNDNkqSNJxJfs55BLAncBdAVd0I7DBkoyRJw5kk+O+pql9MzfQnX816tq0kaf03SfB/Icmbga2SPAf4BPC5YZslSRrKJMF/NLAcuAZ4FXAO8JYhGyVJGs5qT+CqqvuAD/U3SdIGbrXBn+QaVu7TvxNYBryjqjyZS5I2IJMM2fBPwL3cPwb/wf39XcDJwH9Z982SJA1lkuDfs6r2nDZ/TZL/W1V7Jjl0qIZJkoYxycHdbZI8c2omyW7ANv3sitlXkSStrybZ4z8MOCnJVNj/BDgsydbA3wzWMknSIOYM/iQPAh5bVb+V5KFA+qtpTTl90NZJG4hFR589Wq2bjt1/tFraOM3Z1dP/lPM1/fSdM0JfkrQBmqSP//wkb0zy6CQPn7oN3jJJ0iAm6eN/RX9/xLRlBTx23TdHkjS0Sc7c3WWMhkiSxjHJHj9Jngw8CdhyallV/cNQjZIkDWeSIRv+AtiLLvjPAZ4LXAIY/JK0AZrk4O5BwD7ArVX1cuCpwBaDtkqSNJhJgv9n/c86VyTZFrgdD+xK0gZrkj7+ZUm2oxuW+XLgbuCyQVslSRrMJL/qeXU/+YEk5wLbVtXVwzZLkjSU1Xb1JLlgarqqbqqqq6cvkyRtWFa5x59kS+DBwIIkDwPSP7Qt8KgR2iZJGsBcXT2vAl5HF/KXc3/w3wW8f+B2SZIGssrgr6r3Au9N8tqqet+IbZIkDWi1ffyGviRtXCb5Hb8kaSOyyuBPsmd/71m6krQRmWuP//j+/stjNESSNI65ftXzyyQnATslOX7mg1V15HDNkiQNZa7gfz6wL7A33c85JUkbgbl+zvkD4ONJrq+qq0ZskyRpQJP8queHST6d5PYktyU5I8nOg7dMkjSISYL/JOBMujN4dwI+1y+bU39x9ouSXJ/kuiRH9csfnuT8JDf29w/7dTZAkrRmJgn+HarqpKpa0d9OBhZOsN4K4E+r6onA7sARSZ4EHA1cUFWLgQv6eUnSSCYJ/uVJDk2ySX87FPjh6laqqluq6op++ifA9XR/MbwAOKV/2inAgWvXdEnS2pgk+F8B/CFwK3AL3aUYX7EmRZIsAp4GXAo8oqpuge7LAdhhFescnmRZkmXLly9fk3KSpDlMciGW7wEHrG2BJNsAZwCvq6q7kqxulam6JwAnACxZsqTWtr4k6YEmufTiWkuyGV3on1pVn+oX35Zkx6q6JcmOdNfwlbSBWXT02aPWu+nY/UettzEbbJC2dLv2JwLXV9XfTnvoTGBpP70U+OxQbZAkrWzIPf49gZcB1yS5sl/2ZuBY4PQkhwHfA148YBskSTNMHPxJdgf+GtgCeGdVfWau51fVJdx/1a6Z9pm4hZKkdWqua+4+sqpunbboDXQHeQN8CZgz+CVJ66e59vg/kORyur37nwN3AH8E3Ed33V1J0gZolQd3q+pA4ErgrCQvo7vw+n3Ag/GkK0naYM35q56q+hzwn4HtgE8BN1TV8VXlGVWStIGa69KLByS5BLgQuBY4GHhhktOSPG6sBkqS1q25+vjfAewBbAWcU1W7AW9Ishj4K7ovAknSBmau4L+TLty3YtrZtVV1I4a+JG2w5urjfyHdgdwVdL/mkSRtBFZ36cX3jdgWSdIIBhurR5K0fjL4JakxBr8kNcbgl6TGGPyS1BiDX5IaY/BLUmMMfklqjMEvSY0x+CWpMQa/JDXG4Jekxhj8ktQYg1+SGmPwS1JjDH5JaozBL0mNMfglqTEGvyQ1xuCXpMYY/JLUGINfkhpj8EtSYwx+SWqMwS9JjTH4JakxBr8kNWaw4E/ykSS3J7l22rKHJzk/yY39/cOGqi9Jmt2Qe/wnA/vNWHY0cEFVLQYu6OclSSMaLPir6ovAj2YsfgFwSj99CnDgUPUlSbMbu4//EVV1C0B/v8Oqnpjk8CTLkixbvnz5aA2UpI3dentwt6pOqKolVbVk4cKF890cSdpojB38tyXZEaC/v33k+pLUvLGD/0xgaT+9FPjsyPUlqXlD/pzzNODLwOOT3JzkMOBY4DlJbgSe089Lkka06VAvXFWHrOKhfYaqKUlavfX24K4kaRgGvyQ1xuCXpMYY/JLUGINfkhpj8EtSYwx+SWqMwS9JjTH4JakxBr8kNcbgl6TGGPyS1BiDX5IaY/BLUmMMfklqzGDj8UtjW3T02aPWu+nY/UetJ60r7vFLUmMMfklqjMEvSY0x+CWpMQa/JDXG4Jekxhj8ktQYg1+SGmPwS1JjDH5JaozBL0mNMfglqTEO0iZpg+OAfL8e9/glqTEGvyQ1xuCXpMYY/JLUGINfkhpj8EtSYwx+SWqMv+PXOuXvq6X137zs8SfZL8kNSb6Z5Oj5aIMktWr04E+yCfB+4LnAk4BDkjxp7HZIUqvmo6tnN+CbVfVtgCQfB14AfH0e2jKoMbs9ZnZ5zGdtSeu3VNW4BZODgP2q6k/6+ZcBz6yq18x43uHA4f3s44EbRm0oLAB+MHLN+a7d4ja3WrvFbW6x9mOqauHMhfOxx59Zlq307VNVJwAnDN+c2SVZVlVLWqrd4ja3WrvFbW659kzzcXD3ZuDR0+Z3Br4/D+2QpCbNR/B/FVicZJckmwMHA2fOQzskqUmjd/VU1YokrwHOAzYBPlJV143djgnMWzfTPNZucZtbrd3iNrdc+wFGP7grSZpfDtkgSY0x+CWpMQb/DEk+kuT2JNeOXPfRSS5Kcn2S65IcNWLtLZNcluSqvvYxY9Xu62+S5GtJzhq57k1JrklyZZJlI9feLsknk3yj/8z3GKnu4/vtnbrdleR1Y9Tu67++/zd2bZLTkmw5Ut2j+prXDb29s2VIkocnOT/Jjf39w4Zsw+oY/Cs7GdhvHuquAP60qp4I7A4cMeJQFvcAe1fVU4Fdgf2S7D5SbYCjgOtHrDfd71XVrvPw++r3AudW1ROApzLS9lfVDf327go8A/gp8OkxaifZCTgSWFJVT6b7ccfBI9R9MvBKulEDngo8P8niAUuezMoZcjRwQVUtBi7o5+eNwT9DVX0R+NE81L2lqq7op39CFwQ7jVS7qurufnaz/jbKUf8kOwP7Ax8eo976IMm2wLOBEwGq6hdVdcc8NGUf4FtV9d0Ra24KbJVkU+DBjHMOzxOBr1TVT6tqBfAF4IVDFVtFhrwAOKWfPgU4cKj6kzD410NJFgFPAy4dseYmSa4EbgfOr6qxar8H+DPgvpHqTVfA55Nc3g8RMpbHAsuBk/ourg8n2XrE+lMOBk4bq1hV/Tvwv4DvAbcAd1bV50cofS3w7CTbJ3kw8DweeBLpGB5RVbdAt5MH7DBy/Qcw+NczSbYBzgBeV1V3jVW3qu7t//zfGdit//N4UEmeD9xeVZcPXWsV9qyqp9ONFHtEkmePVHdT4OnA/66qpwH/j5H/9O9PnjwA+MSINR9Gt+e7C/AoYOskhw5dt6quB44DzgfOBa6i61ptlsG/HkmyGV3on1pVn5qPNvRdDhczznGOPYEDktwEfBzYO8lHR6gLQFV9v7+/na6fe7eRSt8M3Dztr6pP0n0RjOm5wBVVdduINfcFvlNVy6vql8CngN8eo3BVnVhVT6+qZ9N1w9w4Rt1pbkuyI0B/f/vI9R/A4F9PJAldn+/1VfW3I9demGS7fnoruv+g3xi6blW9qap2rqpFdN0OF1bV4HuAAEm2TvKQqWng9+m6BAZXVbcC/5bk8f2ifRh/WPJDGLGbp/c9YPckD+7/ve/DSAe1k+zQ3/8G8AeMv+1nAkv76aXAZ0eu/wBeenGGJKcBewELktwM/EVVnThC6T2BlwHX9H3tAG+uqnNGqL0jcEp/kZwHAadX1ag/rZwHjwA+3eUPmwIfq6pzR6z/WuDUvsvl28DLxyrc93M/B3jVWDUBqurSJJ8ErqDravka4w1jcEaS7YFfAkdU1Y+HKjRbhgDHAqcnOYzuC/DFQ9WfhEM2SFJj7OqRpMYY/JLUGINfkhpj8EtSYwx+SWqMwd+oJJXkXdPm35jkbevotU9OctC6eK3V1HlxP7LlRUPXGlKSXZM8by3WOy3J1f2Il3+ZZN81XP+mJAtmWf7mNW3L2ljb7davz+Bv1z3AH8z2H38+9ecSTOow4NVV9XtDtWcku9KNHzOxJI8EfruqnlJV766qt1bVP6+j9qxx8K/h5zZljbdb64bB364VdCfPvH7mAzP32JPc3d/vleQLSU5P8q9Jjk3y0nRj+V+T5HHTXmbfJP/SP+/5/fqbJHlnkq/2e6qvmva6FyX5GHDNLO05pH/9a5Mc1y97K/As4ANJ3jnj+Q9K8vf92OtnJTlnanum7+UmWZLk4n5663TjqH+1HzjtBf3y3+y378q+zYv7556d7voF1yZ5Sf/cZ/Tvz+VJzpt2iv6RSb7er//xGW3dHPhL4CV9jZekG7v9M/3zv5LkKbN8fp8HdujX+Z3pn1m/jcckuaJ/357QL98+yef77fsgkFne62PpRs+8Msmp/bLP9Nt0XaYNZpfk7v4vjUuBPZI8L931BS5Jcnz66yvM9t7Ott2zbKOGUlXeGrwBdwPbAjcBDwXeCLytf+xk4KDpz+3v9wLuoDvTdwvg34Fj+seOAt4zbf1z6XYsFtONTbMlcDjwlv45WwDL6Abs2otuoLJdZmnno+jOdFxId4bthcCB/WMX043tPnOdg4Bz+vqPBH48tT399i7op5cAF/fTfw0c2k9vB/wrsDXwPuCl/fLNga2AFwEfmlbvoXRDWX8JWNgvewnwkX76+8AWU689S3v/GPi7afPvoztjHGBv4MpZ1lkEXDtt/lefWb+Nr+2nXw18uJ8+HnhrP70/3eikC2b7tzFj/uH9/VZ0w1ps388X8If99JbAv019hnRDIpy1mvf2Advtbbybe/wNq270z3+guzjGpL5a3bUD7gG+RbfnCd2e+qJpzzu9qu6rqhvphiR4At14OP813ZAUlwLb030xAFxWVd+Zpd5/ogvn5dWNpX4q3Vj2c3kW8Im+/q3AJMcAfh84um/bxXRB9hvAl4E3J/lz4DFV9bN+W/dNclyS36mqO4HHA08Gzu9f4y10I50CXE03PMOhTDYq5LOA/wNQVRcC2yd56ATrTTc1yN/l3P+5PBv4aP+6Z9N9IU7iyCRXAV+hG8546jO7l25QQeg+329P+wynj4WzqvdW88SxevQeurFTTpq2bAV9N2CS0O3pTrln2vR90+bv44H/nmaOBVJ0XQuvrarzpj+QZC+6Pf7ZrNQdMYG51vnVttEF0PR1XlRVN8x4/vV9V8b+wHlJ/qSqLkzyDLr+6b9J8nm60T2vq6rZLqG4P13oHgD8zyS/2X+JrUn713RslanP5V7m/lzm1H82+wJ7VNVP+66xqfft51V179RT53oZZnlvkzxzTdqidcc9/sZV1Y+A0+kOlE65ie6yfNCNn77ZWrz0i/u+9sfRXXjkBuA84L+nG36aJP8xq78AyaXA7yZZkO4A4iF0V1CayyXAi/r6j6DrSppyE/dv24umLT8PeG3/RUeSp/X3j6Xbkz2eboTFpyR5FPDTqvoo3YVFnt5v38L0185Nsll/fOBBwKOr6iK6C85sB2wzo70/AR4ybf6LwEv719kL+EGtm2szTH/d5wKruu7rL6c+I7purB/3of8EusuCzuYbwGPTXUQIuq6uKbO+t6y83RqJwS+AdwHTf93zIbqwvQx4JqveG5/LDXQB/U/Af6uqn9NdXvHrwBXpLkT9QVbzV2d1Vyt6E113zVV0Y8ivbkjbM+iOK0zVuBS4s3/sGOC9Sf6Fbm94ytvpvuCu7tv29n75S4Br+26KJ9B1jf0WcFm/7H8A76iqX9AdWziu7xa5km6s+U2Ajya5hm40ynfXypdZvAh40rSDnG8DliS5mm5Ux6WsG8fQXYnqCrrul++t4nkn0L0Pp9Idq9m0b8vb6bp7VtJ3gb0aODfJJcBt3P+er+q9nbndGomjc2qjlGSbqro73VC8l9FdbevW+W7Xxmzaex7g/cCNVfXu+W6XVmYfvzZWZ6W7uMzmwNsN/VG8MslSuvf8a3R/bWk95B6/JDXGPn5JaozBL0mNMfglqTEGvyQ1xuCXpMb8f6nfSCtsoNDTAAAAAElFTkSuQmCC\n", "text/plain": [ "
" ] @@ -1063,21 +1062,21 @@ }, { "cell_type": "code", - "execution_count": 34, + "execution_count": 37, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "mean = 6.81 ± 1.00, max = 10\n", - "CPU times: user 34.3 s, sys: 20.8 ms, total: 34.3 s\n", - "Wall time: 34.3 s\n" + "mean = 6.81 ± 1.00 guesses; worst = 10\n", + "CPU times: user 41.2 s, sys: 242 ms, total: 41.5 s\n", + "Wall time: 42.1 s\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1100,14 +1099,14 @@ "\n", "Here's a table of results:\n", "\n", - "|
Algorithm|Targets Only
Mean (Max)|Nontargets
Mean (Max)|\n", + "|
Algorithm|Consistent
Mean (Max)|Inconsistent
Mean (Max)|\n", "|--|--|--|\n", - "|baseline random|7.37 (18)| |\n", - "|min(max(reply_counts))|7.15 (18)|7.05 (10)|\n", - "|min(expectation(reply_counts))|7.14 (17)|6.84 (10)|\n", - "|max(entropy(reply_counts))|7.09 (19)|6.81 (10)|\n", + "|baseline random guesser|7.38 (18)| |\n", + "|min(max(partition_counts))|7.15 (18)|7.05 (10)|\n", + "|min(expectation(partition_counts))|7.14 (17)|6.84 (10)|\n", + "|max(entropy(partition_counts))|7.09 (19)|6.81 (10)|\n", "\n", - "So we started out with a mean of 7.37 and a worst score of 18 with the random guesser, and were able to improve by half a guess to a mean of 6.81 and a worst score of 10 using maximization of entropy over reply counts, with nontarget guesses allowed." + "So we started out with a mean of 7.38 and a worst score of 18 with the random guesser, and were able to improve by half a guess to a mean of 6.81 and a worst score of 10 using maximization of entropy over partition counts, with inconsistent guesses allowed." ] }, { @@ -1120,9 +1119,9 @@ "- Try different length words.\n", "- Allow words with repeated letters, like `stars`.\n", "- Have each reply consist of two numbers: the number of letters in common with the target, and the number of letters that are in the exact correct position.\n", - "- Apply the same techniques to **Mastermind**, which uses the two-number reply system over an alphabet of colors, not letters.\n", + "- Apply the same techniques to related games, like Mastermind.\n", "- Examine the strategy that a chooser would use, and how the guesser responds to that. Is there an equilibrium?\n", - "- Our `make_tree` function is **greedy** in that it chooses the guess that minimizes (or maximizes) 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**?\n", + "- Our `make_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", "- Can you improve a tree by editing it? Given a tree, look for interior nodes that have a worse-than-expected average score, and see if the node can be replaced with something better (covering the same target words).\n", "- Research what other computer scientists have done with [Jotto](https://arxiv.org/abs/1107.3342) or [Mastermind](http://serkangur.freeservers.com/).\n", "- What else can you explore?"