\n",
"\n",
"# Jotto and Wordle: Word Guessing Games\n",
"\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 **word list** of allowable words, in as few guesses as possible. Each guess must be one of the allowable 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 remaining consistent target words, and finally the letters that matched (the matches are an aid to you, the reader; they are not known to the guesser). A **consistent target** is a word that would give the same reply to each guess as the replies actually observed. In this game, the guesser gets to the target word, \"wonky\", in 7 guesses. \n",
"\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 Jotto; here are five 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 \"s\" in \"stars\"? **No.** Every word must have 5 different letters.\n",
"- What if the reply is \"5\", but the guess is not the target? **Not allowed**. No two words in the word list may have the same set of five letters. (For example, only one of the anagrams apers/pares/parse/pears/reaps/spare/spear is allowed.)\n",
"- Who chooses the target word? **Random chance**. Jotto is sometimes a two-person game where the chooser is an adversary, but not here.\n",
"\n",
"# Jotto Preliminaries\n",
"\n",
"First off, some Python basics: Import some modules and define the basic types `Word`, `Score`, and `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 math import log2\n",
"import random \n",
"import matplotlib.pyplot as plt\n",
"\n",
"Word = str # A word is a lower-case string of five different letters\n",
"Score = int # A score is the number of guesses it took to get the target word\n",
"Reply = int # A reply is the number of letters in common between guess and target words\n",
"\n",
"random.seed(42) # For reproducibility"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"We can make a Jotto word list by:\n",
"- Starting with a file containing a list of words.\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": 2,
"metadata": {},
"outputs": [],
"source": [
"def read_words(filename) -> List[Word]: return open(filename).read().split()\n",
"\n",
"def allowable(words) -> List[Word]:\n",
" \"\"\"Build a list of allowable Jotto words from an iterable of words.\"\"\"\n",
" anagrams = {frozenset(w): w for w in words if len(w) == 5 == len(set(w))}\n",
" return list(anagrams.values())"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"The [Stanford GraphBase project](https://www-cs-faculty.stanford.edu/~knuth/sgb.html) has a nice list of five-letter words, [sgb-words.txt](sgb-words.txt):"
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"2845"
]
},
"execution_count": 3,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"! [ -e sgb-words.txt ] || curl -O https://norvig.com/ngrams/sgb-words.txt\n",
" \n",
"wordlist = allowable(read_words('sgb-words.txt'))\n",
"\n",
"len(wordlist)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"We see there are 2,845 allowable Jotto words in [sgb-words.txt](sgb-words.txt)."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Playing Jotto\n",
"\n",
"The function `play` will play a game of Jotto 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 the words that are consistent with all the guesses made so far. \n",
" (If the guesser wants to keep track of all the guesses made so far, or all the words in the word list, it can.)\n",
"- `target`: The target word. If none is given, the target word is chosen at random from the wordlist.\n",
"- `wordlist`: The list of allowable words.\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 `None`. \n",
"2. To prevent an infinite loop, the worst score you can get is the number of words in the wordlist."
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {},
"outputs": [],
"source": [
"Guesser = Callable[[Reply, List[Word]], Word]\n",
"\n",
"def play(guesser: Guesser, target=None, wordlist=wordlist, 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 replies\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 None\n",
" targets = [t for t in targets if reply_for(guess, t) == reply]\n",
" if verbose: \n",
" print(f'Guess {turn}: \"{guess}\" Reply: {reply}; Consistent targets: {len(targets)}')\n",
" if guess == target or turn == N: \n",
" return turn\n",
" \n",
"def reply_for(guess, target) -> Reply: \n",
" \"The number of letters in common between the target and guess\"\n",
" return len(set(target).intersection(guess))"
]
},
{
"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": 5,
"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 Jotto Games\n",
"\n",
"Here is the `random_guesser` in action:"
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Guess 1: \"strop\" Reply: 3; Consistent targets: 322\n",
"Guess 2: \"party\" Reply: 1; Consistent targets: 112\n",
"Guess 3: \"obits\" Reply: 3; Consistent targets: 44\n",
"Guess 4: \"sloth\" Reply: 2; Consistent targets: 12\n",
"Guess 5: \"brows\" Reply: 2; Consistent targets: 5\n",
"Guess 6: \"pious\" Reply: 4; Consistent targets: 4\n",
"Guess 7: \"pions\" Reply: 4; Consistent targets: 3\n",
"Guess 8: \"dipso\" Reply: 5; Consistent targets: 1\n"
]
},
{
"data": {
"text/plain": [
"8"
]
},
"execution_count": 6,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"play(random_guesser)"
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Guess 1: \"carpy\" Reply: 0; Consistent targets: 602\n",
"Guess 2: \"litho\" Reply: 2; Consistent targets: 249\n",
"Guess 3: \"loved\" Reply: 0; Consistent targets: 21\n",
"Guess 4: \"fugit\" Reply: 2; Consistent targets: 7\n",
"Guess 5: \"skint\" Reply: 1; Consistent targets: 1\n",
"Guess 6: \"thumb\" Reply: 5; Consistent targets: 1\n"
]
},
{
"data": {
"text/plain": [
"6"
]
},
"execution_count": 7,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"play(random_guesser)"
]
},
{
"cell_type": "code",
"execution_count": 8,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Guess 1: \"thous\" Reply: 1; Consistent targets: 1141\n",
"Guess 2: \"vocal\" Reply: 2; Consistent targets: 340\n",
"Guess 3: \"snack\" Reply: 0; Consistent targets: 46\n",
"Guess 4: \"vigor\" Reply: 2; Consistent targets: 19\n",
"Guess 5: \"oxlip\" Reply: 2; Consistent targets: 10\n",
"Guess 6: \"roble\" Reply: 3; Consistent targets: 4\n",
"Guess 7: \"world\" Reply: 5; Consistent targets: 1\n"
]
},
{
"data": {
"text/plain": [
"7"
]
},
"execution_count": 8,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"play(random_guesser, target='world')"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Partitioning Target Words\n",
"\n",
"A key idea in guessing is to reduce the number of consistent targets. When there is a single consistent target left, the game is over. 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": 9,
"metadata": {},
"outputs": [],
"source": [
"def partition(guess, targets) -> Dict[Reply, List[str]]:\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": [
"To get a feel for how this works, a 2,845 word list is too much to deal with; let's consider just the first 22 words in `wordlist`. Here are two partitions of those 22 words, one by the guess `'girth'` and one by `'ethos'`:"
]
},
{
"cell_type": "code",
"execution_count": 10,
"metadata": {},
"outputs": [],
"source": [
"words22 = wordlist[:22]\n",
"\n",
"assert (partition('girth', words22) ==\n",
" {0: ['would', 'cloud', 'place', 'sound', 'fondu'],\n",
" 1: ['about', 'sword', 'resay', 'nuder', 'house'],\n",
" 2: ['water', 'after', 'ethos', 'while'],\n",
" 3: ['throe', 'write', 'rifts', 'think', 'grate'],\n",
" 4: ['their', 'might'],\n",
" 5: ['girth']})\n",
"\n",
"assert (partition('ethos', words22) ==\n",
" {1: ['would', 'cloud', 'place', 'fondu', 'nuder'],\n",
" 2: ['about', 'sword', 'write', 'rifts', 'water', 'after', 'girth', 'think', 'resay', \n",
" 'sound', 'grate', 'might', 'while'],\n",
" 3: ['their'],\n",
" 4: ['throe', 'house'],\n",
" 5: ['ethos']})"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"No matter what the reply to `'girth'` is, we will be left with no more than 5 targets. \n",
"\n",
"But if we guess `'ethos'` then 13 of the 22 targets would get a reply of 2, and there would be 13 possible targets remaining to deal with. That suggests that `'girth'` is a better guess and that a good strategy is: **guess a word that partitions the possible targets into small branches.**\n",
"\n",
"Since we only need to know the *size* of each branch, not the list of words therein, we can use `partition_counts`:"
]
},
{
"cell_type": "code",
"execution_count": 11,
"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 list(counter.values())"
]
},
{
"cell_type": "code",
"execution_count": 12,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"[2, 5, 5, 5, 4, 1]"
]
},
"execution_count": 12,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"partition_counts('girth', words22)"
]
},
{
"cell_type": "code",
"execution_count": 13,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"[1, 13, 5, 2, 1]"
]
},
"execution_count": 13,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"partition_counts('ethos', words22)"
]
},
{
"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. But since we don't know that, we can instead 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": 14,
"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 already computed. 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 should appear as a leaf in exactly one place in a guess tree."
]
},
{
"cell_type": "code",
"execution_count": 15,
"metadata": {},
"outputs": [],
"source": [
"@dataclass \n",
"class Node:\n",
" \"\"\"A node in a guess tree. It stores the best guess, and a branch for every possible reply.\"\"\"\n",
" guess: Word\n",
" branches: Dict[Reply, 'Tree']\n",
" \n",
" def __repr__(self) -> str: return f'Node(\"{self.guess}\", {self.branches})'\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": 16,
"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, {reply: minimizing_tree(metric, branches[reply]) \n",
" for reply in branches})"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Here is a minimizing tree that covers the 22 words. The tree says that the first guess is `\"girth\"`, and 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": 17,
"metadata": {},
"outputs": [],
"source": [
"tree22 = minimizing_tree(max, words22)\n",
"\n",
"assert (tree22 ==\n",
" Node(\"girth\", \n",
" {0: Node(\"would\", \n",
" {1: 'place', \n",
" 3: Node(\"sound\", {4: 'fondu', 5: 'sound'}), \n",
" 4: 'cloud', \n",
" 5: 'would'}), \n",
" 1: Node(\"about\", \n",
" {1: Node(\"sword\", \n",
" {2: Node(\"resay\", {2: 'nuder', 5: 'resay'}), \n",
" 5: 'sword'}), \n",
" 2: 'house', \n",
" 5: 'about'}), \n",
" 2: Node(\"after\", \n",
" {1: 'while', \n",
" 2: 'ethos', \n",
" 4: 'water', \n",
" 5: 'after'}), \n",
" 3: Node(\"throe\", \n",
" {2: Node(\"rifts\", {2: 'think', 5: 'rifts'}), \n",
" 3: Node(\"write\", {3: 'grate', 5: 'write'}), \n",
" 5: 'throe'}), \n",
" 4: Node(\"their\", \n",
" {3: 'might', \n",
" 5: 'their'}), \n",
" 5: 'girth'}))"
]
},
{
"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:\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",
"- It then returns the guess for the current tree: either the `.guess` attribute or the leaf word. "
]
},
{
"cell_type": "code",
"execution_count": 18,
"metadata": {},
"outputs": [],
"source": [
"class TreeGuesser:\n",
" \"\"\"Given a guess tree, use it to create a callable Guesser that can play Jotto.\"\"\"\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.\"\"\"\n",
" tree = self.tree = self.root if reply is None else self.tree.branches[reply]\n",
" return tree.guess if isinstance(tree, Node) else 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": 19,
"metadata": {},
"outputs": [],
"source": [
"tree = minimizing_tree(max, wordlist)\n",
"guesser = TreeGuesser(tree)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Sample Games with the Minimizing Guesser\n"
]
},
{
"cell_type": "code",
"execution_count": 20,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Guess 1: \"wader\" Reply: 0; Consistent targets: 466\n",
"Guess 2: \"tings\" Reply: 2; Consistent targets: 160\n",
"Guess 3: \"gunky\" Reply: 1; Consistent targets: 54\n",
"Guess 4: \"bouts\" Reply: 2; Consistent targets: 16\n",
"Guess 5: \"clogs\" Reply: 0; Consistent targets: 1\n",
"Guess 6: \"mufti\" Reply: 5; Consistent targets: 1\n"
]
},
{
"data": {
"text/plain": [
"6"
]
},
"execution_count": 20,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"play(guesser)"
]
},
{
"cell_type": "code",
"execution_count": 21,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Guess 1: \"wader\" Reply: 1; Consistent targets: 1012\n",
"Guess 2: \"actin\" Reply: 2; Consistent targets: 355\n",
"Guess 3: \"flats\" Reply: 2; Consistent targets: 113\n",
"Guess 4: \"cloak\" Reply: 3; Consistent targets: 17\n",
"Guess 5: \"backs\" Reply: 2; Consistent targets: 5\n",
"Guess 6: \"clamp\" Reply: 3; Consistent targets: 2\n",
"Guess 7: \"plank\" Reply: 5; Consistent targets: 1\n"
]
},
{
"data": {
"text/plain": [
"7"
]
},
"execution_count": 21,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"play(guesser)"
]
},
{
"cell_type": "code",
"execution_count": 22,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Guess 1: \"wader\" Reply: 3; Consistent targets: 319\n",
"Guess 2: \"sword\" Reply: 1; Consistent targets: 131\n",
"Guess 3: \"paled\" Reply: 4; Consistent targets: 21\n",
"Guess 4: \"abled\" Reply: 3; Consistent targets: 8\n",
"Guess 5: \"paved\" Reply: 4; Consistent targets: 6\n",
"Guess 6: \"caped\" Reply: 4; Consistent targets: 5\n",
"Guess 7: \"paged\" Reply: 4; Consistent targets: 4\n",
"Guess 8: \"adept\" Reply: 4; Consistent targets: 3\n",
"Guess 9: \"paned\" Reply: 4; Consistent targets: 2\n",
"Guess 10: \"payed\" Reply: 4; Consistent targets: 1\n",
"Guess 11: \"amped\" Reply: 5; Consistent targets: 1\n"
]
},
{
"data": {
"text/plain": [
"11"
]
},
"execution_count": 22,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"play(guesser)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Making Inconsistent Guesses\n",
"\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",
"Consider the branch of `tree22` where the reply to the first guess is 1. There are 5 consistent words remaining, and the max-minimizing tree (which starts by guessing `\"about\"`), can take up to 4 more guesses to find the target:"
]
},
{
"cell_type": "code",
"execution_count": 23,
"metadata": {},
"outputs": [],
"source": [
"assert (tree22.branches[1] == \n",
" Node(\"about\", \n",
" {1: Node(\"sword\", \n",
" {2: Node(\"resay\", \n",
" {2: 'nuder', \n",
" 5: 'resay'}), \n",
" 5: 'sword'}), \n",
" 2: 'house', \n",
" 5: 'about'}))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"But now consider this tree, which covers the same five words:"
]
},
{
"cell_type": "code",
"execution_count": 24,
"metadata": {},
"outputs": [],
"source": [
"tree5 = Node(\"nerdy\", {0: 'about', \n",
" 1: 'house', \n",
" 2: 'sword', \n",
" 3: 'resay', \n",
" 4: 'nuder'})"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"The first guess, `\"nerdy\"` is inconsistent–it is not one of the five words. This tree sacrifices the 1-in-5 chance of being right on the first guess in order to be assured that the second guess will be correct. So the min, max, mean, and median is 2 guesses. On the whole, this is better than guessing `\"about\"`, which gives a mean of 2.4 and a worst case of 4. \n",
"\n",
"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 = 400`.)"
]
},
{
"cell_type": "code",
"execution_count": 25,
"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, {reply: minimizing_tree(metric, branches[reply], wordlist, inconsistent) \n",
" for reply in sorted(branches)})\n",
" \n",
"inconsistent_max = 400"
]
},
{
"cell_type": "code",
"execution_count": 26,
"metadata": {},
"outputs": [],
"source": [
"words5 = ['about', 'house', 'sword', 'resay', 'nuder']\n",
"\n",
"assert minimizing_tree(max, words5, inconsistent=True) == tree5"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Evaluating and Reporting on Guessers\n",
"\n",
"To properly evaluate a guesser, a sample of 3 games is not enough to be statistically reliable. 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": 27,
"metadata": {},
"outputs": [],
"source": [
"def report_minimizing_tree(metric, targets=wordlist, wordlist=wordlist, inconsistent=False) -> Tree:\n",
" \"\"\"Build a minimizing tree and report on its scores.\"\"\"\n",
" print(f\"minimizing the {metric.__name__} of partition sizes over\",\n",
" f\"{len(targets):,d} targets in a {len(wordlist):,d} word list,\")\n",
" print(f\"{'' if inconsistent else 'not '}including inconsistent words.\")\n",
" tree = minimizing_tree(metric, targets, wordlist, inconsistent)\n",
" print(f'first guess: \"{tree.guess}\"')\n",
" report(tree_scores(tree))\n",
" return tree\n",
"\n",
"def report(scores: Iterable[Score], label='') -> None:\n",
" \"\"\"Report statistics and a histogram for these scores.\"\"\"\n",
" scores = list(scores)\n",
" ctr = Counter(scores)\n",
" bins = range(min(ctr), max(ctr) + 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)}, scores: {len(scores):,d}\\n'\n",
" 'cumulative:', ', '.join(map(cumulative_pct, range(3, 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))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"To test these functions, and to give another example of inconsistent guessing, consider this list of 11 words:"
]
},
{
"cell_type": "code",
"execution_count": 28,
"metadata": {},
"outputs": [],
"source": [
"ails = 'bails fails hails jails mails nails pails rails tails vails wails'.split()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"A consistent guesser could guess them in any order, but wouldn't gain much information from the replies–every reply is either a 5 (which ends the game) or a 4, which leaves you with all the remaining words. Here is the report:"
]
},
{
"cell_type": "code",
"execution_count": 29,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"minimizing the max of partition sizes over 11 targets in a 2,845 word list,\n",
"not including inconsistent words.\n",
"first guess: \"bails\"\n",
"median: 6 guesses, mean: 6.00 ± 3.32, worst: 11, scores: 11\n",
"cumulative: ≤3:27%, ≤4:36%, ≤5:45%, ≤6:55%, ≤7:64%, ≤8:73%, ≤9:82%, ≤10:91%\n"
]
},
{
"data": {
"image/png": "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\n",
"text/plain": [
"
"
]
},
"metadata": {
"needs_background": "light"
},
"output_type": "display_data"
}
],
"source": [
"t = report_minimizing_tree(max, ails)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"But an inconsistent guesser can make a guesses that more evenly partition the remaining words, giving an average of only 4 guesses, and a worst case of 5 guesses: "
]
},
{
"cell_type": "code",
"execution_count": 30,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"minimizing the max of partition sizes over 11 targets in a 2,845 word list,\n",
"including inconsistent words.\n",
"first guess: \"front\"\n",
"median: 4 guesses, mean: 4.00 ± 0.77, worst: 5, scores: 11\n",
"cumulative: ≤3:27%, ≤4:73%, ≤5:100%, ≤6:100%, ≤7:100%, ≤8:100%, ≤9:100%, ≤10:100%\n"
]
},
{
"data": {
"image/png": "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\n",
"text/plain": [
"
"
]
},
"metadata": {
"needs_background": "light"
},
"output_type": "display_data"
}
],
"source": [
"t = report_minimizing_tree(max, ails, inconsistent=True)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Reports on Consistent Guessers\n",
"\n",
"Here are reports on trees made from minimizing the three metrics, with only consistent guesses allowed: "
]
},
{
"cell_type": "code",
"execution_count": 31,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"minimizing the max of partition sizes over 2,845 targets in a 2,845 word list,\n",
"not including inconsistent words.\n",
"first guess: \"wader\"\n",
"median: 7 guesses, mean: 7.15 ± 1.81, worst: 18, scores: 2,845\n",
"cumulative: ≤3:1%, ≤4:4%, ≤5:13%, ≤6:35%, ≤7:67%, ≤8:86%, ≤9:92%, ≤10:95%\n",
"CPU times: user 6.73 s, sys: 11.3 ms, total: 6.74 s\n",
"Wall time: 6.75 s\n"
]
},
{
"data": {
"image/png": "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\n",
"text/plain": [
"
"
]
},
"metadata": {
"needs_background": "light"
},
"output_type": "display_data"
}
],
"source": [
"%time t = report_minimizing_tree(neg_entropy, inconsistent=True)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Report Summary\n",
"\n",
"Here's a table of the mean and maximum number of guesses for the seven approaches:\n",
"\n",
"| 2,845 words Algorithm|Consistent Only Mean (Max)|Inconsistent Allowed Mean (Max)|\n",
"|--|--|--|\n",
"|random guesser|7.42 (17)| |\n",
"|minimize max|7.15 (18)|7.05 (10)|\n",
"|minimize expectation|7.14 (17)|6.84 (10)|\n",
"|minimize neg_entropy|7.09 (19)|6.82 (10)|\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Wordle\n",
"\n",
"[Wordle](https://www.powerlanguage.co.uk/wordle/) is a [suddenly-popular](https://www.nytimes.com/2022/01/03/technology/wordle-word-game-creator.html) variant of Jotto (with a little Mastermind thrown in) with these differences:\n",
"- Words with repeated letters are allowed (e.g. `'aback'`).\n",
"- Anagrams are allowed (e.g. `'arise'` and `'raise'`).\n",
"- The reply to a guess consists of 5 pieces ([trits](https://en.wiktionary.org/wiki/trit#English)) of information, one for each position in the guess:\n",
" - *Green* if the guess letter is 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",
"- Wordle uses a larger list of 12,971 allowable guess words, but only 2,315 of them can be target words. (I think the idea is to follow [Postel's law](https://en.wikipedia.org/wiki/Robustness_principle) to avoid annoying a player: be conservative in the targets (so that a player is very likely to be familiar with the target word) and be liberal in accepting guess words.)\n",
" \n",
"There is an ambiguity in the rules. Assume the guess is *etude* and the target is *poems*. A strict reading of the rules would say they both *e* positions should be *yellow*, because both instances of *e* are \"in the word but in the wrong spot.\" But it seems Wordle actually reports the first *e* as yellow and the second *e* as a miss."
]
},
{
"cell_type": "code",
"execution_count": 38,
"metadata": {},
"outputs": [],
"source": [
"wordle_small = read_words('wordle-small.txt') # 2,315 target words\n",
"wordle_big = read_words('wordle-big.txt') # 12,971 guess words\n",
"\n",
"Green, Yellow, Miss = 'GY.' # A Wordle reply is 5 characters, each one of 'GY.'\n",
"\n",
"def wordle_reply_for(guess, target) -> str: \n",
" \"The five-character reply for this guess on this target in Wordle.\"\n",
" # We'll start by having each 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 replies 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": "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, 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` with the name of the game they want, `'jotto'` or `'wordle'`. It will set global variables accordingly. I'll also require the programmer to use the right word list and target words."
]
},
{
"cell_type": "code",
"execution_count": 39,
"metadata": {},
"outputs": [],
"source": [
"jotto_reply_for = reply_for"
]
},
{
"cell_type": "code",
"execution_count": 40,
"metadata": {},
"outputs": [],
"source": [
"def setup(game: str) -> None:\n",
" \"Set global variables to play either 'jotto' or 'wordle'.\"\n",
" global reply_for, inconsistent_max\n",
" if game == 'jotto':\n",
" reply_for = jotto_reply_for\n",
" inconsistent_max = 400\n",
" elif game == 'wordle':\n",
" reply_for = wordle_reply_for\n",
" inconsistent_max = 125\n",
" else:\n",
" raise ValueError(f'unknown game: {game}')"
]
},
{
"cell_type": "code",
"execution_count": 41,
"metadata": {},
"outputs": [],
"source": [
"setup('wordle')"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Note that in Jotto, `reply_for` was symmetric; `reply_for(g, t) == reply_for(t, g)`. But that is not true for Wordle. I made some tests for `wordle_reply_for` to give me some confidence I got it right:"
]
},
{
"cell_type": "code",
"execution_count": 42,
"metadata": {},
"outputs": [],
"source": [
"assert reply_for('treat', 'truss') == 'GG...' and reply_for('truss', 'treat') == 'GG...'\n",
"assert reply_for('stars', 'traps') == '.YGYG' and reply_for('traps', 'stars') == 'YYG.G'\n",
"assert reply_for('palls', 'splat') == 'YYG.Y' and reply_for('splat', 'palls') == 'YYGY.'\n",
"assert reply_for('banal', 'apple') == '.Y..Y' and reply_for('apple', 'banal') == 'Y..Y.'\n",
"assert reply_for('banal', 'mania') == '.GGY.' and reply_for('mania', 'banal') == '.GG.Y'\n",
"assert reply_for('epees', 'geese') == 'Y.GYY' and reply_for('geese', 'epees') == '.YGYY'\n",
"assert reply_for('wheee', 'peeve') == '..GYG' and reply_for('peeve', 'wheee') == '.YG.G'"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"We can test the new `reply_for` on a partition of `words22`:"
]
},
{
"cell_type": "code",
"execution_count": 43,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"defaultdict(list,\n",
" {'.YYYY': ['their'],\n",
" '...Y.': ['about'],\n",
" 'G....': ['would'],\n",
" '.Y.YG': ['throe'],\n",
" 'YY...': ['sword'],\n",
" '.....': ['cloud', 'sound', 'fondu'],\n",
" 'GGGGG': ['write'],\n",
" '.YYG.': ['rifts', 'girth'],\n",
" 'GY.YY': ['water'],\n",
" '.Y.YY': ['after'],\n",
" '..GY.': ['think'],\n",
" '.Y..Y': ['resay', 'nuder'],\n",
" '....G': ['place', 'house'],\n",
" '.G.GG': ['grate'],\n",
" '...YY': ['ethos'],\n",
" '..YY.': ['might'],\n",
" 'G.G.G': ['while']})"
]
},
"execution_count": 43,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"partition('write', words22)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"That looks good. Notice that there are many more possible replies in Wordle than the 6 possible replies in Jotto, so the target words are partitioned into smaller branches. It should take fewer guesses to solve a Wordle than a Jotto. How many possible replies are there? There are 3 responses at each of five positions, and 35 = 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",
"# Sample Wordle Games\n",
"\n",
"Let's see what some Wordle games look like, using a random guesser:"
]
},
{
"cell_type": "code",
"execution_count": 44,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Guess 1: \"pluck\" Reply: .Y...; Consistent targets: 269\n",
"Guess 2: \"false\" Reply: ..G.Y; Consistent targets: 9\n",
"Guess 3: \"below\" Reply: GGGGG; Consistent targets: 1\n"
]
},
{
"data": {
"text/plain": [
"3"
]
},
"execution_count": 44,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"play(random_guesser, wordlist=wordle_small)"
]
},
{
"cell_type": "code",
"execution_count": 45,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Guess 1: \"caddy\" Reply: .....; Consistent targets: 729\n",
"Guess 2: \"rupee\" Reply: Y....; Consistent targets: 62\n",
"Guess 3: \"snort\" Reply: G.GGY; Consistent targets: 2\n",
"Guess 4: \"stork\" Reply: GGGG.; Consistent targets: 1\n",
"Guess 5: \"storm\" Reply: GGGGG; Consistent targets: 1\n"
]
},
{
"data": {
"text/plain": [
"5"
]
},
"execution_count": 45,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"play(random_guesser, wordlist=wordle_small)"
]
},
{
"cell_type": "code",
"execution_count": 46,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Guess 1: \"wiser\" Reply: .G...; Consistent targets: 73\n",
"Guess 2: \"ninth\" Reply: .GG..; Consistent targets: 9\n",
"Guess 3: \"final\" Reply: .GG.G; Consistent targets: 1\n",
"Guess 4: \"vinyl\" Reply: GGGGG; Consistent targets: 1\n"
]
},
{
"data": {
"text/plain": [
"4"
]
},
"execution_count": 46,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"play(random_guesser, wordlist=wordle_small)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Reports on Wordle Guessers\n",
"\n",
"Wordle has about the same number of target words as Jotto, but many more guess words, and the `wordle_reply_for` computation is more complex, so computations take longer (more so for the inconsistent guessers). Here are reports on the seven strategies:"
]
},
{
"cell_type": "code",
"execution_count": 47,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"median: 4 guesses, mean: 4.10 ± 1.04, worst: 8, scores: 2,315\n",
"cumulative: ≤3:28%, ≤4:69%, ≤5:92%, ≤6:98%, ≤7:99.4%, ≤8:100%, ≤9:100%, ≤10:100%\n",
"CPU times: user 30.1 s, sys: 29.3 ms, total: 30.1 s\n",
"Wall time: 30.2 s\n"
]
},
{
"data": {
"image/png": "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\n",
"text/plain": [
"
"
]
},
"metadata": {
"needs_background": "light"
},
"output_type": "display_data"
}
],
"source": [
"%time report(play(random_guesser, target, wordle_small, verbose=False) for target in wordle_small)"
]
},
{
"cell_type": "code",
"execution_count": 48,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"minimizing the max of partition sizes over 2,315 targets in a 12,971 word list,\n",
"not including inconsistent words.\n",
"first guess: \"arise\"\n",
"median: 4 guesses, mean: 3.68 ± 0.86, worst: 8, scores: 2,315\n",
"cumulative: ≤3:43%, ≤4:87%, ≤5:97%, ≤6:99.4%, ≤7:99.9%, ≤8:100%, ≤9:100%, ≤10:100%\n",
"CPU times: user 29 s, sys: 36.4 ms, total: 29 s\n",
"Wall time: 29 s\n"
]
},
{
"data": {
"image/png": "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\n",
"text/plain": [
"
"
]
},
"metadata": {
"needs_background": "light"
},
"output_type": "display_data"
}
],
"source": [
"%time t = report_minimizing_tree(neg_entropy, wordle_small, wordle_big, inconsistent=True)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Mission accomplished!** All three metrics solve every target word in 6 guesses or less. \n",
"\n",
"# Jotto and Wordle Evaluation Summary\n",
"\n",
"Here is a summary of the reports on both games:\n",
"\n",
"|
Algorithm|JOTTO Consistent Only Mean (Max)|JOTTO Inconsistent Allowed Mean (Max)|WORDLE Consistent Only Mean (Max)|WORDLE Inconsistent Allowed Mean (Max)||\n",
"|--|--|--|--|--|--|\n",
"|random guesser|7.34 (18)| |4.10 (8) | |\n",
"|minimize max|7.15 (18)|7.05 (10)| 3.68 (8) | 3.62 (6) | \n",
"|minimize expectation|7.14 (17)|6.84 (10)| 3.62 (8) | 3.52 (6) | \n",
"|minimize neg_entropy|7.09 (19)|6.82 (10)| 3.60 (8) | 3.50 (6) |\n",
"\n",
"\n",
"# Sample Wordle Games with Minimizing Guesser\n",
"\n",
"Here are some sample games with the negative-entropy minimizing, inconsistent-guessing guesser:"
]
},
{
"cell_type": "code",
"execution_count": 54,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Guess 1: \"raise\" Reply: ...YY; Consistent targets: 797\n",
"Guess 2: \"spelt\" Reply: G.GG.; Consistent targets: 11\n",
"Guess 3: \"fehme\" Reply: .Y...; Consistent targets: 3\n",
"Guess 4: \"swell\" Reply: GGGGG; Consistent targets: 1\n",
"\n",
"Guess 1: \"raise\" Reply: YY...; Consistent targets: 297\n",
"Guess 2: \"tronc\" Reply: .G..Y; Consistent targets: 12\n",
"Guess 3: \"calmy\" Reply: GY..G; Consistent targets: 2\n",
"Guess 4: \"crazy\" Reply: GGGGG; Consistent targets: 1\n",
"\n",
"Guess 1: \"raise\" Reply: YY...; Consistent targets: 297\n",
"Guess 2: \"tronc\" Reply: .GY..; Consistent targets: 8\n",
"Guess 3: \"abram\" Reply: G.G..; Consistent targets: 2\n",
"Guess 4: \"arrow\" Reply: GGGGG; Consistent targets: 1\n",
"\n",
"Guess 1: \"raise\" Reply: Y.G..; Consistent targets: 75\n",
"Guess 2: \"crypt\" Reply: .G.Y.; Consistent targets: 7\n",
"Guess 3: \"primo\" Reply: GGGGG; Consistent targets: 1\n",
"\n",
"Guess 1: \"raise\" Reply: ..YY.; Consistent targets: 343\n",
"Guess 2: \"shout\" Reply: Y.Y..; Consistent targets: 46\n",
"Guess 3: \"bison\" Reply: .GGY.; Consistent targets: 6\n",
"Guess 4: \"disco\" Reply: GGGGG; Consistent targets: 1\n",
"\n"
]
}
],
"source": [
"for target in random.sample(wordle_small, 5):\n",
" play(TreeGuesser(t), target, wordle_big)\n",
" print()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Best and Worst First Guess Words\n",
"\n",
"Here's a function to create a table of the best and worst first guesses in a game (that is, the highest and lowest scoring words on the partition counts), according to each of the three metrics:"
]
},
{
"cell_type": "code",
"execution_count": 55,
"metadata": {},
"outputs": [],
"source": [
"import pandas as pd\n",
"\n",
"def first_guesses(targets, wordlist) -> pd.DataFrame: \n",
" \"\"\"A data frame of words and scores on the 3 metrics, sorted best to worst.\"\"\"\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 exp_word exp ent_word ent'.split())"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"The best and worst first guesses for **Jotto**:"
]
},
{
"cell_type": "code",
"execution_count": 56,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"CPU times: user 13.9 s, sys: 7.46 ms, total: 13.9 s\n",
"Wall time: 13.9 s\n"
]
},
{
"data": {
"text/html": [
"
\n",
"\n",
"
\n",
" \n",
"
\n",
"
\n",
"
max_word
\n",
"
max
\n",
"
exp_word
\n",
"
exp
\n",
"
ent_word
\n",
"
ent
\n",
"
\n",
" \n",
" \n",
"
\n",
"
0
\n",
"
wader
\n",
"
1012
\n",
"
raved
\n",
"
812.84
\n",
"
debar
\n",
"
-1.949
\n",
"
\n",
"
\n",
"
1
\n",
"
cadre
\n",
"
1026
\n",
"
debar
\n",
"
818.32
\n",
"
alder
\n",
"
-1.946
\n",
"
\n",
"
\n",
"
2
\n",
"
armed
\n",
"
1028
\n",
"
roved
\n",
"
826.51
\n",
"
raved
\n",
"
-1.944
\n",
"
\n",
"
\n",
"
3
\n",
"
diner
\n",
"
1029
\n",
"
orbed
\n",
"
826.71
\n",
"
dater
\n",
"
-1.943
\n",
"
\n",
"
\n",
"
4
\n",
"
coder
\n",
"
1030
\n",
"
wader
\n",
"
827.04
\n",
"
cadre
\n",
"
-1.943
\n",
"
\n",
"
\n",
"
...
\n",
"
...
\n",
"
...
\n",
"
...
\n",
"
...
\n",
"
...
\n",
"
...
\n",
"
\n",
"
\n",
"
2840
\n",
"
coqui
\n",
"
1535
\n",
"
okapi
\n",
"
1105.28
\n",
"
jumpy
\n",
"
-1.575
\n",
"
\n",
"
\n",
"
2841
\n",
"
quota
\n",
"
1548
\n",
"
azoic
\n",
"
1120.19
\n",
"
juicy
\n",
"
-1.566
\n",
"
\n",
"
\n",
"
2842
\n",
"
azoic
\n",
"
1555
\n",
"
axiom
\n",
"
1157.49
\n",
"
axiom
\n",
"
-1.563
\n",
"
\n",
"
\n",
"
2843
\n",
"
axiom
\n",
"
1615
\n",
"
audio
\n",
"
1184.28
\n",
"
audio
\n",
"
-1.494
\n",
"
\n",
"
\n",
"
2844
\n",
"
ouija
\n",
"
1848
\n",
"
ouija
\n",
"
1413.00
\n",
"
ouija
\n",
"
-1.292
\n",
"
\n",
" \n",
"
\n",
"
2845 rows × 6 columns
\n",
"
"
],
"text/plain": [
" max_word max exp_word exp ent_word ent\n",
"0 wader 1012 raved 812.84 debar -1.949\n",
"1 cadre 1026 debar 818.32 alder -1.946\n",
"2 armed 1028 roved 826.51 raved -1.944\n",
"3 diner 1029 orbed 826.71 dater -1.943\n",
"4 coder 1030 wader 827.04 cadre -1.943\n",
"... ... ... ... ... ... ...\n",
"2840 coqui 1535 okapi 1105.28 jumpy -1.575\n",
"2841 quota 1548 azoic 1120.19 juicy -1.566\n",
"2842 azoic 1555 axiom 1157.49 axiom -1.563\n",
"2843 axiom 1615 audio 1184.28 audio -1.494\n",
"2844 ouija 1848 ouija 1413.00 ouija -1.292\n",
"\n",
"[2845 rows x 6 columns]"
]
},
"execution_count": 56,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"setup('jotto')\n",
"%time df = first_guesses(wordlist, wordlist)\n",
"df"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"The top guesses favor the letters \"a\", \"d\", \"e\", and \"r\". \n",
"\n",
"The word \"ouija\" is a uniquely terrible guess; mostly what it does is confirm that a majority of the words have exactly one of the vowels \"aiou\". The output above only shows the top 5 guesses; here are the top 20:"
]
},
{
"cell_type": "code",
"execution_count": 57,
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
"
"
],
"text/plain": [
" max_word max exp_word exp ent_word ent\n",
"0 aesir 168 roate 60.42 soare -5.886\n",
"1 arise 168 raise 61.00 roate -5.883\n",
"2 raise 168 raile 61.33 raise -5.878\n",
"3 reais 168 soare 62.30 raile -5.866\n",
"4 serai 168 arise 63.73 reast -5.865\n",
"... ... ... ... ... ... ...\n",
"12966 susus 1369 gyppy 885.90 yukky -2.205\n",
"12967 fuffy 1374 jugum 900.61 xylyl -2.192\n",
"12968 gyppy 1380 jujus 903.31 immix -2.053\n",
"12969 jugum 1410 qajaq 925.11 jujus -2.038\n",
"12970 immix 1429 immix 967.40 qajaq -1.892\n",
"\n",
"[12971 rows x 6 columns]"
]
},
"execution_count": 58,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"setup('wordle')\n",
"%time df2 = first_guesses(wordle_small, wordle_big)\n",
"df2"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Again, the best words use popular letters. One difference is that in Jotto, the best guesses have two vowels, in Wordle three. The worst words have repeated unpopular letters, like \"qajaq\" and \"yukky\". Here are the top 20 guesses:"
]
},
{
"cell_type": "code",
"execution_count": 59,
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
"
\n",
"\n",
"
\n",
" \n",
"
\n",
"
\n",
"
max_word
\n",
"
max
\n",
"
exp_word
\n",
"
exp
\n",
"
ent_word
\n",
"
ent
\n",
"
\n",
" \n",
" \n",
"
\n",
"
0
\n",
"
aesir
\n",
"
168
\n",
"
roate
\n",
"
60.42
\n",
"
soare
\n",
"
-5.886
\n",
"
\n",
"
\n",
"
1
\n",
"
arise
\n",
"
168
\n",
"
raise
\n",
"
61.00
\n",
"
roate
\n",
"
-5.883
\n",
"
\n",
"
\n",
"
2
\n",
"
raise
\n",
"
168
\n",
"
raile
\n",
"
61.33
\n",
"
raise
\n",
"
-5.878
\n",
"
\n",
"
\n",
"
3
\n",
"
reais
\n",
"
168
\n",
"
soare
\n",
"
62.30
\n",
"
raile
\n",
"
-5.866
\n",
"
\n",
"
\n",
"
4
\n",
"
serai
\n",
"
168
\n",
"
arise
\n",
"
63.73
\n",
"
reast
\n",
"
-5.865
\n",
"
\n",
"
\n",
"
5
\n",
"
aiery
\n",
"
171
\n",
"
irate
\n",
"
63.78
\n",
"
slate
\n",
"
-5.856
\n",
"
\n",
"
\n",
"
6
\n",
"
ayrie
\n",
"
171
\n",
"
orate
\n",
"
63.89
\n",
"
crate
\n",
"
-5.835
\n",
"
\n",
"
\n",
"
7
\n",
"
ariel
\n",
"
173
\n",
"
ariel
\n",
"
65.29
\n",
"
salet
\n",
"
-5.835
\n",
"
\n",
"
\n",
"
8
\n",
"
raile
\n",
"
173
\n",
"
arose
\n",
"
66.02
\n",
"
irate
\n",
"
-5.831
\n",
"
\n",
"
\n",
"
9
\n",
"
aloes
\n",
"
174
\n",
"
raine
\n",
"
67.06
\n",
"
trace
\n",
"
-5.831
\n",
"
\n",
"
\n",
"
10
\n",
"
realo
\n",
"
176
\n",
"
artel
\n",
"
67.50
\n",
"
arise
\n",
"
-5.821
\n",
"
\n",
"
\n",
"
11
\n",
"
stoae
\n",
"
177
\n",
"
taler
\n",
"
67.74
\n",
"
orate
\n",
"
-5.817
\n",
"
\n",
"
\n",
"
12
\n",
"
alone
\n",
"
182
\n",
"
ratel
\n",
"
69.84
\n",
"
stare
\n",
"
-5.807
\n",
"
\n",
"
\n",
"
13
\n",
"
anole
\n",
"
182
\n",
"
aesir
\n",
"
69.88
\n",
"
carte
\n",
"
-5.795
\n",
"
\n",
"
\n",
"
14
\n",
"
aeros
\n",
"
183
\n",
"
arles
\n",
"
69.89
\n",
"
raine
\n",
"
-5.787
\n",
"
\n",
"
\n",
"
15
\n",
"
arose
\n",
"
183
\n",
"
realo
\n",
"
69.95
\n",
"
caret
\n",
"
-5.777
\n",
"
\n",
"
\n",
"
16
\n",
"
soare
\n",
"
183
\n",
"
alter
\n",
"
69.99
\n",
"
ariel
\n",
"
-5.775
\n",
"
\n",
"
\n",
"
17
\n",
"
oiler
\n",
"
186
\n",
"
saner
\n",
"
70.13
\n",
"
taler
\n",
"
-5.771
\n",
"
\n",
"
\n",
"
18
\n",
"
oriel
\n",
"
186
\n",
"
later
\n",
"
70.22
\n",
"
carle
\n",
"
-5.770
\n",
"
\n",
"
\n",
"
19
\n",
"
reoil
\n",
"
186
\n",
"
snare
\n",
"
71.10
\n",
"
slane
\n",
"
-5.770
\n",
"
\n",
" \n",
"
\n",
"
"
],
"text/plain": [
" max_word max exp_word exp ent_word ent\n",
"0 aesir 168 roate 60.42 soare -5.886\n",
"1 arise 168 raise 61.00 roate -5.883\n",
"2 raise 168 raile 61.33 raise -5.878\n",
"3 reais 168 soare 62.30 raile -5.866\n",
"4 serai 168 arise 63.73 reast -5.865\n",
"5 aiery 171 irate 63.78 slate -5.856\n",
"6 ayrie 171 orate 63.89 crate -5.835\n",
"7 ariel 173 ariel 65.29 salet -5.835\n",
"8 raile 173 arose 66.02 irate -5.831\n",
"9 aloes 174 raine 67.06 trace -5.831\n",
"10 realo 176 artel 67.50 arise -5.821\n",
"11 stoae 177 taler 67.74 orate -5.817\n",
"12 alone 182 ratel 69.84 stare -5.807\n",
"13 anole 182 aesir 69.88 carte -5.795\n",
"14 aeros 183 arles 69.89 raine -5.787\n",
"15 arose 183 realo 69.95 caret -5.777\n",
"16 soare 183 alter 69.99 ariel -5.775\n",
"17 oiler 186 saner 70.13 taler -5.771\n",
"18 oriel 186 later 70.22 carle -5.770\n",
"19 reoil 186 snare 71.10 slane -5.770"
]
},
"execution_count": 59,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"df2[:20]"
]
},
{
"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",
" - 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",
" - 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",
" - Research what other computer scientists have done with [Jotto](https://arxiv.org/abs/1107.3342) or [Mastermind](http://serkangur.freeservers.com/).\n",
" - Refactor the code so it can 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; of size 2 an average of 3/2 guesses; and 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? How long would the search take?\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",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.7.6"
}
},
"nbformat": 4,
"nbformat_minor": 4
}