wordle.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "4bee6f21",
   "metadata": {},
   "source": [
    "# Wordle solver - word entropy based algorithm to provide Wordle assistance and overall algorithm assessment\n",
    "\n",
    "## Author:  DM Rosewarne.  Consultant Radiologist, HEE Topol fellow - Team AI\n",
    "\n",
    "The sheet describes a tool for Wordle assistance which uses the revealed game state so far to narrow the range of possible word guesses.  The assistance will always suggest from the 2315 word Wordle vocabulary and will always use all the clue infomation available.  10 choices are given, ranked in order of 'word entropy' a heuristic score intended to select words that are likely to reveal useful information for future rounds (ie common letters and non-repeated letters tend to be favoured).\n",
    "\n",
    "The following cell defines the functions we shall use, and imports from libraries:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "0b59a4ea",
   "metadata": {},
   "outputs": [],
   "source": [
    "from collections import Counter\n",
    "import math\n",
    "import re\n",
    "from itertools import permutations\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "'''\n",
    "Acquire the Wordle vocabulary and strip off the newline\n",
    "\n",
    "''' \n",
    "with open('wordleWordList.txt') as f:\n",
    "    words = f.readlines()\n",
    "WORDLE_WORDS = [w[:-1] for w in words]\n",
    "WORDLE_VOCAB_SIZE = len(WORDLE_WORDS)\n",
    "\n",
    "\n",
    "def form_letter_frequencies(wordList) :\n",
    "    '''\n",
    "    \n",
    "    Return an array of Counter objects containing letter frequencies\n",
    "    at each letter position\n",
    "    \n",
    "    '''\n",
    "    letterConcatenations = ['', '', '', '', '']\n",
    "    for p in range(5):\n",
    "        for w in wordList :\n",
    "            letterConcatenations[p] += w[p]\n",
    "    return [Counter(letterConcatenations[p]) for p in range(5)]\n",
    "\n",
    "LETTER_FREQUENCIES = form_letter_frequencies(WORDLE_WORDS)\n",
    "\n",
    "def entropy(f, N) :\n",
    "    '''\n",
    "    Entropy associated with outcome of frequency f from N\n",
    "    \n",
    "    '''\n",
    "    if f == 0 :\n",
    "        return 0.0\n",
    "    else :\n",
    "        return -(f/N)*math.log(f/N)\n",
    "\n",
    "def score_word_entropy(word, frequencies, vocabSize) :\n",
    "    '''\n",
    "    Entropy associated with 5 letter word taking Wordle vocabularly\n",
    "    frequencies as character probability model and assuming letter \n",
    "    independence (!!).  Note the final contribution which recognises \n",
    "    different letters to be more informative than repeated letters\n",
    "    \n",
    "    '''\n",
    "    score = 0\n",
    "    for p in range(5) :\n",
    "        c = word[p]\n",
    "        score += entropy(frequencies[p][c], vocabSize)\n",
    "    return score+math.log(len(set(permutations(word))))\n",
    "\n",
    "def score_words(wordList) :\n",
    "    '''\n",
    "    Provides a dictionary of word entropies for a list of words\n",
    "    \n",
    "    '''\n",
    "    scoreDict = {}\n",
    "    for w in wordList :\n",
    "        scoreDict[w] = score_word_entropy(w, LETTER_FREQUENCIES, WORDLE_VOCAB_SIZE)\n",
    "    return scoreDict\n",
    "\n",
    "def rank_words(wordList) :\n",
    "    '''\n",
    "    Provides a ranked list of word entropies to act as a basis for recommendation\n",
    "    \n",
    "    '''\n",
    "    return sorted(score_words(wordList).items(), key=lambda k:k[1], reverse = True)\n",
    "    \n",
    "    \n",
    "def implement_green (wordList, letter, position, mode=True) :\n",
    "    '''\n",
    "    Narrow a wordlist given a correct positional clue\n",
    "    (green).  mode = False used with a yellow clue\n",
    "    where this implies that although the letter is used\n",
    "    it is not at the indicated position\n",
    "    \n",
    "    '''\n",
    "    return [w for w in wordList if (w[position] == letter if mode else w[position] != letter)]\n",
    "\n",
    "def implement_yellow (wordList, letter, position) :\n",
    "    wordList = implement_green (wordList, letter, position, False)\n",
    "    '''\n",
    "    Narrow wordlist for yellow clue.  \n",
    "    The letter is in the word but not at the current\n",
    "    position\n",
    "    \n",
    "    '''\n",
    "    return [w for w in wordList if letter in w]\n",
    "\n",
    "def implement_black (wordList, letter) :\n",
    "    '''\n",
    "    Narrow wordlist for black (or grey) clue\n",
    "    Letter not in word.  The case that there are\n",
    "    no more of a given letter is dealth with by\n",
    "    generating a new type of clue with label l\n",
    "    ion functions below\n",
    "    \n",
    "    '''\n",
    "    return[w for w in wordList if letter not in w]\n",
    "\n",
    "def calc_letter_limit(word, feedback, position) :\n",
    "    '''\n",
    "    Count the occurrences of a letter that is present in \n",
    "    a word at given position\n",
    "    \n",
    "    '''\n",
    "    char = word[position]\n",
    "    count = 0\n",
    "    for i in range(len(word)) :\n",
    "        if (word[i] == char) and (feedback[i] == 'y' or feedback[i] == 'g') :\n",
    "            count += 1\n",
    "    return count\n",
    "\n",
    "def implement_letter_limit(wordList, word, clues, position) :\n",
    "    '''\n",
    "    Exclude words with more occurrences of a letter than \n",
    "    indicated by the clues given\n",
    "    \n",
    "    '''\n",
    "    char = word[position]\n",
    "    l = calc_letter_limit(word, clues, position)\n",
    "    return [w for w in wordList if w.count(char) <= l]\n",
    "\n",
    "\n",
    "def parse_clues(word, clues) :\n",
    "    '''\n",
    "    Takes a clue string and replaces a \"b\" character\n",
    "    with \"l\" when the \"b\" indicates that the letter \n",
    "    limit has been reached\n",
    "    \n",
    "    '''\n",
    "    gyLetters = ''\n",
    "    parsedClues = ''\n",
    "    for i in range(len(word)) :\n",
    "        if (clues[i] == 'g') or (clues [i] == 'y') :\n",
    "            gyLetters += word[i]\n",
    "    for i in range(len(word)) :\n",
    "        if (clues[i] == 'b') and (word[i] in gyLetters) :\n",
    "            parsedClues += 'l'\n",
    "        else :\n",
    "            parsedClues += clues[i]\n",
    "    return parsedClues    \n",
    "\n",
    "def implement_clues(wordList, word, clues) :\n",
    "    '''\n",
    "    Narrow a word list by information from a full\n",
    "    set of clues\n",
    "    \n",
    "    '''\n",
    "    clues = parse_clues(word, clues)\n",
    "    p = 0\n",
    "    for c in clues :\n",
    "        if c == 'g' :\n",
    "            wordList = implement_green(wordList, word[p], p)\n",
    "        if c == 'y' :\n",
    "            wordList = implement_yellow(wordList, word[p], p)\n",
    "        if c == 'b' :\n",
    "            wordList = implement_black(wordList, word[p])\n",
    "        if c == 'l' :\n",
    "            wordList = implement_letter_limit(wordList, word, clues, p)\n",
    "        p += 1\n",
    "    return wordList\n",
    "\n",
    "\n",
    "def generate_clue(word, target) :\n",
    "    '''\n",
    "    This is used in algorithm assessment.\n",
    "    It generates the feedback string for guess\n",
    "    \"word\" against known \"target\" word\n",
    "    \n",
    "    '''\n",
    "    letterCounts = Counter(target)\n",
    "    feedbackString = ''\n",
    "    for p in range(len(word)) :\n",
    "        fb = ''\n",
    "        if word[p] == target[p] :\n",
    "            fb = 'g'\n",
    "        elif word[p] not in target :\n",
    "            fb = 'b'\n",
    "        elif fb == '' and Counter(word[:p])[word[p]] < letterCounts[word[p]] :\n",
    "            fb = 'y'\n",
    "        else : \n",
    "            fb = 'l'\n",
    "        feedbackString = feedbackString + fb\n",
    "    return feedbackString\n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "86411628",
   "metadata": {},
   "source": [
    "# Wordle assistance\n",
    "\n",
    "The cell below provides Wordle assistance alongside an active Wordle game.  The user just needs to transcribe the clues given by the game in a format such as 'gbyyg' where g = green, b = black (sometimes rendered grey, but indicating not present or letter count reached) and y = yellow.  The suggested word can be accepted or ignored.  If ignored there is no verification that the word chosen would be accepted by Wordle - it is intended that this is verified first with the game."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "65572889",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "\n",
      "Try number:  1\n",
      "Remaining Wordle words:  2315\n",
      "Top suggestions:\n",
      " [('slate', 6.038993621880171), ('saint', 6.036189873242096), ('slice', 6.029608593304491), ('crane', 6.025661332163921), ('sauce', 6.0236523125994195), ('shale', 6.0167944136368705), ('saute', 6.0137278278904365), ('shine', 6.011309819829561), ('suite', 6.0100806229416905), ('share', 6.0094894967789045)] \n",
      "\n",
      "Enter a 5 letter word or just ENTER for highest ranked choice: \n",
      "Word chosen was:  slate\n",
      "Enter clue string in format \"bgyby\" etc: bybby\n",
      "\n",
      "\n",
      "Try number:  2\n",
      "Remaining Wordle words:  61\n",
      "Top suggestions:\n",
      " [('cruel', 5.889611388190014), ('gruel', 5.828442915228699), ('filer', 5.80495611613633), ('liner', 5.785087847181245), ('model', 5.750159987235904), ('peril', 5.746588861220068), ('bowel', 5.741207996910555), ('lover', 5.740008592442525), ('reply', 5.733220256213952), ('belch', 5.711614843247164)] \n",
      "\n",
      "Enter a 5 letter word or just ENTER for highest ranked choice: \n",
      "Word chosen was:  cruel\n",
      "Enter clue string in format \"bgyby\" etc: bbbyy\n",
      "\n",
      "\n",
      "Try number:  3\n",
      "Remaining Wordle words:  14\n",
      "Top suggestions:\n",
      " [('field', 5.701226133446563), ('felon', 5.661635524513187), ('wield', 5.654037170503758), ('melon', 5.637212455460743), ('newly', 5.617082270023802), ('lemon', 5.568700172880784), ('below', 5.563333983634878), ('whelp', 5.5522999155402335), ('yield', 5.550141495000382), ('helix', 5.477602527057034)] \n",
      "\n",
      "Enter a 5 letter word or just ENTER for highest ranked choice: \n",
      "Word chosen was:  field\n",
      "Enter clue string in format \"bgyby\" etc: bgggg\n",
      "\n",
      "\n",
      "Try number:  4\n",
      "Remaining Wordle words:  2\n",
      "Top suggestions:\n",
      " [('wield', 5.654037170503758), ('yield', 5.550141495000382)] \n",
      "\n",
      "Enter a 5 letter word or just ENTER for highest ranked choice: \n",
      "Word chosen was:  wield\n",
      "Enter clue string in format \"bgyby\" etc: bgggg\n",
      "\n",
      "\n",
      "Try number:  5\n",
      "Remaining Wordle words:  1\n",
      "Top suggestions:\n",
      " [('yield', 5.550141495000382)] \n",
      "\n",
      "Enter a 5 letter word or just ENTER for highest ranked choice: \n",
      "Word chosen was:  yield\n",
      "Enter clue string in format \"bgyby\" etc: ggggg\n",
      "Nice one :-)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "workingList = WORDLE_WORDS\n",
    "NUM_SUGGESTIONS = 10\n",
    "\n",
    "tries = 1\n",
    "endGame = False\n",
    "clues = ''\n",
    "while (tries <= 6) and (endGame == False):\n",
    "    scoreDict = rank_words(workingList) \n",
    "    suggestions = scoreDict[:NUM_SUGGESTIONS]\n",
    "    print('\\n\\nTry number: ', tries)\n",
    "    print('Remaining Wordle words: ', len(workingList))\n",
    "    print ('Top suggestions:\\n', suggestions, '\\n')\n",
    "    validWord = False    \n",
    "    while (not validWord) :\n",
    "        word = input('Enter a 5 letter word or just ENTER for highest ranked choice: ').lower()\n",
    "        if word == '' :\n",
    "            validWord = True\n",
    "            word = suggestions[0][0]\n",
    "            print('Word chosen was: ', word)\n",
    "        if  (not re.search('[b|y|g]{5}', word)) & (len(word) == 5) :\n",
    "            validWord = True            \n",
    "    validClue = False\n",
    "    while (not validClue) :\n",
    "        clues = input('Enter clue string in format \"bgyby\" etc: ')\n",
    "        if re.search('[b|y|g]{5}', clues) :\n",
    "            if len(clues) == 5 :\n",
    "                validClue = True\n",
    "    if clues == 'ggggg' :\n",
    "        print ('Nice one :-)\\n')\n",
    "        endGame = True\n",
    "    workingList = implement_clues(workingList, word, clues)\n",
    "    if len(workingList) == 0 :\n",
    "        print ('No possibilities remain - incorrect clue information entered somewhere :-(')\n",
    "        endGame = True\n",
    "    tries +=1\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b1a12ec3",
   "metadata": {},
   "source": [
    "# Algorithm assessment\n",
    "\n",
    "The cell below evaluates the performance of the above algorithm over all possible Wordle target words."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "id": "65ce97b7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYUAAAEWCAYAAACJ0YulAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAAsTAAALEwEAmpwYAAAZ9klEQVR4nO3debRdZX3/8ffHBIEwCCwCZZKAUgRZKhhQ64AKrQgoVItiBdGiaIs4/xQstbarKNa5ttQiKIMIDaCAQ0VEwKFWCIgyRApChJAIQVQGKeP398fed3O4uTc5N7kn55K8X2tlnT0++3uH3M/Zz97n2akqJEkCeMKwC5AkTR2GgiSpYyhIkjqGgiSpYyhIkjqGgiSpYyhohST5fJK/m6S2npzkniTT2vmLk7x5Mtpu2/uvJIdMVnsTOO4/Jbkjya9X9rF7apiVpJJMb+cn9Xs7xvFen+Q7g2pfgzN92AVo6koyH9gUeAh4GLgWOAU4vqoeAaiqt02grTdX1XfH26aqbgbWXbGqu+N9GHhqVR3U0/7LJ6PtCdaxFfBeYOuqun1lH3+yJZkF3ASsUVUPjbddVZ0GnLay6tLk8UxBy/KKqloP2Bo4FvgAcOJkH2TkHewqaGvgNyszEIb9vRz28bViDAX1pap+X1XnAa8FDkmyE0CSk5L8Uzu9cZJvJPldkjuT/CDJE5KcCjwZ+HrbPfT+nu6MQ5PcDHxvdBdH6ylJLk3y+yTnJtmoPdaLkyzorTHJ/CR7JtkL+CDw2vZ4P2vXd10mbV1HJ/lVktuTnJLkSe26kToOSXJz2/Xzt+N9b5I8qd1/cdve0W37ewIXAJu3dZw0xr6XJHl1O/2C9rh7t/N7JrlyAvX2fi+nJflEW/uNwD5L+/km+ask85L8Nsn5SbYeZ9Pvt6+/a7+m5yV5Y5IfJfl0kjuBD7fLftjT/tOSXND+XlyX5DU96/ZOcm2Su5PcmuR9S6tVg2UoaEKq6lJgAfDCMVa/t103k6bb6YPNLnUwcDPNWce6VfXPPfvsDuwAvGycQ74B+Ctgc5purH/po8ZvAx8B/rM93jPH2OyN7b+XANvSdFv966htXgBsD+wBfCjJDuMc8nPAk9p2dm9rflPbVfZyYGFbxxvH2PcS4MXt9IuAG9s2RuYvmUC9vd/LtwD7AjsDs4G/GKd2kuxP87N6Fc3P7gfA6eNs/qL2dYP2a/pxO/+ctvZNgGNGtb8OTTh+pV3/OuC4JE9vNzkReGt7RroT8L3xatXgGQpaHguBjcZY/iCwGU3/+YNV9YNa9uBaH66qe6vqvnHWn1pVV1fVvcDfAa9JeyF6Bb0e+FRV3VhV9wBHAQeOOkv5h6q6r6p+BvwMWCJc2lpeCxxVVXdX1Xzgk8DBfdZxCY8NgY/2zO/Oo6HQT72938vXAJ+pqluq6s623fG8FfhoVc1rrxN8BHjWUs4WxrKwqj5XVQ+N8bPcF5hfVV9q118BnM2jQfUgsGOS9avqt+16DYmhoOWxBXDnGMs/DtwAfCfJjUmO7KOtWyaw/lfAGsDGfVW5dJu37fW2PZ3mDGdE791Cf2Dsi+AbA08co60t+qzjx8AfJ9kUeBbNhfytkmwM7Maj3TX91Nv7vdqcJb9349ka+Gzb7fc7mp9tJvA1jD72WO0/Z6T99hivB/6oXf9qYG/gV2132vMmcFxNMkNBE5JkV5o/Fj8cva59p/zeqtoWeAXwniR7jKwep8llnUls1TP9ZJp3lXcA9wIzeuqaRtP10W+7C2n+WPW2/RBw2zL2G+2OtqbRbd3az85V9QfgcuCdwNVV9QDw38B7gF9W1R0TqLf3a17Ekt+78dxC032zQc+/tavqv8cqebwvZRntXzKq/XWr6q8BquqyqtqPpmvpHGDOUtrSgBkK6kuS9ZPsC5wBfLmqrhpjm32TPDVJgLtobmN9uF19G01f+EQdlGTHJDOAfwTOqqqHgf8F1kqyT5I1gKOBNXv2uw2YlWS83/HTgXcn2SbJujx6DWLc2yzH0tYyBzgmyXptl8t7gC9PoJlLgLfzaFfRxaPml6feOcA7kmyZZENgaWdtnweOGunjby+cHzDOtouBR5jYz/IbNGdDBydZo/23a5IdkjwxzWcanlRVD/Lo742GxFDQsnw9yd007/b+FvgU8KZxtt0O+C5wD023yHFVdXG77qPA0W33wUTuLjkVOImmK2ct4B3Q3A0F/A1wAs278ntpLnKPOLN9/U2Ssfqov9i2/X2a++7/DzhiAnX1OqI9/o00Z1Bfadvv1yXAejzaVTR6fnnq/QJwPs21kCuAr463YVV9DfgYcEaSu4CraS6Qj7XtH2guJP+o/Vk+d1lfXFXdDfwZcCDNGc+v2+ONhPjBwPz22G8DDhqrHa0c8SE7kqQRnilIkjqGgiSpYyhIkjqGgiSp87geuGrjjTeuWbNmDbsMSXpcufzyy++oqpljrXtch8KsWbOYO3fusMuQpMeVJON+wt3uI0lSx1CQJHUMBUlSx1CQJHUMBUlSx1CQJHUMBUlSx1CQJHUMBUlS53H9iWYJYNaR3xx2CWOaf+w+wy5BmjDPFCRJHUNBktQxFCRJHUNBktQxFCRJHUNBktQxFCRJHUNBktQxFCRJHUNBktQxFCRJHUNBktQxFCRJHUNBktQxFCRJHUNBktTxITvq21R9mI2kyeOZgiSpYyhIkjqGgiSpYyhIkjqGgiSpM9BQSPLuJNckuTrJ6UnWSrJRkguSXN++btiz/VFJbkhyXZKXDbI2SdKSBhYKSbYA3gHMrqqdgGnAgcCRwIVVtR1wYTtPkh3b9U8H9gKOSzJtUPVJkpY06O6j6cDaSaYDM4CFwH7Aye36k4H92+n9gDOq6v6qugm4AdhtwPVJknoMLBSq6lbgE8DNwCLg91X1HWDTqlrUbrMI2KTdZQvglp4mFrTLHiPJYUnmJpm7ePHiQZUvSaulQXYfbUjz7n8bYHNgnSQHLW2XMZbVEguqjq+q2VU1e+bMmZNTrCQJGGz30Z7ATVW1uKoeBL4K/AlwW5LNANrX29vtFwBb9ey/JU13kyRpJRlkKNwMPDfJjCQB9gDmAecBh7TbHAKc206fBxyYZM0k2wDbAZcOsD5J0igDGxCvqn6S5CzgCuAh4KfA8cC6wJwkh9IExwHt9tckmQNc225/eFU9PKj6JElLGugoqVX198Dfj1p8P81Zw1jbHwMcM8iaJEnj8xPNkqSOoSBJ6hgKkqSOoSBJ6hgKkqSOoSBJ6hgKkqSOoSBJ6hgKkqSOoSBJ6hgKkqSOoSBJ6hgKkqSOoSBJ6hgKkqSOoSBJ6hgKkqSOoSBJ6hgKkqSOoSBJ6hgKkqSOoSBJ6hgKkqSOoSBJ6hgKkqSOoSBJ6hgKkqSOoSBJ6hgKkqSOoSBJ6hgKkqSOoSBJ6hgKkqSOoSBJ6hgKkqSOoSBJ6gw0FJJskOSsJL9IMi/J85JslOSCJNe3rxv2bH9UkhuSXJfkZYOsTZK0pEGfKXwW+HZVPQ14JjAPOBK4sKq2Ay5s50myI3Ag8HRgL+C4JNMGXJ8kqcfAQiHJ+sCLgBMBquqBqvodsB9wcrvZycD+7fR+wBlVdX9V3QTcAOw2qPokSUsa5JnCtsBi4EtJfprkhCTrAJtW1SKA9nWTdvstgFt69l/QLnuMJIclmZtk7uLFiwdYviStfgYZCtOBXYB/r6qdgXtpu4rGkTGW1RILqo6vqtlVNXvmzJmTU6kkCRhsKCwAFlTVT9r5s2hC4rYkmwG0r7f3bL9Vz/5bAgsHWJ8kaZSBhUJV/Rq4Jcn27aI9gGuB84BD2mWHAOe20+cBByZZM8k2wHbApYOqT5K0pOn9bJRkp6q6ejnaPwI4LckTgRuBN9EE0ZwkhwI3AwcAVNU1SebQBMdDwOFV9fByHFOStJz6CgXg8+0f9pOAr7R3ES1TVV0JzB5j1R7jbH8McEyfNUmSJllf3UdV9QLg9TR9/nOTfCXJnw60MknSStf3NYWquh44GvgAsDvwL+0nlV81qOIkSStXX6GQ5BlJPk3zieSXAq+oqh3a6U8PsD5J0krU7zWFfwW+AHywqu4bWVhVC5McPZDKJEkrXb+hsDdw38jdQEmeAKxVVX+oqlMHVp0kaaXq95rCd4G1e+ZntMskSauQfkNhraq6Z2SmnZ4xmJIkScPSbyjcm2SXkZkkzwbuW8r2kqTHoX6vKbwLODPJyFhEmwGvHUhFkqSh6SsUquqyJE8DtqcZzfQXVfXgQCuTJK10/Z4pAOwKzGr32TkJVXXKQKqSJA1FvwPinQo8BbgSGBmkrgBDQZJWIf2eKcwGdqyqJR56I0ladfR799HVwB8NshBJ0vD1e6awMXBtkkuB+0cWVtUrB1KVJGko+g2FDw+yCEnS1NDvLamXJNka2K6qvptkBjBtsKVJkla2fofOfgtwFvAf7aItgHMGVJMkaUj6vdB8OPB84C7oHrizyaCKkiQNR7+hcH9VPTAyk2Q6zecUJEmrkH5D4ZIkHwTWbp/NfCbw9cGVJUkahn5D4UhgMXAV8FbgWzTPa5YkrUL6vfvoEZrHcX5hsOVIkoap37GPbmKMawhVte2kVyRJGpqJjH00Yi3gAGCjyS9HkjRMfV1TqKrf9Py7tao+A7x0sKVJkla2fruPdumZfQLNmcN6A6lIkjQ0/XYffbJn+iFgPvCaSa9GkjRU/d599JJBFyJJGr5+u4/es7T1VfWpySlHkjRME7n7aFfgvHb+FcD3gVsGUZQkaTgm8pCdXarqboAkHwbOrKo3D6owSdLK1+8wF08GHuiZfwCYNenVSJKGqt8zhVOBS5N8jeaTzX8OnDKwqiRJQ9Hv3UfHJPkv4IXtojdV1U8HV5YkaRj67T4CmAHcVVWfBRYk2WZANUmShqTfx3H+PfAB4Kh20RrAl/vcd1qSnyb5Rju/UZILklzfvm7Ys+1RSW5Icl2Sl03sS5Ekrah+zxT+HHglcC9AVS2k/2Eu3gnM65k/EriwqrYDLmznSbIjcCDwdGAv4Lgk0/o8hiRpEvQbCg9UVdEOn51knX52SrIlsA9wQs/i/YCT2+mTgf17lp9RVfdX1U3ADcBufdYnSZoE/YbCnCT/AWyQ5C3Ad+nvgTufAd4PPNKzbNOqWgTQvm7SLt+Cx34YbkG77DGSHJZkbpK5ixcv7rN8SVI/lhkKSQL8J3AWcDawPfChqvrcMvbbF7i9qi7vs5aMsWysB/scX1Wzq2r2zJkz+2xaktSPZd6SWlWV5JyqejZwwQTafj7wyiR70zyYZ/0kXwZuS7JZVS1Kshlwe7v9AmCrnv23BBZO4HiSpBXUb/fR/yTZdSINV9VRVbVlVc2iuYD8vao6iGb8pEPazQ4Bzm2nzwMOTLJme7vrdsClEzmmJGnF9PuJ5pcAb0syn+YOpNCcRDxjOY55LM01ikOBm2ke7UlVXZNkDnAtzTMbDq+qh5ejfUnSclpqKCR5clXdDLx8RQ5SVRcDF7fTvwH2GGe7Y4BjVuRYkqTlt6wzhXNoRkf9VZKzq+rVK6EmSdKQLOuaQu8dQdsOshBJ0vAtKxRqnGlJ0ipoWd1Hz0xyF80Zw9rtNDx6oXn9gVYnSVqplhoKVeXYQ5K0GpnI0NmSpFWcoSBJ6hgKkqSOoSBJ6hgKkqSOoSBJ6hgKkqSOoSBJ6hgKkqROv89TkDRBs4785rBLGNP8Y/cZdgmawjxTkCR1DAVJUsdQkCR1DAVJUsdQkCR1DAVJUsdQkCR1DAVJUsdQkCR1DAVJUsdQkCR1DAVJUsdQkCR1DAVJUsdQkCR1DAVJUsdQkCR1DAVJUsdQkCR1DAVJUsdQkCR1BhYKSbZKclGSeUmuSfLOdvlGSS5Icn37umHPPkcluSHJdUleNqjaJEljG+SZwkPAe6tqB+C5wOFJdgSOBC6squ2AC9t52nUHAk8H9gKOSzJtgPVJkkYZWChU1aKquqKdvhuYB2wB7Aec3G52MrB/O70fcEZV3V9VNwE3ALsNqj5J0pJWyjWFJLOAnYGfAJtW1SJoggPYpN1sC+CWnt0WtMskSSvJwEMhybrA2cC7ququpW06xrIao73DksxNMnfx4sWTVaYkiQGHQpI1aALhtKr6arv4tiSbtes3A25vly8AturZfUtg4eg2q+r4qppdVbNnzpw5uOIlaTU0yLuPApwIzKuqT/WsOg84pJ0+BDi3Z/mBSdZMsg2wHXDpoOqTJC1p+gDbfj5wMHBVkivbZR8EjgXmJDkUuBk4AKCqrkkyB7iW5s6lw6vq4QHWJ0kaZWChUFU/ZOzrBAB7jLPPMcAxg6pJkrR0fqJZktQxFCRJHUNBktQxFCRJHUNBktQxFCRJHUNBktQZ5IfXtJxmHfnNYZcgaTXlmYIkqWMoSJI6hoIkqWMoSJI6hoIkqWMoSJI6hoIkqWMoSJI6hoIkqWMoSJI6hoIkqWMoSJI6hoIkqWMoSJI6Dp0trWam6tDs84/dZ9glCM8UJEk9DAVJUsdQkCR1DAVJUsdQkCR1DAVJUsdQkCR1DAVJUsdQkCR1DAVJUsdQkCR1DAVJUsdQkCR1HCVV0pTg6K1Tw5Q7U0iyV5LrktyQ5Mhh1yNJq5MpdaaQZBrwb8CfAguAy5KcV1XXDrcySaur1e0MZqqdKewG3FBVN1bVA8AZwH5DrkmSVhtT6kwB2AK4pWd+AfCc3g2SHAYc1s7ek+S6lVTbsmwM3DHsIsZgXRNjXRNjXRMzaXXlYyu0+9bjrZhqoZAxltVjZqqOB45fOeX0L8ncqpo97DpGs66Jsa6Jsa6Jmap19Zpq3UcLgK165rcEFg6pFkla7Uy1ULgM2C7JNkmeCBwInDfkmiRptTGluo+q6qEkbwfOB6YBX6yqa4ZcVr+mXJdWy7omxromxromZqrW1UlVLXsrSdJqYap1H0mShshQkCR1DIUVlOSLSW5PcvWwaxmRZKskFyWZl+SaJO8cdk0ASdZKcmmSn7V1/cOwa+qVZFqSnyb5xrBrGZFkfpKrklyZZO6w6xmRZIMkZyX5Rft79rwpUNP27fdp5N9dSd417LoAkry7/Z2/OsnpSdYadk3j8ZrCCkryIuAe4JSq2mnY9QAk2QzYrKquSLIecDmw/7CHC0kSYJ2quifJGsAPgXdW1f8Ms64RSd4DzAbWr6p9h10PNKEAzK6qKfVBrCQnAz+oqhPaOwVnVNXvhlxWpx0y51bgOVX1qyHXsgXN7/qOVXVfkjnAt6rqpGHWNR7PFFZQVX0fuHPYdfSqqkVVdUU7fTcwj+bT4kNVjXva2TXaf1PiXUmSLYF9gBOGXctUl2R94EXAiQBV9cBUCoTWHsAvhx0IPaYDayeZDsxgCn/+ylBYxSWZBewM/GTIpQBdF82VwO3ABVU1JeoCPgO8H3hkyHWMVsB3klzeDvEyFWwLLAa+1Ha3nZBknWEXNcqBwOnDLgKgqm4FPgHcDCwCfl9V3xluVeMzFFZhSdYFzgbeVVV3DbsegKp6uKqeRfNp9d2SDL3LLcm+wO1VdfmwaxnD86tqF+DlwOFtd+WwTQd2Af69qnYG7gWmzDD3bXfWK4Ezh10LQJINaQb23AbYHFgnyUHDrWp8hsIqqu2zPxs4raq+Oux6Rmu7Gy4G9hpuJQA8H3hl239/BvDSJF8ebkmNqlrYvt4OfI1mJOFhWwAs6DnLO4smJKaKlwNXVNVtwy6ktSdwU1UtrqoHga8CfzLkmsZlKKyC2gu6JwLzqupTw65nRJKZSTZop9em+c/yi6EWBVTVUVW1ZVXNoul2+F5VDf2dXJJ12hsFaLtn/gwY+l1uVfVr4JYk27eL9gCm0jNPXscU6Tpq3Qw8N8mM9v/mHjTX+aYkQ2EFJTkd+DGwfZIFSQ4ddk0073wPpnnHO3J73t7DLgrYDLgoyc9pxrm6oKqmzO2fU9CmwA+T/Ay4FPhmVX17yDWNOAI4rf1ZPgv4yHDLaSSZQfOQrilzdtyeUZ0FXAFcRfN3d8oOd+EtqZKkjmcKkqSOoSBJ6hgKkqSOoSBJ6hgKkqSOoaDHvSSV5JM98+9L8uFJavukJH8xGW0t4zgHtKONXjRq+awkf7mU/TZPctag69Pqw1DQquB+4FVJNh52Ib3akTr7dSjwN1X1klHLZwFjhkKS6VW1sKoGHlpafRgKWhU8RPNhoHePXjH6nX6Se9rXFye5JMmcJP+b5Ngkr2+f93BVkqf0NLNnkh+02+3b7j8tyceTXJbk50ne2tPuRUm+QvNBpdH1vK5t/+okH2uXfQh4AfD5JB8ftcuxwAvbDyC+O8kbk5yZ5Os0A+XNSvssj6XUtFmS77dtXJ3khcv5fdZqYPqwC5Amyb8BP0/yzxPY55nADjRDn98InFBVu6V5KNERwLva7WYBuwNPoflE9lOBN9CMdrlrkjWBHyUZGflyN2Cnqrqp92BJNgc+Bjwb+C3NH/X9q+ofk7wUeF9VjX6QzpHt8pEweiPwPOAZVXVnOwruiEPHqelVwPlVdUx79jJjAt8jrWYMBa0SququJKcA7wDu63O3y6pqEUCSXwIjf9SvAnq7ceZU1SPA9UluBJ5GMw7RM3rOQp4EbAc8AFw6OhBauwIXV9Xi9pin0TyX4Jw+6x1xQVWN9QyP8Wq6DPhiO0jiOVV15QSPp9WIoaBVyWdoxpf5Us+yh2i7SdvByJ7Ys+7+nulHeuYf4bH/N0aPBVNAgCOq6vzeFUleTDOU9FiyjPr7tbT2l6gJuicE7gOcmuTjVXXKJNWiVYzXFLTKaN89z6HpRhkxn6a7Bpox7ddYjqYPSPKE9jrDtsB1wPnAX7fvvknyx308aOYnwO5JNm67cV4HXLKMfe4G1uuzzjFrSrI1zfMivkAzeu5UGuZaU4xnClrVfBJ4e8/8F4Bzk1wKXMj477KX5jqaP96bAm+rqv9LcgLNtYYr2jOQxcD+S2ukqhYlOQq4iOZd/beq6txlHPvnwEPtSKkn0VyLGM94Nb0Y+H9JHqR5nvgblnFMrcYcJVWS1LH7SJLUMRQkSR1DQZLUMRQkSR1DQZLUMRQkSR1DQZLU+f/fmLK5XT745AAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Average number of tries (all words):  3.7460043196544275\n",
      "Average number of tries (successes only):  3.7107329842931938\n",
      "Rate of failure to reach solution in 6 guesses (%):  0.9935205183585313\n"
     ]
    }
   ],
   "source": [
    "totalTries = 0\n",
    "failCount = 0\n",
    "successCount = 0\n",
    "successTryCount = 0\n",
    "tryList = []\n",
    "\n",
    "for target in WORDLE_WORDS :\n",
    "    workingList = WORDLE_WORDS\n",
    "    tryCount = 0\n",
    "    clues = ''\n",
    "    while clues != 'ggggg' :\n",
    "        tryCount +=1\n",
    "        scoreDict = rank_words(workingList) \n",
    "        word = scoreDict[0][0]\n",
    "        clues = generate_clue(word, target)\n",
    "        workingList = implement_clues(workingList, word, clues)\n",
    "    totalTries += tryCount\n",
    "    tryList.append(tryCount)\n",
    "    if tryCount > 6 :\n",
    "        failCount += 1\n",
    "    else :\n",
    "        successCount +=1\n",
    "        successTryCount += tryCount\n",
    "        \n",
    "\n",
    "\n",
    "plt.hist(tryList, [0.5 + w for w in range(9)])\n",
    "plt.title('Distribution of wordle tries')\n",
    "plt.xlabel('Number of tries')\n",
    "plt.ylabel('Frequency')\n",
    "plt.show()\n",
    "\n",
    "print('Average number of tries (all words): ', totalTries/len(WORDLE_WORDS))\n",
    "print('Average number of tries (successes only): ', successTryCount/successCount)\n",
    "print('Rate of failure to reach solution in 6 guesses (%): ', 100*failCount/len(WORDLE_WORDS))\n",
    "\n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "090a91e7",
   "metadata": {},
   "source": [
    "# Towards an alternative strategy\n",
    "\n",
    "In the below we score a word by the average information revealed by the first feedback clue over the ensemble of Wordle words.  If after feedback there are N possible remaining words, the residual entropy is -log(N).  We suggest that a good starting word would be one that minimises the expectation of this quantity over the Wordle ensemble.  The scatter diagram demonstrates the correlation between this score and the word entropy score used in the assistance algorithm."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "7017f0af",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Top starting suggestions by information gain:\n",
      " [('raise', 3.6729084367414617), ('slate', 3.688250773990957), ('crate', 3.702738501542575), ('irate', 3.705148590802027), ('trace', 3.7057365643912914), ('arise', 3.7123970246417453), ('stare', 3.721865183426486), ('snare', 3.7476441413142076), ('arose', 3.749232944205809), ('least', 3.7604280036378346)] \n",
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "scoresAverageInfoGain={}\n",
    "\n",
    "for word in WORDLE_WORDS :\n",
    "    S = 0   \n",
    "    for target in WORDLE_WORDS :\n",
    "        clues = generate_clue(word, target)\n",
    "        candidateList = implement_clues(WORDLE_WORDS, word, clues)\n",
    "        S += math.log(len(candidateList))\n",
    "    S = S/len(WORDLE_WORDS)\n",
    "    scoresAverageInfoGain[word] = S\n",
    "\n",
    "scoresWordEntropy = score_words(WORDLE_WORDS)\n",
    "\n",
    "\n",
    "NUM_SUGGESTIONS = 10\n",
    "\n",
    "bestStarters = sorted(scoresAverageInfoGain.items(), key=lambda k:k[1], reverse = False)[:NUM_SUGGESTIONS]\n",
    "print ('Top starting suggestions by information gain:\\n', bestStarters, '\\n')\n",
    "\n",
    "x = []\n",
    "y = []\n",
    "for w in scoresAverageInfoGain :\n",
    "    x.append(scoresAverageInfoGain[w]) \n",
    "    y.append(scoresWordEntropy[w])\n",
    "plt.scatter(x, y)\n",
    "plt.title('Word entropy score vs. information gain score')\n",
    "plt.xlabel('Information gain')\n",
    "plt.ylabel('Word entropy')\n",
    "plt.show()   "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fbd8b009",
   "metadata": {},
   "source": [
    "# Comment\n",
    "\n",
    "There is general correlation between the two different word scores, though clearly rather imperfect.  The striking characteristic is the banded structure of word entropy - no doubt related to the contribution to the word entropy from repeated letters through the contribution from the number of letter permutations in the word (not verifed to be so, though, yet).  I have verified the outlier at bottom right 'mamma' - the candidate worst Wordle starter. 'slate' would appear to be a very good starting word - it is the only word common to both top 10's and ranks first for word entropy score and second for information gain.\n",
    "\n",
    "The information gain strategy is too computationally intensive to provide in-game assisstance, but could in principle be extended to trying all combinations of word choices to try N, and scoring the remaining ensemble of possibilies, to see if performance better than the word entropy score can be obtained.  Alternatively, the strategy could be employed after the first try when the tree of possibilities has been narrowed dramatically."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}